add blank line after copyright notices and after header

contrib/hg-ssh

@@ -1,51 +1,52 b''
 #!/usr/bin/env python
 #
 # Copyright 2005-2007 by Intevation GmbH <[e-mail]>
+#
 # Author(s):
 # Thomas Arendsen Hein <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 """
 hg-ssh - a wrapper for ssh access to a limited set of mercurial repos
 
 To be used in ~/.ssh/authorized_keys with the "command" option, see sshd(8):
 command="hg-ssh path/to/repo1 /path/to/repo2 ~/repo3 ~user/repo4" ssh-dss ...
 (probably together with these other useful options:
  no-port-forwarding,no-X11-forwarding,no-agent-forwarding)
 
 This allows pull/push over ssh to to the repositories given as arguments.
 
 If all your repositories are subdirectories of a common directory, you can
 allow shorter paths with:
 command="cd path/to/my/repositories && hg-ssh repo1 subdir/repo2"
 
 You can use pattern matching of your normal shell, e.g.:
 command="cd repos && hg-ssh user/thomas/* projects/{mercurial,foo}"
 """
 
 # enable importing on demand to reduce startup time
 from mercurial import demandimport; demandimport.enable()
 
 from mercurial import dispatch
 
 import sys, os
 
 cwd = os.getcwd()
 allowed_paths = [os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
                  for path in sys.argv[1:]]
 orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?')
 
 if orig_cmd.startswith('hg -R ') and orig_cmd.endswith(' serve --stdio'):
     path = orig_cmd[6:-14]
     repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
     if repo in allowed_paths:
         dispatch.dispatch(['-R', repo, 'serve', '--stdio'])
     else:
         sys.stderr.write("Illegal repository %r\n" % repo)
         sys.exit(-1)
 else:
     sys.stderr.write("Illegal command %r\n" % orig_cmd)
     sys.exit(-1)
 

hgext/children.py

@@ -1,41 +1,42 b''
 # Mercurial extension to provide the 'hg children' command
 #
 # Copyright 2007 by Intevation GmbH <[e-mail]>
+#
 # Author(s):
 # Thomas Arendsen Hein <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from mercurial import cmdutil
 from mercurial.commands import templateopts
 from mercurial.i18n import _
 
 
 def children(ui, repo, file_=None, **opts):
     """show the children of the given or working directory revision
 
     Print the children of the working directory's revisions. If a
     revision is given via --rev/-r, the children of that revision will
     be printed. If a file argument is given, revision in which the
     file was last changed (after the working directory revision or the
     argument to --rev if given) is printed.
     """
     rev = opts.get('rev')
     if file_:
         ctx = repo.filectx(file_, changeid=rev)
     else:
         ctx = repo[rev]
 
     displayer = cmdutil.show_changeset(ui, repo, opts)
     for cctx in ctx.children():
         displayer.show(cctx)
 
 
 cmdtable = {
     "children":
         (children,
          [('r', 'rev', '', _('show children of the specified revision')),
          ] + templateopts,
          _('hg children [-r REV] [FILE]')),
 }

hgext/churn.py

@@ -1,162 +1,163 b''
 # churn.py - create a graph of revisions count grouped by template
 #
 # Copyright 2006 Josef "Jeff" Sipek <[e-mail]>
 # Copyright 2008 Alexander Solovyov <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
+
 '''command to show certain statistics about revision history'''
 
 from mercurial.i18n import _
 from mercurial import patch, cmdutil, util, templater
 import sys
 import time, datetime
 
 def maketemplater(ui, repo, tmpl):
     tmpl = templater.parsestring(tmpl, quoted=False)
     try:
         t = cmdutil.changeset_templater(ui, repo, False, None, None, False)
     except SyntaxError, inst:
         raise util.Abort(inst.args[0])
     t.use_template(tmpl)
     return t
 
 def changedlines(ui, repo, ctx1, ctx2, fns):
     lines = 0
     fmatch = cmdutil.match(repo, pats=fns)
     diff = ''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch))
     for l in diff.split('\n'):
         if (l.startswith("+") and not l.startswith("+++ ") or
             l.startswith("-") and not l.startswith("--- ")):
             lines += 1
     return lines
 
 def countrate(ui, repo, amap, *pats, **opts):
     """Calculate stats"""
     if opts.get('dateformat'):
         def getkey(ctx):
             t, tz = ctx.date()
             date = datetime.datetime(*time.gmtime(float(t) - tz)[:6])
             return date.strftime(opts['dateformat'])
     else:
         tmpl = opts.get('template', '{author|email}')
         tmpl = maketemplater(ui, repo, tmpl)
         def getkey(ctx):
             ui.pushbuffer()
             tmpl.show(ctx)
             return ui.popbuffer()
 
     count = pct = 0
     rate = {}
     df = False
     if opts.get('date'):
         df = util.matchdate(opts['date'])
 
     get = util.cachefunc(lambda r: repo[r].changeset())
     changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
     for st, rev, fns in changeiter:
         if not st == 'add':
             continue
         if df and not df(get(rev)[2][0]): # doesn't match date format
             continue
 
         ctx = repo[rev]
         key = getkey(ctx)
         key = amap.get(key, key) # alias remap
         if opts.get('changesets'):
             rate[key] = rate.get(key, 0) + 1
         else:
             parents = ctx.parents()
             if len(parents) > 1:
                 ui.note(_('Revision %d is a merge, ignoring...\n') % (rev,))
                 continue
 
             ctx1 = parents[0]
             lines = changedlines(ui, repo, ctx1, ctx, fns)
             rate[key] = rate.get(key, 0) + lines
 
         if opts.get('progress'):
             count += 1
             newpct = int(100.0 * count / max(len(repo), 1))
             if pct < newpct:
                 pct = newpct
                 ui.write("\r" + _("generating stats: %d%%") % pct)
                 sys.stdout.flush()
 
     if opts.get('progress'):
         ui.write("\r")
         sys.stdout.flush()
 
     return rate
 
 
 def churn(ui, repo, *pats, **opts):
     '''graph count of revisions grouped by template
 
     Will graph count of changed lines or revisions grouped by template
     or alternatively by date, if dateformat is used. In this case it
     will override template.
 
     By default statistics are counted for number of changed lines.
 
     Examples:
 
       # display count of changed lines for every committer
       hg churn -t '{author|email}'
 
       # display daily activity graph
       hg churn -f '%H' -s -c
 
       # display activity of developers by month
       hg churn -f '%Y-%m' -s -c
 
       # display count of lines changed in every year
       hg churn -f '%Y' -s
 
     The map file format used to specify aliases is fairly simple:
 
     <alias email> <actual email>'''
     def pad(s, l):
         return (s + " " * l)[:l]
 
     amap = {}
     aliases = opts.get('aliases')
     if aliases:
         for l in open(aliases, "r"):
             l = l.strip()
             alias, actual = l.split()
             amap[alias] = actual
 
     rate = countrate(ui, repo, amap, *pats, **opts).items()
     if not rate:
         return
 
     sortfn = ((not opts.get('sort')) and (lambda a, b: cmp(b[1], a[1])) or None)
     rate.sort(sortfn)
 
     maxcount = float(max([v for k, v in rate]))
     maxname = max([len(k) for k, v in rate])
 
     ttywidth = util.termwidth()
     ui.debug(_("assuming %i character terminal\n") % ttywidth)
     width = ttywidth - maxname - 2 - 6 - 2 - 2
 
     for date, count in rate:
         print "%s %6d %s" % (pad(date, maxname), count,
                              "*" * int(count * width / maxcount))
 
 
 cmdtable = {
     "churn":
         (churn,
          [('r', 'rev', [], _('count rate for the specified revision or range')),
           ('d', 'date', '', _('count rate for revisions matching date spec')),
           ('t', 'template', '{author|email}', _('template to group changesets')),
           ('f', 'dateformat', '',
               _('strftime-compatible format for grouping by date')),
           ('c', 'changesets', False, _('count rate by number of changesets')),
           ('s', 'sort', False, _('sort by key (default: sort by count)')),
           ('', 'aliases', '', _('file with email aliases')),
           ('', 'progress', None, _('show progress'))],
          _("hg churn [-d DATE] [-r REV] [--aliases FILE] [--progress] [FILE]")),
 }

hgext/convert/__init__.py

@@ -1,261 +1,262 b''
 # 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 version 2, incorporated herein by reference.
+
 '''converting foreign VCS repositories to Mercurial'''
 
 import convcmd
 import cvsps
 import subversion
 from mercurial import commands
 from mercurial.i18n import _
 
 # 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 [identifiers]:
     - Mercurial [hg]
     - CVS [cvs]
     - Darcs [darcs]
     - git [git]
     - Subversion [svn]
     - Monotone [mtn]
     - GNU Arch [gnuarch]
     - Bazaar [bzr]
     - Perforce [p4]
 
     Accepted destination formats [identifiers]:
     - Mercurial [hg]
     - Subversion [svn] (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 directories 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
     comma-separated values. 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.ignoreerrors=False    (boolean)
         ignore integrity errors when reading. Use it to fix Mercurial
         repositories with missing revlogs, by converting from and to
         Mercurial.
     --config convert.hg.saverev=False         (boolean)
         store original revision ID in changeset (forces target IDs to
         change)
     --config convert.hg.startrev=0            (hg revision identifier)
         convert start revision and its descendants
 
     CVS Source
     ----------
 
     CVS source will use a sandbox (i.e. a checked-out copy) from CVS
     to indicate the starting point of what will be converted. Direct
     access to the repository files is not needed, unless of course the
     repository is :local:. The conversion uses the top level directory
     in the sandbox to find the CVS repository, and then uses CVS rlog
     commands to find files to convert. This means that unless a
     filemap is given, all files under the starting directory will be
     converted, and that any directory reorganisation in the CVS
     sandbox is ignored.
 
     Because CVS does not have changesets, it is necessary to collect
     individual commits to CVS and merge them into changesets. CVS
     source uses its internal changeset merging code by default but can
     be configured to call the external 'cvsps' program by setting:
         --config convert.cvsps='cvsps -A -u --cvs-direct -q'
     This is a legacy option and may be removed in future.
 
     The options shown are the defaults.
 
     Internal cvsps is selected by setting
         --config convert.cvsps=builtin
     and has a few more configurable options:
         --config convert.cvsps.cache=True     (boolean)
             Set to False to disable remote log caching, for testing and
             debugging purposes.
         --config convert.cvsps.fuzz=60        (integer)
             Specify the maximum time (in seconds) that is allowed
             between commits with identical user and log message in a
             single changeset. When very large files were checked in as
             part of a changeset then the default may not be long
             enough.
         --config convert.cvsps.mergeto='{{mergetobranch ([-\w]+)}}'
             Specify a regular expression to which commit log messages
             are matched. If a match occurs, then the conversion
             process will insert a dummy revision merging the branch on
             which this log message occurs to the branch indicated in
             the regex.
         --config convert.cvsps.mergefrom='{{mergefrombranch ([-\w]+)}}'
             Specify a regular expression to which commit log messages
             are matched. If a match occurs, then the conversion
             process will add the most recent revision on the branch
             indicated in the regex as the second parent of the
             changeset.
 
     The hgext/convert/cvsps wrapper script allows the builtin
     changeset merging code to be run without doing a conversion. Its
     parameters and output are similar to that of cvsps 2.1.
 
     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.
 
     Perforce Source
     ---------------
 
     The Perforce (P4) importer can be given a p4 depot path or a
     client specification as source. It will convert all files in the
     source to a flat Mercurial repository, ignoring labels, branches
     and integrations. Note that when a depot path is given you then
     usually should specify a target directory, because otherwise the
     target may be named ...-hg.
 
     It is possible to limit the amount of source history to be
     converted by specifying an initial Perforce revision.
 
     --config convert.p4.startrev=0            (perforce changelist number)
         specify initial Perforce 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 subversion.debugsvnlog(ui, **opts)
 
 def debugcvsps(ui, *args, **opts):
     '''create changeset information from CVS
 
     This command is intended as a debugging tool for the CVS to
     Mercurial converter, and can be used as a direct replacement for
     cvsps.
 
     Hg debugcvsps reads the CVS rlog for current directory (or any
     named directory) in the CVS repository, and converts the log to a
     series of changesets based on matching commit log entries and
     dates.'''
     return cvsps.debugcvsps(ui, *args, **opts)
 
 commands.norepo += " convert debugsvnlog debugcvsps"
 
 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'),
     "debugcvsps":
         (debugcvsps,
          [
           # Main options shared with cvsps-2.1
           ('b', 'branches', [], _('only return changes on specified branches')),
           ('p', 'prefix', '', _('prefix to remove from file names')),
           ('r', 'revisions', [], _('only return changes after or between specified tags')),
           ('u', 'update-cache', None, _("update cvs log cache")),
           ('x', 'new-cache', None, _("create new cvs log cache")),
           ('z', 'fuzz', 60, _('set commit time fuzz in seconds')),
           ('', 'root', '', _('specify cvsroot')),
           # Options specific to builtin cvsps
           ('', 'parents', '', _('show parent changesets')),
           ('', 'ancestors', '', _('show current changeset in ancestor branches')),
           # Options that are ignored for compatibility with cvsps-2.1
           ('A', 'cvs-direct', None, _('ignored for compatibility')),
          ],
          _('hg debugcvsps [OPTION]... [PATH]...')),
 }

hgext/fetch.py

@@ -1,146 +1,147 b''
 # 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 version 2, 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, url
 from mercurial.lock import release
 
 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 branch 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.
     '''
 
     date = opts.get('date')
     if date:
         opts['date'] = util.parsedate(date)
 
     parent, p2 = repo.dirstate.parents()
     branch = repo.dirstate.branch()
     branchnode = repo.branchtags().get(branch)
     if parent != branchnode:
         raise util.Abort(_('working dir not at branch tip '
                            '(use "hg update" to check out branch 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'))
         bheads = repo.branchheads(branch)
         bheads = [head for head in bheads if len(repo[head].children()) == 0]
         if len(bheads) > 1:
             raise util.Abort(_('multiple heads in this branch '
                                '(use "hg heads ." and "hg merge" to merge)'))
 
         other = hg.repository(cmdutil.remoteui(repo, opts),
                               ui.expandpath(source))
         ui.status(_('pulling from %s\n') %
                   url.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']]
 
         # Are there any changes at all?
         modheads = repo.pull(other, heads=revs)
         if modheads == 0:
             return 0
 
         # Is this a simple fast-forward along the current branch?
         newheads = repo.branchheads(branch)
         newheads = [head for head in newheads if len(repo[head].children()) == 0]
         newchildren = repo.changelog.nodesbetween([parent], newheads)[2]
         if len(newheads) == 1:
             if newchildren[0] != parent:
                 return hg.clean(repo, newchildren[0])
             else:
                 return
 
         # Are there more than one additional branch heads?
         newchildren = [n for n in newchildren if n != parent]
         newparent = parent
         if newchildren:
             newparent = newchildren[0]
             hg.clean(repo, newparent)
         newheads = [n for n in newheads if n != newparent]
         if len(newheads) > 1:
             ui.status(_('not merging with %d other new branch heads '
                         '(use "hg heads ." and "hg merge" to merge them)\n') %
                       (len(newheads) - 1))
             return
 
         # Otherwise, let's merge.
         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') %
                         url.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)))
 
     finally:
         release(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,415 +1,416 b''
 # 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 version 2, incorporated herein by reference.
+
 '''show revision graphs in terminal windows
 
 This extension adds a --graph option to the incoming, outgoing and log
 commands. When this options is given, an ascii representation of the
 revision graph is also shown.
 '''
 
 import os
 from mercurial.cmdutil import revrange, show_changeset
 from mercurial.commands import templateopts
 from mercurial.i18n import _
 from mercurial.node import nullrev
 from mercurial import bundlerepo, changegroup, cmdutil, commands, extensions
 from mercurial import hg, url, util
 
 def revisions(repo, start, stop):
     """cset DAG generator yielding (rev, node, [parents]) tuples
 
     This generator function walks through the revision history from revision
     start to revision stop (which must be less than or equal to start).
     """
     assert start >= stop
     cur = start
     while cur >= stop:
         ctx = repo[cur]
         parents = [p.rev() for p in ctx.parents() if p.rev() != nullrev]
         parents.sort()
         yield (ctx, parents)
         cur -= 1
 
 def filerevs(repo, path, start, stop):
     """file cset DAG generator yielding (rev, node, [parents]) tuples
 
     This generator function walks through the revision history of a single
     file from revision start to revision stop (which must be less than or
     equal to start).
     """
     assert start >= stop
     filerev = len(repo.file(path)) - 1
     while filerev >= 0:
         fctx = repo.filectx(path, fileid=filerev)
         parents = [f.linkrev() for f in fctx.parents() if f.path() == path]
         parents.sort()
         if fctx.rev() <= start:
             yield (fctx, parents)
         if fctx.rev() <= stop:
             break
         filerev -= 1
 
 def grapher(nodes):
     """grapher for asciigraph on a list of nodes and their parents
 
     nodes must generate tuples (node, parents, char, lines) where
      - parents must generate the parents of node, in sorted order,
        and max length 2,
      - char is the char to print as the node symbol, and
      - lines are the lines to display next to the node.
     """
     seen = []
     for node, parents, char, lines in nodes:
         if node not in seen:
             seen.append(node)
         nodeidx = seen.index(node)
 
         knownparents = []
         newparents = []
         for parent in parents:
             if parent in seen:
                 knownparents.append(parent)
             else:
                 newparents.append(parent)
 
         ncols = len(seen)
         nextseen = seen[:]
         nextseen[nodeidx:nodeidx + 1] = newparents
         edges = [(nodeidx, nextseen.index(p)) for p in knownparents]
 
         if len(newparents) > 0:
             edges.append((nodeidx, nodeidx))
         if len(newparents) > 1:
             edges.append((nodeidx, nodeidx + 1))
         nmorecols = len(nextseen) - ncols
         seen = nextseen
         yield (char, lines, nodeidx, edges, ncols, nmorecols)
 
 def fix_long_right_edges(edges):
     for (i, (start, end)) in enumerate(edges):
         if end > start:
             edges[i] = (start, end + 1)
 
 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 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 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 ascii(ui, grapher):
     """prints an ASCII graph of the DAG returned by the grapher
 
     grapher is a generator that emits tuples with the following elements:
 
       - Character to use as node's symbol.
       - List of lines to display as the node's text.
       - 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.
     """
     prev_n_columns_diff = 0
     prev_node_index = 0
     for (node_ch, node_lines, node_index, edges, n_columns, n_columns_diff) in grapher:
 
         assert -2 < n_columns_diff < 2
         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(node_lines) > 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(node_lines) <= 2 and not add_padding_line
 
         # nodeline is the line containing the node character (typically o)
         nodeline = ["|", " "] * node_index
         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(node_lines) < len(lines):
             node_lines.append("")
         if len(lines) < len(node_lines):
             extra_interline = ["|", " "] * (n_columns + n_columns_diff)
             while len(lines) < len(node_lines):
                 lines.append(extra_interline)
 
         # print lines
         indentation_level = max(n_columns, n_columns + n_columns_diff)
         for (line, logstr) in zip(lines, node_lines):
             ln = "%-*s %s" % (2 * indentation_level, "".join(line), logstr)
             ui.write(ln.rstrip() + '\n')
 
         # ... and start over
         prev_node_index = node_index
         prev_n_columns_diff = n_columns_diff
 
 def get_revs(repo, rev_opt):
     if rev_opt:
         revs = revrange(repo, rev_opt)
         return (max(revs), min(revs))
     else:
         return (len(repo) - 1, 0)
 
 def check_unsupported_flags(opts):
     for op in ["follow", "follow_first", "date", "copies", "keyword", "remove",
                "only_merges", "user", "only_branch", "prune", "newest_first",
                "no_merges", "include", "exclude"]:
         if op in opts and opts[op]:
             raise util.Abort(_("--graph option is incompatible with --%s") % op)
 
 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.
     """
 
     check_unsupported_flags(opts)
     limit = cmdutil.loglimit(opts)
     start, stop = get_revs(repo, opts["rev"])
     stop = max(stop, start - limit + 1)
     if start == nullrev:
         return
 
     if path:
         path = util.canonpath(repo.root, os.getcwd(), path)
     if path: # could be reset in canonpath
         revdag = filerevs(repo, path, start, stop)
     else:
         revdag = revisions(repo, start, stop)
 
     graphdag = graphabledag(ui, repo, revdag, opts)
     ascii(ui, grapher(graphdag))
 
 def graphrevs(repo, nodes, opts):
     include = set(nodes)
     limit = cmdutil.loglimit(opts)
     count = 0
     for node in reversed(nodes):
         if count >= limit:
             break
         ctx = repo[node]
         parents = [p.rev() for p in ctx.parents() if p.node() in include]
         parents.sort()
         yield (ctx, parents)
         count += 1
 
 def graphabledag(ui, repo, revdag, opts):
     showparents = [ctx.node() for ctx in repo[None].parents()]
     displayer = show_changeset(ui, repo, opts, buffered=True)
     for (ctx, parents) in revdag:
         displayer.show(ctx)
         lines = displayer.hunk.pop(ctx.rev()).split('\n')[:-1]
         char = ctx.node() in showparents and '@' or 'o'
         yield (ctx.rev(), parents, char, lines)
 
 def goutgoing(ui, repo, dest=None, **opts):
     """show the outgoing changesets alongside an ASCII revision graph
 
     Print the outgoing changesets alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
 
     check_unsupported_flags(opts)
     dest, revs, checkout = hg.parseurl(
         ui.expandpath(dest or 'default-push', dest or 'default'),
         opts.get('rev'))
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
     other = hg.repository(cmdutil.remoteui(ui, opts), dest)
     ui.status(_('comparing with %s\n') % url.hidepassword(dest))
     o = repo.findoutgoing(other, force=opts.get('force'))
     if not o:
         ui.status(_("no changes found\n"))
         return
 
     o = repo.changelog.nodesbetween(o, revs)[0]
     revdag = graphrevs(repo, o, opts)
     graphdag = graphabledag(ui, repo, revdag, opts)
     ascii(ui, grapher(graphdag))
 
 def gincoming(ui, repo, source="default", **opts):
     """show the incoming changesets alongside an ASCII revision graph
 
     Print the incoming changesets alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
 
     check_unsupported_flags(opts)
     source, revs, checkout = hg.parseurl(ui.expandpath(source), opts.get('rev'))
     other = hg.repository(cmdutil.remoteui(repo, opts), source)
     ui.status(_('comparing with %s\n') % url.hidepassword(source))
     if revs:
         revs = [other.lookup(rev) for rev in revs]
     incoming = repo.findincoming(other, heads=revs, force=opts["force"])
     if not incoming:
         try:
             os.unlink(opts["bundle"])
         except:
             pass
         ui.status(_("no changes found\n"))
         return
 
     cleanup = None
     try:
 
         fname = opts["bundle"]
         if fname or not other.local():
             # create a bundle (uncompressed if other repo is not local)
             if revs is None:
                 cg = other.changegroup(incoming, "incoming")
             else:
                 cg = other.changegroupsubset(incoming, revs, 'incoming')
             bundletype = other.local() and "HG10BZ" or "HG10UN"
             fname = cleanup = changegroup.writebundle(cg, fname, bundletype)
             # keep written bundle?
             if opts["bundle"]:
                 cleanup = None
             if not other.local():
                 # use the created uncompressed bundlerepo
                 other = bundlerepo.bundlerepository(ui, repo.root, fname)
 
         chlist = other.changelog.nodesbetween(incoming, revs)[0]
         revdag = graphrevs(other, chlist, opts)
         graphdag = graphabledag(ui, repo, revdag, opts)
         ascii(ui, grapher(graphdag))
 
     finally:
         if hasattr(other, 'close'):
             other.close()
         if cleanup:
             os.unlink(cleanup)
 
 def uisetup(ui):
     '''Initialize the extension.'''
     _wrapcmd(ui, 'log', commands.table, graphlog)
     _wrapcmd(ui, 'incoming', commands.table, gincoming)
     _wrapcmd(ui, 'outgoing', commands.table, goutgoing)
 
 def _wrapcmd(ui, cmd, table, wrapfn):
     '''wrap the command'''
     def graph(orig, *args, **kwargs):
         if kwargs['graph']:
             return wrapfn(*args, **kwargs)
         return orig(*args, **kwargs)
     entry = extensions.wrapcommand(table, cmd, graph)
     entry[1].append(('G', 'graph', None, _("show the revision DAG")))
 
 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,359 b''
 # 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 version 2, incorporated herein by reference.
+
 '''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
 from mercurial.i18n import _
 
 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[node1].manifest()
         mmap2 = repo[node2].manifest()
         m = cmdutil.match(repo, files)
         modified, added, removed  = repo.status(node1, node2, m)[:3]
         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)
             chunks = patch.diff(repo, node1, node2, match=m,
                                 opts=patch.diffopts(ui, {'git': True}))
             for chunk in chunks:
                 repo.ui.write(chunk)
         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[n]
     ui.write("tree %s\n" % short(ctx.changeset()[0])) # use ctx.node() instead ??
     for p in ctx.parents():
         ui.write("parent %s\n" % p)
 
     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 = len(repo)
         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[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/parentrevspec.py

@@ -1,96 +1,97 b''
 # Mercurial extension to make it easy to refer to the parent of a revision
 #
 # Copyright (C) 2007 Alexis S. L. Carvalho <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
+
 '''\
 use suffixes to refer to ancestor revisions
 
 This extension allows you to use git-style suffixes to refer to the
 ancestors of a specific revision.
 
 For example, if you can refer to a revision as "foo", then:
 
 - foo^N = Nth parent of foo:
   foo^0 = foo
   foo^1 = first parent of foo
   foo^2 = second parent of foo
   foo^  = foo^1
 
 - foo~N = Nth first grandparent of foo
   foo~0 = foo
   foo~1 = foo^1 = foo^ = first parent of foo
   foo~2 = foo^1^1 = foo^^ = first parent of first parent of foo
 '''
 from mercurial import error
 
 def reposetup(ui, repo):
     if not repo.local():
         return
 
     class parentrevspecrepo(repo.__class__):
         def lookup(self, key):
             try:
                 _super = super(parentrevspecrepo, self)
                 return _super.lookup(key)
             except error.RepoError:
                 pass
 
             circ = key.find('^')
             tilde = key.find('~')
             if circ < 0 and tilde < 0:
                 raise
             elif circ >= 0 and tilde >= 0:
                 end = min(circ, tilde)
             else:
                 end = max(circ, tilde)
 
             cl = self.changelog
             base = key[:end]
             try:
                 node = _super.lookup(base)
             except error.RepoError:
                 # eek - reraise the first error
                 return _super.lookup(key)
 
             rev = cl.rev(node)
             suffix = key[end:]
             i = 0
             while i < len(suffix):
                 # foo^N => Nth parent of foo
                 # foo^0 == foo
                 # foo^1 == foo^ == 1st parent of foo
                 # foo^2 == 2nd parent of foo
                 if suffix[i] == '^':
                     j = i + 1
                     p = cl.parentrevs(rev)
                     if j < len(suffix) and suffix[j].isdigit():
                         j += 1
                         n = int(suffix[i+1:j])
                         if n > 2 or n == 2 and p[1] == -1:
                             raise
                     else:
                         n = 1
                     if n:
                         rev = p[n - 1]
                     i = j
                 # foo~N => Nth first grandparent of foo
                 # foo~0 = foo
                 # foo~1 = foo^1 == foo^ == 1st parent of foo
                 # foo~2 = foo^1^1 == foo^^ == 1st parent of 1st parent of foo
                 elif suffix[i] == '~':
                     j = i + 1
                     while j < len(suffix) and suffix[j].isdigit():
                         j += 1
                     if j == i + 1:
                         raise
                     n = int(suffix[i+1:j])
                     for k in xrange(n):
                         rev = cl.parentrevs(rev)[0]
                     i = j
                 else:
                     raise
             return cl.node(rev)
 
     repo.__class__ = parentrevspecrepo

hgext/win32mbcs.py

@@ -1,125 +1,126 b''
 # win32mbcs.py -- MBCS filename support for Mercurial
 #
 # Copyright (c) 2008 Shun-ichi Goto <[e-mail]>
 #
 # Version: 0.2
 # Author:  Shun-ichi Goto <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 #
+
 """allow to use MBCS path with problematic encoding.
 
 Some MBCS encodings are not good for some path operations (i.e.
 splitting path, case conversion, etc.) with its encoded bytes. We call
 such a encoding (i.e. shift_jis and big5) as "problematic encoding".
 This extension can be used to fix the issue with those encodings by
 wrapping some functions to convert to unicode string before path
 operation.
 
 This extension is usefull for:
  * Japanese Windows users using shift_jis encoding.
  * Chinese Windows users using big5 encoding.
  * All users who use a repository with one of problematic encodings on
    case-insensitive file system.
 
 This extension is not needed for:
  * Any user who use only ascii chars in path.
  * Any user who do not use any of problematic encodings.
 
 Note that there are some limitations on using this extension:
  * You should use single encoding in one repository.
  * You should set same encoding for the repository by locale or
    HGENCODING.
 
 To use this extension, enable the extension in .hg/hgrc or ~/.hgrc:
 
   [extensions]
   hgext.win32mbcs =
 
 Path encoding conversion are done between unicode and
 encoding.encoding which is decided by mercurial from current locale
 setting or HGENCODING.
 
 """
 
 import os
 from mercurial.i18n import _
 from mercurial import util, encoding
 
 def decode(arg):
     if isinstance(arg, str):
         uarg = arg.decode(encoding.encoding)
         if arg == uarg.encode(encoding.encoding):
             return uarg
         raise UnicodeError("Not local encoding")
     elif isinstance(arg, tuple):
         return tuple(map(decode, arg))
     elif isinstance(arg, list):
         return map(decode, arg)
     return arg
 
 def encode(arg):
     if isinstance(arg, unicode):
         return arg.encode(encoding.encoding)
     elif isinstance(arg, tuple):
         return tuple(map(encode, arg))
     elif isinstance(arg, list):
         return map(encode, arg)
     return arg
 
 def wrapper(func, args):
     # check argument is unicode, then call original
     for arg in args:
         if isinstance(arg, unicode):
             return func(*args)
 
     try:
         # convert arguments to unicode, call func, then convert back
         return encode(func(*decode(args)))
     except UnicodeError:
         # If not encoded with encoding.encoding, report it then
         # continue with calling original function.
         raise util.Abort(_("[win32mbcs] filename conversion fail with"
                          " %s encoding\n") % (encoding.encoding))
 
 def wrapname(name):
     idx = name.rfind('.')
     module = name[:idx]
     name = name[idx+1:]
     module = eval(module)
     func = getattr(module, name)
     def f(*args):
         return wrapper(func, args)
     try:
         f.__name__ = func.__name__                # fail with python23
     except Exception:
         pass
     setattr(module, name, f)
 
 # List of functions to be wrapped.
 # NOTE: os.path.dirname() and os.path.basename() are safe because
 #       they use result of os.path.split()
 funcs = '''os.path.join os.path.split os.path.splitext
  os.path.splitunc os.path.normpath os.path.normcase os.makedirs
  util.endswithsep util.splitpath util.checkcase util.fspath'''
 
 # codec and alias names of sjis and big5 to be faked.
 problematic_encodings = '''big5 big5-tw csbig5 big5hkscs big5-hkscs
  hkscs cp932 932 ms932 mskanji ms-kanji shift_jis csshiftjis shiftjis
  sjis s_jis shift_jis_2004 shiftjis2004 sjis_2004 sjis2004
  shift_jisx0213 shiftjisx0213 sjisx0213 s_jisx0213'''
 
 def reposetup(ui, repo):
     # TODO: decide use of config section for this extension
     if not os.path.supports_unicode_filenames:
         ui.warn(_("[win32mbcs] cannot activate on this platform.\n"))
         return
 
     # fake is only for relevant environment.
     if encoding.encoding.lower() in problematic_encodings.split():
         for f in funcs.split():
             wrapname(f)
         ui.debug(_("[win32mbcs] activated with encoding: %s\n")
                  % encoding.encoding)
 

mercurial/hbisect.py

@@ -1,144 +1,145 b''
 # changelog bisection for mercurial
 #
 # Copyright 2007 Matt Mackall
 # Copyright 2005, 2006 Benoit Boissinot <[e-mail]>
+#
 # Inspired by git bisect, extension skeleton taken from mq.py.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 import os
 from i18n import _
 from node import short, hex
 import util
 
 def bisect(changelog, state):
     """find the next node (if any) for testing during a bisect search.
     returns a (nodes, number, good) tuple.
 
     'nodes' is the final result of the bisect if 'number' is 0.
     Otherwise 'number' indicates the remaining possible candidates for
     the search and 'nodes' contains the next bisect target.
     'good' is True if bisect is searching for a first good changeset, False
     if searching for a first bad one.
     """
 
     clparents = changelog.parentrevs
     skip = set([changelog.rev(n) for n in state['skip']])
 
     def buildancestors(bad, good):
         # only the earliest bad revision matters
         badrev = min([changelog.rev(n) for n in bad])
         goodrevs = [changelog.rev(n) for n in good]
         # build ancestors array
         ancestors = [[]] * (len(changelog) + 1) # an extra for [-1]
 
         # clear good revs from array
         for node in goodrevs:
             ancestors[node] = None
         for rev in xrange(len(changelog), -1, -1):
             if ancestors[rev] is None:
                 for prev in clparents(rev):
                     ancestors[prev] = None
 
         if ancestors[badrev] is None:
             return badrev, None
         return badrev, ancestors
 
     good = 0
     badrev, ancestors = buildancestors(state['bad'], state['good'])
     if not ancestors: # looking for bad to good transition?
         good = 1
         badrev, ancestors = buildancestors(state['good'], state['bad'])
     bad = changelog.node(badrev)
     if not ancestors: # now we're confused
         raise util.Abort(_("Inconsistent state, %s:%s is good and bad")
                          % (badrev, short(bad)))
 
     # build children dict
     children = {}
     visit = [badrev]
     candidates = []
     while visit:
         rev = visit.pop(0)
         if ancestors[rev] == []:
             candidates.append(rev)
             for prev in clparents(rev):
                 if prev != -1:
                     if prev in children:
                         children[prev].append(rev)
                     else:
                         children[prev] = [rev]
                         visit.append(prev)
 
     candidates.sort()
     # have we narrowed it down to one entry?
     # or have all other possible candidates besides 'bad' have been skipped?
     tot = len(candidates)
     unskipped = [c for c in candidates if (c not in skip) and (c != badrev)]
     if tot == 1 or not unskipped:
         return ([changelog.node(rev) for rev in candidates], 0, good)
     perfect = tot // 2
 
     # find the best node to test
     best_rev = None
     best_len = -1
     poison = {}
     for rev in candidates:
         if rev in poison:
             for c in children.get(rev, []):
                 poison[c] = True # poison children
             continue
 
         a = ancestors[rev] or [rev]
         ancestors[rev] = None
 
         x = len(a) # number of ancestors
         y = tot - x # number of non-ancestors
         value = min(x, y) # how good is this test?
         if value > best_len and rev not in skip:
             best_len = value
             best_rev = rev
             if value == perfect: # found a perfect candidate? quit early
                 break
 
         if y < perfect and rev not in skip: # all downhill from here?
             for c in children.get(rev, []):
                 poison[c] = True # poison children
             continue
 
         for c in children.get(rev, []):
             if ancestors[c]:
                 ancestors[c] = list(set(ancestors[c] + a))
             else:
                 ancestors[c] = a + [c]
 
     assert best_rev is not None
     best_node = changelog.node(best_rev)
 
     return ([best_node], tot, good)
 
 
 def load_state(repo):
     state = {'good': [], 'bad': [], 'skip': []}
     if os.path.exists(repo.join("bisect.state")):
         for l in repo.opener("bisect.state"):
             kind, node = l[:-1].split()
             node = repo.lookup(node)
             if kind not in state:
                 raise util.Abort(_("unknown bisect kind %s") % kind)
             state[kind].append(node)
     return state
 
 
 def save_state(repo, state):
     f = repo.opener("bisect.state", "w", atomictemp=True)
     wlock = repo.wlock()
     try:
         for kind in state:
             for node in state[kind]:
                 f.write("%s %s\n" % (kind, hex(node)))
         f.rename()
     finally:
         wlock.release()