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

comparison mercurial/logcmdutil.py @ 35927:572f36e9a780

logcmdutil: drop redundant "log" from function names (API) A few exceptions: - s/loglimit/getlimit/ to avoid name conflict - s/_logrevs/_initialrevs/ to clarify its functionality

author	Yuya Nishihara <yuya@tcha.org>
date	Sun, 21 Jan 2018 12:48:39 +0900
parents	b0014780c7fc
children	64f4a6808704

comparison

equal deleted inserted replaced

-:b0014780c7fc
+:572f36e9a780
 templatekw,
 templater,
 util,
 )
-def loglimit(opts):
+def getlimit(opts):
 """get the log limit according to option -l/--limit"""
 limit = opts.get('limit')
 if limit:
 try:
 limit = int(limit)
 class changesettemplater(changesetprinter):
 '''format changeset information.
 Note: there are a variety of convenience functions to build a
 changesettemplater for common cases. See functions such as:
-makelogtemplater, changesetdisplayer, buildcommittemplate, or other
+maketemplater, changesetdisplayer, buildcommittemplate, or other
 functions that use changesest_templater.
 '''
 # Arguments before "buffered" used to be positional. Consider not
 # adding/removing arguments before "buffered" to not break callers.
 if self._parts['footer']:
 if not self.footer:
 self.footer = templater.stringify(
 self.t(self._parts['footer'], **props))
-def logtemplatespec(tmpl, mapfile):
+def templatespec(tmpl, mapfile):
 if mapfile:
 return formatter.templatespec('changeset', tmpl, mapfile)
 else:
 return formatter.templatespec('', tmpl, None)
-def _lookuplogtemplate(ui, tmpl, style):
+def _lookuptemplate(ui, tmpl, style):
 """Find the template matching the given template spec or style
 See formatter.lookuptemplate() for details.
 """
 # ui settings
 if not tmpl and not style: # template are stronger than style
 tmpl = ui.config('ui', 'logtemplate')
 if tmpl:
-return logtemplatespec(templater.unquotestring(tmpl), None)
+return templatespec(templater.unquotestring(tmpl), None)
 else:
 style = util.expandpath(ui.config('ui', 'style'))
 if not tmpl and style:
 mapfile = style
 if not os.path.split(mapfile)[0]:
 mapname = (templater.templatepath('map-cmdline.' + mapfile)
 or templater.templatepath(mapfile))
 if mapname:
 mapfile = mapname
-return logtemplatespec(None, mapfile)
+return templatespec(None, mapfile)
 if not tmpl:
-return logtemplatespec(None, None)
+return templatespec(None, None)
 return formatter.lookuptemplate(ui, 'changeset', tmpl)
-def makelogtemplater(ui, repo, tmpl, buffered=False):
+def maketemplater(ui, repo, tmpl, buffered=False):
 """Create a changesettemplater from a literal template 'tmpl'
 byte-string."""
-spec = logtemplatespec(tmpl, None)
+spec = templatespec(tmpl, None)
 return changesettemplater(ui, repo, spec, buffered=buffered)
 def changesetdisplayer(ui, repo, opts, buffered=False):
 """show one changeset using template or regular display.
 match = scmutil.matchall(repo)
 if opts.get('template') == 'json':
 return jsonchangeset(ui, repo, match, opts, buffered)
-spec = _lookuplogtemplate(ui, opts.get('template'), opts.get('style'))
+spec = _lookuptemplate(ui, opts.get('template'), opts.get('style'))
 if not spec.ref and not spec.tmpl and not spec.mapfile:
 return changesetprinter(ui, repo, match, opts, buffered)
 return changesettemplater(ui, repo, spec, match, opts, buffered)
-def _makelogmatcher(repo, revs, pats, opts):
+def _makematcher(repo, revs, pats, opts):
 """Build matcher and expanded patterns from log options
 If --follow, revs are the revisions to follow from.
 Returns (match, pats, slowpath) where
 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):
+def _makenofollowfilematcher(repo, pats, opts):
 '''hook for extensions to override the filematcher for non-follow cases'''
 return None
 _opt2logrevset = {
 'no_merges':        ('not merge()', None),
 'keyword':          ('keyword(%s)', '%lr'),
 'prune':            ('ancestors(%s)', 'not %lr'),
 'user':             ('user(%s)', '%lr'),
 }
-def _makelogrevset(repo, match, pats, slowpath, opts):
+def _makerevset(repo, match, pats, slowpath, opts):
 """Return a revset string built from log options and file patterns"""
 opts = dict(opts)
 # follow or not follow?
 follow = opts.get('follow') or opts.get('follow_first')
 expr = '(' + ' and '.join(expr) + ')'
 else:
 expr = None
 return expr
-def _logrevs(repo, opts):
+def _initialrevs(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'):
 revs = scmutil.revrange(repo, opts['rev'])
 elif follow and repo.dirstate.p1() == nullid:
 else:
 revs = smartset.spanset(repo)
 revs.reverse()
 return revs
-def getlogrevs(repo, pats, opts):
+def getrevs(repo, pats, opts):
 """Return (revs, filematcher) where revs is a smartset
 filematcher is a callable taking a revision number and returning a match
 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 = loglimit(opts)
+limit = getlimit(opts)
-revs = _logrevs(repo, opts)
+revs = _initialrevs(repo, opts)
 if not revs:
 return smartset.baseset(), None
-match, pats, slowpath = _makelogmatcher(repo, revs, pats, opts)
+match, pats, slowpath = _makematcher(repo, revs, pats, opts)
 filematcher = None
 if follow:
 if slowpath or match.always():
 revs = dagop.revancestors(repo, revs, followfirst=followfirst)
 else:
 revs, filematcher = _fileancestors(repo, revs, match, followfirst)
 revs.reverse()
 if filematcher is None:
-filematcher = _makenofollowlogfilematcher(repo, pats, opts)
+filematcher = _makenofollowfilematcher(repo, pats, opts)
 if filematcher is None:
 def filematcher(rev):
 return match
-expr = _makelogrevset(repo, match, pats, slowpath, opts)
+expr = _makerevset(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
+# _makerevset because it might depend on the order of revs
 if not (revs.isdescending() or revs.istopo()):
 revs.sort(reverse=True)
 if expr:
 matcher = revset.match(None, expr)
 revs = matcher(repo, revs)
 if limit is not None:
 revs = revs.slice(0, limit)
 return revs, filematcher
-def _parselinerangelogopt(repo, opts):
+def _parselinerangeopt(repo, opts):
 """Parse --line-range log option and return a list of tuples (filename,
 (fromline, toline)).
 """
 linerangebyfname = []
 for pat in opts.get('line_range', []):
 fname = scmutil.parsefollowlinespattern(repo, None, pat, msg)
 linerangebyfname.append(
 (fname, util.processlinerange(fromline, toline)))
 return linerangebyfname
-def getloglinerangerevs(repo, userrevs, opts):
+def getlinerangerevs(repo, userrevs, opts):
 """Return (revs, filematcher, hunksfilter).
 "revs" are revisions obtained by processing "line-range" log options and
 walking block ancestors of each specified file/line-range.
 """
 wctx = repo[None]
 # Two-levels map of "rev -> file ctx -> [line range]".
 linerangesbyrev = {}
-for fname, (fromline, toline) in _parselinerangelogopt(repo, opts):
+for fname, (fromline, toline) in _parselinerangeopt(repo, opts):
 if fname not in wctx:
 raise error.Abort(_('cannot follow file not in parent '
 'revision: "%s"') % fname)
 fctx = wctx.filectx(fname)
 for fctx, linerange in dagop.blockancestors(fctx, fromline, toline):
 if op in opts and opts[op]:
 raise error.Abort(_("-G/--graph option is incompatible with --%s")
 % op.replace("_", "-"))
 def graphrevs(repo, nodes, opts):
-limit = loglimit(opts)
+limit = getlimit(opts)
 nodes.reverse()
 if limit is not None:
 nodes = nodes[:limit]
 return graphmod.nodes(repo, nodes)

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/logcmdutil.py @ 35927:572f36e9a780