mercurial-scm/hg: comparison mercurial/cmdutil.py

equal deleted inserted replaced

-:5fe6f946f111
+:3e394e0558d7
 def _fileancestors(repo, revs, match, followfirst):
 fctxs = []
 for r in revs:
 ctx = repo[r]
 fctxs.extend(ctx[f].introfilectx() for f in ctx.walk(match))
-return dagop.filerevancestors(fctxs, followfirst=followfirst)
-def _makefollowlogfilematcher(repo, files, followfirst):
 # When displaying a revision with --patch --follow FILE, we have
 # to know which file of the revision must be diffed. With
 # --follow, we want the names of the ancestors of FILE in the
-# revision, stored in "fcache". "fcache" is populated by
+# revision, stored in "fcache". "fcache" is populated as a side effect
-# reproducing the graph traversal already done by --follow revset
+# of the graph traversal.
-# and relating revs to file names (which is not "correct" but
-# good enough).
 fcache = {}
-fcacheready = [False]
-pctx = repo['.']
-def populate():
-for fn in files:
-fctx = pctx[fn]
-fcache.setdefault(fctx.introrev(), set()).add(fctx.path())
-for c in fctx.ancestors(followfirst=followfirst):
-fcache.setdefault(c.rev(), set()).add(c.path())
 def filematcher(rev):
-if not fcacheready[0]:
-# Lazy initialization
-fcacheready[0] = True
-populate()
 return scmutil.matchfiles(repo, fcache.get(rev, []))
-return filematcher
+def revgen():
+for rev, cs in dagop.filectxancestors(fctxs, followfirst=followfirst):
+fcache[rev] = [c.path() for c in cs]
+yield rev
+return smartset.generatorset(revgen(), iterasc=False), filematcher
 def _makenofollowlogfilematcher(repo, pats, opts):
 '''hook for extensions to override the filematcher for non-follow cases'''
 return None
 'prune':            ('ancestors(%s)', 'not %lr'),
 'user':             ('user(%s)', '%lr'),
 }
 def _makelogrevset(repo, match, pats, slowpath, opts):
-"""Return (expr, filematcher) where expr is a revset string built
+"""Return a revset string built from log options and file patterns"""
-from log options and file patterns or None. If --stat or --patch
-are not passed filematcher is None. Otherwise it is a callable
-taking a revision number and returning a match objects filtering
-the files to be detailed when displaying the revision.
-"""
 opts = dict(opts)
 # follow or not follow?
 follow = opts.get('follow') or opts.get('follow_first')
 # branch and only_branch are really aliases and must be handled at
 matchargs.append('x:' + p)
 opts['_matchfiles'] = matchargs
 elif not follow:
 opts['_patslog'] = list(pats)
-filematcher = None
-if opts.get('patch') or opts.get('stat'):
-# When following files, track renames via a special matcher.
-# If we're forced to take the slowpath it means we're following
-# at least one pattern/directory, so don't bother with rename tracking.
-if follow and not match.always() and not slowpath:
-# _makefollowlogfilematcher expects its files argument to be
-# relative to the repo root, so use match.files(), not pats.
-filematcher = _makefollowlogfilematcher(repo, match.files(),
-opts.get('follow_first'))
-else:
-filematcher = _makenofollowlogfilematcher(repo, pats, opts)
-if filematcher is None:
-filematcher = lambda rev: match
 expr = []
 for op, val in sorted(opts.iteritems()):
 if not val:
 continue
 if op not in _opt2logrevset:
 if expr:
 expr = '(' + ' and '.join(expr) + ')'
 else:
 expr = None
-return expr, filematcher
+return expr
 def _logrevs(repo, opts):
 """Return the initial set of revisions to be filtered or followed"""
 follow = opts.get('follow') or opts.get('follow_first')
 if opts.get('rev'):
 return revs
 def getlogrevs(repo, pats, opts):
 """Return (revs, filematcher) where revs is a smartset
-If --stat or --patch is not passed, filematcher is None. Otherwise it
+filematcher is a callable taking a revision number and returning a match
-is a callable taking a revision number and returning a match objects
+objects filtering the files to be detailed when displaying the revision.
-filtering the files to be detailed when displaying the revision.
 """
 follow = opts.get('follow') or opts.get('follow_first')
 followfirst = opts.get('follow_first')
 limit = loglimit(opts)
 revs = _logrevs(repo, opts)
 if not revs:
 return smartset.baseset(), None
 match, pats, slowpath = _makelogmatcher(repo, revs, pats, opts)
+filematcher = None
 if follow:
 if slowpath or match.always():
 revs = dagop.revancestors(repo, revs, followfirst=followfirst)
 else:
-revs = _fileancestors(repo, revs, match, followfirst)
+revs, filematcher = _fileancestors(repo, revs, match, followfirst)
 revs.reverse()
-expr, filematcher = _makelogrevset(repo, match, pats, slowpath, opts)
+if filematcher is None:
+filematcher = _makenofollowlogfilematcher(repo, pats, opts)
+if filematcher is None:
+def filematcher(rev):
+return match
+expr = _makelogrevset(repo, match, pats, slowpath, opts)
 if opts.get('graph') and opts.get('rev'):
 # User-specified revs might be unsorted, but don't sort before
 # _makelogrevset because it might depend on the order of revs
 if not (revs.isdescending() or revs.istopo()):
 revs.sort(reverse=True)

changeset 35690	3e394e0558d7
parent 35689	5fe6f946f111
child 35743	3c2a6246fd63