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

equal deleted inserted replaced

-:f113ac0750f3
+:29b83c08afe0
 tempnode2 = None
 submatch = matchmod.subdirmatcher(subpath, match)
 sub.diff(ui, diffopts, tempnode2, submatch, changes=changes,
 stat=stat, fp=fp, prefix=prefix)
+class changesetdiffer(object):
+"""Generate diff of changeset with pre-configured filtering functions"""
+def _makefilematcher(self, ctx):
+return scmutil.matchall(ctx.repo())
+def _makehunksfilter(self, ctx):
+return None
+def showdiff(self, ui, ctx, diffopts, stat=False):
+repo = ctx.repo()
+node = ctx.node()
+prev = ctx.p1().node()
+diffordiffstat(ui, repo, diffopts, prev, node,
+match=self._makefilematcher(ctx), stat=stat,
+hunksfilterfn=self._makehunksfilter(ctx))
 def changesetlabels(ctx):
 labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]
 if ctx.obsolete():
 labels.append('changeset.obsolete')
 if ctx.isunstable():
 return ' '.join(labels)
 class changesetprinter(object):
 '''show changeset information when templating not requested.'''
-def __init__(self, ui, repo, makefilematcher=None, makehunksfilter=None,
+def __init__(self, ui, repo, differ=None, diffopts=None, buffered=False):
-diffopts=None, buffered=False):
 self.ui = ui
 self.repo = repo
 self.buffered = buffered
-self._makefilematcher = makefilematcher or (lambda ctx: None)
+self._differ = differ or changesetdiffer()
-self._makehunksfilter = makehunksfilter or (lambda ctx: None)
 self.diffopts = diffopts or {}
 self.header = {}
 self.hunk = {}
 self.lastheader = None
 self.footer = None
 def _exthook(self, ctx):
 '''empty method used by extension as a hook point
 '''
 def _showpatch(self, ctx):
-matchfn = self._makefilematcher(ctx)
-hunksfilterfn = self._makehunksfilter(ctx)
-if not matchfn:
-return
 stat = self.diffopts.get('stat')
 diff = self.diffopts.get('patch')
 diffopts = patch.diffallopts(self.ui, self.diffopts)
-node = ctx.node()
-prev = ctx.p1().node()
 if stat:
-diffordiffstat(self.ui, self.repo, diffopts, prev, node,
+self._differ.showdiff(self.ui, ctx, diffopts, stat=True)
-match=matchfn, stat=True,
-hunksfilterfn=hunksfilterfn)
 if stat and diff:
 self.ui.write("\n")
 if diff:
-diffordiffstat(self.ui, self.repo, diffopts, prev, node,
+self._differ.showdiff(self.ui, ctx, diffopts, stat=False)
-match=matchfn, stat=False,
-hunksfilterfn=hunksfilterfn)
 if stat or diff:
 self.ui.write("\n")
 class jsonchangeset(changesetprinter):
 '''format changeset information.'''
-def __init__(self, ui, repo, makefilematcher=None, makehunksfilter=None,
+def __init__(self, ui, repo, differ=None, diffopts=None, buffered=False):
-diffopts=None, buffered=False):
+changesetprinter.__init__(self, ui, repo, differ, diffopts, buffered)
-changesetprinter.__init__(self, ui, repo, makefilematcher,
-makehunksfilter, diffopts, buffered)
 self.cache = {}
 self._first = True
 def close(self):
 if not self._first:
 if copies:
 self.ui.write((',\n  "copies": {%s}') %
 ", ".join('"%s": "%s"' % (j(k), j(v))
 for k, v in copies))
-matchfn = self._makefilematcher(ctx)
 stat = self.diffopts.get('stat')
 diff = self.diffopts.get('patch')
 diffopts = patch.difffeatureopts(self.ui, self.diffopts, git=True)
-node, prev = ctx.node(), ctx.p1().node()
+if stat:
-if matchfn and stat:
 self.ui.pushbuffer()
-diffordiffstat(self.ui, self.repo, diffopts, prev, node,
+self._differ.showdiff(self.ui, ctx, diffopts, stat=True)
-match=matchfn, stat=True)
 self.ui.write((',\n  "diffstat": "%s"')
 % j(self.ui.popbuffer()))
-if matchfn and diff:
+if diff:
 self.ui.pushbuffer()
-diffordiffstat(self.ui, self.repo, diffopts, prev, node,
+self._differ.showdiff(self.ui, ctx, diffopts, stat=False)
-match=matchfn, stat=False)
 self.ui.write((',\n  "diff": "%s"') % j(self.ui.popbuffer()))
 self.ui.write("\n }")
 class changesettemplater(changesetprinter):
 functions that use changesest_templater.
 '''
 # Arguments before "buffered" used to be positional. Consider not
 # adding/removing arguments before "buffered" to not break callers.
-def __init__(self, ui, repo, tmplspec, makefilematcher=None,
+def __init__(self, ui, repo, tmplspec, differ=None, diffopts=None,
-makehunksfilter=None, diffopts=None, buffered=False):
+buffered=False):
-changesetprinter.__init__(self, ui, repo, makefilematcher,
+changesetprinter.__init__(self, ui, repo, differ, diffopts, buffered)
-makehunksfilter, diffopts, buffered)
 tres = formatter.templateresources(ui, repo)
 self.t = formatter.loadtemplater(ui, tmplspec,
 defaults=templatekw.keywords,
 resources=tres,
 cache=templatekw.defaulttempl)
 """Create a changesettemplater from a literal template 'tmpl'
 byte-string."""
 spec = templatespec(tmpl, None)
 return changesettemplater(ui, repo, spec, buffered=buffered)
-def changesetdisplayer(ui, repo, opts, makefilematcher=None,
+def changesetdisplayer(ui, repo, opts, differ=None, buffered=False):
-makehunksfilter=None, buffered=False):
 """show one changeset using template or regular display.
 Display format will be the first non-empty hit of:
 1. option 'template'
 2. option 'style'
 3. [ui] setting 'logtemplate'
 4. [ui] setting 'style'
 If all of these values are either the unset or the empty string,
 regular display via changesetprinter() is done.
 """
-# options
+postargs = (differ, opts, buffered)
-if not makefilematcher and (opts.get('patch') or opts.get('stat')):
-def makefilematcher(ctx):
-return scmutil.matchall(repo)
-postargs = (makefilematcher, makehunksfilter, opts, buffered)
 if opts.get('template') == 'json':
 return jsonchangeset(ui, repo, *postargs)
 spec = _lookuptemplate(ui, opts.get('template'), opts.get('style'))
 revs = smartset.spanset(repo)
 revs.reverse()
 return revs
 def getrevs(repo, pats, opts):
-"""Return (revs, filematcher) where revs is a smartset
+"""Return (revs, differ) where revs is a smartset
-filematcher is a callable taking a changectx and returning a match
+differ is a changesetdiffer with pre-configured file matcher.
-objects 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 = getlimit(opts)
 revs = _initialrevs(repo, opts)
 if expr:
 matcher = revset.match(None, expr)
 revs = matcher(repo, revs)
 if limit is not None:
 revs = revs.slice(0, limit)
-return revs, filematcher
+differ = changesetdiffer()
+differ._makefilematcher = filematcher
+return revs, differ
 def _parselinerangeopt(repo, opts):
 """Parse --line-range log option and return a list of tuples (filename,
 (fromline, toline)).
 """
 linerangebyfname.append(
 (fname, util.processlinerange(fromline, toline)))
 return linerangebyfname
 def getlinerangerevs(repo, userrevs, opts):
-"""Return (revs, filematcher, hunksfilter).
+"""Return (revs, differ).
 "revs" are revisions obtained by processing "line-range" log options and
 walking block ancestors of each specified file/line-range.
-"filematcher(ctx) -> match" is a factory function returning a match object
+"differ" is a changesetdiffer with pre-configured file matcher and hunks
-for a given revision for file patterns specified in --line-range option.
+filter.
-"hunksfilter(ctx) -> filterfn(fctx, hunks)" is a factory function
-returning a hunks filtering function.
 """
 wctx = repo[None]
 # Two-levels map of "rev -> file ctx -> [line range]".
 linerangesbyrev = {}
 files = list(linerangesbyrev.get(ctx.rev(), []))
 return scmutil.matchfiles(repo, files)
 revs = sorted(linerangesbyrev, reverse=True)
-return revs, filematcher, hunksfilter
+differ = changesetdiffer()
+differ._makefilematcher = filematcher
+differ._makehunksfilter = hunksfilter
+return revs, differ
 def _graphnodeformatter(ui, displayer):
 spec = ui.config('ui', 'graphnodetemplate')
 if not spec:
 return templatekw.showgraphnode  # fast path for "{graphnode}"
 for type, char, width, coldata in itertools.chain([firstedge], edges):
 graphmod.ascii(ui, state, type, char, lines, coldata)
 lines = []
 displayer.close()
-def graphlog(ui, repo, revs, filematcher, opts):
+def graphlog(ui, repo, revs, differ, opts):
 # Parameters are identical to log command ones
 revdag = graphmod.dagwalker(repo, revs)
 getrenamed = None
 if opts.get('copies'):
 if opts.get('rev'):
 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
 ui.pager('log')
-displayer = changesetdisplayer(ui, repo, opts, makefilematcher=filematcher,
+displayer = changesetdisplayer(ui, repo, opts, differ, buffered=True)
-buffered=True)
 displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges, getrenamed)
 def checkunsupportedgraphflags(pats, opts):
 for op in ["newest_first"]:
 if op in opts and opts[op]:

changeset 36007	29b83c08afe0
parent 36005	dd77e36eabb6
child 36008	006ff7268c5c