mercurial: comparison mercurial/logcmdutil.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 )
 def getlimit(opts):
 """get the log limit according to option -l/--limit"""
-limit = opts.get('limit')
+limit = opts.get(b'limit')
 if limit:
 try:
 limit = int(limit)
 except ValueError:
-raise error.Abort(_('limit must be a positive integer'))
+raise error.Abort(_(b'limit must be a positive integer'))
 if limit <= 0:
-raise error.Abort(_('limit must be positive'))
+raise error.Abort(_(b'limit must be positive'))
 else:
 limit = None
 return limit
 match,
 changes=None,
 stat=False,
 fp=None,
 graphwidth=0,
-prefix='',
+prefix=b'',
-root='',
+root=b'',
 listsubrepos=False,
 hunksfilterfn=None,
 ):
 '''show diff or diffstat.'''
 ctx1 = repo[node1]
 ctx2 = repo[node2]
 if root:
 relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)
 else:
-relroot = ''
+relroot = b''
 copysourcematch = None
 def compose(f, g):
 return lambda x: f(g(x))
 def pathfn(f):
 return posixpath.join(prefix, f)
-if relroot != '':
+if relroot != b'':
 # XXX relative roots currently don't work if the root is within a
 # subrepo
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 uirelroot = uipathfn(pathfn(relroot))
-relroot += '/'
+relroot += b'/'
 for matchroot in match.files():
 if not matchroot.startswith(relroot):
 ui.warn(
-_('warning: %s not inside relative root %s\n')
+_(b'warning: %s not inside relative root %s\n')
 % (uipathfn(pathfn(matchroot)), uirelroot)
 )
-relrootmatch = scmutil.match(ctx2, pats=[relroot], default='path')
+relrootmatch = scmutil.match(ctx2, pats=[relroot], default=b'path')
 match = matchmod.intersectmatchers(match, relrootmatch)
 copysourcematch = relrootmatch
 checkroot = repo.ui.configbool(
-'devel', 'all-warnings'
+b'devel', b'all-warnings'
-) or repo.ui.configbool('devel', 'check-relroot')
+) or repo.ui.configbool(b'devel', b'check-relroot')
 def relrootpathfn(f):
 if checkroot and not f.startswith(relroot):
 raise AssertionError(
-"file %s doesn't start with relroot %s" % (f, relroot)
+b"file %s doesn't start with relroot %s" % (f, relroot)
 )
 return f[len(relroot) :]
 pathfn = compose(relrootpathfn, pathfn)
 hunksfilterfn=self._makehunksfilter(ctx),
 )
 def changesetlabels(ctx):
-labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]
+labels = [b'log.changeset', b'changeset.%s' % ctx.phasestr()]
 if ctx.obsolete():
-labels.append('changeset.obsolete')
+labels.append(b'changeset.obsolete')
 if ctx.isunstable():
-labels.append('changeset.unstable')
+labels.append(b'changeset.unstable')
 for instability in ctx.instabilities():
-labels.append('instability.%s' % instability)
+labels.append(b'instability.%s' % instability)
-return ' '.join(labels)
+return b' '.join(labels)
 class changesetprinter(object):
 '''show changeset information when templating not requested.'''
 self.ui = ui
 self.repo = repo
 self.buffered = buffered
 self._differ = differ or changesetdiffer()
 self._diffopts = patch.diffallopts(ui, diffopts)
-self._includestat = diffopts and diffopts.get('stat')
+self._includestat = diffopts and diffopts.get(b'stat')
-self._includediff = diffopts and diffopts.get('patch')
+self._includediff = diffopts and diffopts.get(b'patch')
 self.header = {}
 self.hunk = {}
 self.lastheader = None
 self.footer = None
 self._columns = templatekw.getlogcolumns()
 self._show(ctx, copies, props)
 def _show(self, ctx, copies, props):
 '''show a single changeset or file revision'''
 changenode = ctx.node()
-graphwidth = props.get('graphwidth', 0)
+graphwidth = props.get(b'graphwidth', 0)
 if self.ui.quiet:
 self.ui.write(
-"%s\n" % scmutil.formatchangeid(ctx), label='log.node'
+b"%s\n" % scmutil.formatchangeid(ctx), label=b'log.node'
 )
 return
 columns = self._columns
 self.ui.write(
-columns['changeset'] % scmutil.formatchangeid(ctx),
+columns[b'changeset'] % scmutil.formatchangeid(ctx),
 label=changesetlabels(ctx),
 )
 # branches are shown first before any other names due to backwards
 # compatibility
 branch = ctx.branch()
 # don't show the default branch name
-if branch != 'default':
+if branch != b'default':
-self.ui.write(columns['branch'] % branch, label='log.branch')
+self.ui.write(columns[b'branch'] % branch, label=b'log.branch')
 for nsname, ns in self.repo.names.iteritems():
 # branches has special logic already handled above, so here we just
 # skip it
-if nsname == 'branches':
+if nsname == b'branches':
 continue
 # we will use the templatename as the color name since those two
 # should be the same
 for name in ns.names(self.repo, changenode):
-self.ui.write(ns.logfmt % name, label='log.%s' % ns.colorname)
+self.ui.write(ns.logfmt % name, label=b'log.%s' % ns.colorname)
 if self.ui.debugflag:
-self.ui.write(columns['phase'] % ctx.phasestr(), label='log.phase')
+self.ui.write(
+columns[b'phase'] % ctx.phasestr(), label=b'log.phase'
+)
 for pctx in scmutil.meaningfulparents(self.repo, ctx):
-label = 'log.parent changeset.%s' % pctx.phasestr()
+label = b'log.parent changeset.%s' % pctx.phasestr()
 self.ui.write(
-columns['parent'] % scmutil.formatchangeid(pctx), label=label
+columns[b'parent'] % scmutil.formatchangeid(pctx), label=label
 )
 if self.ui.debugflag:
 mnode = ctx.manifestnode()
 if mnode is None:
 mnode = wdirid
 mrev = wdirrev
 else:
 mrev = self.repo.manifestlog.rev(mnode)
 self.ui.write(
-columns['manifest']
+columns[b'manifest']
 % scmutil.formatrevnode(self.ui, mrev, mnode),
-label='ui.debug log.manifest',
+label=b'ui.debug log.manifest',
 )
-self.ui.write(columns['user'] % ctx.user(), label='log.user')
+self.ui.write(columns[b'user'] % ctx.user(), label=b'log.user')
 self.ui.write(
-columns['date'] % dateutil.datestr(ctx.date()), label='log.date'
+columns[b'date'] % dateutil.datestr(ctx.date()), label=b'log.date'
 )
 if ctx.isunstable():
 instabilities = ctx.instabilities()
 self.ui.write(
-columns['instability'] % ', '.join(instabilities),
+columns[b'instability'] % b', '.join(instabilities),
-label='log.instability',
+label=b'log.instability',
 )
 elif ctx.obsolete():
 self._showobsfate(ctx)
 self._exthook(ctx)
 if self.ui.debugflag:
 files = ctx.p1().status(ctx)[:3]
-for key, value in zip(['files', 'files+', 'files-'], files):
+for key, value in zip([b'files', b'files+', b'files-'], files):
 if value:
 self.ui.write(
-columns[key] % " ".join(value),
+columns[key] % b" ".join(value),
-label='ui.debug log.files',
+label=b'ui.debug log.files',
 )
 elif ctx.files() and self.ui.verbose:
 self.ui.write(
-columns['files'] % " ".join(ctx.files()),
+columns[b'files'] % b" ".join(ctx.files()),
-label='ui.note log.files',
+label=b'ui.note log.files',
 )
 if copies and self.ui.verbose:
-copies = ['%s (%s)' % c for c in copies]
+copies = [b'%s (%s)' % c for c in copies]
 self.ui.write(
-columns['copies'] % ' '.join(copies), label='ui.note log.copies'
+columns[b'copies'] % b' '.join(copies),
+label=b'ui.note log.copies',
 )
 extra = ctx.extra()
 if extra and self.ui.debugflag:
 for key, value in sorted(extra.items()):
 self.ui.write(
-columns['extra'] % (key, stringutil.escapestr(value)),
+columns[b'extra'] % (key, stringutil.escapestr(value)),
-label='ui.debug log.extra',
+label=b'ui.debug log.extra',
 )
 description = ctx.description().strip()
 if description:
 if self.ui.verbose:
 self.ui.write(
-_("description:\n"), label='ui.note log.description'
+_(b"description:\n"), label=b'ui.note log.description'
 )
-self.ui.write(description, label='ui.note log.description')
+self.ui.write(description, label=b'ui.note log.description')
-self.ui.write("\n\n")
+self.ui.write(b"\n\n")
 else:
 self.ui.write(
-columns['summary'] % description.splitlines()[0],
+columns[b'summary'] % description.splitlines()[0],
-label='log.summary',
+label=b'log.summary',
 )
-self.ui.write("\n")
+self.ui.write(b"\n")
 self._showpatch(ctx, graphwidth)
 def _showobsfate(self, ctx):
 # TODO: do not depend on templater
 tres = formatter.templateresources(self.repo.ui, self.repo)
 t = formatter.maketemplater(
 self.repo.ui,
-'{join(obsfate, "\n")}',
+b'{join(obsfate, "\n")}',
 defaults=templatekw.keywords,
 resources=tres,
 )
-obsfate = t.renderdefault({'ctx': ctx}).splitlines()
+obsfate = t.renderdefault({b'ctx': ctx}).splitlines()
 if obsfate:
 for obsfateline in obsfate:
 self.ui.write(
-self._columns['obsolete'] % obsfateline, label='log.obsfate'
+self._columns[b'obsolete'] % obsfateline,
+label=b'log.obsfate',
 )
 def _exthook(self, ctx):
 '''empty method used by extension as a hook point
 '''
 if self._includestat:
 self._differ.showdiff(
 self.ui, ctx, self._diffopts, graphwidth, stat=True
 )
 if self._includestat and self._includediff:
-self.ui.write("\n")
+self.ui.write(b"\n")
 if self._includediff:
 self._differ.showdiff(
 self.ui, ctx, self._diffopts, graphwidth, stat=False
 )
 if self._includestat or self._includediff:
-self.ui.write("\n")
+self.ui.write(b"\n")
 class changesetformatter(changesetprinter):
 """Format changeset information by generic formatter"""
 branch=ctx.branch(),
 phase=ctx.phasestr(),
 user=ctx.user(),
 date=fm.formatdate(ctx.date()),
 desc=ctx.description(),
-bookmarks=fm.formatlist(ctx.bookmarks(), name='bookmark'),
+bookmarks=fm.formatlist(ctx.bookmarks(), name=b'bookmark'),
-tags=fm.formatlist(ctx.tags(), name='tag'),
+tags=fm.formatlist(ctx.tags(), name=b'tag'),
 parents=fm.formatlist(
-[fm.hexfunc(c.node()) for c in ctx.parents()], name='node'
+[fm.hexfunc(c.node()) for c in ctx.parents()], name=b'node'
 ),
 )
 if self.ui.debugflag:
 fm.data(
 extra=fm.formatdict(ctx.extra()),
 )
 files = ctx.p1().status(ctx)
 fm.data(
-modified=fm.formatlist(files[0], name='file'),
+modified=fm.formatlist(files[0], name=b'file'),
-added=fm.formatlist(files[1], name='file'),
+added=fm.formatlist(files[1], name=b'file'),
-removed=fm.formatlist(files[2], name='file'),
+removed=fm.formatlist(files[2], name=b'file'),
 )
 elif self.ui.verbose:
-fm.data(files=fm.formatlist(ctx.files(), name='file'))
+fm.data(files=fm.formatlist(ctx.files(), name=b'file'))
 if copies:
 fm.data(
-copies=fm.formatdict(copies, key='name', value='source')
+copies=fm.formatdict(copies, key=b'name', value=b'source')
 )
 if self._includestat:
 self.ui.pushbuffer()
 self._differ.showdiff(self.ui, ctx, self._diffopts, stat=True)
 )
 self._counter = itertools.count()
 self._tref = tmplspec.ref
 self._parts = {
-'header': '',
+b'header': b'',
-'footer': '',
+b'footer': b'',
 tmplspec.ref: tmplspec.ref,
-'docheader': '',
+b'docheader': b'',
-'docfooter': '',
+b'docfooter': b'',
-'separator': '',
+b'separator': b'',
 }
 if tmplspec.mapfile:
 # find correct templates for current mode, for backward
 # compatibility with 'log -v/-q/--debug' using a mapfile
 tmplmodes = [
-(True, ''),
+(True, b''),
-(self.ui.verbose, '_verbose'),
+(self.ui.verbose, b'_verbose'),
-(self.ui.quiet, '_quiet'),
+(self.ui.quiet, b'_quiet'),
-(self.ui.debugflag, '_debug'),
+(self.ui.debugflag, b'_debug'),
 ]
 for mode, postfix in tmplmodes:
 for t in self._parts:
 cur = t + postfix
 if mode and cur in self.t:
 else:
 partnames = [p for p in self._parts.keys() if p != tmplspec.ref]
 m = formatter.templatepartsmap(tmplspec, self.t, partnames)
 self._parts.update(m)
-if self._parts['docheader']:
+if self._parts[b'docheader']:
-self.ui.write(self.t.render(self._parts['docheader'], {}))
+self.ui.write(self.t.render(self._parts[b'docheader'], {}))
 def close(self):
-if self._parts['docfooter']:
+if self._parts[b'docfooter']:
 if not self.footer:
-self.footer = ""
+self.footer = b""
-self.footer += self.t.render(self._parts['docfooter'], {})
+self.footer += self.t.render(self._parts[b'docfooter'], {})
 return super(changesettemplater, self).close()
 def _show(self, ctx, copies, props):
 '''show a single changeset or file revision'''
 props = props.copy()
-props['ctx'] = ctx
+props[b'ctx'] = ctx
-props['index'] = index = next(self._counter)
+props[b'index'] = index = next(self._counter)
-props['revcache'] = {'copies': copies}
+props[b'revcache'] = {b'copies': copies}
-graphwidth = props.get('graphwidth', 0)
+graphwidth = props.get(b'graphwidth', 0)
 # write separator, which wouldn't work well with the header part below
 # since there's inherently a conflict between header (across items) and
 # separator (per item)
-if self._parts['separator'] and index > 0:
+if self._parts[b'separator'] and index > 0:
-self.ui.write(self.t.render(self._parts['separator'], {}))
+self.ui.write(self.t.render(self._parts[b'separator'], {}))
 # write header
-if self._parts['header']:
+if self._parts[b'header']:
-h = self.t.render(self._parts['header'], props)
+h = self.t.render(self._parts[b'header'], props)
 if self.buffered:
 self.header[ctx.rev()] = h
 else:
 if self.lastheader != h:
 self.lastheader = h
 # write changeset metadata, then patch if requested
 key = self._parts[self._tref]
 self.ui.write(self.t.render(key, props))
 self._showpatch(ctx, graphwidth)
-if self._parts['footer']:
+if self._parts[b'footer']:
 if not self.footer:
-self.footer = self.t.render(self._parts['footer'], props)
+self.footer = self.t.render(self._parts[b'footer'], props)
 def templatespec(tmpl, mapfile):
 if pycompat.ispy3:
-assert not isinstance(tmpl, str), 'tmpl must not be a str'
+assert not isinstance(tmpl, str), b'tmpl must not be a str'
 if mapfile:
-return formatter.templatespec('changeset', tmpl, mapfile)
+return formatter.templatespec(b'changeset', tmpl, mapfile)
 else:
-return formatter.templatespec('', tmpl, None)
+return formatter.templatespec(b'', tmpl, None)
 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')
+tmpl = ui.config(b'ui', b'logtemplate')
 if tmpl:
 return templatespec(templater.unquotestring(tmpl), None)
 else:
-style = util.expandpath(ui.config('ui', 'style'))
+style = util.expandpath(ui.config(b'ui', b'style'))
 if not tmpl and style:
 mapfile = style
 if not os.path.split(mapfile)[0]:
 mapname = templater.templatepath(
-'map-cmdline.' + mapfile
+b'map-cmdline.' + mapfile
 ) or templater.templatepath(mapfile)
 if mapname:
 mapfile = mapname
 return templatespec(None, mapfile)
 if not tmpl:
 return templatespec(None, None)
-return formatter.lookuptemplate(ui, 'changeset', tmpl)
+return formatter.lookuptemplate(ui, b'changeset', tmpl)
 def maketemplater(ui, repo, tmpl, buffered=False):
 """Create a changesettemplater from a literal template 'tmpl'
 byte-string."""
 4. [ui] setting 'style'
 If all of these values are either the unset or the empty string,
 regular display via changesetprinter() is done.
 """
 postargs = (differ, opts, buffered)
-if opts.get('template') in {'cbor', 'json'}:
+if opts.get(b'template') in {b'cbor', b'json'}:
-fm = ui.formatter('log', opts)
+fm = ui.formatter(b'log', opts)
 return changesetformatter(ui, repo, fm, *postargs)
-spec = _lookuptemplate(ui, opts.get('template'), opts.get('style'))
+spec = _lookuptemplate(ui, opts.get(b'template'), opts.get(b'style'))
 if not spec.ref and not spec.tmpl and not spec.mapfile:
 return changesetprinter(ui, repo, *postargs)
 return changesettemplater(ui, repo, spec, *postargs)
 # _matchfiles() revset but walkchangerevs() builds its matcher with
 # scmutil.match(). The difference is input pats are globbed on
 # platforms without shell expansion (windows).
 wctx = repo[None]
 match, pats = scmutil.matchandpats(wctx, pats, opts)
-slowpath = match.anypats() or (not match.always() and opts.get('removed'))
+slowpath = match.anypats() or (not match.always() and opts.get(b'removed'))
 if not slowpath:
-follow = opts.get('follow') or opts.get('follow_first')
+follow = opts.get(b'follow') or opts.get(b'follow_first')
 startctxs = []
-if follow and opts.get('rev'):
+if follow and opts.get(b'rev'):
 startctxs = [repo[r] for r in revs]
 for f in match.files():
 if follow and startctxs:
 # No idea if the path was a directory at that revision, so
 # take the slow path.
 if os.path.exists(repo.wjoin(f)):
 slowpath = True
 continue
 else:
 raise error.Abort(
-_('cannot follow file not in parent ' 'revision: "%s"')
+_(
+b'cannot follow file not in parent '
+b'revision: "%s"'
+)
 % f
 )
 filelog = repo.file(f)
 if not filelog:
 # A zero count may be a directory or deleted file, so
 # try to find matching entries on the slow path.
 if follow:
 raise error.Abort(
-_('cannot follow nonexistent file: "%s"') % f
+_(b'cannot follow nonexistent file: "%s"') % f
 )
 slowpath = True
 # We decided to fall back to the slowpath because at least one
 # of the paths was not a file. Check to see if at least one of them
 # existed in history - in that case, we'll continue down the
 # slowpath; otherwise, we can turn off the slowpath
 if slowpath:
 for path in match.files():
-if path == '.' or path in repo.store:
+if path == b'.' or path in repo.store:
 break
 else:
 slowpath = False
 return match, pats, slowpath
 '''hook for extensions to override the filematcher for non-follow cases'''
 return None
 _opt2logrevset = {
-'no_merges': ('not merge()', None),
+b'no_merges': (b'not merge()', None),
-'only_merges': ('merge()', None),
+b'only_merges': (b'merge()', None),
-'_matchfiles': (None, '_matchfiles(%ps)'),
+b'_matchfiles': (None, b'_matchfiles(%ps)'),
-'date': ('date(%s)', None),
+b'date': (b'date(%s)', None),
-'branch': ('branch(%s)', '%lr'),
+b'branch': (b'branch(%s)', b'%lr'),
-'_patslog': ('filelog(%s)', '%lr'),
+b'_patslog': (b'filelog(%s)', b'%lr'),
-'keyword': ('keyword(%s)', '%lr'),
+b'keyword': (b'keyword(%s)', b'%lr'),
-'prune': ('ancestors(%s)', 'not %lr'),
+b'prune': (b'ancestors(%s)', b'not %lr'),
-'user': ('user(%s)', '%lr'),
+b'user': (b'user(%s)', b'%lr'),
 }
 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')
+follow = opts.get(b'follow') or opts.get(b'follow_first')
 # branch and only_branch are really aliases and must be handled at
 # the same time
-opts['branch'] = opts.get('branch', []) + opts.get('only_branch', [])
+opts[b'branch'] = opts.get(b'branch', []) + opts.get(b'only_branch', [])
-opts['branch'] = [repo.lookupbranch(b) for b in opts['branch']]
+opts[b'branch'] = [repo.lookupbranch(b) for b in opts[b'branch']]
 if slowpath:
 # See walkchangerevs() slow path.
 #
 # pats/include/exclude cannot be represented as separate
 # revset expressions as their filtering logic applies at file
 # level. For instance "-I a -X b" matches a revision touching
 # "a" and "b" while "file(a) and not file(b)" does
 # not. Besides, filesets are evaluated against the working
 # directory.
-matchargs = ['r:', 'd:relpath']
+matchargs = [b'r:', b'd:relpath']
 for p in pats:
-matchargs.append('p:' + p)
+matchargs.append(b'p:' + p)
-for p in opts.get('include', []):
+for p in opts.get(b'include', []):
-matchargs.append('i:' + p)
+matchargs.append(b'i:' + p)
-for p in opts.get('exclude', []):
+for p in opts.get(b'exclude', []):
-matchargs.append('x:' + p)
+matchargs.append(b'x:' + p)
-opts['_matchfiles'] = matchargs
+opts[b'_matchfiles'] = matchargs
 elif not follow:
-opts['_patslog'] = list(pats)
+opts[b'_patslog'] = list(pats)
 expr = []
 for op, val in sorted(opts.iteritems()):
 if not val:
 continue
 if op not in _opt2logrevset:
 continue
 revop, listop = _opt2logrevset[op]
-if revop and '%' not in revop:
+if revop and b'%' not in revop:
 expr.append(revop)
 elif not listop:
 expr.append(revsetlang.formatspec(revop, val))
 else:
 if revop:
 val = [revsetlang.formatspec(revop, v) for v in val]
 expr.append(revsetlang.formatspec(listop, val))
 if expr:
-expr = '(' + ' and '.join(expr) + ')'
+expr = b'(' + b' and '.join(expr) + b')'
 else:
 expr = None
 return expr
 def _initialrevs(repo, opts):
 """Return the initial set of revisions to be filtered or followed"""
-follow = opts.get('follow') or opts.get('follow_first')
+follow = opts.get(b'follow') or opts.get(b'follow_first')
-if opts.get('rev'):
+if opts.get(b'rev'):
-revs = scmutil.revrange(repo, opts['rev'])
+revs = scmutil.revrange(repo, opts[b'rev'])
 elif follow and repo.dirstate.p1() == nullid:
 revs = smartset.baseset()
 elif follow:
-revs = repo.revs('.')
+revs = repo.revs(b'.')
 else:
 revs = smartset.spanset(repo)
 revs.reverse()
 return revs
 def getrevs(repo, pats, opts):
 """Return (revs, differ) where revs is a smartset
 differ is a changesetdiffer with pre-configured file matcher.
 """
-follow = opts.get('follow') or opts.get('follow_first')
+follow = opts.get(b'follow') or opts.get(b'follow_first')
-followfirst = opts.get('follow_first')
+followfirst = opts.get(b'follow_first')
 limit = getlimit(opts)
 revs = _initialrevs(repo, opts)
 if not revs:
 return smartset.baseset(), None
 match, pats, slowpath = _makematcher(repo, revs, pats, opts)
 def filematcher(ctx):
 return match
 expr = _makerevset(repo, match, pats, slowpath, opts)
-if opts.get('graph'):
+if opts.get(b'graph'):
 # User-specified revs might be unsorted, but don't sort before
 # _makerevset because it might depend on the order of revs
-if repo.ui.configbool('experimental', 'log.topo'):
+if repo.ui.configbool(b'experimental', b'log.topo'):
 if not revs.istopo():
 revs = dagop.toposort(revs, repo.changelog.parentrevs)
 # TODO: try to iterate the set lazily
 revs = revset.baseset(list(revs), istopo=True)
 elif not (revs.isdescending() or revs.istopo()):
 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', []):
+for pat in opts.get(b'line_range', []):
 try:
-pat, linerange = pat.rsplit(',', 1)
+pat, linerange = pat.rsplit(b',', 1)
 except ValueError:
-raise error.Abort(_('malformatted line-range pattern %s') % pat)
+raise error.Abort(_(b'malformatted line-range pattern %s') % pat)
 try:
-fromline, toline = map(int, linerange.split(':'))
+fromline, toline = map(int, linerange.split(b':'))
 except ValueError:
-raise error.Abort(_("invalid line range for %s") % pat)
+raise error.Abort(_(b"invalid line range for %s") % pat)
-msg = _("line range pattern '%s' must match exactly one file") % pat
+msg = _(b"line range pattern '%s' must match exactly one file") % pat
 fname = scmutil.parsefollowlinespattern(repo, None, pat, msg)
 linerangebyfname.append(
 (fname, util.processlinerange(fromline, toline))
 )
 return linerangebyfname
 # Two-levels map of "rev -> file ctx -> [line range]".
 linerangesbyrev = {}
 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
+_(b'cannot follow file not in parent ' b'revision: "%s"')
+% fname
 )
 fctx = wctx.filectx(fname)
 for fctx, linerange in dagop.blockancestors(fctx, fromline, toline):
 rev = fctx.introrev()
 if rev not in userrevs:
 differ._makehunksfilter = hunksfilter
 return revs, differ
 def _graphnodeformatter(ui, displayer):
-spec = ui.config('ui', 'graphnodetemplate')
+spec = ui.config(b'ui', b'graphnodetemplate')
 if not spec:
 return templatekw.getgraphnode  # fast path for "{graphnode}"
 spec = templater.unquotestring(spec)
 if isinstance(displayer, changesettemplater):
 templ = formatter.maketemplater(
 ui, spec, defaults=templatekw.keywords, resources=tres
 )
 def formatnode(repo, ctx):
-props = {'ctx': ctx, 'repo': repo}
+props = {b'ctx': ctx, b'repo': repo}
 return templ.renderdefault(props)
 return formatnode
 def displaygraph(ui, repo, dag, displayer, edgefn, getcopies=None, props=None):
 props = props or {}
 formatnode = _graphnodeformatter(ui, displayer)
 state = graphmod.asciistate()
-styles = state['styles']
+styles = state[b'styles']
 # only set graph styling if HGPLAIN is not set.
-if ui.plain('graph'):
+if ui.plain(b'graph'):
 # set all edge styles to |, the default pre-3.8 behaviour
-styles.update(dict.fromkeys(styles, '|'))
+styles.update(dict.fromkeys(styles, b'|'))
 else:
 edgetypes = {
-'parent': graphmod.PARENT,
+b'parent': graphmod.PARENT,
-'grandparent': graphmod.GRANDPARENT,
+b'grandparent': graphmod.GRANDPARENT,
-'missing': graphmod.MISSINGPARENT,
+b'missing': graphmod.MISSINGPARENT,
 }
 for name, key in edgetypes.items():
 # experimental config: experimental.graphstyle.*
 styles[key] = ui.config(
-'experimental', 'graphstyle.%s' % name, styles[key]
+b'experimental', b'graphstyle.%s' % name, styles[key]
 )
 if not styles[key]:
 styles[key] = None
 # experimental config: experimental.graphshorten
-state['graphshorten'] = ui.configbool('experimental', 'graphshorten')
+state[b'graphshorten'] = ui.configbool(b'experimental', b'graphshorten')
 for rev, type, ctx, parents in dag:
 char = formatnode(repo, ctx)
 copies = getcopies(ctx) if getcopies else None
 edges = edgefn(type, char, state, rev, parents)
 firstedge = next(edges)
 width = firstedge[2]
 displayer.show(
 ctx, copies=copies, graphwidth=width, **pycompat.strkwargs(props)
 )
-lines = displayer.hunk.pop(rev).split('\n')
+lines = displayer.hunk.pop(rev).split(b'\n')
 if not lines[-1]:
 del lines[-1]
 displayer.flush(ctx)
 for type, char, width, coldata in itertools.chain([firstedge], edges):
 graphmod.ascii(ui, state, type, char, lines, coldata)
 displayer.flush(ctx)
 displayer.close()
 def checkunsupportedgraphflags(pats, opts):
-for op in ["newest_first"]:
+for op in [b"newest_first"]:
 if op in opts and opts[op]:
 raise error.Abort(
-_("-G/--graph option is incompatible with --%s")
+_(b"-G/--graph option is incompatible with --%s")
-% op.replace("_", "-")
+% op.replace(b"_", b"-")
 )
 def graphrevs(repo, nodes, opts):
 limit = getlimit(opts)

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43100	90b9a7e06c2c