convert comments to docstrings in a bunch of extensions

hgext/churn.py

@@ -1,206 +1,205
 # churn.py - create a graph showing who changed the most lines
 #
 # Copyright 2006 Josef "Jeff" Sipek <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
-#
-#
-# Aliases map file format is simple one alias per line in the following
-# format:
-#
-# <alias email> <actual email>
+'''allow graphing the number of lines changed per contributor'''
 
 from mercurial.i18n import gettext as _
 from mercurial import mdiff, cmdutil, util, node
 import os, sys
 
 def get_tty_width():
     if 'COLUMNS' in os.environ:
         try:
             return int(os.environ['COLUMNS'])
         except ValueError:
             pass
     try:
         import termios, array, fcntl
         for dev in (sys.stdout, sys.stdin):
             try:
                 fd = dev.fileno()
                 if not os.isatty(fd):
                     continue
                 arri = fcntl.ioctl(fd, termios.TIOCGWINSZ, '\0' * 8)
                 return array.array('h', arri)[1]
             except ValueError:
                 pass
     except ImportError:
         pass
     return 80
 
 def __gather(ui, repo, node1, node2):
     def dirtywork(f, mmap1, mmap2):
         lines = 0
 
         to = mmap1 and repo.file(f).read(mmap1[f]) or None
         tn = mmap2 and repo.file(f).read(mmap2[f]) or None
 
         diff = mdiff.unidiff(to, "", tn, "", f, f).split("\n")
 
         for line in diff:
             if not line:
                 continue # skip EOF
             if line.startswith(" "):
                 continue # context line
             if line.startswith("--- ") or line.startswith("+++ "):
                 continue # begining of diff
             if line.startswith("@@ "):
                 continue # info line
 
             # changed lines
             lines += 1
 
         return lines
 
     ##
 
     lines = 0
 
     changes = repo.status(node1, node2)[:5]
 
     modified, added, removed, deleted, unknown = changes
 
     who = repo.changelog.read(node2)[1]
     who = util.email(who) # get the email of the person
 
     mmap1 = repo.manifest.read(repo.changelog.read(node1)[0])
     mmap2 = repo.manifest.read(repo.changelog.read(node2)[0])
     for f in modified:
         lines += dirtywork(f, mmap1, mmap2)
 
     for f in added:
         lines += dirtywork(f, None, mmap2)
 
     for f in removed:
         lines += dirtywork(f, mmap1, None)
 
     for f in deleted:
         lines += dirtywork(f, mmap1, mmap2)
 
     for f in unknown:
         lines += dirtywork(f, mmap1, mmap2)
 
     return (who, lines)
 
 def gather_stats(ui, repo, amap, revs=None, progress=False):
     stats = {}
 
     cl    = repo.changelog
 
     if not revs:
         revs = range(0, cl.count())
 
     nr_revs = len(revs)
     cur_rev = 0
 
     for rev in revs:
         cur_rev += 1 # next revision
 
         node2    = cl.node(rev)
         node1    = cl.parents(node2)[0]
 
         if cl.parents(node2)[1] != node.nullid:
             ui.note(_('Revision %d is a merge, ignoring...\n') % (rev,))
             continue
 
         who, lines = __gather(ui, repo, node1, node2)
 
         # remap the owner if possible
         if who in amap:
             ui.note("using '%s' alias for '%s'\n" % (amap[who], who))
             who = amap[who]
 
         if not who in stats:
             stats[who] = 0
         stats[who] += lines
 
         ui.note("rev %d: %d lines by %s\n" % (rev, lines, who))
 
         if progress:
             nr_revs = max(nr_revs, 1)
             if int(100.0*(cur_rev - 1)/nr_revs) < int(100.0*cur_rev/nr_revs):
                 ui.write("\rGenerating stats: %d%%" % (int(100.0*cur_rev/nr_revs),))
                 sys.stdout.flush()
 
     if progress:
         ui.write("\r")
         sys.stdout.flush()
 
     return stats
 
 def churn(ui, repo, **opts):
-    "Graphs the number of lines changed"
+    '''graphs the number of lines changed
+
+    The map file format used to specify aliases is fairly simple:
+
+    <alias email> <actual email>'''
 
     def pad(s, l):
         if len(s) < l:
             return s + " " * (l-len(s))
         return s[0:l]
 
     def graph(n, maximum, width, char):
         maximum = max(1, maximum)
         n = int(n * width / float(maximum))
 
         return char * (n)
 
     def get_aliases(f):
         aliases = {}
 
         for l in f.readlines():
             l = l.strip()
             alias, actual = l.split()
             aliases[alias] = actual
 
         return aliases
 
     amap = {}
     aliases = opts.get('aliases')
     if aliases:
         try:
             f = open(aliases,"r")
         except OSError, e:
             print "Error: " + e
             return
 
         amap = get_aliases(f)
         f.close()
 
     revs = [int(r) for r in cmdutil.revrange(repo, opts['rev'])]
     revs.sort()
     stats = gather_stats(ui, repo, amap, revs, opts.get('progress'))
 
     # make a list of tuples (name, lines) and sort it in descending order
     ordered = stats.items()
     if not ordered:
         return
     ordered.sort(lambda x, y: cmp(y[1], x[1]))
     max_churn = ordered[0][1]
 
     tty_width = get_tty_width()
     ui.note(_("assuming %i character terminal\n") % tty_width)
     tty_width -= 1
 
     max_user_width = max([len(user) for user, churn in ordered])
 
     graph_width = tty_width - max_user_width - 1 - 6 - 2 - 2
 
     for user, churn in ordered:
         print "%s %6d %s" % (pad(user, max_user_width),
                              churn,
                              graph(churn, max_churn, graph_width, '*'))
 
 cmdtable = {
     "churn":
     (churn,
      [('r', 'rev', [], _('limit statistics to the specified revisions')),
       ('', 'aliases', '', _('file with email aliases')),
       ('', 'progress', None, _('show progress'))],
     'hg churn [-r revision range] [-a file] [--progress]'),
 }

hgext/convert/__init__.py

@@ -1,149 +1,150
 # convert.py Foreign SCM converter
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
+'''converting foreign VCS repositories to Mercurial'''
 
 import convcmd
 from mercurial import commands
 
 # Commands definition was moved elsewhere to ease demandload job.
 
 def convert(ui, src, dest=None, revmapfile=None, **opts):
     """Convert a foreign SCM repository to a Mercurial one.
 
     Accepted source formats:
     - Mercurial
     - CVS
     - Darcs
     - git
     - Subversion
     - Monotone
     - GNU Arch
 
     Accepted destination formats:
     - Mercurial
     - Subversion (history on branches is not preserved)
 
     If no revision is given, all revisions will be converted. Otherwise,
     convert will only import up to the named revision (given in a format
     understood by the source).
 
     If no destination directory name is specified, it defaults to the
     basename of the source with '-hg' appended.  If the destination
     repository doesn't exist, it will be created.
 
     If <REVMAP> isn't given, it will be put in a default location
     (<dest>/.hg/shamap by default).  The <REVMAP> is a simple text
     file that maps each source commit ID to the destination ID for
     that revision, like so:
     <source ID> <destination ID>
 
     If the file doesn't exist, it's automatically created.  It's updated
     on each commit copied, so convert-repo can be interrupted and can
     be run repeatedly to copy new commits.
 
     The [username mapping] file is a simple text file that maps each source
     commit author to a destination commit author. It is handy for source SCMs
     that use unix logins to identify authors (eg: CVS). One line per author
     mapping and the line format is:
     srcauthor=whatever string you want
 
     The filemap is a file that allows filtering and remapping of files
     and directories.  Comment lines start with '#'.  Each line can
     contain one of the following directives:
 
       include path/to/file
 
       exclude path/to/file
 
       rename from/file to/file
 
     The 'include' directive causes a file, or all files under a
     directory, to be included in the destination repository, and the
     exclusion of all other files and dirs not explicitely included.
     The 'exclude' directive causes files or directories to be omitted.
     The 'rename' directive renames a file or directory.  To rename from a
     subdirectory into the root of the repository, use '.' as the path to
     rename to.
 
     The splicemap is a file that allows insertion of synthetic
     history, letting you specify the parents of a revision.  This is
     useful if you want to e.g. give a Subversion merge two parents, or
     graft two disconnected series of history together.  Each entry
     contains a key, followed by a space, followed by one or two
     values, separated by spaces.  The key is the revision ID in the
     source revision control system whose parents should be modified
     (same format as a key in .hg/shamap).  The values are the revision
     IDs (in either the source or destination revision control system)
     that should be used as the new parents for that node.
 
     Mercurial Source
     -----------------
 
     --config convert.hg.saverev=True          (boolean)
         allow target to preserve source revision ID
 
     Subversion Source
     -----------------
 
     Subversion source detects classical trunk/branches/tags layouts.
     By default, the supplied "svn://repo/path/" source URL is
     converted as a single branch. If "svn://repo/path/trunk" exists
     it replaces the default branch. If "svn://repo/path/branches"
     exists, its subdirectories are listed as possible branches. If
     "svn://repo/path/tags" exists, it is looked for tags referencing
     converted branches. Default "trunk", "branches" and "tags" values
     can be overriden with following options. Set them to paths
     relative to the source URL, or leave them blank to disable
     autodetection.
 
     --config convert.svn.branches=branches    (directory name)
         specify the directory containing branches
     --config convert.svn.tags=tags            (directory name)
         specify the directory containing tags
     --config convert.svn.trunk=trunk          (directory name)
         specify the name of the trunk branch
 
     Source history can be retrieved starting at a specific revision,
     instead of being integrally converted. Only single branch
     conversions are supported.
 
     --config convert.svn.startrev=0           (svn revision number)
         specify start Subversion revision.
 
     Mercurial Destination
     ---------------------
 
     --config convert.hg.clonebranches=False   (boolean)
         dispatch source branches in separate clones.
     --config convert.hg.tagsbranch=default    (branch name)
         tag revisions branch name
     --config convert.hg.usebranchnames=True   (boolean)
         preserve branch names
 
     """
     return convcmd.convert(ui, src, dest, revmapfile, **opts)
 
 def debugsvnlog(ui, **opts):
     return convcmd.debugsvnlog(ui, **opts)
 
 commands.norepo += " convert debugsvnlog"
 
 cmdtable = {
     "convert":
         (convert,
          [('A', 'authors', '', 'username mapping filename'),
           ('d', 'dest-type', '', 'destination repository type'),
           ('', 'filemap', '', 'remap file names using contents of file'),
           ('r', 'rev', '', 'import up to target revision REV'),
           ('s', 'source-type', '', 'source repository type'),
           ('', 'splicemap', '', 'splice synthesized history into place'),
           ('', 'datesort', None, 'try to sort changesets by date')],
          'hg convert [OPTION]... SOURCE [DEST [REVMAP]]'),
     "debugsvnlog":
         (debugsvnlog,
          [],
          'hg debugsvnlog'),
 }

hgext/fetch.py

@@ -1,127 +1,128
 # fetch.py - pull and merge remote changes
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
+'''pulling, updating and merging in one command'''
 
 from mercurial.i18n import _
 from mercurial.node import nullid, short
 from mercurial import commands, cmdutil, hg, util
 
 def fetch(ui, repo, source='default', **opts):
     '''Pull changes from a remote repository, merge new changes if needed.
 
     This finds all changes from the repository at the specified path
     or URL and adds them to the local repository.
 
     If the pulled changes add a new head, the head is automatically
     merged, and the result of the merge is committed.  Otherwise, the
     working directory is updated to include the new changes.
 
     When a merge occurs, the newly pulled changes are assumed to be
     "authoritative".  The head of the new changes is used as the first
     parent, with local changes as the second.  To switch the merge
     order, use --switch-parent.
 
     See 'hg help dates' for a list of formats valid for -d/--date.
     '''
 
     def postincoming(other, modheads):
         if modheads == 0:
             return 0
         if modheads == 1:
             return hg.clean(repo, repo.changelog.tip())
         newheads = repo.heads(parent)
         newchildren = [n for n in repo.heads(parent) if n != parent]
         newparent = parent
         if newchildren:
             newparent = newchildren[0]
             hg.clean(repo, newparent)
         newheads = [n for n in repo.heads() if n != newparent]
         if len(newheads) > 1:
             ui.status(_('not merging with %d other new heads '
                         '(use "hg heads" and "hg merge" to merge them)') %
                       (len(newheads) - 1))
             return
         err = False
         if newheads:
             # By default, we consider the repository we're pulling
             # *from* as authoritative, so we merge our changes into
             # theirs.
             if opts['switch_parent']:
                 firstparent, secondparent = newparent, newheads[0]
             else:
                 firstparent, secondparent = newheads[0], newparent
                 ui.status(_('updating to %d:%s\n') %
                           (repo.changelog.rev(firstparent),
                            short(firstparent)))
             hg.clean(repo, firstparent)
             ui.status(_('merging with %d:%s\n') %
                       (repo.changelog.rev(secondparent), short(secondparent)))
             err = hg.merge(repo, secondparent, remind=False)
         if not err:
             mod, add, rem = repo.status()[:3]
             message = (cmdutil.logmessage(opts) or
                        (_('Automated merge with %s') %
                         util.removeauth(other.url())))
             force_editor = opts.get('force_editor') or opts.get('edit')
             n = repo.commit(mod + add + rem, message,
                             opts['user'], opts['date'], force=True,
                             force_editor=force_editor)
             ui.status(_('new changeset %d:%s merges remote changes '
                         'with local\n') % (repo.changelog.rev(n),
                                            short(n)))
 
     def pull():
         cmdutil.setremoteconfig(ui, opts)
 
         other = hg.repository(ui, ui.expandpath(source))
         ui.status(_('pulling from %s\n') %
                   util.hidepassword(ui.expandpath(source)))
         revs = None
         if opts['rev']:
             if not other.local():
                 raise util.Abort(_("fetch -r doesn't work for remote "
                                    "repositories yet"))
             else:
                 revs = [other.lookup(rev) for rev in opts['rev']]
         modheads = repo.pull(other, heads=revs)
         return postincoming(other, modheads)
 
     date = opts.get('date')
     if date:
         opts['date'] = util.parsedate(date)
 
     parent, p2 = repo.dirstate.parents()
     if parent != repo.changelog.tip():
         raise util.Abort(_('working dir not at tip '
                            '(use "hg update" to check out tip)'))
     if p2 != nullid:
         raise util.Abort(_('outstanding uncommitted merge'))
     wlock = lock = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         mod, add, rem, del_ = repo.status()[:4]
         if mod or add or rem:
             raise util.Abort(_('outstanding uncommitted changes'))
         if del_:
             raise util.Abort(_('working directory is missing some files'))
         if len(repo.heads()) > 1:
             raise util.Abort(_('multiple heads in this repository '
                                '(use "hg heads" and "hg merge" to merge)'))
         return pull()
     finally:
         del lock, wlock
 
 cmdtable = {
     'fetch':
         (fetch,
         [('r', 'rev', [], _('a specific revision you would like to pull')),
          ('e', 'edit', None, _('edit commit message')),
          ('', 'force-editor', None, _('edit commit message (DEPRECATED)')),
          ('', 'switch-parent', None, _('switch parents when merging')),
         ] + commands.commitopts + commands.commitopts2 + commands.remoteopts,
         _('hg fetch [SOURCE]')),
 }

hgext/graphlog.py

@@ -1,326 +1,327
 # ASCII graph log extension for Mercurial
 #
 # Copyright 2007 Joel Rosdahl <[e-mail]>
 #
 # This software may be used and distributed according to the terms of
 # the GNU General Public License, incorporated herein by reference.
+'''show revision graphs in terminal windows'''
 
 import os
 import sys
 from mercurial.cmdutil import revrange, show_changeset
 from mercurial.commands import templateopts
 from mercurial.i18n import _
 from mercurial.node import nullrev
 from mercurial.util import Abort, canonpath
 
 def revision_grapher(repo, start_rev, stop_rev):
     """incremental revision grapher
 
     This generator function walks through the revision history from
     revision start_rev to revision stop_rev (which must be less than
     or equal to start_rev) and for each revision emits tuples with the
     following elements:
 
       - Current revision.
       - Current node.
       - Column of the current node in the set of ongoing edges.
       - Edges; a list of (col, next_col) indicating the edges between
         the current node and its parents.
       - Number of columns (ongoing edges) in the current revision.
       - The difference between the number of columns (ongoing edges)
         in the next revision and the number of columns (ongoing edges)
         in the current revision. That is: -1 means one column removed;
         0 means no columns added or removed; 1 means one column added.
     """
 
     assert start_rev >= stop_rev
     curr_rev = start_rev
     revs = []
     while curr_rev >= stop_rev:
         node = repo.changelog.node(curr_rev)
 
         # Compute revs and next_revs.
         if curr_rev not in revs:
             # New head.
             revs.append(curr_rev)
         rev_index = revs.index(curr_rev)
         next_revs = revs[:]
 
         # Add parents to next_revs.
         parents = get_rev_parents(repo, curr_rev)
         parents_to_add = []
         for parent in parents:
             if parent not in next_revs:
                 parents_to_add.append(parent)
         parents_to_add.sort()
         next_revs[rev_index:rev_index + 1] = parents_to_add
 
         edges = []
         for parent in parents:
             edges.append((rev_index, next_revs.index(parent)))
 
         n_columns_diff = len(next_revs) - len(revs)
         yield (curr_rev, node, rev_index, edges, len(revs), n_columns_diff)
 
         revs = next_revs
         curr_rev -= 1
 
 def filelog_grapher(repo, path, start_rev, stop_rev):
     """incremental file log grapher
 
     This generator function walks through the revision history of a
     single file from revision start_rev to revision stop_rev (which must
     be less than or equal to start_rev) and for each revision emits
     tuples with the following elements:
 
       - Current revision.
       - Current node.
       - Column of the current node in the set of ongoing edges.
       - Edges; a list of (col, next_col) indicating the edges between
         the current node and its parents.
       - Number of columns (ongoing edges) in the current revision.
       - The difference between the number of columns (ongoing edges)
         in the next revision and the number of columns (ongoing edges)
         in the current revision. That is: -1 means one column removed;
         0 means no columns added or removed; 1 means one column added.
     """
 
     assert start_rev >= stop_rev
     curr_rev = start_rev
     revs = []
     filerev = repo.file(path).count() - 1
     while filerev >= 0:
         fctx = repo.filectx(path, fileid=filerev)
 
         # Compute revs and next_revs.
         if filerev not in revs:
             revs.append(filerev)
         rev_index = revs.index(filerev)
         next_revs = revs[:]
 
         # Add parents to next_revs.
         parents = [f.filerev() for f in fctx.parents() if f.path() == path]
         parents_to_add = []
         for parent in parents:
             if parent not in next_revs:
                 parents_to_add.append(parent)
         parents_to_add.sort()
         next_revs[rev_index:rev_index + 1] = parents_to_add
 
         edges = []
         for parent in parents:
             edges.append((rev_index, next_revs.index(parent)))
 
         changerev = fctx.linkrev()
         if changerev <= start_rev:
             node = repo.changelog.node(changerev)
             n_columns_diff = len(next_revs) - len(revs)
             yield (changerev, node, rev_index, edges, len(revs), n_columns_diff)
         if changerev <= stop_rev:
             break
         revs = next_revs
         filerev -= 1
 
 def get_rev_parents(repo, rev):
     return [x for x in repo.changelog.parentrevs(rev) if x != nullrev]
 
 def fix_long_right_edges(edges):
     for (i, (start, end)) in enumerate(edges):
         if end > start:
             edges[i] = (start, end + 1)
 
 def draw_edges(edges, nodeline, interline):
     for (start, end) in edges:
         if start == end + 1:
             interline[2 * end + 1] = "/"
         elif start == end - 1:
             interline[2 * start + 1] = "\\"
         elif start == end:
             interline[2 * start] = "|"
         else:
             nodeline[2 * end] = "+"
             if start > end:
                 (start, end) = (end,start)
             for i in range(2 * start + 1, 2 * end):
                 if nodeline[i] != "+":
                     nodeline[i] = "-"
 
 def format_line(line, level, logstr):
     text = "%-*s %s" % (2 * level, "".join(line), logstr)
     return "%s\n" % text.rstrip()
 
 def get_nodeline_edges_tail(
         node_index, p_node_index, n_columns, n_columns_diff, p_diff, fix_tail):
     if fix_tail and n_columns_diff == p_diff and n_columns_diff != 0:
         # Still going in the same non-vertical direction.
         if n_columns_diff == -1:
             start = max(node_index + 1, p_node_index)
             tail = ["|", " "] * (start - node_index - 1)
             tail.extend(["/", " "] * (n_columns - start))
             return tail
         else:
             return ["\\", " "] * (n_columns - node_index - 1)
     else:
         return ["|", " "] * (n_columns - node_index - 1)
 
 def get_padding_line(ni, n_columns, edges):
     line = []
     line.extend(["|", " "] * ni)
     if (ni, ni - 1) in edges or (ni, ni) in edges:
         # (ni, ni - 1)      (ni, ni)
         # | | | |           | | | |
         # +---o |           | o---+
         # | | c |           | c | |
         # | |/ /            | |/ /
         # | | |             | | |
         c = "|"
     else:
         c = " "
     line.extend([c, " "])
     line.extend(["|", " "] * (n_columns - ni - 1))
     return line
 
 def get_limit(limit_opt):
     if limit_opt:
         try:
             limit = int(limit_opt)
         except ValueError:
             raise Abort(_("limit must be a positive integer"))
         if limit <= 0:
             raise Abort(_("limit must be positive"))
     else:
         limit = sys.maxint
     return limit
 
 def get_revs(repo, rev_opt):
     if rev_opt:
         revs = revrange(repo, rev_opt)
         return (max(revs), min(revs))
     else:
         return (repo.changelog.count() - 1, 0)
 
 def graphlog(ui, repo, path=None, **opts):
     """show revision history alongside an ASCII revision graph
 
     Print a revision history alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
 
     limit = get_limit(opts["limit"])
     (start_rev, stop_rev) = get_revs(repo, opts["rev"])
     stop_rev = max(stop_rev, start_rev - limit + 1)
     if start_rev == nullrev:
         return
     cs_printer = show_changeset(ui, repo, opts)
     if path:
         cpath = canonpath(repo.root, os.getcwd(), path)
         grapher = filelog_grapher(repo, cpath, start_rev, stop_rev)
     else:
         grapher = revision_grapher(repo, start_rev, stop_rev)
     repo_parents = repo.dirstate.parents()
     prev_n_columns_diff = 0
     prev_node_index = 0
 
     for (rev, node, node_index, edges, n_columns, n_columns_diff) in grapher:
         # log_strings is the list of all log strings to draw alongside
         # the graph.
         ui.pushbuffer()
         cs_printer.show(rev, node)
         log_strings = ui.popbuffer().split("\n")[:-1]
 
         if n_columns_diff == -1:
             # Transform
             #
             #     | | |        | | |
             #     o | |  into  o---+
             #     |X /         |/ /
             #     | |          | |
             fix_long_right_edges(edges)
 
         # add_padding_line says whether to rewrite
         #
         #     | | | |        | | | |
         #     | o---+  into  | o---+
         #     |  / /         |   | |  # <--- padding line
         #     o | |          |  / /
         #                    o | |
         add_padding_line = (len(log_strings) > 2 and
                             n_columns_diff == -1 and
                             [x for (x, y) in edges if x + 1 < y])
 
         # fix_nodeline_tail says whether to rewrite
         #
         #     | | o | |        | | o | |
         #     | | |/ /         | | |/ /
         #     | o | |    into  | o / /   # <--- fixed nodeline tail
         #     | |/ /           | |/ /
         #     o | |            o | |
         fix_nodeline_tail = len(log_strings) <= 2 and not add_padding_line
 
         # nodeline is the line containing the node character (@ or o).
         nodeline = ["|", " "] * node_index
         if node in repo_parents:
             node_ch = "@"
         else:
             node_ch = "o"
         nodeline.extend([node_ch, " "])
 
         nodeline.extend(
             get_nodeline_edges_tail(
                 node_index, prev_node_index, n_columns, n_columns_diff,
                 prev_n_columns_diff, fix_nodeline_tail))
 
         # shift_interline is the line containing the non-vertical
         # edges between this entry and the next.
         shift_interline = ["|", " "] * node_index
         if n_columns_diff == -1:
             n_spaces = 1
             edge_ch = "/"
         elif n_columns_diff == 0:
             n_spaces = 2
             edge_ch = "|"
         else:
             n_spaces = 3
             edge_ch = "\\"
         shift_interline.extend(n_spaces * [" "])
         shift_interline.extend([edge_ch, " "] * (n_columns - node_index - 1))
 
         # Draw edges from the current node to its parents.
         draw_edges(edges, nodeline, shift_interline)
 
         # lines is the list of all graph lines to print.
         lines = [nodeline]
         if add_padding_line:
             lines.append(get_padding_line(node_index, n_columns, edges))
         lines.append(shift_interline)
 
         # Make sure that there are as many graph lines as there are
         # log strings.
         while len(log_strings) < len(lines):
             log_strings.append("")
         if len(lines) < len(log_strings):
             extra_interline = ["|", " "] * (n_columns + n_columns_diff)
             while len(lines) < len(log_strings):
                 lines.append(extra_interline)
 
         # Print lines.
         indentation_level = max(n_columns, n_columns + n_columns_diff)
         for (line, logstr) in zip(lines, log_strings):
             ui.write(format_line(line, indentation_level, logstr))
 
         # ...and start over.
         prev_node_index = node_index
         prev_n_columns_diff = n_columns_diff
 
 cmdtable = {
     "glog":
         (graphlog,
          [('l', 'limit', '', _('limit number of changes displayed')),
           ('p', 'patch', False, _('show patch')),
           ('r', 'rev', [], _('show the specified revision or range')),
          ] + templateopts,
          _('hg glog [OPTION]... [FILE]')),
 }

hgext/hgk.py

@@ -1,358 +1,357
 # Minimal support for git commands on an hg repository
 #
 # Copyright 2005, 2006 Chris Mason <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
-#
-# The hgk extension allows browsing the history of a repository in a
-# graphical way. It requires Tcl/Tk version 8.4 or later. (Tcl/Tk is
-# not distributed with Mercurial.)
-#
-# hgk consists of two parts: a Tcl script that does the displaying and
-# querying of information, and an extension to mercurial named hgk.py,
-# which provides hooks for hgk to get information. hgk can be found in
-# the contrib directory, and hgk.py can be found in the hgext
-# directory.
-#
-# To load the hgext.py extension, add it to your .hgrc file (you have
-# to use your global $HOME/.hgrc file, not one in a repository). You
-# can specify an absolute path:
-#
-#   [extensions]
-#   hgk=/usr/local/lib/hgk.py
-#
-# Mercurial can also scan the default python library path for a file
-# named 'hgk.py' if you set hgk empty:
-#
-#   [extensions]
-#   hgk=
-#
-# The hg view command will launch the hgk Tcl script. For this command
-# to work, hgk must be in your search path. Alternately, you can
-# specify the path to hgk in your .hgrc file:
-#
-#   [hgk]
-#   path=/location/of/hgk
-#
-# hgk can make use of the extdiff extension to visualize
-# revisions. Assuming you had already configured extdiff vdiff
-# command, just add:
-#
-#   [hgk]
-#   vdiff=vdiff
-#
-# Revisions context menu will now display additional entries to fire
-# vdiff on hovered and selected revisions.
+'''browsing the repository in a graphical way
+
+The hgk extension allows browsing the history of a repository in a
+graphical way. It requires Tcl/Tk version 8.4 or later. (Tcl/Tk is
+not distributed with Mercurial.)
+
+hgk consists of two parts: a Tcl script that does the displaying and
+querying of information, and an extension to mercurial named hgk.py,
+which provides hooks for hgk to get information. hgk can be found in
+the contrib directory, and hgk.py can be found in the hgext directory.
+
+To load the hgext.py extension, add it to your .hgrc file (you have
+to use your global $HOME/.hgrc file, not one in a repository). You
+can specify an absolute path:
+
+  [extensions]
+  hgk=/usr/local/lib/hgk.py
+
+Mercurial can also scan the default python library path for a file
+named 'hgk.py' if you set hgk empty:
+
+  [extensions]
+  hgk=
+
+The hg view command will launch the hgk Tcl script. For this command
+to work, hgk must be in your search path. Alternately, you can
+specify the path to hgk in your .hgrc file:
+
+  [hgk]
+  path=/location/of/hgk
+
+hgk can make use of the extdiff extension to visualize revisions.
+Assuming you had already configured extdiff vdiff command, just add:
+
+  [hgk]
+  vdiff=vdiff
+
+Revisions context menu will now display additional entries to fire
+vdiff on hovered and selected revisions.'''
 
 import os
 from mercurial import commands, util, patch, revlog, cmdutil
 from mercurial.node import nullid, nullrev, short
 
 def difftree(ui, repo, node1=None, node2=None, *files, **opts):
     """diff trees from two commits"""
     def __difftree(repo, node1, node2, files=[]):
         assert node2 is not None
         mmap = repo.changectx(node1).manifest()
         mmap2 = repo.changectx(node2).manifest()
         m = cmdutil.match(repo, files)
         status = repo.status(node1, node2, match=m)[:5]
         modified, added, removed, deleted, unknown = status
 
         empty = short(nullid)
 
         for f in modified:
             # TODO get file permissions
             ui.write(":100664 100664 %s %s M\t%s\t%s\n" %
                      (short(mmap[f]), short(mmap2[f]), f, f))
         for f in added:
             ui.write(":000000 100664 %s %s N\t%s\t%s\n" %
                      (empty, short(mmap2[f]), f, f))
         for f in removed:
             ui.write(":100664 000000 %s %s D\t%s\t%s\n" %
                      (short(mmap[f]), empty, f, f))
     ##
 
     while True:
         if opts['stdin']:
             try:
                 line = raw_input().split(' ')
                 node1 = line[0]
                 if len(line) > 1:
                     node2 = line[1]
                 else:
                     node2 = None
             except EOFError:
                 break
         node1 = repo.lookup(node1)
         if node2:
             node2 = repo.lookup(node2)
         else:
             node2 = node1
             node1 = repo.changelog.parents(node1)[0]
         if opts['patch']:
             if opts['pretty']:
                 catcommit(ui, repo, node2, "")
             m = cmdutil.match(repo, files)
             patch.diff(repo, node1, node2, match=m,
                        opts=patch.diffopts(ui, {'git': True}))
         else:
             __difftree(repo, node1, node2, files=files)
         if not opts['stdin']:
             break
 
 def catcommit(ui, repo, n, prefix, ctx=None):
     nlprefix = '\n' + prefix;
     if ctx is None:
         ctx = repo.changectx(n)
     (p1, p2) = ctx.parents()
     ui.write("tree %s\n" % short(ctx.changeset()[0])) # use ctx.node() instead ??
     if p1: ui.write("parent %s\n" % short(p1.node()))
     if p2: ui.write("parent %s\n" % short(p2.node()))
     date = ctx.date()
     description = ctx.description().replace("\0", "")
     lines = description.splitlines()
     if lines and lines[-1].startswith('committer:'):
         committer = lines[-1].split(': ')[1].rstrip()
     else:
         committer = ctx.user()
 
     ui.write("author %s %s %s\n" % (ctx.user(), int(date[0]), date[1]))
     ui.write("committer %s %s %s\n" % (committer, int(date[0]), date[1]))
     ui.write("revision %d\n" % ctx.rev())
     ui.write("branch %s\n\n" % ctx.branch())
 
     if prefix != "":
         ui.write("%s%s\n" % (prefix, description.replace('\n', nlprefix).strip()))
     else:
         ui.write(description + "\n")
     if prefix:
         ui.write('\0')
 
 def base(ui, repo, node1, node2):
     """Output common ancestor information"""
     node1 = repo.lookup(node1)
     node2 = repo.lookup(node2)
     n = repo.changelog.ancestor(node1, node2)
     ui.write(short(n) + "\n")
 
 def catfile(ui, repo, type=None, r=None, **opts):
     """cat a specific revision"""
     # in stdin mode, every line except the commit is prefixed with two
     # spaces.  This way the our caller can find the commit without magic
     # strings
     #
     prefix = ""
     if opts['stdin']:
         try:
             (type, r) = raw_input().split(' ');
             prefix = "    "
         except EOFError:
             return
 
     else:
         if not type or not r:
             ui.warn("cat-file: type or revision not supplied\n")
             commands.help_(ui, 'cat-file')
 
     while r:
         if type != "commit":
             ui.warn("aborting hg cat-file only understands commits\n")
             return 1;
         n = repo.lookup(r)
         catcommit(ui, repo, n, prefix)
         if opts['stdin']:
             try:
                 (type, r) = raw_input().split(' ');
             except EOFError:
                 break
         else:
             break
 
 # git rev-tree is a confusing thing.  You can supply a number of
 # commit sha1s on the command line, and it walks the commit history
 # telling you which commits are reachable from the supplied ones via
 # a bitmask based on arg position.
 # you can specify a commit to stop at by starting the sha1 with ^
 def revtree(ui, args, repo, full="tree", maxnr=0, parents=False):
     def chlogwalk():
         count = repo.changelog.count()
         i = count
         l = [0] * 100
         chunk = 100
         while True:
             if chunk > i:
                 chunk = i
                 i = 0
             else:
                 i -= chunk
 
             for x in xrange(0, chunk):
                 if i + x >= count:
                     l[chunk - x:] = [0] * (chunk - x)
                     break
                 if full != None:
                     l[x] = repo.changectx(i + x)
                     l[x].changeset() # force reading
                 else:
                     l[x] = 1
             for x in xrange(chunk-1, -1, -1):
                 if l[x] != 0:
                     yield (i + x, full != None and l[x] or None)
             if i == 0:
                 break
 
     # calculate and return the reachability bitmask for sha
     def is_reachable(ar, reachable, sha):
         if len(ar) == 0:
             return 1
         mask = 0
         for i in xrange(len(ar)):
             if sha in reachable[i]:
                 mask |= 1 << i
 
         return mask
 
     reachable = []
     stop_sha1 = []
     want_sha1 = []
     count = 0
 
     # figure out which commits they are asking for and which ones they
     # want us to stop on
     for i in xrange(len(args)):
         if args[i].startswith('^'):
             s = repo.lookup(args[i][1:])
             stop_sha1.append(s)
             want_sha1.append(s)
         elif args[i] != 'HEAD':
             want_sha1.append(repo.lookup(args[i]))
 
     # calculate the graph for the supplied commits
     for i in xrange(len(want_sha1)):
         reachable.append({});
         n = want_sha1[i];
         visit = [n];
         reachable[i][n] = 1
         while visit:
             n = visit.pop(0)
             if n in stop_sha1:
                 continue
             for p in repo.changelog.parents(n):
                 if p not in reachable[i]:
                     reachable[i][p] = 1
                     visit.append(p)
                 if p in stop_sha1:
                     continue
 
     # walk the repository looking for commits that are in our
     # reachability graph
     for i, ctx in chlogwalk():
         n = repo.changelog.node(i)
         mask = is_reachable(want_sha1, reachable, n)
         if mask:
             parentstr = ""
             if parents:
                 pp = repo.changelog.parents(n)
                 if pp[0] != nullid:
                     parentstr += " " + short(pp[0])
                 if pp[1] != nullid:
                     parentstr += " " + short(pp[1])
             if not full:
                 ui.write("%s%s\n" % (short(n), parentstr))
             elif full == "commit":
                 ui.write("%s%s\n" % (short(n), parentstr))
                 catcommit(ui, repo, n, '    ', ctx)
             else:
                 (p1, p2) = repo.changelog.parents(n)
                 (h, h1, h2) = map(short, (n, p1, p2))
                 (i1, i2) = map(repo.changelog.rev, (p1, p2))
 
                 date = ctx.date()[0]
                 ui.write("%s %s:%s" % (date, h, mask))
                 mask = is_reachable(want_sha1, reachable, p1)
                 if i1 != nullrev and mask > 0:
                     ui.write("%s:%s " % (h1, mask)),
                 mask = is_reachable(want_sha1, reachable, p2)
                 if i2 != nullrev and mask > 0:
                     ui.write("%s:%s " % (h2, mask))
                 ui.write("\n")
             if maxnr and count >= maxnr:
                 break
             count += 1
 
 def revparse(ui, repo, *revs, **opts):
     """Parse given revisions"""
     def revstr(rev):
         if rev == 'HEAD':
             rev = 'tip'
         return revlog.hex(repo.lookup(rev))
 
     for r in revs:
         revrange = r.split(':', 1)
         ui.write('%s\n' % revstr(revrange[0]))
         if len(revrange) == 2:
             ui.write('^%s\n' % revstr(revrange[1]))
 
 # git rev-list tries to order things by date, and has the ability to stop
 # at a given commit without walking the whole repo.  TODO add the stop
 # parameter
 def revlist(ui, repo, *revs, **opts):
     """print revisions"""
     if opts['header']:
         full = "commit"
     else:
         full = None
     copy = [x for x in revs]
     revtree(ui, copy, repo, full, opts['max_count'], opts['parents'])
 
 def config(ui, repo, **opts):
     """print extension options"""
     def writeopt(name, value):
         ui.write('k=%s\nv=%s\n' % (name, value))
 
     writeopt('vdiff', ui.config('hgk', 'vdiff', ''))
 
 
 def view(ui, repo, *etc, **opts):
     "start interactive history viewer"
     os.chdir(repo.root)
     optstr = ' '.join(['--%s %s' % (k, v) for k, v in opts.iteritems() if v])
     cmd = ui.config("hgk", "path", "hgk") + " %s %s" % (optstr, " ".join(etc))
     ui.debug("running %s\n" % cmd)
     util.system(cmd)
 
 cmdtable = {
     "^view":
         (view,
          [('l', 'limit', '', 'limit number of changes displayed')],
          'hg view [-l LIMIT] [REVRANGE]'),
     "debug-diff-tree":
         (difftree,
          [('p', 'patch', None, 'generate patch'),
           ('r', 'recursive', None, 'recursive'),
           ('P', 'pretty', None, 'pretty'),
           ('s', 'stdin', None, 'stdin'),
           ('C', 'copy', None, 'detect copies'),
           ('S', 'search', "", 'search')],
          'hg git-diff-tree [OPTION]... NODE1 NODE2 [FILE]...'),
     "debug-cat-file":
         (catfile,
          [('s', 'stdin', None, 'stdin')],
          'hg debug-cat-file [OPTION]... TYPE FILE'),
     "debug-config":
         (config, [], 'hg debug-config'),
     "debug-merge-base":
         (base, [], 'hg debug-merge-base node node'),
     "debug-rev-parse":
         (revparse,
          [('', 'default', '', 'ignored')],
          'hg debug-rev-parse REV'),
     "debug-rev-list":
         (revlist,
          [('H', 'header', None, 'header'),
           ('t', 'topo-order', None, 'topo-order'),
           ('p', 'parents', None, 'parents'),
           ('n', 'max-count', 0, 'max-count')],
          'hg debug-rev-list [options] revs'),
 }

hgext/highlight.py

@@ -1,100 +1,98
-"""
-This is Mercurial extension for syntax highlighting in the file
-revision view of hgweb.
+"""a mercurial extension for syntax highlighting in hgweb
 
 It depends on the pygments syntax highlighting library:
 http://pygments.org/
 
 To enable the extension add this to hgrc:
 
 [extensions]
 hgext.highlight =
 
 There is a single configuration option:
 
 [web]
 pygments_style = <style>
 
 The default is 'colorful'.
 
 -- Adam Hupp <[e-mail]>
 """
 
 from mercurial import demandimport
 demandimport.ignore.extend(['pkgutil', 'pkg_resources', '__main__',])
 
 from mercurial.hgweb import webcommands, webutil, common
 from mercurial import util
 from mercurial.templatefilters import filters
 
 from pygments import highlight
 from pygments.util import ClassNotFound
 from pygments.lexers import guess_lexer, guess_lexer_for_filename, TextLexer
 from pygments.formatters import HtmlFormatter
 
 SYNTAX_CSS = ('\n<link rel="stylesheet" href="{url}highlightcss" '
               'type="text/css" />')
 
 def pygmentize(field, fctx, style, tmpl):
 
     # append a <link ...> to the syntax highlighting css
     old_header = ''.join(tmpl('header'))
     if SYNTAX_CSS not in old_header:
         new_header =  old_header + SYNTAX_CSS
         tmpl.cache['header'] = new_header
 
     text = fctx.data()
     if util.binary(text):
         return
 
     # To get multi-line strings right, we can't format line-by-line
     try:
         lexer = guess_lexer_for_filename(fctx.path(), text[:1024],
                                          encoding=util._encoding)
     except (ClassNotFound, ValueError):
         try:
             lexer = guess_lexer(text[:1024], encoding=util._encoding)
         except (ClassNotFound, ValueError):
             lexer = TextLexer(encoding=util._encoding)
 
     formatter = HtmlFormatter(style=style, encoding=util._encoding)
 
     colorized = highlight(text, lexer, formatter)
     # strip wrapping div
     colorized = colorized[:colorized.find('\n</pre>')]
     colorized = colorized[colorized.find('<pre>')+5:]
     coloriter = iter(colorized.splitlines())
 
     filters['colorize'] = lambda x: coloriter.next()
 
     oldl = tmpl.cache[field]
     newl = oldl.replace('line|escape', 'line|colorize')
     tmpl.cache[field] = newl
 
 web_filerevision = webcommands._filerevision
 web_annotate = webcommands.annotate
 
 def filerevision_highlight(web, tmpl, fctx):
     style = web.config('web', 'pygments_style', 'colorful')
     pygmentize('fileline', fctx, style, tmpl)
     return web_filerevision(web, tmpl, fctx)
 
 def annotate_highlight(web, req, tmpl):
     fctx = webutil.filectx(web.repo, req)
     style = web.config('web', 'pygments_style', 'colorful')
     pygmentize('annotateline', fctx, style, tmpl)
     return web_annotate(web, req, tmpl)
 
 def generate_css(web, req, tmpl):
     pg_style = web.config('web', 'pygments_style', 'colorful')
     fmter = HtmlFormatter(style = pg_style)
     req.respond(common.HTTP_OK, 'text/css')
     return ['/* pygments_style = %s */\n\n' % pg_style, fmter.get_style_defs('')]
 
 
 # monkeypatch in the new version
 
 webcommands._filerevision = filerevision_highlight
 webcommands.annotate = annotate_highlight
 webcommands.highlightcss = generate_css
 webcommands.__all__.append('highlightcss')

hgext/patchbomb.py

@@ -1,469 +1,466
-# Command for sending a collection of Mercurial changesets as a series
-# of patch emails.
-#
-# The series is started off with a "[PATCH 0 of N]" introduction,
-# which describes the series as a whole.
-#
-# Each patch email has a Subject line of "[PATCH M of N] ...", using
-# the first line of the changeset description as the subject text.
-# The message contains two or three body parts:
-#
-#   The remainder of the changeset description.
-#
-#   [Optional] If the diffstat program is installed, the result of
-#   running diffstat on the patch.
-#
-#   The patch itself, as generated by "hg export".
-#
-# Each message refers to all of its predecessors using the In-Reply-To
-# and References headers, so they will show up as a sequence in
-# threaded mail and news readers, and in mail archives.
-#
-# For each changeset, you will be prompted with a diffstat summary and
-# the changeset summary, so you can be sure you are sending the right
-# changes.
-#
-# To enable this extension:
-#
-#   [extensions]
-#   hgext.patchbomb =
-#
-# To configure other defaults, add a section like this to your hgrc
-# file:
-#
-#   [email]
-#   from = My Name <my@email>
-#   to = recipient1, recipient2, ...
-#   cc = cc1, cc2, ...
-#   bcc = bcc1, bcc2, ...
-#
-# Then you can use the "hg email" command to mail a series of changesets
-# as a patchbomb.
-#
-# To avoid sending patches prematurely, it is a good idea to first run
-# the "email" command with the "-n" option (test only).  You will be
-# prompted for an email recipient address, a subject an an introductory
-# message describing the patches of your patchbomb.  Then when all is
-# done, patchbomb messages are displayed. If PAGER environment variable
-# is set, your pager will be fired up once for each patchbomb message, so
-# you can verify everything is alright.
-#
-# The "-m" (mbox) option is also very useful.  Instead of previewing
-# each patchbomb message in a pager or sending the messages directly,
-# it will create a UNIX mailbox file with the patch emails.  This
-# mailbox file can be previewed with any mail user agent which supports
-# UNIX mbox files, i.e. with mutt:
-#
-#   % mutt -R -f mbox
-#
-# When you are previewing the patchbomb messages, you can use `formail'
-# (a utility that is commonly installed as part of the procmail package),
-# to send each message out:
-#
-#  % formail -s sendmail -bm -t < mbox
-#
-# That should be all.  Now your patchbomb is on its way out.
+'''sending Mercurial changesets as a series of patch emails
+
+The series is started off with a "[PATCH 0 of N]" introduction,
+which describes the series as a whole.
+
+Each patch email has a Subject line of "[PATCH M of N] ...", using
+the first line of the changeset description as the subject text.
+The message contains two or three body parts:
+
+  The remainder of the changeset description.
+
+  [Optional] If the diffstat program is installed, the result of
+  running diffstat on the patch.
+
+  The patch itself, as generated by "hg export".
+
+Each message refers to all of its predecessors using the In-Reply-To
+and References headers, so they will show up as a sequence in
+threaded mail and news readers, and in mail archives.
+
+For each changeset, you will be prompted with a diffstat summary and
+the changeset summary, so you can be sure you are sending the right changes.
+
+To enable this extension:
+
+  [extensions]
+  hgext.patchbomb =
+
+To configure other defaults, add a section like this to your hgrc file:
+
+  [email]
+  from = My Name <my@email>
+  to = recipient1, recipient2, ...
+  cc = cc1, cc2, ...
+  bcc = bcc1, bcc2, ...
+
+Then you can use the "hg email" command to mail a series of changesets
+as a patchbomb.
+
+To avoid sending patches prematurely, it is a good idea to first run
+the "email" command with the "-n" option (test only).  You will be
+prompted for an email recipient address, a subject an an introductory
+message describing the patches of your patchbomb.  Then when all is
+done, patchbomb messages are displayed. If PAGER environment variable
+is set, your pager will be fired up once for each patchbomb message, so
+you can verify everything is alright.
+
+The "-m" (mbox) option is also very useful.  Instead of previewing
+each patchbomb message in a pager or sending the messages directly,
+it will create a UNIX mailbox file with the patch emails.  This
+mailbox file can be previewed with any mail user agent which supports
+UNIX mbox files, i.e. with mutt:
+
+  % mutt -R -f mbox
+
+When you are previewing the patchbomb messages, you can use `formail'
+(a utility that is commonly installed as part of the procmail package),
+to send each message out:
+
+  % formail -s sendmail -bm -t < mbox
+
+That should be all. Now your patchbomb is on its way out.'''
 
 import os, errno, socket, tempfile, cStringIO
 import email.MIMEMultipart, email.MIMEText, email.MIMEBase
 import email.Utils, email.Encoders, email.Generator
 from mercurial import cmdutil, commands, hg, mail, patch, util
 from mercurial.i18n import _
 from mercurial.node import bin
 
 def patchbomb(ui, repo, *revs, **opts):
     '''send changesets by email
 
     By default, diffs are sent in the format generated by hg export,
     one per message.  The series starts with a "[PATCH 0 of N]"
     introduction, which describes the series as a whole.
 
     Each patch email has a Subject line of "[PATCH M of N] ...", using
     the first line of the changeset description as the subject text.
     The message contains two or three body parts.  First, the rest of
     the changeset description.  Next, (optionally) if the diffstat
     program is installed, the result of running diffstat on the patch.
     Finally, the patch itself, as generated by "hg export".
 
     With --outgoing, emails will be generated for patches not
     found in the destination repository (or only those which are
     ancestors of the specified revisions if any are provided)
 
     With --bundle, changesets are selected as for --outgoing,
     but a single email containing a binary Mercurial bundle as an
     attachment will be sent.
 
     Examples:
 
     hg email -r 3000          # send patch 3000 only
     hg email -r 3000 -r 3001  # send patches 3000 and 3001
     hg email -r 3000:3005     # send patches 3000 through 3005
     hg email 3000             # send patch 3000 (deprecated)
 
     hg email -o               # send all patches not in default
     hg email -o DEST          # send all patches not in DEST
     hg email -o -r 3000       # send all ancestors of 3000 not in default
     hg email -o -r 3000 DEST  # send all ancestors of 3000 not in DEST
 
     hg email -b               # send bundle of all patches not in default
     hg email -b DEST          # send bundle of all patches not in DEST
     hg email -b -r 3000       # bundle of all ancestors of 3000 not in default
     hg email -b -r 3000 DEST  # bundle of all ancestors of 3000 not in DEST
 
     Before using this command, you will need to enable email in your hgrc.
     See the [email] section in hgrc(5) for details.
     '''
 
     def prompt(prompt, default = None, rest = ': ', empty_ok = False):
         if not ui.interactive:
             return default
         if default:
             prompt += ' [%s]' % default
         prompt += rest
         while True:
             r = ui.prompt(prompt, default=default)
             if r:
                 return r
             if default is not None:
                 return default
             if empty_ok:
                 return r
             ui.warn(_('Please enter a valid value.\n'))
 
     def confirm(s, denial):
         if not prompt(s, default = 'y', rest = '? ').lower().startswith('y'):
             raise util.Abort(denial)
 
     def cdiffstat(summary, patchlines):
         s = patch.diffstat(patchlines)
         if s:
             if summary:
                 ui.write(summary, '\n')
                 ui.write(s, '\n')
             confirm(_('Does the diffstat above look okay'),
                     _('diffstat rejected'))
         elif s is None:
             ui.warn(_('No diffstat information available.\n'))
             s = ''
         return s
 
     def makepatch(patch, idx, total):
         desc = []
         node = None
         body = ''
         for line in patch:
             if line.startswith('#'):
                 if line.startswith('# Node ID'):
                     node = line.split()[-1]
                 continue
             if line.startswith('diff -r') or line.startswith('diff --git'):
                 break
             desc.append(line)
         if not node:
             raise ValueError
 
         if opts['attach']:
              body = ('\n'.join(desc[1:]).strip() or
                    'Patch subject is complete summary.')
              body += '\n\n\n'
 
         if opts.get('plain'):
             while patch and patch[0].startswith('# '):
                 patch.pop(0)
             if patch:
                 patch.pop(0)
             while patch and not patch[0].strip():
                 patch.pop(0)
         if opts.get('diffstat'):
             body += cdiffstat('\n'.join(desc), patch) + '\n\n'
         if opts.get('attach') or opts.get('inline'):
             msg = email.MIMEMultipart.MIMEMultipart()
             if body:
                 msg.attach(email.MIMEText.MIMEText(body, 'plain'))
             p = email.MIMEText.MIMEText('\n'.join(patch), 'x-patch')
             binnode = bin(node)
             # if node is mq patch, it will have patch file name as tag
             patchname = [t for t in repo.nodetags(binnode)
                          if t.endswith('.patch') or t.endswith('.diff')]
             if patchname:
                 patchname = patchname[0]
             elif total > 1:
                 patchname = cmdutil.make_filename(repo, '%b-%n.patch',
                                                   binnode, idx, total)
             else:
                 patchname = cmdutil.make_filename(repo, '%b.patch', binnode)
             disposition = 'inline'
             if opts['attach']:
                 disposition = 'attachment'
             p['Content-Disposition'] = disposition + '; filename=' + patchname
             msg.attach(p)
         else:
             body += '\n'.join(patch)
             msg = email.MIMEText.MIMEText(body)
 
         subj = desc[0].strip().rstrip('. ')
         if total == 1:
             subj = '[PATCH] ' + (opts.get('subject') or subj)
         else:
             tlen = len(str(total))
             subj = '[PATCH %0*d of %d] %s' % (tlen, idx, total, subj)
         msg['Subject'] = subj
         msg['X-Mercurial-Node'] = node
         return msg
 
     def outgoing(dest, revs):
         '''Return the revisions present locally but not in dest'''
         dest = ui.expandpath(dest or 'default-push', dest or 'default')
         revs = [repo.lookup(rev) for rev in revs]
         other = hg.repository(ui, dest)
         ui.status(_('comparing with %s\n') % dest)
         o = repo.findoutgoing(other)
         if not o:
             ui.status(_("no changes found\n"))
             return []
         o = repo.changelog.nodesbetween(o, revs or None)[0]
         return [str(repo.changelog.rev(r)) for r in o]
 
     def getbundle(dest):
         tmpdir = tempfile.mkdtemp(prefix='hg-email-bundle-')
         tmpfn = os.path.join(tmpdir, 'bundle')
         try:
             commands.bundle(ui, repo, tmpfn, dest, **opts)
             return open(tmpfn, 'rb').read()
         finally:
             try:
                 os.unlink(tmpfn)
             except:
                 pass
             os.rmdir(tmpdir)
 
     if not (opts.get('test') or opts.get('mbox')):
         # really sending
         mail.validateconfig(ui)
 
     if not (revs or opts.get('rev')
             or opts.get('outgoing') or opts.get('bundle')):
         raise util.Abort(_('specify at least one changeset with -r or -o'))
 
     cmdutil.setremoteconfig(ui, opts)
     if opts.get('outgoing') and opts.get('bundle'):
         raise util.Abort(_("--outgoing mode always on with --bundle;"
                            " do not re-specify --outgoing"))
 
     if opts.get('outgoing') or opts.get('bundle'):
         if len(revs) > 1:
             raise util.Abort(_("too many destinations"))
         dest = revs and revs[0] or None
         revs = []
 
     if opts.get('rev'):
         if revs:
             raise util.Abort(_('use only one form to specify the revision'))
         revs = opts.get('rev')
 
     if opts.get('outgoing'):
         revs = outgoing(dest, opts.get('rev'))
     if opts.get('bundle'):
         opts['revs'] = revs
 
     # start
     if opts.get('date'):
         start_time = util.parsedate(opts.get('date'))
     else:
         start_time = util.makedate()
 
     def genmsgid(id):
         return '<%s.%s@%s>' % (id[:20], int(start_time[0]), socket.getfqdn())
 
     def getdescription(body, sender):
         if opts.get('desc'):
             body = open(opts.get('desc')).read()
         else:
             ui.write(_('\nWrite the introductory message for the '
                        'patch series.\n\n'))
             body = ui.edit(body, sender)
         return body
 
     def getexportmsgs():
         patches = []
 
         class exportee:
             def __init__(self, container):
                 self.lines = []
                 self.container = container
                 self.name = 'email'
 
             def write(self, data):
                 self.lines.append(data)
 
             def close(self):
                 self.container.append(''.join(self.lines).split('\n'))
                 self.lines = []
 
         commands.export(ui, repo, *revs, **{'output': exportee(patches),
                                             'switch_parent': False,
                                             'text': None,
                                             'git': opts.get('git')})
 
         jumbo = []
         msgs = []
 
         ui.write(_('This patch series consists of %d patches.\n\n')
                  % len(patches))
 
         for p, i in zip(patches, xrange(len(patches))):
             jumbo.extend(p)
             msgs.append(makepatch(p, i + 1, len(patches)))
 
         if len(patches) > 1:
             tlen = len(str(len(patches)))
 
             subj = '[PATCH %0*d of %d] %s' % (
                 tlen, 0, len(patches),
                 opts.get('subject') or
                 prompt('Subject:',
                        rest=' [PATCH %0*d of %d] ' % (tlen, 0, len(patches))))
 
             body = ''
             if opts.get('diffstat'):
                 d = cdiffstat(_('Final summary:\n'), jumbo)
                 if d:
                     body = '\n' + d
 
             body = getdescription(body, sender)
             msg = email.MIMEText.MIMEText(body)
             msg['Subject'] = subj
 
             msgs.insert(0, msg)
         return msgs
 
     def getbundlemsgs(bundle):
         subj = (opts.get('subject')
                 or prompt('Subject:', default='A bundle for your repository'))
 
         body = getdescription('', sender)
         msg = email.MIMEMultipart.MIMEMultipart()
         if body:
             msg.attach(email.MIMEText.MIMEText(body, 'plain'))
         datapart = email.MIMEBase.MIMEBase('application', 'x-mercurial-bundle')
         datapart.set_payload(bundle)
         datapart.add_header('Content-Disposition', 'attachment',
                             filename='bundle.hg')
         email.Encoders.encode_base64(datapart)
         msg.attach(datapart)
         msg['Subject'] = subj
         return [msg]
 
     sender = (opts.get('from') or ui.config('email', 'from') or
               ui.config('patchbomb', 'from') or
               prompt('From', ui.username()))
 
     if opts.get('bundle'):
         msgs = getbundlemsgs(getbundle(dest))
     else:
         msgs = getexportmsgs()
 
     def getaddrs(opt, prpt, default = None):
         addrs = opts.get(opt) or (ui.config('email', opt) or
                                   ui.config('patchbomb', opt) or
                                   prompt(prpt, default = default)).split(',')
         return [a.strip() for a in addrs if a.strip()]
 
     to = getaddrs('to', 'To')
     cc = getaddrs('cc', 'Cc', '')
 
     bcc = opts.get('bcc') or (ui.config('email', 'bcc') or
                           ui.config('patchbomb', 'bcc') or '').split(',')
     bcc = [a.strip() for a in bcc if a.strip()]
 
     ui.write('\n')
 
     parent = None
 
     sender_addr = email.Utils.parseaddr(sender)[1]
     sendmail = None
     for m in msgs:
         try:
             m['Message-Id'] = genmsgid(m['X-Mercurial-Node'])
         except TypeError:
             m['Message-Id'] = genmsgid('patchbomb')
         if parent:
             m['In-Reply-To'] = parent
         else:
             parent = m['Message-Id']
         m['Date'] = util.datestr(start_time, "%a, %d %b %Y %H:%M:%S %1%2")
 
         start_time = (start_time[0] + 1, start_time[1])
         m['From'] = sender
         m['To'] = ', '.join(to)
         if cc:
             m['Cc']  = ', '.join(cc)
         if bcc:
             m['Bcc'] = ', '.join(bcc)
         if opts.get('test'):
             ui.status('Displaying ', m['Subject'], ' ...\n')
             ui.flush()
             if 'PAGER' in os.environ:
                 fp = util.popen(os.environ['PAGER'], 'w')
             else:
                 fp = ui
             generator = email.Generator.Generator(fp, mangle_from_=False)
             try:
                 generator.flatten(m, 0)
                 fp.write('\n')
             except IOError, inst:
                 if inst.errno != errno.EPIPE:
                     raise
             if fp is not ui:
                 fp.close()
         elif opts.get('mbox'):
             ui.status('Writing ', m['Subject'], ' ...\n')
             fp = open(opts.get('mbox'), 'In-Reply-To' in m and 'ab+' or 'wb+')
             generator = email.Generator.Generator(fp, mangle_from_=True)
             date = util.datestr(start_time, '%a %b %d %H:%M:%S %Y')
             fp.write('From %s %s\n' % (sender_addr, date))
             generator.flatten(m, 0)
             fp.write('\n\n')
             fp.close()
         else:
             if not sendmail:
                 sendmail = mail.connect(ui)
             ui.status('Sending ', m['Subject'], ' ...\n')
             # Exim does not remove the Bcc field
             del m['Bcc']
             fp = cStringIO.StringIO()
             generator = email.Generator.Generator(fp, mangle_from_=False)
             generator.flatten(m, 0)
             sendmail(sender, to + bcc + cc, fp.getvalue())
 
 cmdtable = {
     "email":
         (patchbomb,
          [('a', 'attach', None, _('send patches as attachments')),
           ('i', 'inline', None, _('send patches as inline attachments')),
           ('', 'bcc', [], _('email addresses of blind copy recipients')),
           ('c', 'cc', [], _('email addresses of copy recipients')),
           ('d', 'diffstat', None, _('add diffstat output to messages')),
           ('', 'date', '', _('use the given date as the sending date')),
           ('', 'desc', '', _('use the given file as the series description')),
           ('g', 'git', None, _('use git extended diff format')),
           ('f', 'from', '', _('email address of sender')),
           ('', 'plain', None, _('omit hg patch header')),
           ('n', 'test', None, _('print messages that would be sent')),
           ('m', 'mbox', '',
            _('write messages to mbox file instead of sending them')),
           ('o', 'outgoing', None,
            _('send changes not found in the target repository')),
           ('b', 'bundle', None,
            _('send changes not in target as a binary bundle')),
           ('r', 'rev', [], _('a revision to send')),
           ('s', 'subject', '',
            _('subject of first message (intro or single patch)')),
           ('t', 'to', [], _('email addresses of recipients')),
           ('', 'force', None,
            _('run even when remote repository is unrelated (with -b)')),
           ('', 'base', [],
            _('a base changeset to specify instead of a destination (with -b)')),
          ] + commands.remoteopts,
          _('hg email [OPTION]... [DEST]...'))
 }