largefiles: teach log to handle patterns

Adding the standin to the patterns list was (possibly) harmless before, but was
wrong, because the pattern list was already updated above that code.  Now that
patterns are handled, it was actually harmful.  For example, in this test:

    $ hg log -G glob:**another*

the adjusted pattern list would have been:

    ['glob:**another*', '.hglf/.', 'glob:.hglf/**another*']

which causes every largefile in the root to be matched.


I'm not sure why 'glob:a*' picks up the rename of a -> b commit in test-log.t,
but a simple 'a' doesn't.  But it doesn't appear to be caused by the largefiles
extension.

hgext/largefiles/overrides.py

@@ -1,1365 +1,1378
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''Overridden Mercurial commands and functions for the largefiles extension'''
 
 import os
 import copy
 
 from mercurial import hg, util, cmdutil, scmutil, match as match_, \
         archival, pathutil, revset
 from mercurial.i18n import _
 from mercurial.node import hex
 
 import lfutil
 import lfcommands
 import basestore
 
 # -- Utility functions: commonly/repeatedly needed functionality ---------------
 
 def composelargefilematcher(match, manifest):
     '''create a matcher that matches only the largefiles in the original
     matcher'''
     m = copy.copy(match)
     lfile = lambda f: lfutil.standin(f) in manifest
     m._files = filter(lfile, m._files)
     m._fmap = set(m._files)
     m._always = False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: lfile(f) and origmatchfn(f)
     return m
 
 def composenormalfilematcher(match, manifest, exclude=None):
     excluded = set()
     if exclude is not None:
         excluded.update(exclude)
 
     m = copy.copy(match)
     notlfile = lambda f: not (lfutil.isstandin(f) or lfutil.standin(f) in
             manifest or f in excluded)
     m._files = filter(notlfile, m._files)
     m._fmap = set(m._files)
     m._always = False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
     return m
 
 def installnormalfilesmatchfn(manifest):
     '''installmatchfn with a matchfn that ignores all largefiles'''
     def overridematch(ctx, pats=[], opts={}, globbed=False,
             default='relpath'):
         match = oldmatch(ctx, pats, opts, globbed, default)
         return composenormalfilematcher(match, manifest)
     oldmatch = installmatchfn(overridematch)
 
 def installmatchfn(f):
     '''monkey patch the scmutil module with a custom match function.
     Warning: it is monkey patching the _module_ on runtime! Not thread safe!'''
     oldmatch = scmutil.match
     setattr(f, 'oldmatch', oldmatch)
     scmutil.match = f
     return oldmatch
 
 def restorematchfn():
     '''restores scmutil.match to what it was before installmatchfn
     was called.  no-op if scmutil.match is its original function.
 
     Note that n calls to installmatchfn will require n calls to
     restore the original matchfn.'''
     scmutil.match = getattr(scmutil.match, 'oldmatch')
 
 def installmatchandpatsfn(f):
     oldmatchandpats = scmutil.matchandpats
     setattr(f, 'oldmatchandpats', oldmatchandpats)
     scmutil.matchandpats = f
     return oldmatchandpats
 
 def restorematchandpatsfn():
     '''restores scmutil.matchandpats to what it was before
     installmatchandpatsfn was called. No-op if scmutil.matchandpats
     is its original function.
 
     Note that n calls to installmatchandpatsfn will require n calls
     to restore the original matchfn.'''
     scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats',
             scmutil.matchandpats)
 
 def addlargefiles(ui, repo, isaddremove, matcher, **opts):
     large = opts.get('large')
     lfsize = lfutil.getminsize(
         ui, lfutil.islfilesrepo(repo), opts.get('lfsize'))
 
     lfmatcher = None
     if lfutil.islfilesrepo(repo):
         lfpats = ui.configlist(lfutil.longname, 'patterns', default=[])
         if lfpats:
             lfmatcher = match_.match(repo.root, '', list(lfpats))
 
     lfnames = []
     m = copy.copy(matcher)
     m.bad = lambda x, y: None
     wctx = repo[None]
     for f in repo.walk(m):
         exact = m.exact(f)
         lfile = lfutil.standin(f) in wctx
         nfile = f in wctx
         exists = lfile or nfile
 
         # addremove in core gets fancy with the name, add doesn't
         if isaddremove:
             name = m.uipath(f)
         else:
             name = m.rel(f)
 
         # Don't warn the user when they attempt to add a normal tracked file.
         # The normal add code will do that for us.
         if exact and exists:
             if lfile:
                 ui.warn(_('%s already a largefile\n') % name)
             continue
 
         if (exact or not exists) and not lfutil.isstandin(f):
             # In case the file was removed previously, but not committed
             # (issue3507)
             if not repo.wvfs.exists(f):
                 continue
 
             abovemin = (lfsize and
                         repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024)
             if large or abovemin or (lfmatcher and lfmatcher(f)):
                 lfnames.append(f)
                 if ui.verbose or not exact:
                     ui.status(_('adding %s as a largefile\n') % name)
 
     bad = []
 
     # Need to lock, otherwise there could be a race condition between
     # when standins are created and added to the repo.
     wlock = repo.wlock()
     try:
         if not opts.get('dry_run'):
             standins = []
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for f in lfnames:
                 standinname = lfutil.standin(f)
                 lfutil.writestandin(repo, standinname, hash='',
                     executable=lfutil.getexecutable(repo.wjoin(f)))
                 standins.append(standinname)
                 if lfdirstate[f] == 'r':
                     lfdirstate.normallookup(f)
                 else:
                     lfdirstate.add(f)
             lfdirstate.write()
             bad += [lfutil.splitstandin(f)
                     for f in repo[None].add(standins)
                     if f in m.files()]
 
         added = [f for f in lfnames if f not in bad]
     finally:
         wlock.release()
     return added, bad
 
 def removelargefiles(ui, repo, isaddremove, matcher, **opts):
     after = opts.get('after')
     m = composelargefilematcher(matcher, repo[None].manifest())
     try:
         repo.lfstatus = True
         s = repo.status(match=m, clean=not isaddremove)
     finally:
         repo.lfstatus = False
     manifest = repo[None].manifest()
     modified, added, deleted, clean = [[f for f in list
                                         if lfutil.standin(f) in manifest]
                                        for list in (s.modified, s.added,
                                                     s.deleted, s.clean)]
 
     def warn(files, msg):
         for f in files:
             ui.warn(msg % m.rel(f))
         return int(len(files) > 0)
 
     result = 0
 
     if after:
         remove = deleted
         result = warn(modified + added + clean,
                       _('not removing %s: file still exists\n'))
     else:
         remove = deleted + clean
         result = warn(modified, _('not removing %s: file is modified (use -f'
                                   ' to force removal)\n'))
         result = warn(added, _('not removing %s: file has been marked for add'
                                ' (use forget to undo)\n')) or result
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in sorted(remove):
             if ui.verbose or not m.exact(f):
                 # addremove in core gets fancy with the name, remove doesn't
                 if isaddremove:
                     name = m.uipath(f)
                 else:
                     name = m.rel(f)
                 ui.status(_('removing %s\n') % name)
 
             if not opts.get('dry_run'):
                 if not after:
                     util.unlinkpath(repo.wjoin(f), ignoremissing=True)
 
         if opts.get('dry_run'):
             return result
 
         remove = [lfutil.standin(f) for f in remove]
         # If this is being called by addremove, let the original addremove
         # function handle this.
         if not isaddremove:
             for f in remove:
                 util.unlinkpath(repo.wjoin(f), ignoremissing=True)
         repo[None].forget(remove)
 
         for f in remove:
             lfutil.synclfdirstate(repo, lfdirstate, lfutil.splitstandin(f),
                                   False)
 
         lfdirstate.write()
     finally:
         wlock.release()
 
     return result
 
 # For overriding mercurial.hgweb.webcommands so that largefiles will
 # appear at their right place in the manifests.
 def decodepath(orig, path):
     return lfutil.splitstandin(path) or path
 
 # -- Wrappers: modify existing commands --------------------------------
 
 def overrideadd(orig, ui, repo, *pats, **opts):
     if opts.get('normal') and opts.get('large'):
         raise util.Abort(_('--normal cannot be used with --large'))
     return orig(ui, repo, *pats, **opts)
 
 def cmdutiladd(orig, ui, repo, matcher, prefix, explicitonly, **opts):
     # The --normal flag short circuits this override
     if opts.get('normal'):
         return orig(ui, repo, matcher, prefix, explicitonly, **opts)
 
     ladded, lbad = addlargefiles(ui, repo, False, matcher, **opts)
     normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(),
                                              ladded)
     bad = orig(ui, repo, normalmatcher, prefix, explicitonly, **opts)
 
     bad.extend(f for f in lbad)
     return bad
 
 def cmdutilremove(orig, ui, repo, matcher, prefix, after, force, subrepos):
     normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())
     result = orig(ui, repo, normalmatcher, prefix, after, force, subrepos)
     return removelargefiles(ui, repo, False, matcher, after=after,
                             force=force) or result
 
 def overridestatusfn(orig, repo, rev2, **opts):
     try:
         repo._repo.lfstatus = True
         return orig(repo, rev2, **opts)
     finally:
         repo._repo.lfstatus = False
 
 def overridestatus(orig, ui, repo, *pats, **opts):
     try:
         repo.lfstatus = True
         return orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
 def overridedirty(orig, repo, ignoreupdate=False):
     try:
         repo._repo.lfstatus = True
         return orig(repo, ignoreupdate)
     finally:
         repo._repo.lfstatus = False
 
 def overridelog(orig, ui, repo, *pats, **opts):
     def overridematchandpats(ctx, pats=[], opts={}, globbed=False,
             default='relpath'):
         """Matcher that merges root directory with .hglf, suitable for log.
         It is still possible to match .hglf directly.
         For any listed files run log on the standin too.
         matchfn tries both the given filename and with .hglf stripped.
         """
         matchandpats = oldmatchandpats(ctx, pats, opts, globbed, default)
         m, p = copy.copy(matchandpats)
 
         if m.always():
             # We want to match everything anyway, so there's no benefit trying
             # to add standins.
             return matchandpats
 
         pats = set(p)
-        # TODO: handling of patterns in both cases below
+
+        def fixpats(pat, tostandin=lfutil.standin):
+            kindpat = match_._patsplit(pat, None)
+
+            if kindpat[0] is not None:
+                return kindpat[0] + ':' + tostandin(kindpat[1])
+            return tostandin(kindpat[1])
+
         if m._cwd:
             if os.path.isabs(m._cwd):
                 # TODO: handle largefile magic when invoked from other cwd
                 return matchandpats
             back = (m._cwd.count('/') + 1) * '../'
-            pats.update(back + lfutil.standin(m._cwd + '/' + f) for f in p)
+
+            def tostandin(f):
+                return back + lfutil.standin(m._cwd + '/' + f)
+
+            pats.update(fixpats(f, tostandin) for f in p)
         else:
-            pats.update(lfutil.standin(f) for f in p)
+            pats.update(fixpats(f) for f in p)
 
         for i in range(0, len(m._files)):
+            # Don't add '.hglf' to m.files, since that is already covered by '.'
+            if m._files[i] == '.':
+                continue
             standin = lfutil.standin(m._files[i])
             # If the "standin" is a directory, append instead of replace to
             # support naming a directory on the command line with only
             # largefiles.  The original directory is kept to support normal
             # files.
             if standin in repo[ctx.node()]:
                 m._files[i] = standin
             elif m._files[i] not in repo[ctx.node()] \
                     and repo.wvfs.isdir(standin):
                 m._files.append(standin)
-            pats.add(standin)
 
         m._fmap = set(m._files)
         m._always = False
         origmatchfn = m.matchfn
         def lfmatchfn(f):
             lf = lfutil.splitstandin(f)
             if lf is not None and origmatchfn(lf):
                 return True
             r = origmatchfn(f)
             return r
         m.matchfn = lfmatchfn
 
         return m, pats
 
     # For hg log --patch, the match object is used in two different senses:
     # (1) to determine what revisions should be printed out, and
     # (2) to determine what files to print out diffs for.
     # The magic matchandpats override should be used for case (1) but not for
     # case (2).
     def overridemakelogfilematcher(repo, pats, opts):
         pctx = repo[None]
         match, pats = oldmatchandpats(pctx, pats, opts)
         return lambda rev: match
 
     oldmatchandpats = installmatchandpatsfn(overridematchandpats)
     oldmakelogfilematcher = cmdutil._makenofollowlogfilematcher
     setattr(cmdutil, '_makenofollowlogfilematcher', overridemakelogfilematcher)
 
     try:
         return orig(ui, repo, *pats, **opts)
     finally:
         restorematchandpatsfn()
         setattr(cmdutil, '_makenofollowlogfilematcher', oldmakelogfilematcher)
 
 def overrideverify(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     all = opts.pop('lfa', False)
     contents = opts.pop('lfc', False)
 
     result = orig(ui, repo, *pats, **opts)
     if large or all or contents:
         result = result or lfcommands.verifylfiles(ui, repo, all, contents)
     return result
 
 def overridedebugstate(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     if large:
         class fakerepo(object):
             dirstate = lfutil.openlfdirstate(ui, repo)
         orig(ui, fakerepo, *pats, **opts)
     else:
         orig(ui, repo, *pats, **opts)
 
 # Override needs to refresh standins so that update's normal merge
 # will go through properly. Then the other update hook (overriding repo.update)
 # will get the new files. Filemerge is also overridden so that the merge
 # will merge standins correctly.
 def overrideupdate(orig, ui, repo, *pats, **opts):
     # Need to lock between the standins getting updated and their
     # largefiles getting updated
     wlock = repo.wlock()
     try:
         if opts['check']:
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             unsure, s = lfdirstate.status(
                 match_.always(repo.root, repo.getcwd()),
                 [], False, False, False)
 
             mod = len(s.modified) > 0
             for lfile in unsure:
                 standin = lfutil.standin(lfile)
                 if repo['.'][standin].data().strip() != \
                         lfutil.hashfile(repo.wjoin(lfile)):
                     mod = True
                 else:
                     lfdirstate.normal(lfile)
             lfdirstate.write()
             if mod:
                 raise util.Abort(_('uncommitted changes'))
         return orig(ui, repo, *pats, **opts)
     finally:
         wlock.release()
 
 # Before starting the manifest merge, merge.updates will call
 # _checkunknownfile to check if there are any files in the merged-in
 # changeset that collide with unknown files in the working copy.
 #
 # The largefiles are seen as unknown, so this prevents us from merging
 # in a file 'foo' if we already have a largefile with the same name.
 #
 # The overridden function filters the unknown files by removing any
 # largefiles. This makes the merge proceed and we can then handle this
 # case further in the overridden calculateupdates function below.
 def overridecheckunknownfile(origfn, repo, wctx, mctx, f, f2=None):
     if lfutil.standin(repo.dirstate.normalize(f)) in wctx:
         return False
     return origfn(repo, wctx, mctx, f, f2)
 
 # The manifest merge handles conflicts on the manifest level. We want
 # to handle changes in largefile-ness of files at this level too.
 #
 # The strategy is to run the original calculateupdates and then process
 # the action list it outputs. There are two cases we need to deal with:
 #
 # 1. Normal file in p1, largefile in p2. Here the largefile is
 #    detected via its standin file, which will enter the working copy
 #    with a "get" action. It is not "merge" since the standin is all
 #    Mercurial is concerned with at this level -- the link to the
 #    existing normal file is not relevant here.
 #
 # 2. Largefile in p1, normal file in p2. Here we get a "merge" action
 #    since the largefile will be present in the working copy and
 #    different from the normal file in p2. Mercurial therefore
 #    triggers a merge action.
 #
 # In both cases, we prompt the user and emit new actions to either
 # remove the standin (if the normal file was kept) or to remove the
 # normal file and get the standin (if the largefile was kept). The
 # default prompt answer is to use the largefile version since it was
 # presumably changed on purpose.
 #
 # Finally, the merge.applyupdates function will then take care of
 # writing the files into the working copy and lfcommands.updatelfiles
 # will update the largefiles.
 def overridecalculateupdates(origfn, repo, p1, p2, pas, branchmerge, force,
                              partial, acceptremote, followcopies):
     overwrite = force and not branchmerge
     actions, diverge, renamedelete = origfn(
         repo, p1, p2, pas, branchmerge, force, partial, acceptremote,
         followcopies)
 
     if overwrite:
         return actions, diverge, renamedelete
 
     # Convert to dictionary with filename as key and action as value.
     lfiles = set()
     for f in actions:
         splitstandin = f and lfutil.splitstandin(f)
         if splitstandin in p1:
             lfiles.add(splitstandin)
         elif lfutil.standin(f) in p1:
             lfiles.add(f)
 
     for lfile in lfiles:
         standin = lfutil.standin(lfile)
         (lm, largs, lmsg) = actions.get(lfile, (None, None, None))
         (sm, sargs, smsg) = actions.get(standin, (None, None, None))
         if sm in ('g', 'dc') and lm != 'r':
             # Case 1: normal file in the working copy, largefile in
             # the second parent
             usermsg = _('remote turned local normal file %s into a largefile\n'
                         'use (l)argefile or keep (n)ormal file?'
                         '$$ &Largefile $$ &Normal file') % lfile
             if repo.ui.promptchoice(usermsg, 0) == 0: # pick remote largefile
                 actions[lfile] = ('r', None, 'replaced by standin')
                 actions[standin] = ('g', sargs, 'replaces standin')
             else: # keep local normal file
                 actions[lfile] = ('k', None, 'replaces standin')
                 if branchmerge:
                     actions[standin] = ('k', None, 'replaced by non-standin')
                 else:
                     actions[standin] = ('r', None, 'replaced by non-standin')
         elif lm in ('g', 'dc') and sm != 'r':
             # Case 2: largefile in the working copy, normal file in
             # the second parent
             usermsg = _('remote turned local largefile %s into a normal file\n'
                     'keep (l)argefile or use (n)ormal file?'
                     '$$ &Largefile $$ &Normal file') % lfile
             if repo.ui.promptchoice(usermsg, 0) == 0: # keep local largefile
                 if branchmerge:
                     # largefile can be restored from standin safely
                     actions[lfile] = ('k', None, 'replaced by standin')
                     actions[standin] = ('k', None, 'replaces standin')
                 else:
                     # "lfile" should be marked as "removed" without
                     # removal of itself
                     actions[lfile] = ('lfmr', None,
                                       'forget non-standin largefile')
 
                     # linear-merge should treat this largefile as 're-added'
                     actions[standin] = ('a', None, 'keep standin')
             else: # pick remote normal file
                 actions[lfile] = ('g', largs, 'replaces standin')
                 actions[standin] = ('r', None, 'replaced by non-standin')
 
     return actions, diverge, renamedelete
 
 def mergerecordupdates(orig, repo, actions, branchmerge):
     if 'lfmr' in actions:
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         for lfile, args, msg in actions['lfmr']:
             # this should be executed before 'orig', to execute 'remove'
             # before all other actions
             repo.dirstate.remove(lfile)
             # make sure lfile doesn't get synclfdirstate'd as normal
             lfdirstate.add(lfile)
         lfdirstate.write()
 
     return orig(repo, actions, branchmerge)
 
 
 # Override filemerge to prompt the user about how they wish to merge
 # largefiles. This will handle identical edits without prompting the user.
 def overridefilemerge(origfn, repo, mynode, orig, fcd, fco, fca, labels=None):
     if not lfutil.isstandin(orig):
         return origfn(repo, mynode, orig, fcd, fco, fca, labels=labels)
 
     ahash = fca.data().strip().lower()
     dhash = fcd.data().strip().lower()
     ohash = fco.data().strip().lower()
     if (ohash != ahash and
         ohash != dhash and
         (dhash == ahash or
          repo.ui.promptchoice(
              _('largefile %s has a merge conflict\nancestor was %s\n'
                'keep (l)ocal %s or\ntake (o)ther %s?'
                '$$ &Local $$ &Other') %
                (lfutil.splitstandin(orig), ahash, dhash, ohash),
              0) == 1)):
         repo.wwrite(fcd.path(), fco.data(), fco.flags())
     return 0
 
 # Copy first changes the matchers to match standins instead of
 # largefiles.  Then it overrides util.copyfile in that function it
 # checks if the destination largefile already exists. It also keeps a
 # list of copied files so that the largefiles can be copied and the
 # dirstate updated.
 def overridecopy(orig, ui, repo, pats, opts, rename=False):
     # doesn't remove largefile on rename
     if len(pats) < 2:
         # this isn't legal, let the original function deal with it
         return orig(ui, repo, pats, opts, rename)
 
     # This could copy both lfiles and normal files in one command,
     # but we don't want to do that. First replace their matcher to
     # only match normal files and run it, then replace it to just
     # match largefiles and run it again.
     nonormalfiles = False
     nolfiles = False
     installnormalfilesmatchfn(repo[None].manifest())
     try:
         try:
             result = orig(ui, repo, pats, opts, rename)
         except util.Abort, e:
             if str(e) != _('no files to copy'):
                 raise e
             else:
                 nonormalfiles = True
             result = 0
     finally:
         restorematchfn()
 
     # The first rename can cause our current working directory to be removed.
     # In that case there is nothing left to copy/rename so just quit.
     try:
         repo.getcwd()
     except OSError:
         return result
 
     def makestandin(relpath):
         path = pathutil.canonpath(repo.root, repo.getcwd(), relpath)
         return os.path.join(repo.wjoin(lfutil.standin(path)))
 
     fullpats = scmutil.expandpats(pats)
     dest = fullpats[-1]
 
     if os.path.isdir(dest):
         if not os.path.isdir(makestandin(dest)):
             os.makedirs(makestandin(dest))
 
     try:
         try:
             # When we call orig below it creates the standins but we don't add
             # them to the dir state until later so lock during that time.
             wlock = repo.wlock()
 
             manifest = repo[None].manifest()
             def overridematch(ctx, pats=[], opts={}, globbed=False,
                     default='relpath'):
                 newpats = []
                 # The patterns were previously mangled to add the standin
                 # directory; we need to remove that now
                 for pat in pats:
                     if match_.patkind(pat) is None and lfutil.shortname in pat:
                         newpats.append(pat.replace(lfutil.shortname, ''))
                     else:
                         newpats.append(pat)
                 match = oldmatch(ctx, newpats, opts, globbed, default)
                 m = copy.copy(match)
                 lfile = lambda f: lfutil.standin(f) in manifest
                 m._files = [lfutil.standin(f) for f in m._files if lfile(f)]
                 m._fmap = set(m._files)
                 origmatchfn = m.matchfn
                 m.matchfn = lambda f: (lfutil.isstandin(f) and
                                     (f in manifest) and
                                     origmatchfn(lfutil.splitstandin(f)) or
                                     None)
                 return m
             oldmatch = installmatchfn(overridematch)
             listpats = []
             for pat in pats:
                 if match_.patkind(pat) is not None:
                     listpats.append(pat)
                 else:
                     listpats.append(makestandin(pat))
 
             try:
                 origcopyfile = util.copyfile
                 copiedfiles = []
                 def overridecopyfile(src, dest):
                     if (lfutil.shortname in src and
                         dest.startswith(repo.wjoin(lfutil.shortname))):
                         destlfile = dest.replace(lfutil.shortname, '')
                         if not opts['force'] and os.path.exists(destlfile):
                             raise IOError('',
                                 _('destination largefile already exists'))
                     copiedfiles.append((src, dest))
                     origcopyfile(src, dest)
 
                 util.copyfile = overridecopyfile
                 result += orig(ui, repo, listpats, opts, rename)
             finally:
                 util.copyfile = origcopyfile
 
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for (src, dest) in copiedfiles:
                 if (lfutil.shortname in src and
                     dest.startswith(repo.wjoin(lfutil.shortname))):
                     srclfile = src.replace(repo.wjoin(lfutil.standin('')), '')
                     destlfile = dest.replace(repo.wjoin(lfutil.standin('')), '')
                     destlfiledir = os.path.dirname(repo.wjoin(destlfile)) or '.'
                     if not os.path.isdir(destlfiledir):
                         os.makedirs(destlfiledir)
                     if rename:
                         os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile))
 
                         # The file is gone, but this deletes any empty parent
                         # directories as a side-effect.
                         util.unlinkpath(repo.wjoin(srclfile), True)
                         lfdirstate.remove(srclfile)
                     else:
                         util.copyfile(repo.wjoin(srclfile),
                                       repo.wjoin(destlfile))
 
                     lfdirstate.add(destlfile)
             lfdirstate.write()
         except util.Abort, e:
             if str(e) != _('no files to copy'):
                 raise e
             else:
                 nolfiles = True
     finally:
         restorematchfn()
         wlock.release()
 
     if nolfiles and nonormalfiles:
         raise util.Abort(_('no files to copy'))
 
     return result
 
 # When the user calls revert, we have to be careful to not revert any
 # changes to other largefiles accidentally. This means we have to keep
 # track of the largefiles that are being reverted so we only pull down
 # the necessary largefiles.
 #
 # Standins are only updated (to match the hash of largefiles) before
 # commits. Update the standins then run the original revert, changing
 # the matcher to hit standins instead of largefiles. Based on the
 # resulting standins update the largefiles.
 def overriderevert(orig, ui, repo, *pats, **opts):
     # Because we put the standins in a bad state (by updating them)
     # and then return them to a correct state we need to lock to
     # prevent others from changing them in their incorrect state.
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         s = lfutil.lfdirstatestatus(lfdirstate, repo)
         lfdirstate.write()
         for lfile in s.modified:
             lfutil.updatestandin(repo, lfutil.standin(lfile))
         for lfile in s.deleted:
             if (os.path.exists(repo.wjoin(lfutil.standin(lfile)))):
                 os.unlink(repo.wjoin(lfutil.standin(lfile)))
 
         oldstandins = lfutil.getstandinsstate(repo)
 
         def overridematch(ctx, pats=[], opts={}, globbed=False,
                 default='relpath'):
             match = oldmatch(ctx, pats, opts, globbed, default)
             m = copy.copy(match)
 
             # revert supports recursing into subrepos, and though largefiles
             # currently doesn't work correctly in that case, this match is
             # called, so the lfdirstate above may not be the correct one for
             # this invocation of match.
             lfdirstate = lfutil.openlfdirstate(ctx._repo.ui, ctx._repo, False)
 
             def tostandin(f):
                 if lfutil.standin(f) in ctx:
                     return lfutil.standin(f)
                 elif lfutil.standin(f) in repo[None] or lfdirstate[f] == 'r':
                     return None
                 return f
             m._files = [tostandin(f) for f in m._files]
             m._files = [f for f in m._files if f is not None]
             m._fmap = set(m._files)
             origmatchfn = m.matchfn
             def matchfn(f):
                 if lfutil.isstandin(f):
                     return (origmatchfn(lfutil.splitstandin(f)) and
                             (f in repo[None] or f in ctx))
                 return origmatchfn(f)
             m.matchfn = matchfn
             return m
         oldmatch = installmatchfn(overridematch)
         try:
             orig(ui, repo, *pats, **opts)
         finally:
             restorematchfn()
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
         # lfdirstate should be 'normallookup'-ed for updated files,
         # because reverting doesn't touch dirstate for 'normal' files
         # when target revision is explicitly specified: in such case,
         # 'n' and valid timestamp in dirstate doesn't ensure 'clean'
         # of target (standin) file.
         lfcommands.updatelfiles(ui, repo, filelist, printmessage=False,
                                 normallookup=True)
 
     finally:
         wlock.release()
 
 # after pulling changesets, we need to take some extra care to get
 # largefiles updated remotely
 def overridepull(orig, ui, repo, source=None, **opts):
     revsprepull = len(repo)
     if not source:
         source = 'default'
     repo.lfpullsource = source
     result = orig(ui, repo, source, **opts)
     revspostpull = len(repo)
     lfrevs = opts.get('lfrev', [])
     if opts.get('all_largefiles'):
         lfrevs.append('pulled()')
     if lfrevs and revspostpull > revsprepull:
         numcached = 0
         repo.firstpulled = revsprepull # for pulled() revset expression
         try:
             for rev in scmutil.revrange(repo, lfrevs):
                 ui.note(_('pulling largefiles for revision %s\n') % rev)
                 (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
                 numcached += len(cached)
         finally:
             del repo.firstpulled
         ui.status(_("%d largefiles cached\n") % numcached)
     return result
 
 def pulledrevsetsymbol(repo, subset, x):
     """``pulled()``
     Changesets that just has been pulled.
 
     Only available with largefiles from pull --lfrev expressions.
 
     .. container:: verbose
 
       Some examples:
 
       - pull largefiles for all new changesets::
 
           hg pull -lfrev "pulled()"
 
       - pull largefiles for all new branch heads::
 
           hg pull -lfrev "head(pulled()) and not closed()"
 
     """
 
     try:
         firstpulled = repo.firstpulled
     except AttributeError:
         raise util.Abort(_("pulled() only available in --lfrev"))
     return revset.baseset([r for r in subset if r >= firstpulled])
 
 def overrideclone(orig, ui, source, dest=None, **opts):
     d = dest
     if d is None:
         d = hg.defaultdest(source)
     if opts.get('all_largefiles') and not hg.islocal(d):
             raise util.Abort(_(
             '--all-largefiles is incompatible with non-local destination %s') %
             d)
 
     return orig(ui, source, dest, **opts)
 
 def hgclone(orig, ui, opts, *args, **kwargs):
     result = orig(ui, opts, *args, **kwargs)
 
     if result is not None:
         sourcerepo, destrepo = result
         repo = destrepo.local()
 
         # If largefiles is required for this repo, permanently enable it locally
         if 'largefiles' in repo.requirements:
             fp = repo.vfs('hgrc', 'a', text=True)
             try:
                 fp.write('\n[extensions]\nlargefiles=\n')
             finally:
                 fp.close()
 
         # Caching is implicitly limited to 'rev' option, since the dest repo was
         # truncated at that point.  The user may expect a download count with
         # this option, so attempt whether or not this is a largefile repo.
         if opts.get('all_largefiles'):
             success, missing = lfcommands.downloadlfiles(ui, repo, None)
 
             if missing != 0:
                 return None
 
     return result
 
 def overriderebase(orig, ui, repo, **opts):
     if not util.safehasattr(repo, '_largefilesenabled'):
         return orig(ui, repo, **opts)
 
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         return orig(ui, repo, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
 
 def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None,
             prefix='', mtime=None, subrepos=None):
     # No need to lock because we are only reading history and
     # largefile caches, neither of which are modified.
     lfcommands.cachelfiles(repo.ui, repo, node)
 
     if kind not in archival.archivers:
         raise util.Abort(_("unknown archive type '%s'") % kind)
 
     ctx = repo[node]
 
     if kind == 'files':
         if prefix:
             raise util.Abort(
                 _('cannot give prefix when archiving to files'))
     else:
         prefix = archival.tidyprefix(dest, kind, prefix)
 
     def write(name, mode, islink, getdata):
         if matchfn and not matchfn(name):
             return
         data = getdata()
         if decode:
             data = repo.wwritedata(name, data)
         archiver.addfile(prefix + name, mode, islink, data)
 
     archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
 
     if repo.ui.configbool("ui", "archivemeta", True):
         def metadata():
             base = 'repo: %s\nnode: %s\nbranch: %s\n' % (
                 hex(repo.changelog.node(0)), hex(node), ctx.branch())
 
             tags = ''.join('tag: %s\n' % t for t in ctx.tags()
                            if repo.tagtype(t) == 'global')
             if not tags:
                 repo.ui.pushbuffer()
                 opts = {'template': '{latesttag}\n{latesttagdistance}',
                         'style': '', 'patch': None, 'git': None}
                 cmdutil.show_changeset(repo.ui, repo, opts).show(ctx)
                 ltags, dist = repo.ui.popbuffer().split('\n')
                 tags = ''.join('latesttag: %s\n' % t for t in ltags.split(':'))
                 tags += 'latesttagdistance: %s\n' % dist
 
             return base + tags
 
         write('.hg_archival.txt', 0644, False, metadata)
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         if lfutil.isstandin(f):
             path = lfutil.findfile(repo, getdata().strip())
             if path is None:
                 raise util.Abort(
                     _('largefile %s not found in repo store or system cache')
                     % lfutil.splitstandin(f))
             f = lfutil.splitstandin(f)
 
             def getdatafn():
                 fd = None
                 try:
                     fd = open(path, 'rb')
                     return fd.read()
                 finally:
                     if fd:
                         fd.close()
 
             getdata = getdatafn
         write(f, 'x' in ff and 0755 or 0644, 'l' in ff, getdata)
 
     if subrepos:
         for subpath in sorted(ctx.substate):
             sub = ctx.sub(subpath)
             submatch = match_.narrowmatcher(subpath, matchfn)
             sub.archive(archiver, prefix, submatch)
 
     archiver.done()
 
 def hgsubrepoarchive(orig, repo, archiver, prefix, match=None):
     repo._get(repo._state + ('hg',))
     rev = repo._state[1]
     ctx = repo._repo[rev]
 
     lfcommands.cachelfiles(repo.ui, repo._repo, ctx.node())
 
     def write(name, mode, islink, getdata):
         # At this point, the standin has been replaced with the largefile name,
         # so the normal matcher works here without the lfutil variants.
         if match and not match(f):
             return
         data = getdata()
 
         archiver.addfile(prefix + repo._path + '/' + name, mode, islink, data)
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         if lfutil.isstandin(f):
             path = lfutil.findfile(repo._repo, getdata().strip())
             if path is None:
                 raise util.Abort(
                     _('largefile %s not found in repo store or system cache')
                     % lfutil.splitstandin(f))
             f = lfutil.splitstandin(f)
 
             def getdatafn():
                 fd = None
                 try:
                     fd = open(os.path.join(prefix, path), 'rb')
                     return fd.read()
                 finally:
                     if fd:
                         fd.close()
 
             getdata = getdatafn
 
         write(f, 'x' in ff and 0755 or 0644, 'l' in ff, getdata)
 
     for subpath in sorted(ctx.substate):
         sub = ctx.sub(subpath)
         submatch = match_.narrowmatcher(subpath, match)
         sub.archive(archiver, os.path.join(prefix, repo._path) + '/', submatch)
 
 # If a largefile is modified, the change is not reflected in its
 # standin until a commit. cmdutil.bailifchanged() raises an exception
 # if the repo has uncommitted changes. Wrap it to also check if
 # largefiles were changed. This is used by bisect, backout and fetch.
 def overridebailifchanged(orig, repo):
     orig(repo)
     repo.lfstatus = True
     s = repo.status()
     repo.lfstatus = False
     if s.modified or s.added or s.removed or s.deleted:
         raise util.Abort(_('uncommitted changes'))
 
 def cmdutilforget(orig, ui, repo, match, prefix, explicitonly):
     normalmatcher = composenormalfilematcher(match, repo[None].manifest())
     bad, forgot = orig(ui, repo, normalmatcher, prefix, explicitonly)
     m = composelargefilematcher(match, repo[None].manifest())
 
     try:
         repo.lfstatus = True
         s = repo.status(match=m, clean=True)
     finally:
         repo.lfstatus = False
     forget = sorted(s.modified + s.added + s.deleted + s.clean)
     forget = [f for f in forget if lfutil.standin(f) in repo[None].manifest()]
 
     for f in forget:
         if lfutil.standin(f) not in repo.dirstate and not \
                 repo.wvfs.isdir(lfutil.standin(f)):
             ui.warn(_('not removing %s: file is already untracked\n')
                     % m.rel(f))
             bad.append(f)
 
     for f in forget:
         if ui.verbose or not m.exact(f):
             ui.status(_('removing %s\n') % m.rel(f))
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in forget:
             if lfdirstate[f] == 'a':
                 lfdirstate.drop(f)
             else:
                 lfdirstate.remove(f)
         lfdirstate.write()
         standins = [lfutil.standin(f) for f in forget]
         for f in standins:
             util.unlinkpath(repo.wjoin(f), ignoremissing=True)
         rejected = repo[None].forget(standins)
     finally:
         wlock.release()
 
     bad.extend(f for f in rejected if f in m.files())
     forgot.extend(f for f in forget if f not in rejected)
     return bad, forgot
 
 def _getoutgoings(repo, other, missing, addfunc):
     """get pairs of filename and largefile hash in outgoing revisions
     in 'missing'.
 
     largefiles already existing on 'other' repository are ignored.
 
     'addfunc' is invoked with each unique pairs of filename and
     largefile hash value.
     """
     knowns = set()
     lfhashes = set()
     def dedup(fn, lfhash):
         k = (fn, lfhash)
         if k not in knowns:
             knowns.add(k)
             lfhashes.add(lfhash)
     lfutil.getlfilestoupload(repo, missing, dedup)
     if lfhashes:
         lfexists = basestore._openstore(repo, other).exists(lfhashes)
         for fn, lfhash in knowns:
             if not lfexists[lfhash]: # lfhash doesn't exist on "other"
                 addfunc(fn, lfhash)
 
 def outgoinghook(ui, repo, other, opts, missing):
     if opts.pop('large', None):
         lfhashes = set()
         if ui.debugflag:
             toupload = {}
             def addfunc(fn, lfhash):
                 if fn not in toupload:
                     toupload[fn] = []
                 toupload[fn].append(lfhash)
                 lfhashes.add(lfhash)
             def showhashes(fn):
                 for lfhash in sorted(toupload[fn]):
                     ui.debug('    %s\n' % (lfhash))
         else:
             toupload = set()
             def addfunc(fn, lfhash):
                 toupload.add(fn)
                 lfhashes.add(lfhash)
             def showhashes(fn):
                 pass
         _getoutgoings(repo, other, missing, addfunc)
 
         if not toupload:
             ui.status(_('largefiles: no files to upload\n'))
         else:
             ui.status(_('largefiles to upload (%d entities):\n')
                       % (len(lfhashes)))
             for file in sorted(toupload):
                 ui.status(lfutil.splitstandin(file) + '\n')
                 showhashes(file)
             ui.status('\n')
 
 def summaryremotehook(ui, repo, opts, changes):
     largeopt = opts.get('large', False)
     if changes is None:
         if largeopt:
             return (False, True) # only outgoing check is needed
         else:
             return (False, False)
     elif largeopt:
         url, branch, peer, outgoing = changes[1]
         if peer is None:
             # i18n: column positioning for "hg summary"
             ui.status(_('largefiles: (no remote repo)\n'))
             return
 
         toupload = set()
         lfhashes = set()
         def addfunc(fn, lfhash):
             toupload.add(fn)
             lfhashes.add(lfhash)
         _getoutgoings(repo, peer, outgoing.missing, addfunc)
 
         if not toupload:
             # i18n: column positioning for "hg summary"
             ui.status(_('largefiles: (no files to upload)\n'))
         else:
             # i18n: column positioning for "hg summary"
             ui.status(_('largefiles: %d entities for %d files to upload\n')
                       % (len(lfhashes), len(toupload)))
 
 def overridesummary(orig, ui, repo, *pats, **opts):
     try:
         repo.lfstatus = True
         orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
 def scmutiladdremove(orig, repo, matcher, prefix, opts={}, dry_run=None,
                      similarity=None):
     if not lfutil.islfilesrepo(repo):
         return orig(repo, matcher, prefix, opts, dry_run, similarity)
     # Get the list of missing largefiles so we can remove them
     lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
     unsure, s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [],
                                   False, False, False)
 
     # Call into the normal remove code, but the removing of the standin, we want
     # to have handled by original addremove.  Monkey patching here makes sure
     # we don't remove the standin in the largefiles code, preventing a very
     # confused state later.
     if s.deleted:
         m = copy.copy(matcher)
 
         # The m._files and m._map attributes are not changed to the deleted list
         # because that affects the m.exact() test, which in turn governs whether
         # or not the file name is printed, and how.  Simply limit the original
         # matches to those in the deleted status list.
         matchfn = m.matchfn
         m.matchfn = lambda f: f in s.deleted and matchfn(f)
 
         removelargefiles(repo.ui, repo, True, m, **opts)
     # Call into the normal add code, and any files that *should* be added as
     # largefiles will be
     added, bad = addlargefiles(repo.ui, repo, True, matcher, **opts)
     # Now that we've handled largefiles, hand off to the original addremove
     # function to take care of the rest.  Make sure it doesn't do anything with
     # largefiles by passing a matcher that will ignore them.
     matcher = composenormalfilematcher(matcher, repo[None].manifest(), added)
     return orig(repo, matcher, prefix, opts, dry_run, similarity)
 
 # Calling purge with --all will cause the largefiles to be deleted.
 # Override repo.status to prevent this from happening.
 def overridepurge(orig, ui, repo, *dirs, **opts):
     # XXX Monkey patching a repoview will not work. The assigned attribute will
     # be set on the unfiltered repo, but we will only lookup attributes in the
     # unfiltered repo if the lookup in the repoview object itself fails. As the
     # monkey patched method exists on the repoview class the lookup will not
     # fail. As a result, the original version will shadow the monkey patched
     # one, defeating the monkey patch.
     #
     # As a work around we use an unfiltered repo here. We should do something
     # cleaner instead.
     repo = repo.unfiltered()
     oldstatus = repo.status
     def overridestatus(node1='.', node2=None, match=None, ignored=False,
                         clean=False, unknown=False, listsubrepos=False):
         r = oldstatus(node1, node2, match, ignored, clean, unknown,
                       listsubrepos)
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         unknown = [f for f in r.unknown if lfdirstate[f] == '?']
         ignored = [f for f in r.ignored if lfdirstate[f] == '?']
         return scmutil.status(r.modified, r.added, r.removed, r.deleted,
                               unknown, ignored, r.clean)
     repo.status = overridestatus
     orig(ui, repo, *dirs, **opts)
     repo.status = oldstatus
 def overriderollback(orig, ui, repo, **opts):
     wlock = repo.wlock()
     try:
         before = repo.dirstate.parents()
         orphans = set(f for f in repo.dirstate
                       if lfutil.isstandin(f) and repo.dirstate[f] != 'r')
         result = orig(ui, repo, **opts)
         after = repo.dirstate.parents()
         if before == after:
             return result # no need to restore standins
 
         pctx = repo['.']
         for f in repo.dirstate:
             if lfutil.isstandin(f):
                 orphans.discard(f)
                 if repo.dirstate[f] == 'r':
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
                 elif f in pctx:
                     fctx = pctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                 else:
                     # content of standin is not so important in 'a',
                     # 'm' or 'n' (coming from the 2nd parent) cases
                     lfutil.writestandin(repo, f, '', False)
         for standin in orphans:
             repo.wvfs.unlinkpath(standin, ignoremissing=True)
 
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         orphans = set(lfdirstate)
         lfiles = lfutil.listlfiles(repo)
         for file in lfiles:
             lfutil.synclfdirstate(repo, lfdirstate, file, True)
             orphans.discard(file)
         for lfile in orphans:
             lfdirstate.drop(lfile)
         lfdirstate.write()
     finally:
         wlock.release()
     return result
 
 def overridetransplant(orig, ui, repo, *revs, **opts):
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         result = orig(ui, repo, *revs, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
     return result
 
 def overridecat(orig, ui, repo, file1, *pats, **opts):
     ctx = scmutil.revsingle(repo, opts.get('rev'))
     err = 1
     notbad = set()
     m = scmutil.match(ctx, (file1,) + pats, opts)
     origmatchfn = m.matchfn
     def lfmatchfn(f):
         if origmatchfn(f):
             return True
         lf = lfutil.splitstandin(f)
         if lf is None:
             return False
         notbad.add(lf)
         return origmatchfn(lf)
     m.matchfn = lfmatchfn
     origbadfn = m.bad
     def lfbadfn(f, msg):
         if not f in notbad:
             origbadfn(f, msg)
     m.bad = lfbadfn
     for f in ctx.walk(m):
         fp = cmdutil.makefileobj(repo, opts.get('output'), ctx.node(),
                                  pathname=f)
         lf = lfutil.splitstandin(f)
         if lf is None or origmatchfn(f):
             # duplicating unreachable code from commands.cat
             data = ctx[f].data()
             if opts.get('decode'):
                 data = repo.wwritedata(f, data)
             fp.write(data)
         else:
             hash = lfutil.readstandin(repo, lf, ctx.rev())
             if not lfutil.inusercache(repo.ui, hash):
                 store = basestore._openstore(repo)
                 success, missing = store.get([(lf, hash)])
                 if len(success) != 1:
                     raise util.Abort(
                         _('largefile %s is not in cache and could not be '
                           'downloaded')  % lf)
             path = lfutil.usercachepath(repo.ui, hash)
             fpin = open(path, "rb")
             for chunk in util.filechunkiter(fpin, 128 * 1024):
                 fp.write(chunk)
             fpin.close()
         fp.close()
         err = 0
     return err
 
 def mergeupdate(orig, repo, node, branchmerge, force, partial,
                 *args, **kwargs):
     wlock = repo.wlock()
     try:
         # branch |       |         |
         #  merge | force | partial | action
         # -------+-------+---------+--------------
         #    x   |   x   |    x    | linear-merge
         #    o   |   x   |    x    | branch-merge
         #    x   |   o   |    x    | overwrite (as clean update)
         #    o   |   o   |    x    | force-branch-merge (*1)
         #    x   |   x   |    o    |   (*)
         #    o   |   x   |    o    |   (*)
         #    x   |   o   |    o    | overwrite (as revert)
         #    o   |   o   |    o    |   (*)
         #
         # (*) don't care
         # (*1) deprecated, but used internally (e.g: "rebase --collapse")
 
         linearmerge = not branchmerge and not force and not partial
 
         if linearmerge or (branchmerge and force and not partial):
             # update standins for linear-merge or force-branch-merge,
             # because largefiles in the working directory may be modified
             lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
             unsure, s = lfdirstate.status(match_.always(repo.root,
                                                         repo.getcwd()),
                                           [], False, False, False)
             pctx = repo['.']
             for lfile in unsure + s.modified:
                 lfileabs = repo.wvfs.join(lfile)
                 if not os.path.exists(lfileabs):
                     continue
                 lfhash = lfutil.hashrepofile(repo, lfile)
                 standin = lfutil.standin(lfile)
                 lfutil.writestandin(repo, standin, lfhash,
                                     lfutil.getexecutable(lfileabs))
                 if (standin in pctx and
                     lfhash == lfutil.readstandin(repo, lfile, '.')):
                     lfdirstate.normal(lfile)
             for lfile in s.added:
                 lfutil.updatestandin(repo, lfutil.standin(lfile))
             lfdirstate.write()
 
         if linearmerge:
             # Only call updatelfiles on the standins that have changed
             # to save time
             oldstandins = lfutil.getstandinsstate(repo)
 
         result = orig(repo, node, branchmerge, force, partial, *args, **kwargs)
 
         filelist = None
         if linearmerge:
             newstandins = lfutil.getstandinsstate(repo)
             filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
 
         lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
                                 normallookup=partial, checked=linearmerge)
 
         return result
     finally:
         wlock.release()
 
 def scmutilmarktouched(orig, repo, files, *args, **kwargs):
     result = orig(repo, files, *args, **kwargs)
 
     filelist = [lfutil.splitstandin(f) for f in files if lfutil.isstandin(f)]
     if filelist:
         lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
                                 printmessage=False, normallookup=True)
 
     return result

tests/test-largefiles-misc.t

@@ -1,1021 +1,1053
 This file contains testcases that tend to be related to special cases or less
 common commands affecting largefile.
 
 Each sections should be independent of each others.
 
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 
 
 Test copies and moves from a directory other than root (issue3516)
 =========================================================================
 
   $ hg init lf_cpmv
   $ cd lf_cpmv
   $ mkdir dira
   $ mkdir dira/dirb
   $ touch dira/dirb/largefile
   $ hg add --large dira/dirb/largefile
   $ hg commit -m "added"
   Invoking status precommit hook
   A dira/dirb/largefile
   $ cd dira
   $ hg cp dirb/largefile foo/largefile
   $ hg ci -m "deep copy"
   Invoking status precommit hook
   A dira/foo/largefile
   $ find . | sort
   .
   ./dirb
   ./dirb/largefile
   ./foo
   ./foo/largefile
   $ hg mv foo/largefile baz/largefile
   $ hg ci -m "moved"
   Invoking status precommit hook
   A dira/baz/largefile
   R dira/foo/largefile
   $ find . | sort
   .
   ./baz
   ./baz/largefile
   ./dirb
   ./dirb/largefile
   $ cd ..
   $ hg mv dira dirc
   moving .hglf/dira/baz/largefile to .hglf/dirc/baz/largefile (glob)
   moving .hglf/dira/dirb/largefile to .hglf/dirc/dirb/largefile (glob)
   $ find * | sort
   dirc
   dirc/baz
   dirc/baz/largefile
   dirc/dirb
   dirc/dirb/largefile
 
   $ hg clone -q . ../fetch
   $ hg --config extensions.fetch= fetch ../fetch
   abort: uncommitted changes
   [255]
   $ hg up -qC
   $ cd ..
 
 Clone a local repository owned by another user
 ===================================================
 
 #if unix-permissions
 
 We have to simulate that here by setting $HOME and removing write permissions
   $ ORIGHOME="$HOME"
   $ mkdir alice
   $ HOME="`pwd`/alice"
   $ cd alice
   $ hg init pubrepo
   $ cd pubrepo
   $ dd if=/dev/zero bs=1k count=11k > a-large-file 2> /dev/null
   $ hg add --large a-large-file
   $ hg commit -m "Add a large file"
   Invoking status precommit hook
   A a-large-file
   $ cd ..
   $ chmod -R a-w pubrepo
   $ cd ..
   $ mkdir bob
   $ HOME="`pwd`/bob"
   $ cd bob
   $ hg clone --pull ../alice/pubrepo pubrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ chmod -R u+w alice/pubrepo
   $ HOME="$ORIGHOME"
 
 #endif
 
 
 Symlink to a large largefile should behave the same as a symlink to a normal file
 =====================================================================================
 
 #if symlink
 
   $ hg init largesymlink
   $ cd largesymlink
   $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null
   $ hg add --large largefile
   $ hg commit -m "commit a large file"
   Invoking status precommit hook
   A largefile
   $ ln -s largefile largelink
   $ hg add largelink
   $ hg commit -m "commit a large symlink"
   Invoking status precommit hook
   A largelink
   $ rm -f largelink
   $ hg up >/dev/null
   $ test -f largelink
   [1]
   $ test -L largelink
   [1]
   $ rm -f largelink # make next part of the test independent of the previous
   $ hg up -C >/dev/null
   $ test -f largelink
   $ test -L largelink
   $ cd ..
 
 #endif
 
 
 test for pattern matching on 'hg status':
 ==============================================
 
 
 to boost performance, largefiles checks whether specified patterns are
 related to largefiles in working directory (NOT to STANDIN) or not.
 
   $ hg init statusmatch
   $ cd statusmatch
 
   $ mkdir -p a/b/c/d
   $ echo normal > a/b/c/d/e.normal.txt
   $ hg add a/b/c/d/e.normal.txt
   $ echo large > a/b/c/d/e.large.txt
   $ hg add --large a/b/c/d/e.large.txt
   $ mkdir -p a/b/c/x
   $ echo normal > a/b/c/x/y.normal.txt
   $ hg add a/b/c/x/y.normal.txt
   $ hg commit -m 'add files'
   Invoking status precommit hook
   A a/b/c/d/e.large.txt
   A a/b/c/d/e.normal.txt
   A a/b/c/x/y.normal.txt
 
 (1) no pattern: no performance boost
   $ hg status -A
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 (2) pattern not related to largefiles: performance boost
   $ hg status -A a/b/c/x
   C a/b/c/x/y.normal.txt
 
 (3) pattern related to largefiles: no performance boost
   $ hg status -A a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
 
 (4) pattern related to STANDIN (not to largefiles): performance boost
   $ hg status -A .hglf/a
   C .hglf/a/b/c/d/e.large.txt
 
 (5) mixed case: no performance boost
   $ hg status -A a/b/c/x a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 verify that largefiles doesn't break filesets
 
   $ hg log --rev . --exclude "set:binary()"
   changeset:   0:41bd42f10efa
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
 verify that large files in subrepos handled properly
   $ hg init subrepo
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
   Invoking status precommit hook
   A .hgsub
   ? .hgsubstate
   $ echo "rev 1" > subrepo/large.txt
   $ hg add --large subrepo/large.txt
   $ hg sum
   parent: 1:8ee150ea2e9c tip
    add subrepo
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg st
   $ hg st -S
   A subrepo/large.txt
   $ hg ci -S -m "commit top repo"
   committing subrepository subrepo
   Invoking status precommit hook
   A large.txt
   Invoking status precommit hook
   M .hgsubstate
 # No differences
   $ hg st -S
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: (clean)
   update: (current)
   $ echo "rev 2" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg ci -m "this commit should fail without -S"
   abort: uncommitted changes in subrepo subrepo
   (use --subrepos for recursive commit)
   [255]
 
 Add a normal file to the subrepo, then test archiving
 
   $ echo 'normal file' > subrepo/normal.txt
   $ touch large.dat
   $ mv subrepo/large.txt subrepo/renamed-large.txt
   $ hg addremove -S --dry-run
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg addremove --dry-run subrepo
   removing subrepo/large.txt (glob)
   adding subrepo/normal.txt (glob)
   adding subrepo/renamed-large.txt (glob)
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
   $ cd ..
 
   $ hg -R statusmatch addremove --dry-run statusmatch/subrepo
   removing statusmatch/subrepo/large.txt (glob)
   adding statusmatch/subrepo/normal.txt (glob)
   adding statusmatch/subrepo/renamed-large.txt (glob)
   $ hg -R statusmatch status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg -R statusmatch addremove --dry-run -S
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ cd statusmatch
 
   $ mv subrepo/renamed-large.txt subrepo/large.txt
   $ hg addremove subrepo
   adding subrepo/normal.txt (glob)
   $ hg forget subrepo/normal.txt
 
   $ hg addremove -S
   adding large.dat as a largefile
   adding subrepo/normal.txt
   $ rm large.dat
 
   $ hg addremove subrepo
   $ hg addremove -S
   removing large.dat
 
 Lock in subrepo, otherwise the change isn't archived
 
   $ hg ci -S -m "add normal file to top level"
   committing subrepository subrepo
   Invoking status precommit hook
   M large.txt
   A normal.txt
   Invoking status precommit hook
   M .hgsubstate
   $ hg archive -S ../lf_subrepo_archive
   $ find ../lf_subrepo_archive | sort
   ../lf_subrepo_archive
   ../lf_subrepo_archive/.hg_archival.txt
   ../lf_subrepo_archive/.hgsub
   ../lf_subrepo_archive/.hgsubstate
   ../lf_subrepo_archive/a
   ../lf_subrepo_archive/a/b
   ../lf_subrepo_archive/a/b/c
   ../lf_subrepo_archive/a/b/c/d
   ../lf_subrepo_archive/a/b/c/d/e.large.txt
   ../lf_subrepo_archive/a/b/c/d/e.normal.txt
   ../lf_subrepo_archive/a/b/c/x
   ../lf_subrepo_archive/a/b/c/x/y.normal.txt
   ../lf_subrepo_archive/subrepo
   ../lf_subrepo_archive/subrepo/large.txt
   ../lf_subrepo_archive/subrepo/normal.txt
 
 Test update with subrepos.
 
   $ hg update 0
   getting changed largefiles
   0 largefiles updated, 1 removed
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -S
   $ hg update tip
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 # modify a large file
   $ echo "modified" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
 # update -C should revert the change.
   $ hg update -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   getting changed largefiles
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 
   $ hg forget -v subrepo/large.txt
   removing subrepo/large.txt (glob)
 
 Test reverting a forgotten file
   $ hg revert -R subrepo subrepo/large.txt
   $ hg status -SA subrepo/large.txt
   C subrepo/large.txt
 
   $ hg rm -v subrepo/large.txt
   removing subrepo/large.txt (glob)
   $ hg revert -R subrepo subrepo/large.txt
   $ rm subrepo/large.txt
   $ hg addremove -S
   removing subrepo/large.txt
   $ hg st -S
   R subrepo/large.txt
 
 Test archiving a revision that references a subrepo that is not yet
 cloned (see test-subrepo-recursion.t):
 
   $ hg clone -U . ../empty
   $ cd ../empty
   $ hg archive --subrepos -r tip ../archive.tar.gz
   cloning subrepo subrepo from $TESTTMP/statusmatch/subrepo
   $ cd ..
 
 
 
 
 
 
 Test addremove, forget and others
 ==============================================
 
 Test that addremove picks up largefiles prior to the initial commit (issue3541)
 
   $ hg init addrm2
   $ cd addrm2
   $ touch large.dat
   $ touch large2.dat
   $ touch normal
   $ hg add --large large.dat
   $ hg addremove -v
   adding large2.dat as a largefile
   adding normal
 
 Test that forgetting all largefiles reverts to islfilesrepo() == False
 (addremove will add *.dat as normal files now)
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg addremove -v
   adding large.dat
   adding large2.dat
 
 Test commit's addremove option prior to the first commit
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg add --large large.dat
   $ hg ci -Am "commit"
   adding large2.dat as a largefile
   Invoking status precommit hook
   A large.dat
   A large2.dat
   A normal
   $ find .hglf | sort
   .hglf
   .hglf/large.dat
   .hglf/large2.dat
 
 Test actions on largefiles using relative paths from subdir
 
   $ mkdir sub
   $ cd sub
   $ echo anotherlarge > anotherlarge
   $ hg add --large anotherlarge
   $ hg st
   A sub/anotherlarge
   $ hg st anotherlarge
   A anotherlarge
   $ hg commit -m anotherlarge anotherlarge
   Invoking status precommit hook
   A sub/anotherlarge
   $ hg log anotherlarge
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg log -G anotherlarge
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     anotherlarge
   |
+
+  $ hg log glob:another*
+  changeset:   1:9627a577c5e9
+  tag:         tip
+  user:        test
+  date:        Thu Jan 01 00:00:00 1970 +0000
+  summary:     anotherlarge
+  
+  $ hg log -G glob:another*
+  @  changeset:   1:9627a577c5e9
+  |  tag:         tip
+  |  user:        test
+  |  date:        Thu Jan 01 00:00:00 1970 +0000
+  |  summary:     anotherlarge
+  |
+
   $ echo more >> anotherlarge
   $ hg st .
   M anotherlarge
   $ hg cat anotherlarge
   anotherlarge
   $ hg revert anotherlarge
   $ hg st
   ? sub/anotherlarge.orig
   $ cd ..
 
+Test glob logging from the root dir
+  $ hg log glob:**another*
+  changeset:   1:9627a577c5e9
+  tag:         tip
+  user:        test
+  date:        Thu Jan 01 00:00:00 1970 +0000
+  summary:     anotherlarge
+  
+  $ hg log -G glob:**another*
+  @  changeset:   1:9627a577c5e9
+  |  tag:         tip
+  |  user:        test
+  |  date:        Thu Jan 01 00:00:00 1970 +0000
+  |  summary:     anotherlarge
+  |
+
   $ cd ..
 
 Check error message while exchange
 =========================================================
 
 issue3651: summary/outgoing with largefiles shows "no remote repo"
 unexpectedly
 
   $ mkdir issue3651
   $ cd issue3651
 
   $ hg init src
   $ echo a > src/a
   $ hg -R src add --large src/a
   $ hg -R src commit -m '#0'
   Invoking status precommit hook
   A a
 
 check messages when no remote repository is specified:
 "no remote repo" route for "hg outgoing --large" is not tested here,
 because it can't be reproduced easily.
 
   $ hg init clone1
   $ hg -R clone1 -q pull src
   $ hg -R clone1 -q update
   $ hg -R clone1 paths | grep default
   [1]
 
   $ hg -R clone1 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   largefiles: (no remote repo)
 
 check messages when there is no files to upload:
 
   $ hg -q clone src clone2
   $ hg -R clone2 paths | grep default
   default = $TESTTMP/issue3651/src (glob)
 
   $ hg -R clone2 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   largefiles: (no files to upload)
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
   [1]
 
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
 
 check messages when there are files to upload:
 
   $ echo b > clone2/b
   $ hg -R clone2 add --large clone2/b
   $ hg -R clone2 commit -m '#1'
   Invoking status precommit hook
   A b
   $ hg -R clone2 summary --large
   parent: 1:1acbe71ce432 tip
    #1
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 1 entities for 1 files to upload
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   changeset:   1:1acbe71ce432
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     #1
   
   largefiles to upload (1 entities):
   b
   
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   @  1
   
   largefiles to upload (1 entities):
   b
   
 
   $ cp clone2/b clone2/b1
   $ cp clone2/b clone2/b2
   $ hg -R clone2 add --large clone2/b1 clone2/b2
   $ hg -R clone2 commit -m '#2: add largefiles referring same entity'
   Invoking status precommit hook
   A b1
   A b2
   $ hg -R clone2 summary --large
   parent: 2:6095d0695d70 tip
    #2: add largefiles referring same entity
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 1 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   largefiles to upload (1 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 1 clone2/.hglf/b
   89e6c98d92887913cadf06b2adb97f26cde4849b
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   finding outgoing largefiles: 0/2 revision (0.00%)
   finding outgoing largefiles: 1/2 revision (50.00%)
   largefiles to upload (1 entities):
   b
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
   $ echo bbb > clone2/b
   $ hg -R clone2 commit -m '#3: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ echo bbbb > clone2/b
   $ hg -R clone2 commit -m '#4: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ cp clone2/b1 clone2/b
   $ hg -R clone2 commit -m '#5: refer existing largefile entity again'
   Invoking status precommit hook
   M b
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 3 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (3 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 3 clone2/.hglf/b
   c801c9cfe94400963fcb683246217d5db77f9a9a
   $ hg -R clone2 cat -r 4 clone2/.hglf/b
   13f9ed0898e315bf59dc2973fec52037b6f441a2
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/5 revision (0.00%)
   finding outgoing largefiles: 1/5 revision (20.00%)
   finding outgoing largefiles: 2/5 revision (40.00%)
   finding outgoing largefiles: 3/5 revision (60.00%)
   finding outgoing largefiles: 4/5 revision (80.00%)
   largefiles to upload (3 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       89e6c98d92887913cadf06b2adb97f26cde4849b
       c801c9cfe94400963fcb683246217d5db77f9a9a
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
 Pushing revision #1 causes uploading entity 89e6c98d9288, which is
 shared also by largefiles b1, b2 in revision #2 and b in revision #5.
 
 Then, entity 89e6c98d9288 is not treated as "outgoing entity" at "hg
 summary" and "hg outgoing", even though files in outgoing revision #2
 and #5 refer it.
 
   $ hg -R clone2 push -r 1 -q
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 2 entities for 1 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (2 entities):
   b
   
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/4 revision (0.00%)
   finding outgoing largefiles: 1/4 revision (25.00%)
   finding outgoing largefiles: 2/4 revision (50.00%)
   finding outgoing largefiles: 3/4 revision (75.00%)
   largefiles to upload (2 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       c801c9cfe94400963fcb683246217d5db77f9a9a
   
 
   $ cd ..
 
 merge action 'd' for 'local renamed directory to d2/g' which has no filename
 ==================================================================================
 
   $ hg init merge-action
   $ cd merge-action
   $ touch l
   $ hg add --large l
   $ mkdir d1
   $ touch d1/f
   $ hg ci -Aqm0
   Invoking status precommit hook
   A d1/f
   A l
   $ echo > d1/f
   $ touch d1/g
   $ hg ci -Aqm1
   Invoking status precommit hook
   M d1/f
   A d1/g
   $ hg up -qr0
   $ hg mv d1 d2
   moving d1/f to d2/f (glob)
   $ hg ci -qm2
   Invoking status precommit hook
   A d2/f
   R d1/f
   $ hg merge
   merging d2/f and d1/f to d2/f
   getting changed largefiles
   0 largefiles updated, 0 removed
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 
 Merge conflicts:
 =====================
 
   $ hg init merge
   $ cd merge
   $ echo 0 > f-different
   $ echo 0 > f-same
   $ echo 0 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ hg add --large *
   $ hg ci -m0
   Invoking status precommit hook
   A f-different
   A f-same
   A f-unchanged-1
   A f-unchanged-2
   $ echo tmp1 > f-unchanged-1
   $ echo tmp1 > f-unchanged-2
   $ echo tmp1 > f-same
   $ hg ci -m1
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ echo 2 > f-different
   $ echo 0 > f-unchanged-1
   $ echo 1 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m2
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg up -qr0
   $ echo tmp2 > f-unchanged-1
   $ echo tmp2 > f-unchanged-2
   $ echo tmp2 > f-same
   $ hg ci -m3
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   created new head
   $ echo 1 > f-different
   $ echo 1 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m4
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg merge
   largefile f-different has a merge conflict
   ancestor was 09d2af8dd22201dd8d48e5dcfcaed281ff9422c7
   keep (l)ocal e5fa44f2b31c1fb553b6021e7360d07d5d91ff5e or
   take (o)ther 7448d8798a4380162d4b56f9b452e2f6f9e24e7a? l
   getting changed largefiles
   1 largefiles updated, 0 removed
   0 files updated, 4 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat f-different
   1
   $ cat f-same
   1
   $ cat f-unchanged-1
   1
   $ cat f-unchanged-2
   1
   $ cd ..
 
 Test largefile insulation (do not enabled a side effect
 ========================================================
 
 Check whether "largefiles" feature is supported only in repositories
 enabling largefiles extension.
 
   $ mkdir individualenabling
   $ cd individualenabling
 
   $ hg init enabledlocally
   $ echo large > enabledlocally/large
   $ hg -R enabledlocally add --large enabledlocally/large
   $ hg -R enabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ hg init notenabledlocally
   $ echo large > notenabledlocally/large
   $ hg -R notenabledlocally add --large notenabledlocally/large
   $ hg -R notenabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > # disable globally
   > largefiles=!
   > EOF
   $ cat >> enabledlocally/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg -R enabledlocally root
   $TESTTMP/individualenabling/enabledlocally (glob)
   $ hg -R notenabledlocally root
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see http://mercurial.selenic.com/wiki/MissingRequirement for more information)
   [255]
 
   $ hg init push-dst
   $ hg -R enabledlocally push push-dst
   pushing to push-dst
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg init pull-src
   $ hg -R pull-src pull enabledlocally
   pulling from enabledlocally
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg clone enabledlocally clone-dst
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see http://mercurial.selenic.com/wiki/MissingRequirement for more information)
   [255]
   $ test -d clone-dst
   [1]
   $ hg clone --pull enabledlocally clone-pull-dst
   abort: required features are not supported in the destination: largefiles
   [255]
   $ test -d clone-pull-dst
   [1]
 
 #if serve
 
 Test largefiles specific peer setup, when largefiles is enabled
 locally (issue4109)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
   $ mkdir -p $TESTTMP/individualenabling/usercache
 
   $ hg serve -R enabledlocally -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg init pull-dst
   $ cat > pull-dst/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > [largefiles]
   > # ignore system cache to force largefiles specific wire proto access
   > usercache=$TESTTMP/individualenabling/usercache
   > EOF
   $ hg -R pull-dst -q pull -u http://localhost:$HGPORT
 
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 #endif
 
 Test overridden functions work correctly even for repos disabling
 largefiles (issue4547)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
 (test updating implied by clone)
 
   $ hg init enabled-but-no-largefiles
   $ echo normal1 > enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles commit -m '#0@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal1
   $ cat >> enabled-but-no-largefiles/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg clone -q enabled-but-no-largefiles no-largefiles
 
 (test rebasing implied by pull: precommit while rebasing unexpectedly
 shows "normal3" as "?", because lfdirstate isn't yet written out at
 that time)
 
   $ echo normal2 > enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles commit -m '#1@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal2
 
   $ echo normal3 > no-largefiles/normal3
   $ hg -R no-largefiles add no-largefiles/normal3
   $ hg -R no-largefiles commit -m '#1@no-largefiles'
   Invoking status precommit hook
   A normal3
 
   $ hg -R no-largefiles -q pull --rebase
   Invoking status precommit hook
   ? normal3
 
 (test reverting)
 
   $ hg init subrepo-root
   $ cat >> subrepo-root/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ echo large > subrepo-root/large
   $ hg -R subrepo-root add --large subrepo-root/large
   $ hg clone -q no-largefiles subrepo-root/no-largefiles
   $ cat > subrepo-root/.hgsub <<EOF
   > no-largefiles = no-largefiles
   > EOF
   $ hg -R subrepo-root add subrepo-root/.hgsub
   $ hg -R subrepo-root commit -m '#0'
   Invoking status precommit hook
   A .hgsub
   A large
   ? .hgsubstate
   $ echo dirty >> subrepo-root/large
   $ echo dirty >> subrepo-root/no-largefiles/normal1
   $ hg -R subrepo-root status -S
   M large
   M no-largefiles/normal1
   $ hg -R subrepo-root revert --all
   reverting subrepo-root/.hglf/large (glob)
   reverting subrepo no-largefiles
   reverting subrepo-root/no-largefiles/normal1 (glob)
 
   $ cd ..
 
 
 Test "pull --rebase" when rebase is enabled before largefiles (issue3861)
 =========================================================================
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
   $ mkdir issue3861
   $ cd issue3861
   $ hg init src
   $ hg clone -q src dst
   $ echo a > src/a
   $ hg -R src commit -Aqm "#0"
   Invoking status precommit hook
   A a
 
   $ cat >> dst/.hg/hgrc <<EOF
   > [extensions]
   > largefiles=
   > EOF
   $ hg -R dst pull --rebase
   pulling from $TESTTMP/issue3861/src (glob)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   nothing to rebase - working directory parent is already an ancestor of destination bf5e395ced2c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..

tests/test-log.t

@@ -1,1972 +1,1994
 Log on empty repository: checking consistency
 
   $ hg init empty
   $ cd empty
   $ hg log
   $ hg log -r 1
   abort: unknown revision '1'!
   [255]
   $ hg log -r -1:0
   abort: unknown revision '-1'!
   [255]
   $ hg log -r 'branch(name)'
   abort: unknown revision 'name'!
   [255]
   $ hg log -r null -q
   -1:000000000000
 
 The g is crafted to have 2 filelog topological heads in a linear
 changeset graph
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ echo f > f
   $ hg ci -Ama -d '1 0'
   adding a
   adding f
 
   $ hg cp a b
   $ hg cp f g
   $ hg ci -mb -d '2 0'
 
   $ mkdir dir
   $ hg mv b dir
   $ echo g >> g
   $ echo f >> f
   $ hg ci -mc -d '3 0'
 
   $ hg mv a b
   $ hg cp -f f g
   $ echo a > d
   $ hg add d
   $ hg ci -md -d '4 0'
 
   $ hg mv dir/b e
   $ hg ci -me -d '5 0'
 
 Make sure largefiles doesn't interfere with logging a regular file
   $ hg log a --config extensions.largefiles=
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   $ hg log a
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
+  $ hg log glob:a*
+  changeset:   3:2ca5ba701980
+  user:        test
+  date:        Thu Jan 01 00:00:04 1970 +0000
+  summary:     d
+  
+  changeset:   0:9161b9aeaf16
+  user:        test
+  date:        Thu Jan 01 00:00:01 1970 +0000
+  summary:     a
+  
+  $ hg log glob:a* --config extensions.largefiles=
+  changeset:   3:2ca5ba701980
+  user:        test
+  date:        Thu Jan 01 00:00:04 1970 +0000
+  summary:     d
+  
+  changeset:   0:9161b9aeaf16
+  user:        test
+  date:        Thu Jan 01 00:00:01 1970 +0000
+  summary:     a
+  
 log on directory
 
   $ hg log dir
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   $ hg log somethingthatdoesntexist dir
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
 
 -f, non-existent directory
 
   $ hg log -f dir
   abort: cannot follow file not in parent revision: "dir"
   [255]
 
 -f, directory
 
   $ hg up -q 3
   $ hg log -f dir
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
 -f, directory with --patch
 
   $ hg log -f dir -p
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null* (glob)
   +++ b/dir/b* (glob)
   @@ -0,0 +1,1 @@
   +a
   
 
 -f, pattern
 
   $ hg log -f -I 'dir**' -p
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null* (glob)
   +++ b/dir/b* (glob)
   @@ -0,0 +1,1 @@
   +a
   
   $ hg up -q 4
 
 -f, a wrong style
 
   $ hg log -f -l1 --style something
   abort: style 'something' not found
   (available styles: bisect, changelog, compact, default, phases, xml)
   [255]
 
 -f, phases style
 
 
   $ hg log -f -l1 --style phases
   changeset:   4:7e4639b4691b
   tag:         tip
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
 
 -f, but no args
 
   $ hg log -f
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
 
 one rename
 
   $ hg up -q 2
   $ hg log -vf a
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 many renames
 
   $ hg up -q tip
   $ hg log -vf e
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   files:       dir/b e
   description:
   e
   
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   files:       b dir/b f g
   description:
   c
   
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   files:       b g
   description:
   b
   
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 
 log -pf dir/b
 
   $ hg up -q 3
   $ hg log -pf dir/b
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 log -pf b inside dir
 
   $ hg --cwd=dir log -pf b
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 log -pf, but no args
 
   $ hg log -pf
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   diff -r f8954cd4dc1f -r 2ca5ba701980 a
   --- a/a	Thu Jan 01 00:00:03 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r f8954cd4dc1f -r 2ca5ba701980 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r f8954cd4dc1f -r 2ca5ba701980 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r f8954cd4dc1f -r 2ca5ba701980 g
   --- a/g	Thu Jan 01 00:00:03 1970 +0000
   +++ b/g	Thu Jan 01 00:00:04 1970 +0000
   @@ -1,2 +1,2 @@
    f
   -g
   +f
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f b
   --- a/b	Thu Jan 01 00:00:02 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r d89b0a12d229 -r f8954cd4dc1f f
   --- a/f	Thu Jan 01 00:00:02 1970 +0000
   +++ b/f	Thu Jan 01 00:00:03 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +f
   diff -r d89b0a12d229 -r f8954cd4dc1f g
   --- a/g	Thu Jan 01 00:00:02 1970 +0000
   +++ b/g	Thu Jan 01 00:00:03 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +g
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 9161b9aeaf16 -r d89b0a12d229 g
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/g	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 000000000000 -r 9161b9aeaf16 f
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/f	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   
 
 log -vf dir/b
 
   $ hg log -vf dir/b
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   files:       b dir/b f g
   description:
   c
   
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   files:       b g
   description:
   b
   
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 
 -f and multiple filelog heads
 
   $ hg up -q 2
   $ hg log -f g --template '{rev}\n'
   2
   1
   0
   $ hg up -q tip
   $ hg log -f g --template '{rev}\n'
   3
   2
   0
 
 
 log copies with --copies
 
   $ hg log -vC --template '{rev} {file_copies}\n'
   4 e (dir/b)
   3 b (a)g (f)
   2 dir/b (b)
   1 b (a)g (f)
   0 
 
 log copies switch without --copies, with old filecopy template
 
   $ hg log -v --template '{rev} {file_copies_switch%filecopy}\n'
   4 
   3 
   2 
   1 
   0 
 
 log copies switch with --copies
 
   $ hg log -vC --template '{rev} {file_copies_switch}\n'
   4 e (dir/b)
   3 b (a)g (f)
   2 dir/b (b)
   1 b (a)g (f)
   0 
 
 
 log copies with hardcoded style and with --style=default
 
   $ hg log -vC -r4
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   files:       dir/b e
   copies:      e (dir/b)
   description:
   e
   
   
   $ hg log -vC -r4 --style=default
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   files:       dir/b e
   copies:      e (dir/b)
   description:
   e
   
   
   $ hg log -vC -r4 -Tjson
   [
    {
     "rev": 4,
     "node": "7e4639b4691b9f84b81036a8d4fb218ce3c5e3a3",
     "branch": "default",
     "phase": "draft",
     "user": "test",
     "date": [5, 0],
     "desc": "e",
     "bookmarks": [],
     "tags": ["tip"],
     "parents": ["2ca5ba7019804f1f597249caddf22a64d34df0ba"],
     "files": ["dir/b", "e"],
     "copies": {"e": "dir/b"}
    }
   ]
 
 log copies, non-linear manifest
 
   $ hg up -C 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg mv dir/b e
   $ echo foo > foo
   $ hg ci -Ame2 -d '6 0'
   adding foo
   created new head
   $ hg log -v --template '{rev} {file_copies}\n' -r 5
   5 e (dir/b)
 
 
 log copies, execute bit set
 
 #if execbit
   $ chmod +x e
   $ hg ci -me3 -d '7 0'
   $ hg log -v --template '{rev} {file_copies}\n' -r 6
   6 
 #endif
 
 
 log -p d
 
   $ hg log -pv d
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   files:       a b d g
   description:
   d
   
   
   diff -r f8954cd4dc1f -r 2ca5ba701980 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 
 log --removed file
 
   $ hg log --removed -v a
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   files:       a b d g
   description:
   d
   
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 log --removed revrange file
 
   $ hg log --removed -v -r0:2 a
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
   $ cd ..
 
 log --follow tests
 
   $ hg init follow
   $ cd follow
 
   $ echo base > base
   $ hg ci -Ambase -d '1 0'
   adding base
 
   $ echo r1 >> base
   $ hg ci -Amr1 -d '1 0'
   $ echo r2 >> base
   $ hg ci -Amr2 -d '1 0'
 
   $ hg up -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b1 > b1
   $ hg ci -Amb1 -d '1 0'
   adding b1
   created new head
 
 
 log -f
 
   $ hg log -f
   changeset:   3:e62f78d544b4
   tag:         tip
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
 
 
 log -f -r '1 + 4'
 
   $ hg up -C 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b2 > b2
   $ hg ci -Amb2 -d '1 0'
   adding b2
   created new head
   $ hg log -f -r '1 + 4'
   changeset:   4:ddb82e70d1a1
   tag:         tip
   parent:      0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b2
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
 log -f -r null
 
   $ hg log -f -r null
   changeset:   -1:000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   $ hg log -f -r null -G
   o  changeset:   -1:000000000000
      user:
      date:        Thu Jan 01 00:00:00 1970 +0000
   
 
 
 log -f with null parent
 
   $ hg up -C null
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg log -f
 
 
 log -r .  with two parents
 
   $ hg up -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg log -r .
   changeset:   3:e62f78d544b4
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
 
 
 log -r .  with one parent
 
   $ hg ci -mm12 -d '1 0'
   $ hg log -r .
   changeset:   5:302e9dd6890d
   tag:         tip
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
 
   $ echo postm >> b1
   $ hg ci -Amb1.1 -d'1 0'
 
 
 log --follow-first
 
   $ hg log --follow-first
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   changeset:   5:302e9dd6890d
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
   changeset:   3:e62f78d544b4
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
 
 
 log -P 2
 
   $ hg log -P 2
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   changeset:   5:302e9dd6890d
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
   changeset:   4:ddb82e70d1a1
   parent:      0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b2
   
   changeset:   3:e62f78d544b4
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
 
 
 log -r tip -p --git
 
   $ hg log -r tip -p --git
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   diff --git a/b1 b/b1
   --- a/b1
   +++ b/b1
   @@ -1,1 +1,2 @@
    b1
   +postm
   
 
 
 log -r ""
 
   $ hg log -r ''
   hg: parse error: empty query
   [255]
 
 log -r <some unknown node id>
 
   $ hg log -r 1000000000000000000000000000000000000000
   abort: unknown revision '1000000000000000000000000000000000000000'!
   [255]
 
 log -k r1
 
   $ hg log -k r1
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
 log -p -l2 --color=always
 
   $ hg --config extensions.color= --config color.mode=ansi \
   >  log -p -l2 --color=always
   \x1b[0;33mchangeset:   6:2404bbcab562\x1b[0m (esc)
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   \x1b[0;1mdiff -r 302e9dd6890d -r 2404bbcab562 b1\x1b[0m (esc)
   \x1b[0;31;1m--- a/b1	Thu Jan 01 00:00:01 1970 +0000\x1b[0m (esc)
   \x1b[0;32;1m+++ b/b1	Thu Jan 01 00:00:01 1970 +0000\x1b[0m (esc)
   \x1b[0;35m@@ -1,1 +1,2 @@\x1b[0m (esc)
    b1
   \x1b[0;32m+postm\x1b[0m (esc)
   
   \x1b[0;33mchangeset:   5:302e9dd6890d\x1b[0m (esc)
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
   \x1b[0;1mdiff -r e62f78d544b4 -r 302e9dd6890d b2\x1b[0m (esc)
   \x1b[0;31;1m--- /dev/null	Thu Jan 01 00:00:00 1970 +0000\x1b[0m (esc)
   \x1b[0;32;1m+++ b/b2	Thu Jan 01 00:00:01 1970 +0000\x1b[0m (esc)
   \x1b[0;35m@@ -0,0 +1,1 @@\x1b[0m (esc)
   \x1b[0;32m+b2\x1b[0m (esc)
   
 
 
 log -r tip --stat
 
   $ hg log -r tip --stat
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
    b1 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ cd ..
 
 
 User
 
   $ hg init usertest
   $ cd usertest
 
   $ echo a > a
   $ hg ci -A -m "a" -u "User One <[e-mail]>"
   adding a
   $ echo b > b
   $ hg ci -A -m "b" -u "User Two <[e-mail]>"
   adding b
 
   $ hg log -u "User One <[e-mail]>"
   changeset:   0:29a4c94f1924
   user:        User One <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg log -u "user1" -u "user2"
   changeset:   1:e834b5e69c0e
   tag:         tip
   user:        User Two <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:29a4c94f1924
   user:        User One <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg log -u "user3"
 
   $ cd ..
 
   $ hg init branches
   $ cd branches
 
   $ echo a > a
   $ hg ci -A -m "commit on default"
   adding a
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg ci -A -m "commit on test"
   adding b
 
   $ hg up default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -A -m "commit on default"
   adding c
   $ hg up test
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -A -m "commit on test"
   adding c
 
 
 log -b default
 
   $ hg log -b default
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 
 
 log -b test
 
   $ hg log -b test
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
 
 
 log -b dummy
 
   $ hg log -b dummy
   abort: unknown revision 'dummy'!
   [255]
 
 
 log -b .
 
   $ hg log -b .
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
 
 
 log -b default -b test
 
   $ hg log -b default -b test
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 
 
 log -b default -b .
 
   $ hg log -b default -b .
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 
 
 log -b . -b test
 
   $ hg log -b . -b test
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
 
 
 log -b 2
 
   $ hg log -b 2
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 #if gettext
 
 Test that all log names are translated (e.g. branches, bookmarks, tags):
 
   $ hg bookmark babar -r tip
 
   $ HGENCODING=UTF-8 LANGUAGE=de hg log -r tip
   \xc3\x84nderung:        3:f5d8de11c2e2 (esc)
   Zweig:           test
   Lesezeichen:     babar
   Marke:           tip
   Vorg\xc3\xa4nger:       1:d32277701ccb (esc)
   Nutzer:          test
   Datum:           Thu Jan 01 00:00:00 1970 +0000
   Zusammenfassung: commit on test
   
   $ hg bookmark -d babar
 
 #endif
 
 log -p --cwd dir (in subdir)
 
   $ mkdir dir
   $ hg log -p --cwd dir
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   diff -r d32277701ccb -r f5d8de11c2e2 c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   diff -r 24427303d56f -r c3a4f03cc9a7 c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   diff -r 24427303d56f -r d32277701ccb b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   diff -r 000000000000 -r 24427303d56f a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 
 log -p -R repo
 
   $ cd dir
   $ hg log -p -R .. ../a
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   diff -r 000000000000 -r 24427303d56f a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
   $ cd ../..
 
   $ hg init follow2
   $ cd follow2
 
 # Build the following history:
 # tip - o - x - o - x - x
 #    \                 /
 #     o - o - o - x
 #      \     /
 #         o
 #
 # Where "o" is a revision containing "foo" and
 # "x" is a revision without "foo"
 
   $ touch init
   $ hg ci -A -m "init, unrelated"
   adding init
   $ echo 'foo' > init
   $ hg ci -m "change, unrelated"
   $ echo 'foo' > foo
   $ hg ci -A -m "add unrelated old foo"
   adding foo
   $ hg rm foo
   $ hg ci -m "delete foo, unrelated"
   $ echo 'related' > foo
   $ hg ci -A -m "add foo, related"
   adding foo
 
   $ hg up 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ touch branch
   $ hg ci -A -m "first branch, unrelated"
   adding branch
   created new head
   $ touch foo
   $ hg ci -A -m "create foo, related"
   adding foo
   $ echo 'change' > foo
   $ hg ci -m "change foo, related"
 
   $ hg up 6
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'change foo in branch' > foo
   $ hg ci -m "change foo in branch, related"
   created new head
   $ hg merge 7
   merging foo
   warning: conflicts during merge.
   merging foo incomplete! (edit conflicts, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ echo 'merge 1' > foo
   $ hg resolve -m foo
   (no more unresolved files)
   $ hg ci -m "First merge, related"
 
   $ hg merge 4
   merging foo
   warning: conflicts during merge.
   merging foo incomplete! (edit conflicts, then use 'hg resolve --mark')
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ echo 'merge 2' > foo
   $ hg resolve -m foo
   (no more unresolved files)
   $ hg ci -m "Last merge, related"
 
   $ hg log --graph
   @    changeset:   10:4dae8563d2c5
   |\   tag:         tip
   | |  parent:      9:7b35701b003e
   | |  parent:      4:88176d361b69
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     Last merge, related
   | |
   | o    changeset:   9:7b35701b003e
   | |\   parent:      8:e5416ad8a855
   | | |  parent:      7:87fe3144dcfa
   | | |  user:        test
   | | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | | |  summary:     First merge, related
   | | |
   | | o  changeset:   8:e5416ad8a855
   | | |  parent:      6:dc6c325fe5ee
   | | |  user:        test
   | | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | | |  summary:     change foo in branch, related
   | | |
   | o |  changeset:   7:87fe3144dcfa
   | |/   user:        test
   | |    date:        Thu Jan 01 00:00:00 1970 +0000
   | |    summary:     change foo, related
   | |
   | o  changeset:   6:dc6c325fe5ee
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     create foo, related
   | |
   | o  changeset:   5:73db34516eb9
   | |  parent:      0:e87515fd044a
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     first branch, unrelated
   | |
   o |  changeset:   4:88176d361b69
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     add foo, related
   | |
   o |  changeset:   3:dd78ae4afb56
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     delete foo, unrelated
   | |
   o |  changeset:   2:c4c64aedf0f7
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     add unrelated old foo
   | |
   o |  changeset:   1:e5faa7440653
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     change, unrelated
   |
   o  changeset:   0:e87515fd044a
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     init, unrelated
   
 
   $ hg --traceback log -f foo
   changeset:   10:4dae8563d2c5
   tag:         tip
   parent:      9:7b35701b003e
   parent:      4:88176d361b69
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Last merge, related
   
   changeset:   9:7b35701b003e
   parent:      8:e5416ad8a855
   parent:      7:87fe3144dcfa
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     First merge, related
   
   changeset:   8:e5416ad8a855
   parent:      6:dc6c325fe5ee
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo in branch, related
   
   changeset:   7:87fe3144dcfa
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo, related
   
   changeset:   6:dc6c325fe5ee
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     create foo, related
   
   changeset:   4:88176d361b69
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo, related
   
 
 Also check when maxrev < lastrevfilelog
 
   $ hg --traceback log -f -r4 foo
   changeset:   4:88176d361b69
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo, related
   
   changeset:   2:c4c64aedf0f7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add unrelated old foo
   
   $ cd ..
 
 Issue2383: hg log showing _less_ differences than hg diff
 
   $ hg init issue2383
   $ cd issue2383
 
 Create a test repo:
 
   $ echo a > a
   $ hg ci -Am0
   adding a
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg co 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b > a
   $ hg ci -m2
   created new head
 
 Merge:
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 Make sure there's a file listed in the merge to trigger the bug:
 
   $ echo c > a
   $ hg ci -m3
 
 Two files shown here in diff:
 
   $ hg diff --rev 2:3
   diff -r b09be438c43a -r 8e07aafe1edc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -b
   +c
   diff -r b09be438c43a -r 8e07aafe1edc b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +b
 
 Diff here should be the same:
 
   $ hg log -vpr 3
   changeset:   3:8e07aafe1edc
   tag:         tip
   parent:      2:b09be438c43a
   parent:      1:925d80f479bb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   description:
   3
   
   
   diff -r b09be438c43a -r 8e07aafe1edc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -b
   +c
   diff -r b09be438c43a -r 8e07aafe1edc b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
   $ cd ..
 
 'hg log -r rev fn' when last(filelog(fn)) != rev
 
   $ hg init simplelog
   $ cd simplelog
   $ echo f > a
   $ hg ci -Am'a' -d '0 0'
   adding a
   $ echo f >> a
   $ hg ci -Am'a bis' -d '1 0'
 
   $ hg log -r0 a
   changeset:   0:9f758d63dcde
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 enable obsolete to test hidden feature
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution=createmarkers
   > EOF
 
   $ hg log --template='{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg debugobsolete a765632148dc55d38c35c4f247c618701886cb2f
   $ hg up null -q
   $ hg log --template='{rev}:{node}\n'
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg log --template='{rev}:{node}\n' --hidden
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg log -r a
   abort: hidden revision 'a'!
   (use --hidden to access hidden revisions)
   [255]
 
 test that parent prevent a changeset to be hidden
 
   $ hg up 1 -q --hidden
   $ hg log --template='{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
 
 test that second parent prevent a changeset to be hidden too
 
   $ hg debugsetparents 0 1 # nothing suitable to merge here
   $ hg log --template='{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg debugsetparents 1
   $ hg up -q null
 
 bookmarks prevent a changeset being hidden
 
   $ hg bookmark --hidden -r 1 X
   $ hg log --template '{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg bookmark -d X
 
 divergent bookmarks are not hidden
 
   $ hg bookmark --hidden -r 1 X@foo
   $ hg log --template '{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
 
 clear extensions configuration
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=!" >> $HGRCPATH
   $ cd ..
 
 test -u/-k for problematic encoding
 # unicode: cp932:
 # u30A2    0x83 0x41(= 'A')
 # u30C2    0x83 0x61(= 'a')
 
   $ hg init problematicencoding
   $ cd problematicencoding
 
   $ python > setup.sh <<EOF
   > print u'''
   > echo a > text
   > hg add text
   > hg --encoding utf-8 commit -u '\u30A2' -m none
   > echo b > text
   > hg --encoding utf-8 commit -u '\u30C2' -m none
   > echo c > text
   > hg --encoding utf-8 commit -u none -m '\u30A2'
   > echo d > text
   > hg --encoding utf-8 commit -u none -m '\u30C2'
   > '''.encode('utf-8')
   > EOF
   $ sh < setup.sh
 
 test in problematic encoding
   $ python > test.sh <<EOF
   > print u'''
   > hg --encoding cp932 log --template '{rev}\\n' -u '\u30A2'
   > echo ====
   > hg --encoding cp932 log --template '{rev}\\n' -u '\u30C2'
   > echo ====
   > hg --encoding cp932 log --template '{rev}\\n' -k '\u30A2'
   > echo ====
   > hg --encoding cp932 log --template '{rev}\\n' -k '\u30C2'
   > '''.encode('cp932')
   > EOF
   $ sh < test.sh
   0
   ====
   1
   ====
   2
   0
   ====
   3
   1
 
   $ cd ..
 
 test hg log on non-existent files and on directories
   $ hg init issue1340
   $ cd issue1340
   $ mkdir d1; mkdir D2; mkdir D3.i; mkdir d4.hg; mkdir d5.d; mkdir .d6
   $ echo 1 > d1/f1
   $ echo 1 > D2/f1
   $ echo 1 > D3.i/f1
   $ echo 1 > d4.hg/f1
   $ echo 1 > d5.d/f1
   $ echo 1 > .d6/f1
   $ hg -q add .
   $ hg commit -m "a bunch of weird directories"
   $ hg log -l1 d1/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 f1
   $ hg log -l1 . | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 ./ | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D2 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D2/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D3.i | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D3.i/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d4.hg | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d4.hg/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d5.d | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d5.d/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 .d6 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 .d6/f1 | grep changeset
   changeset:   0:65624cd9070a
 
 issue3772: hg log -r :null showing revision 0 as well
 
   $ hg log -r :null
   changeset:   0:65624cd9070a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a bunch of weird directories
   
   changeset:   -1:000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   $ hg log -r null:null
   changeset:   -1:000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
 Check that adding an arbitrary name shows up in log automatically
 
   $ cat > ../names.py <<EOF
   > """A small extension to test adding arbitrary names to a repo"""
   > from mercurial.namespaces import namespace
   > 
   > def reposetup(ui, repo):
   >     foo = {'foo': repo[0].node()}
   >     names = lambda r: foo.keys()
   >     namemap = lambda r, name: foo.get(name)
   >     nodemap = lambda r, node: [name for name, n in foo.iteritems()
   >                                if n == node]
   >     ns = namespace("bars", templatename="bar", logname="barlog",
   >                    colorname="barcolor", listnames=names, namemap=namemap,
   >                    nodemap=nodemap)
   > 
   >     repo.names.addnamespace(ns)
   > EOF
 
   $ hg --config extensions.names=../names.py log -r 0
   changeset:   0:65624cd9070a
   tag:         tip
   barlog:      foo
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a bunch of weird directories
   
   $ hg --config extensions.names=../names.py \
   >  --config extensions.color= --config color.log.barcolor=red \
   >  --color=always log -r 0
   \x1b[0;33mchangeset:   0:65624cd9070a\x1b[0m (esc)
   tag:         tip
   \x1b[0;31mbarlog:      foo\x1b[0m (esc)
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a bunch of weird directories
   
   $ hg --config extensions.names=../names.py log -r 0 --template '{bars}\n'
   foo
 
   $ cd ..
 
 hg log -f dir across branches
 
   $ hg init acrossbranches
   $ cd acrossbranches
   $ mkdir d
   $ echo a > d/a && hg ci -Aqm a
   $ echo b > d/a && hg ci -Aqm b
   $ hg up -q 0
   $ echo b > d/a && hg ci -Aqm c
   $ hg log -f d -T '{desc}' -G
   @  c
   |
   o  a
   
 Ensure that largefiles doesn't interfere with following a normal file
   $ hg  --config extensions.largefiles= log -f d -T '{desc}' -G
   @  c
   |
   o  a
   
   $ hg log -f d/a -T '{desc}' -G
   @  c
   |
   o  a
   
   $ cd ..
 
 hg log -f with linkrev pointing to another branch
 -------------------------------------------------
 
 create history with a filerev whose linkrev points to another branch
 
   $ hg init branchedlinkrev
   $ cd branchedlinkrev
   $ echo 1 > a
   $ hg commit -Am 'content1'
   adding a
   $ echo 2 > a
   $ hg commit -m 'content2'
   $ hg up --rev 'desc(content1)'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo unrelated > unrelated
   $ hg commit -Am 'unrelated'
   adding unrelated
   created new head
   $ hg graft -r 'desc(content2)'
   grafting 1:2294ae80ad84 "content2"
   $ echo 3 > a
   $ hg commit -m 'content3'
   $ hg log -G
   @  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   o  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   2:2029acd1168c
   |  parent:      0:ae0a3c9f9e95
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     unrelated
   |
   | o  changeset:   1:2294ae80ad84
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 log -f on the file should list the graft result.
 
   $ hg log -Gf a
   @  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   o  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 plain log lists the original version
 (XXX we should probably list both)
 
   $ hg log -G a
   @  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   | o  changeset:   1:2294ae80ad84
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 hg log -f from the grafted changeset
 (The bootstrap should properly take the topology in account)
 
   $ hg up 'desc(content3)^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -Gf a
   @  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 Test that we use the first non-hidden changeset in that case.
 
 (hide the changeset)
 
   $ hg log -T '{node}\n' -r 1
   2294ae80ad8447bc78383182eeac50cb049df623
   $ hg debugobsolete 2294ae80ad8447bc78383182eeac50cb049df623
   $ hg log -G
   o  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   @  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   2:2029acd1168c
   |  parent:      0:ae0a3c9f9e95
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     unrelated
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 Check that log on the file does not drop the file revision.
 
   $ hg log -G a
   o  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   @  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 Even when a head revision is linkrev-shadowed.
 
   $ hg log -T '{node}\n' -r 4
   50b9b36e9c5df2c6fc6dcefa8ad0da929e84aed2
   $ hg debugobsolete 50b9b36e9c5df2c6fc6dcefa8ad0da929e84aed2
   $ hg log -G a
   @  changeset:   3:15b2327059e5
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
   $ cd ..
 
 Even when the file revision is missing from some head:
 
   $ hg init issue4490
   $ cd issue4490
   $ echo '[experimental]' >> .hg/hgrc
   $ echo 'evolution=createmarkers' >> .hg/hgrc
   $ echo a > a
   $ hg ci -Am0
   adding a
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ echo B > b
   $ hg ci --amend -m 1
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am2
   adding c
   created new head
   $ hg up 'head() and not .'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   o  changeset:   4:db815d6d32e6
   |  tag:         tip
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | @  changeset:   3:9bc8ce7f9356
   |/   parent:      0:f7b1eb17ad24
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
   $ hg log -f -G b
   @  changeset:   3:9bc8ce7f9356
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     1
   |
   $ hg log -G b
   @  changeset:   3:9bc8ce7f9356
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     1
   |
   $ cd ..
 
 Check proper report when the manifest changes but not the file issue4499
 ------------------------------------------------------------------------
 
   $ hg init issue4499
   $ cd issue4499
   $ for f in A B C D F E G H I J K L M N O P Q R S T U; do
   >     echo 1 > $f;
   >     hg add $f;
   > done
   $ hg commit -m 'A1B1C1'
   $ echo 2 > A
   $ echo 2 > B
   $ echo 2 > C
   $ hg commit -m 'A2B2C2'
   $ hg up 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 > A
   $ echo 2 > B
   $ echo 2 > C
   $ hg commit -m 'A3B2C2'
   created new head
 
   $ hg log -G
   @  changeset:   2:fe5fc3d0eb17
   |  tag:         tip
   |  parent:      0:abf4f0e38563
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     A3B2C2
   |
   | o  changeset:   1:07dcc6b312c0
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     A2B2C2
   |
   o  changeset:   0:abf4f0e38563
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A1B1C1
   
 
 Log -f on B should reports current changesets
 
   $ hg log -fG B
   @  changeset:   2:fe5fc3d0eb17
   |  tag:         tip
   |  parent:      0:abf4f0e38563
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     A3B2C2
   |
   o  changeset:   0:abf4f0e38563
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A1B1C1
   
   $ cd ..