Mercurial > public > mercurial-scm > hg
diff mercurial/revset.py @ 43077:687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Done with
python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py')
black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**')
# skip-blame mass-reformatting only
Differential Revision: https://phab.mercurial-scm.org/D6972
| author | Augie Fackler <augie@google.com> |
|---|---|
| date | Sun, 06 Oct 2019 09:48:39 -0400 |
| parents | 2372284d9457 |
| children | c59eb1560c44 |
line wrap: on
line diff
--- a/mercurial/revset.py Sun Oct 06 09:45:02 2019 -0400 +++ b/mercurial/revset.py Sun Oct 06 09:48:39 2019 -0400 @@ -93,22 +93,22 @@ # # There are a few revsets that always redefine the order if 'define' is # specified: 'sort(X)', 'reverse(X)', 'x:y'. -anyorder = 'any' # don't care the order, could be even random-shuffled -defineorder = 'define' # ALWAYS redefine, or ALWAYS follow the current order -followorder = 'follow' # MUST follow the current order +anyorder = b'any' # don't care the order, could be even random-shuffled +defineorder = b'define' # ALWAYS redefine, or ALWAYS follow the current order +followorder = b'follow' # MUST follow the current order # helpers def getset(repo, subset, x, order=defineorder): if not x: - raise error.ParseError(_("missing argument")) + raise error.ParseError(_(b"missing argument")) return methods[x[0]](repo, subset, *x[1:], order=order) def _getrevsource(repo, r): extra = repo[r].extra() - for label in ('source', 'transplant_source', 'rebase_source'): + for label in (b'source', b'transplant_source', b'rebase_source'): if label in extra: try: return repo[extra[label]].rev() @@ -126,7 +126,7 @@ def stringset(repo, subset, x, order): if not x: - raise error.ParseError(_("empty string is not a valid revision")) + raise error.ParseError(_(b"empty string is not a valid revision")) x = scmutil.intrev(scmutil.revsymbol(repo, x)) if x in subset or x in _virtualrevs and isinstance(subset, fullreposet): return baseset([x]) @@ -246,7 +246,7 @@ def relationset(repo, subset, x, y, order): - raise error.ParseError(_("can't use a relation in this context")) + raise error.ParseError(_(b"can't use a relation in this context")) def _splitrange(a, b): @@ -285,8 +285,8 @@ # descendants() predicates a, b = getintrange( z, - _('relation subscript must be an integer or a range'), - _('relation subscript bounds must be integers'), + _(b'relation subscript must be an integer or a range'), + _(b'relation subscript bounds must be integers'), deffirst=-(dagop.maxlogdepth - 1), deflast=+(dagop.maxlogdepth - 1), ) @@ -323,18 +323,18 @@ def subscriptset(repo, subset, x, y, order): - raise error.ParseError(_("can't use a subscript in this context")) + raise error.ParseError(_(b"can't use a subscript in this context")) def listset(repo, subset, *xs, **opts): raise error.ParseError( - _("can't use a list in this context"), - hint=_('see \'hg help "revsets.x or y"\''), + _(b"can't use a list in this context"), + hint=_(b'see \'hg help "revsets.x or y"\''), ) def keyvaluepair(repo, subset, k, v, order): - raise error.ParseError(_("can't use a key-value pair in this context")) + raise error.ParseError(_(b"can't use a key-value pair in this context")) def func(repo, subset, a, b, order): @@ -369,16 +369,16 @@ predicate = registrar.revsetpredicate() -@predicate('_destupdate') +@predicate(b'_destupdate') def _destupdate(repo, subset, x): # experimental revset for update destination - args = getargsdict(x, 'limit', 'clean') + args = getargsdict(x, b'limit', b'clean') return subset & baseset( [destutil.destupdate(repo, **pycompat.strkwargs(args))[0]] ) -@predicate('_destmerge') +@predicate(b'_destmerge') def _destmerge(repo, subset, x): # experimental revset for merge destination sourceset = None @@ -387,7 +387,7 @@ return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)]) -@predicate('adds(pattern)', safe=True, weight=30) +@predicate(b'adds(pattern)', safe=True, weight=30) def adds(repo, subset, x): """Changesets that add a file matching pattern. @@ -396,11 +396,11 @@ directory. """ # i18n: "adds" is a keyword - pat = getstring(x, _("adds requires a pattern")) + pat = getstring(x, _(b"adds requires a pattern")) return checkstatus(repo, subset, pat, 1) -@predicate('ancestor(*changeset)', safe=True, weight=0.5) +@predicate(b'ancestor(*changeset)', safe=True, weight=0.5) def ancestor(repo, subset, x): """A greatest common ancestor of the changesets. @@ -432,7 +432,7 @@ return subset & s -@predicate('ancestors(set[, depth])', safe=True) +@predicate(b'ancestors(set[, depth])', safe=True) def ancestors(repo, subset, x): """Changesets that are ancestors of changesets in set, including the given changesets themselves. @@ -441,30 +441,30 @@ the specified generation. """ # startdepth is for internal use only until we can decide the UI - args = getargsdict(x, 'ancestors', 'set depth startdepth') - if 'set' not in args: + args = getargsdict(x, b'ancestors', b'set depth startdepth') + if b'set' not in args: # i18n: "ancestors" is a keyword - raise error.ParseError(_('ancestors takes at least 1 argument')) + raise error.ParseError(_(b'ancestors takes at least 1 argument')) startdepth = stopdepth = None - if 'startdepth' in args: + if b'startdepth' in args: n = getinteger( - args['startdepth'], "ancestors expects an integer startdepth" + args[b'startdepth'], b"ancestors expects an integer startdepth" ) if n < 0: - raise error.ParseError("negative startdepth") + raise error.ParseError(b"negative startdepth") startdepth = n - if 'depth' in args: + if b'depth' in args: # i18n: "ancestors" is a keyword - n = getinteger(args['depth'], _("ancestors expects an integer depth")) + n = getinteger(args[b'depth'], _(b"ancestors expects an integer depth")) if n < 0: - raise error.ParseError(_("negative depth")) + raise error.ParseError(_(b"negative depth")) stopdepth = n + 1 return _ancestors( - repo, subset, args['set'], startdepth=startdepth, stopdepth=stopdepth + repo, subset, args[b'set'], startdepth=startdepth, stopdepth=stopdepth ) -@predicate('_firstancestors', safe=True) +@predicate(b'_firstancestors', safe=True) def _firstancestors(repo, subset, x): # ``_firstancestors(set)`` # Like ``ancestors(set)`` but follows only the first parents. @@ -483,7 +483,7 @@ break if len(c) > 1: raise error.RepoLookupError( - _("revision in set has more than one child") + _(b"revision in set has more than one child") ) r = c[0].rev() else: @@ -496,7 +496,7 @@ Changesets that are the Nth ancestor (first parents only) of a changeset in set. """ - n = getinteger(n, _("~ expects a number")) + n = getinteger(n, _(b"~ expects a number")) if n < 0: # children lookup return _childrenspec(repo, subset, x, -n, order) @@ -512,19 +512,19 @@ return subset & ps -@predicate('author(string)', safe=True, weight=10) +@predicate(b'author(string)', safe=True, weight=10) def author(repo, subset, x): """Alias for ``user(string)``. """ # i18n: "author" is a keyword - n = getstring(x, _("author requires a string")) + n = getstring(x, _(b"author requires a string")) kind, pattern, matcher = _substringmatcher(n, casesensitive=False) return subset.filter( - lambda x: matcher(repo[x].user()), condrepr=('<user %r>', n) + lambda x: matcher(repo[x].user()), condrepr=(b'<user %r>', n) ) -@predicate('bisect(string)', safe=True) +@predicate(b'bisect(string)', safe=True) def bisect(repo, subset, x): """Changesets marked in the specified bisect status: @@ -537,41 +537,41 @@ - ``current`` : the cset currently being bisected """ # i18n: "bisect" is a keyword - status = getstring(x, _("bisect requires a string")).lower() + status = getstring(x, _(b"bisect requires a string")).lower() state = set(hbisect.get(repo, status)) return subset & state # Backward-compatibility # - no help entry so that we do not advertise it any more -@predicate('bisected', safe=True) +@predicate(b'bisected', safe=True) def bisected(repo, subset, x): return bisect(repo, subset, x) -@predicate('bookmark([name])', safe=True) +@predicate(b'bookmark([name])', safe=True) def bookmark(repo, subset, x): """The named bookmark or all bookmarks. Pattern matching is supported for `name`. See :hg:`help revisions.patterns`. """ # i18n: "bookmark" is a keyword - args = getargs(x, 0, 1, _('bookmark takes one or no arguments')) + args = getargs(x, 0, 1, _(b'bookmark takes one or no arguments')) if args: bm = getstring( args[0], # i18n: "bookmark" is a keyword - _('the argument to bookmark must be a string'), + _(b'the argument to bookmark must be a string'), ) kind, pattern, matcher = stringutil.stringmatcher(bm) bms = set() - if kind == 'literal': + if kind == b'literal': if bm == pattern: pattern = repo._bookmarks.expandname(pattern) bmrev = repo._bookmarks.get(pattern, None) if not bmrev: raise error.RepoLookupError( - _("bookmark '%s' does not exist") % pattern + _(b"bookmark '%s' does not exist") % pattern ) bms.add(repo[bmrev].rev()) else: @@ -587,7 +587,7 @@ return subset & bms -@predicate('branch(string or set)', safe=True, weight=10) +@predicate(b'branch(string or set)', safe=True, weight=10) def branch(repo, subset, x): """ All changesets belonging to the given branch or the branches of the given @@ -605,26 +605,27 @@ return repo[r].branch() try: - b = getstring(x, '') + b = getstring(x, b'') except error.ParseError: # not a string, but another revspec, e.g. tip() pass else: kind, pattern, matcher = stringutil.stringmatcher(b) - if kind == 'literal': + if kind == b'literal': # note: falls through to the revspec case if no branch with # this name exists and pattern kind is not specified explicitly if repo.branchmap().hasbranch(pattern): return subset.filter( - lambda r: matcher(getbranch(r)), condrepr=('<branch %r>', b) + lambda r: matcher(getbranch(r)), + condrepr=(b'<branch %r>', b), ) - if b.startswith('literal:'): + if b.startswith(b'literal:'): raise error.RepoLookupError( - _("branch '%s' does not exist") % pattern + _(b"branch '%s' does not exist") % pattern ) else: return subset.filter( - lambda r: matcher(getbranch(r)), condrepr=('<branch %r>', b) + lambda r: matcher(getbranch(r)), condrepr=(b'<branch %r>', b) ) s = getset(repo, fullreposet(repo), x) @@ -634,11 +635,11 @@ c = s.__contains__ return subset.filter( lambda r: c(r) or getbranch(r) in b, - condrepr=lambda: '<branch %r>' % _sortedb(b), + condrepr=lambda: b'<branch %r>' % _sortedb(b), ) -@predicate('phasedivergent()', safe=True) +@predicate(b'phasedivergent()', safe=True) def phasedivergent(repo, subset, x): """Mutable changesets marked as successors of public changesets. @@ -646,12 +647,12 @@ (EXPERIMENTAL) """ # i18n: "phasedivergent" is a keyword - getargs(x, 0, 0, _("phasedivergent takes no arguments")) - phasedivergent = obsmod.getrevs(repo, 'phasedivergent') + getargs(x, 0, 0, _(b"phasedivergent takes no arguments")) + phasedivergent = obsmod.getrevs(repo, b'phasedivergent') return subset & phasedivergent -@predicate('bundle()', safe=True) +@predicate(b'bundle()', safe=True) def bundle(repo, subset, x): """Changesets in the bundle. @@ -660,7 +661,7 @@ try: bundlerevs = repo.changelog.bundlerevs except AttributeError: - raise error.Abort(_("no bundle provided - specify with -R")) + raise error.Abort(_(b"no bundle provided - specify with -R")) return subset & bundlerevs @@ -671,7 +672,7 @@ 1: added 2: removed """ - hasset = matchmod.patkind(pat) == 'set' + hasset = matchmod.patkind(pat) == b'set' mcache = [None] @@ -701,7 +702,7 @@ if m(f): return True - return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat)) + return subset.filter(matches, condrepr=(b'<status[%r] %r>', field, pat)) def _children(repo, subset, parentset): @@ -722,7 +723,7 @@ return baseset(cs) -@predicate('children(set)', safe=True) +@predicate(b'children(set)', safe=True) def children(repo, subset, x): """Child changesets of changesets in set. """ @@ -731,19 +732,19 @@ return subset & cs -@predicate('closed()', safe=True, weight=10) +@predicate(b'closed()', safe=True, weight=10) def closed(repo, subset, x): """Changeset is closed. """ # i18n: "closed" is a keyword - getargs(x, 0, 0, _("closed takes no arguments")) + getargs(x, 0, 0, _(b"closed takes no arguments")) return subset.filter( - lambda r: repo[r].closesbranch(), condrepr='<branch closed>' + lambda r: repo[r].closesbranch(), condrepr=b'<branch closed>' ) # for internal use -@predicate('_commonancestorheads(set)', safe=True) +@predicate(b'_commonancestorheads(set)', safe=True) def _commonancestorheads(repo, subset, x): # This is an internal method is for quickly calculating "heads(::x and # ::y)" @@ -756,7 +757,7 @@ return subset & baseset(ancs) -@predicate('commonancestors(set)', safe=True) +@predicate(b'commonancestors(set)', safe=True) def commonancestors(repo, subset, x): """Changesets that are ancestors of every changeset in set. """ @@ -768,7 +769,7 @@ return subset -@predicate('contains(pattern)', weight=100) +@predicate(b'contains(pattern)', weight=100) def contains(repo, subset, x): """The revision's manifest contains a file matching pattern (but might not modify it). See :hg:`help patterns` for information about file patterns. @@ -778,7 +779,7 @@ for efficiency. """ # i18n: "contains" is a keyword - pat = getstring(x, _("contains requires a pattern")) + pat = getstring(x, _(b"contains requires a pattern")) def matches(x): if not matchmod.patkind(pat): @@ -793,10 +794,10 @@ return True return False - return subset.filter(matches, condrepr=('<contains %r>', pat)) - - -@predicate('converted([id])', safe=True) + return subset.filter(matches, condrepr=(b'<contains %r>', pat)) + + +@predicate(b'converted([id])', safe=True) def converted(repo, subset, x): """Changesets converted from the given identifier in the old repository if present, or all converted changesets if no identifier is specified. @@ -807,33 +808,33 @@ rev = None # i18n: "converted" is a keyword - l = getargs(x, 0, 1, _('converted takes one or no arguments')) + l = getargs(x, 0, 1, _(b'converted takes one or no arguments')) if l: # i18n: "converted" is a keyword - rev = getstring(l[0], _('converted requires a revision')) + rev = getstring(l[0], _(b'converted requires a revision')) def _matchvalue(r): - source = repo[r].extra().get('convert_revision', None) + source = repo[r].extra().get(b'convert_revision', None) return source is not None and (rev is None or source.startswith(rev)) return subset.filter( - lambda r: _matchvalue(r), condrepr=('<converted %r>', rev) + lambda r: _matchvalue(r), condrepr=(b'<converted %r>', rev) ) -@predicate('date(interval)', safe=True, weight=10) +@predicate(b'date(interval)', safe=True, weight=10) def date(repo, subset, x): """Changesets within the interval, see :hg:`help dates`. """ # i18n: "date" is a keyword - ds = getstring(x, _("date requires a string")) + ds = getstring(x, _(b"date requires a string")) dm = dateutil.matchdate(ds) return subset.filter( - lambda x: dm(repo[x].date()[0]), condrepr=('<date %r>', ds) + lambda x: dm(repo[x].date()[0]), condrepr=(b'<date %r>', ds) ) -@predicate('desc(string)', safe=True, weight=10) +@predicate(b'desc(string)', safe=True, weight=10) def desc(repo, subset, x): """Search commit message for string. The match is case-insensitive. @@ -841,12 +842,12 @@ :hg:`help revisions.patterns`. """ # i18n: "desc" is a keyword - ds = getstring(x, _("desc requires a string")) + ds = getstring(x, _(b"desc requires a string")) kind, pattern, matcher = _substringmatcher(ds, casesensitive=False) return subset.filter( - lambda r: matcher(repo[r].description()), condrepr=('<desc %r>', ds) + lambda r: matcher(repo[r].description()), condrepr=(b'<desc %r>', ds) ) @@ -860,7 +861,7 @@ return subset & s -@predicate('descendants(set[, depth])', safe=True) +@predicate(b'descendants(set[, depth])', safe=True) def descendants(repo, subset, x): """Changesets which are descendants of changesets in set, including the given changesets themselves. @@ -869,37 +870,39 @@ the specified generation. """ # startdepth is for internal use only until we can decide the UI - args = getargsdict(x, 'descendants', 'set depth startdepth') - if 'set' not in args: + args = getargsdict(x, b'descendants', b'set depth startdepth') + if b'set' not in args: # i18n: "descendants" is a keyword - raise error.ParseError(_('descendants takes at least 1 argument')) + raise error.ParseError(_(b'descendants takes at least 1 argument')) startdepth = stopdepth = None - if 'startdepth' in args: + if b'startdepth' in args: n = getinteger( - args['startdepth'], "descendants expects an integer startdepth" + args[b'startdepth'], b"descendants expects an integer startdepth" ) if n < 0: - raise error.ParseError("negative startdepth") + raise error.ParseError(b"negative startdepth") startdepth = n - if 'depth' in args: + if b'depth' in args: # i18n: "descendants" is a keyword - n = getinteger(args['depth'], _("descendants expects an integer depth")) + n = getinteger( + args[b'depth'], _(b"descendants expects an integer depth") + ) if n < 0: - raise error.ParseError(_("negative depth")) + raise error.ParseError(_(b"negative depth")) stopdepth = n + 1 return _descendants( - repo, subset, args['set'], startdepth=startdepth, stopdepth=stopdepth + repo, subset, args[b'set'], startdepth=startdepth, stopdepth=stopdepth ) -@predicate('_firstdescendants', safe=True) +@predicate(b'_firstdescendants', safe=True) def _firstdescendants(repo, subset, x): # ``_firstdescendants(set)`` # Like ``descendants(set)`` but follows only the first parents. return _descendants(repo, subset, x, followfirst=True) -@predicate('destination([set])', safe=True, weight=10) +@predicate(b'destination([set])', safe=True, weight=10) def destination(repo, subset, x): """Changesets that were created by a graft, transplant or rebase operation, with the given revisions specified as the source. Omitting the optional set @@ -943,23 +946,23 @@ return subset.filter( dests.__contains__, - condrepr=lambda: '<destination %r>' % _sortedb(dests), + condrepr=lambda: b'<destination %r>' % _sortedb(dests), ) -@predicate('contentdivergent()', safe=True) +@predicate(b'contentdivergent()', safe=True) def contentdivergent(repo, subset, x): """ Final successors of changesets with an alternative set of final successors. (EXPERIMENTAL) """ # i18n: "contentdivergent" is a keyword - getargs(x, 0, 0, _("contentdivergent takes no arguments")) - contentdivergent = obsmod.getrevs(repo, 'contentdivergent') + getargs(x, 0, 0, _(b"contentdivergent takes no arguments")) + contentdivergent = obsmod.getrevs(repo, b'contentdivergent') return subset & contentdivergent -@predicate('expectsize(set[, size])', safe=True, takeorder=True) +@predicate(b'expectsize(set[, size])', safe=True, takeorder=True) def expectsize(repo, subset, x, order): """Return the given revset if size matches the revset size. Abort if the revset doesn't expect given size. @@ -968,28 +971,28 @@ For example, ``expectsize(0:1, 3:5)`` will abort as revset size is 2 and 2 is not between 3 and 5 inclusive.""" - args = getargsdict(x, 'expectsize', 'set size') + args = getargsdict(x, b'expectsize', b'set size') minsize = 0 maxsize = len(repo) + 1 - err = '' - if 'size' not in args or 'set' not in args: - raise error.ParseError(_('invalid set of arguments')) + err = b'' + if b'size' not in args or b'set' not in args: + raise error.ParseError(_(b'invalid set of arguments')) minsize, maxsize = getintrange( - args['size'], - _('expectsize requires a size range' ' or a positive integer'), - _('size range bounds must be integers'), + args[b'size'], + _(b'expectsize requires a size range' b' or a positive integer'), + _(b'size range bounds must be integers'), minsize, maxsize, ) if minsize < 0 or maxsize < 0: - raise error.ParseError(_('negative size')) - rev = getset(repo, fullreposet(repo), args['set'], order=order) + raise error.ParseError(_(b'negative size')) + rev = getset(repo, fullreposet(repo), args[b'set'], order=order) if minsize != maxsize and (len(rev) < minsize or len(rev) > maxsize): err = _( - 'revset size mismatch.' ' expected between %d and %d, got %d' + b'revset size mismatch.' b' expected between %d and %d, got %d' ) % (minsize, maxsize, len(rev)) elif minsize == maxsize and len(rev) != minsize: - err = _('revset size mismatch.' ' expected %d, got %d') % ( + err = _(b'revset size mismatch.' b' expected %d, got %d') % ( minsize, len(rev), ) @@ -1001,31 +1004,31 @@ return rev & subset -@predicate('extdata(source)', safe=False, weight=100) +@predicate(b'extdata(source)', safe=False, weight=100) def extdata(repo, subset, x): """Changesets in the specified extdata source. (EXPERIMENTAL)""" # i18n: "extdata" is a keyword - args = getargsdict(x, 'extdata', 'source') + args = getargsdict(x, b'extdata', b'source') source = getstring( - args.get('source'), + args.get(b'source'), # i18n: "extdata" is a keyword - _('extdata takes at least 1 string argument'), + _(b'extdata takes at least 1 string argument'), ) data = scmutil.extdatasource(repo, source) return subset & baseset(data) -@predicate('extinct()', safe=True) +@predicate(b'extinct()', safe=True) def extinct(repo, subset, x): """Obsolete changesets with obsolete descendants only. """ # i18n: "extinct" is a keyword - getargs(x, 0, 0, _("extinct takes no arguments")) - extincts = obsmod.getrevs(repo, 'extinct') + getargs(x, 0, 0, _(b"extinct takes no arguments")) + extincts = obsmod.getrevs(repo, b'extinct') return subset & extincts -@predicate('extra(label, [value])', safe=True) +@predicate(b'extra(label, [value])', safe=True) def extra(repo, subset, x): """Changesets with the given label in the extra metadata, with the given optional value. @@ -1033,20 +1036,20 @@ Pattern matching is supported for `value`. See :hg:`help revisions.patterns`. """ - args = getargsdict(x, 'extra', 'label value') - if 'label' not in args: + args = getargsdict(x, b'extra', b'label value') + if b'label' not in args: # i18n: "extra" is a keyword - raise error.ParseError(_('extra takes at least 1 argument')) + raise error.ParseError(_(b'extra takes at least 1 argument')) # i18n: "extra" is a keyword label = getstring( - args['label'], _('first argument to extra must be ' 'a string') + args[b'label'], _(b'first argument to extra must be ' b'a string') ) value = None - if 'value' in args: + if b'value' in args: # i18n: "extra" is a keyword value = getstring( - args['value'], _('second argument to extra must be ' 'a string') + args[b'value'], _(b'second argument to extra must be ' b'a string') ) kind, value, matcher = stringutil.stringmatcher(value) @@ -1055,11 +1058,11 @@ return label in extra and (value is None or matcher(extra[label])) return subset.filter( - lambda r: _matchvalue(r), condrepr=('<extra[%r] %r>', label, value) + lambda r: _matchvalue(r), condrepr=(b'<extra[%r] %r>', label, value) ) -@predicate('filelog(pattern)', safe=True) +@predicate(b'filelog(pattern)', safe=True) def filelog(repo, subset, x): """Changesets connected to the specified filelog. @@ -1074,7 +1077,7 @@ """ # i18n: "filelog" is a keyword - pat = getstring(x, _("filelog requires a pattern")) + pat = getstring(x, _(b"filelog requires a pattern")) s = set() cl = repo.changelog @@ -1123,7 +1126,7 @@ return subset & s -@predicate('first(set, [n])', safe=True, takeorder=True, weight=0) +@predicate(b'first(set, [n])', safe=True, takeorder=True, weight=0) def first(repo, subset, x, order): """An alias for limit(). """ @@ -1131,52 +1134,53 @@ def _follow(repo, subset, x, name, followfirst=False): - args = getargsdict(x, name, 'file startrev') + args = getargsdict(x, name, b'file startrev') revs = None - if 'startrev' in args: - revs = getset(repo, fullreposet(repo), args['startrev']) - if 'file' in args: - x = getstring(args['file'], _("%s expected a pattern") % name) + if b'startrev' in args: + revs = getset(repo, fullreposet(repo), args[b'startrev']) + if b'file' in args: + x = getstring(args[b'file'], _(b"%s expected a pattern") % name) if revs is None: revs = [None] fctxs = [] for r in revs: ctx = mctx = repo[r] if r is None: - ctx = repo['.'] + ctx = repo[b'.'] m = matchmod.match( - repo.root, repo.getcwd(), [x], ctx=mctx, default='path' + repo.root, repo.getcwd(), [x], ctx=mctx, default=b'path' ) fctxs.extend(ctx[f].introfilectx() for f in ctx.manifest().walk(m)) s = dagop.filerevancestors(fctxs, followfirst) else: if revs is None: - revs = baseset([repo['.'].rev()]) + revs = baseset([repo[b'.'].rev()]) s = dagop.revancestors(repo, revs, followfirst) return subset & s -@predicate('follow([file[, startrev]])', safe=True) +@predicate(b'follow([file[, startrev]])', safe=True) def follow(repo, subset, x): """ An alias for ``::.`` (ancestors of the working directory's first parent). If file pattern is specified, the histories of files matching given pattern in the revision given by startrev are followed, including copies. """ - return _follow(repo, subset, x, 'follow') - - -@predicate('_followfirst', safe=True) + return _follow(repo, subset, x, b'follow') + + +@predicate(b'_followfirst', safe=True) def _followfirst(repo, subset, x): # ``followfirst([file[, startrev]])`` # Like ``follow([file[, startrev]])`` but follows only the first parent # of every revisions or files revisions. - return _follow(repo, subset, x, '_followfirst', followfirst=True) + return _follow(repo, subset, x, b'_followfirst', followfirst=True) @predicate( - 'followlines(file, fromline:toline[, startrev=., descend=False])', safe=True + b'followlines(file, fromline:toline[, startrev=., descend=False])', + safe=True, ) def followlines(repo, subset, x): """Changesets modifying `file` in line range ('fromline', 'toline'). @@ -1189,40 +1193,40 @@ descendants of 'startrev' are returned though renames are (currently) not followed in this direction. """ - args = getargsdict(x, 'followlines', 'file *lines startrev descend') - if len(args['lines']) != 1: - raise error.ParseError(_("followlines requires a line range")) - - rev = '.' - if 'startrev' in args: - revs = getset(repo, fullreposet(repo), args['startrev']) + args = getargsdict(x, b'followlines', b'file *lines startrev descend') + if len(args[b'lines']) != 1: + raise error.ParseError(_(b"followlines requires a line range")) + + rev = b'.' + if b'startrev' in args: + revs = getset(repo, fullreposet(repo), args[b'startrev']) if len(revs) != 1: raise error.ParseError( # i18n: "followlines" is a keyword - _("followlines expects exactly one revision") + _(b"followlines expects exactly one revision") ) rev = revs.last() - pat = getstring(args['file'], _("followlines requires a pattern")) + pat = getstring(args[b'file'], _(b"followlines requires a pattern")) # i18n: "followlines" is a keyword - msg = _("followlines expects exactly one file") + msg = _(b"followlines expects exactly one file") fname = scmutil.parsefollowlinespattern(repo, rev, pat, msg) fromline, toline = util.processlinerange( *getintrange( - args['lines'][0], + args[b'lines'][0], # i18n: "followlines" is a keyword - _("followlines expects a line number or a range"), - _("line range bounds must be integers"), + _(b"followlines expects a line number or a range"), + _(b"line range bounds must be integers"), ) ) fctx = repo[rev].filectx(fname) descend = False - if 'descend' in args: + if b'descend' in args: descend = getboolean( - args['descend'], + args[b'descend'], # i18n: "descend" is a keyword - _("descend argument must be a boolean"), + _(b"descend argument must be a boolean"), ) if descend: rs = generatorset( @@ -1247,16 +1251,16 @@ return subset & rs -@predicate('all()', safe=True) +@predicate(b'all()', safe=True) def getall(repo, subset, x): """All changesets, the same as ``0:tip``. """ # i18n: "all" is a keyword - getargs(x, 0, 0, _("all takes no arguments")) + getargs(x, 0, 0, _(b"all takes no arguments")) return subset & spanset(repo) # drop "null" if any -@predicate('grep(regex)', weight=10) +@predicate(b'grep(regex)', weight=10) def grep(repo, subset, x): """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')`` to ensure special escape characters are handled correctly. Unlike @@ -1264,10 +1268,10 @@ """ try: # i18n: "grep" is a keyword - gr = re.compile(getstring(x, _("grep requires a string"))) + gr = re.compile(getstring(x, _(b"grep requires a string"))) except re.error as e: raise error.ParseError( - _('invalid match pattern: %s') % stringutil.forcebytestr(e) + _(b'invalid match pattern: %s') % stringutil.forcebytestr(e) ) def matches(x): @@ -1277,10 +1281,10 @@ return True return False - return subset.filter(matches, condrepr=('<grep %r>', gr.pattern)) - - -@predicate('_matchfiles', safe=True) + return subset.filter(matches, condrepr=(b'<grep %r>', gr.pattern)) + + +@predicate(b'_matchfiles', safe=True) def _matchfiles(repo, subset, x): # _matchfiles takes a revset list of prefixed arguments: # @@ -1294,38 +1298,38 @@ # initialized. Use 'd:' to set the default matching mode, default # to 'glob'. At most one 'r:' and 'd:' argument can be passed. - l = getargs(x, 1, -1, "_matchfiles requires at least one argument") + l = getargs(x, 1, -1, b"_matchfiles requires at least one argument") pats, inc, exc = [], [], [] rev, default = None, None for arg in l: - s = getstring(arg, "_matchfiles requires string arguments") + s = getstring(arg, b"_matchfiles requires string arguments") prefix, value = s[:2], s[2:] - if prefix == 'p:': + if prefix == b'p:': pats.append(value) - elif prefix == 'i:': + elif prefix == b'i:': inc.append(value) - elif prefix == 'x:': + elif prefix == b'x:': exc.append(value) - elif prefix == 'r:': + elif prefix == b'r:': if rev is not None: raise error.ParseError( - '_matchfiles expected at most one ' 'revision' + b'_matchfiles expected at most one ' b'revision' ) - if value == '': # empty means working directory + if value == b'': # empty means working directory rev = node.wdirrev else: rev = value - elif prefix == 'd:': + elif prefix == b'd:': if default is not None: raise error.ParseError( - '_matchfiles expected at most one ' 'default mode' + b'_matchfiles expected at most one ' b'default mode' ) default = value else: - raise error.ParseError('invalid _matchfiles prefix: %s' % prefix) + raise error.ParseError(b'invalid _matchfiles prefix: %s' % prefix) if not default: - default = 'glob' - hasset = any(matchmod.patkind(p) == 'set' for p in pats + inc + exc) + default = b'glob' + hasset = any(matchmod.patkind(p) == b'set' for p in pats + inc + exc) mcache = [None] @@ -1361,8 +1365,8 @@ return subset.filter( matches, condrepr=( - '<matchfiles patterns=%r, include=%r ' - 'exclude=%r, default=%r, rev=%r>', + b'<matchfiles patterns=%r, include=%r ' + b'exclude=%r, default=%r, rev=%r>', pats, inc, exc, @@ -1372,7 +1376,7 @@ ) -@predicate('file(pattern)', safe=True, weight=10) +@predicate(b'file(pattern)', safe=True, weight=10) def hasfile(repo, subset, x): """Changesets affecting files matched by pattern. @@ -1382,16 +1386,16 @@ This predicate uses ``glob:`` as the default kind of pattern. """ # i18n: "file" is a keyword - pat = getstring(x, _("file requires a pattern")) - return _matchfiles(repo, subset, ('string', 'p:' + pat)) - - -@predicate('head()', safe=True) + pat = getstring(x, _(b"file requires a pattern")) + return _matchfiles(repo, subset, (b'string', b'p:' + pat)) + + +@predicate(b'head()', safe=True) def head(repo, subset, x): """Changeset is a named branch head. """ # i18n: "head" is a keyword - getargs(x, 0, 0, _("head takes no arguments")) + getargs(x, 0, 0, _(b"head takes no arguments")) hs = set() cl = repo.changelog for ls in repo.branchmap().iterheads(): @@ -1399,7 +1403,7 @@ return subset & baseset(hs) -@predicate('heads(set)', safe=True, takeorder=True) +@predicate(b'heads(set)', safe=True, takeorder=True) def heads(repo, subset, x, order): """Members of set with no children in set. """ @@ -1421,17 +1425,17 @@ return subset & heads -@predicate('hidden()', safe=True) +@predicate(b'hidden()', safe=True) def hidden(repo, subset, x): """Hidden changesets. """ # i18n: "hidden" is a keyword - getargs(x, 0, 0, _("hidden takes no arguments")) - hiddenrevs = repoview.filterrevs(repo, 'visible') + getargs(x, 0, 0, _(b"hidden takes no arguments")) + hiddenrevs = repoview.filterrevs(repo, b'visible') return subset & hiddenrevs -@predicate('keyword(string)', safe=True, weight=10) +@predicate(b'keyword(string)', safe=True, weight=10) def keyword(repo, subset, x): """Search commit message, user name, and names of changed files for string. The match is case-insensitive. @@ -1440,7 +1444,7 @@ ``grep(regex)``. """ # i18n: "keyword" is a keyword - kw = encoding.lower(getstring(x, _("keyword requires a string"))) + kw = encoding.lower(getstring(x, _(b"keyword requires a string"))) def matches(r): c = repo[r] @@ -1449,44 +1453,46 @@ for t in c.files() + [c.user(), c.description()] ) - return subset.filter(matches, condrepr=('<keyword %r>', kw)) - - -@predicate('limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0) + return subset.filter(matches, condrepr=(b'<keyword %r>', kw)) + + +@predicate(b'limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0) def limit(repo, subset, x, order): """First n members of set, defaulting to 1, starting from offset. """ - args = getargsdict(x, 'limit', 'set n offset') - if 'set' not in args: + args = getargsdict(x, b'limit', b'set n offset') + if b'set' not in args: # i18n: "limit" is a keyword - raise error.ParseError(_("limit requires one to three arguments")) + raise error.ParseError(_(b"limit requires one to three arguments")) # i18n: "limit" is a keyword - lim = getinteger(args.get('n'), _("limit expects a number"), default=1) + lim = getinteger(args.get(b'n'), _(b"limit expects a number"), default=1) if lim < 0: - raise error.ParseError(_("negative number to select")) + raise error.ParseError(_(b"negative number to select")) # i18n: "limit" is a keyword - ofs = getinteger(args.get('offset'), _("limit expects a number"), default=0) + ofs = getinteger( + args.get(b'offset'), _(b"limit expects a number"), default=0 + ) if ofs < 0: - raise error.ParseError(_("negative offset")) - os = getset(repo, fullreposet(repo), args['set']) + raise error.ParseError(_(b"negative offset")) + os = getset(repo, fullreposet(repo), args[b'set']) ls = os.slice(ofs, ofs + lim) if order == followorder and lim > 1: return subset & ls return ls & subset -@predicate('last(set, [n])', safe=True, takeorder=True) +@predicate(b'last(set, [n])', safe=True, takeorder=True) def last(repo, subset, x, order): """Last n members of set, defaulting to 1. """ # i18n: "last" is a keyword - l = getargs(x, 1, 2, _("last requires one or two arguments")) + l = getargs(x, 1, 2, _(b"last requires one or two arguments")) lim = 1 if len(l) == 2: # i18n: "last" is a keyword - lim = getinteger(l[1], _("last expects a number")) + lim = getinteger(l[1], _(b"last expects a number")) if lim < 0: - raise error.ParseError(_("negative number to select")) + raise error.ParseError(_(b"negative number to select")) os = getset(repo, fullreposet(repo), l[0]) os.reverse() ls = os.slice(0, lim) @@ -1496,7 +1502,7 @@ return ls & subset -@predicate('max(set)', safe=True) +@predicate(b'max(set)', safe=True) def maxrev(repo, subset, x): """Changeset with highest revision number in set. """ @@ -1504,20 +1510,20 @@ try: m = os.max() if m in subset: - return baseset([m], datarepr=('<max %r, %r>', subset, os)) + return baseset([m], datarepr=(b'<max %r, %r>', subset, os)) except ValueError: # os.max() throws a ValueError when the collection is empty. # Same as python's max(). pass - return baseset(datarepr=('<max %r, %r>', subset, os)) - - -@predicate('merge()', safe=True) + return baseset(datarepr=(b'<max %r, %r>', subset, os)) + + +@predicate(b'merge()', safe=True) def merge(repo, subset, x): """Changeset is a merge changeset. """ # i18n: "merge" is a keyword - getargs(x, 0, 0, _("merge takes no arguments")) + getargs(x, 0, 0, _(b"merge takes no arguments")) cl = repo.changelog nullrev = node.nullrev @@ -1527,15 +1533,15 @@ except error.WdirUnsupported: return bool(repo[r].p2()) - return subset.filter(ismerge, condrepr='<merge>') - - -@predicate('branchpoint()', safe=True) + return subset.filter(ismerge, condrepr=b'<merge>') + + +@predicate(b'branchpoint()', safe=True) def branchpoint(repo, subset, x): """Changesets with more than one child. """ # i18n: "branchpoint" is a keyword - getargs(x, 0, 0, _("branchpoint takes no arguments")) + getargs(x, 0, 0, _(b"branchpoint takes no arguments")) cl = repo.changelog if not subset: return baseset() @@ -1548,11 +1554,11 @@ if p >= baserev: parentscount[p - baserev] += 1 return subset.filter( - lambda r: parentscount[r - baserev] > 1, condrepr='<branchpoint>' + lambda r: parentscount[r - baserev] > 1, condrepr=b'<branchpoint>' ) -@predicate('min(set)', safe=True) +@predicate(b'min(set)', safe=True) def minrev(repo, subset, x): """Changeset with lowest revision number in set. """ @@ -1560,15 +1566,15 @@ try: m = os.min() if m in subset: - return baseset([m], datarepr=('<min %r, %r>', subset, os)) + return baseset([m], datarepr=(b'<min %r, %r>', subset, os)) except ValueError: # os.min() throws a ValueError when the collection is empty. # Same as python's min(). pass - return baseset(datarepr=('<min %r, %r>', subset, os)) - - -@predicate('modifies(pattern)', safe=True, weight=30) + return baseset(datarepr=(b'<min %r, %r>', subset, os)) + + +@predicate(b'modifies(pattern)', safe=True, weight=30) def modifies(repo, subset, x): """Changesets modifying files matched by pattern. @@ -1577,11 +1583,11 @@ directory. """ # i18n: "modifies" is a keyword - pat = getstring(x, _("modifies requires a pattern")) + pat = getstring(x, _(b"modifies requires a pattern")) return checkstatus(repo, subset, pat, 0) -@predicate('named(namespace)') +@predicate(b'named(namespace)') def named(repo, subset, x): """The changesets in a given namespace. @@ -1589,18 +1595,20 @@ :hg:`help revisions.patterns`. """ # i18n: "named" is a keyword - args = getargs(x, 1, 1, _('named requires a namespace argument')) + args = getargs(x, 1, 1, _(b'named requires a namespace argument')) ns = getstring( args[0], # i18n: "named" is a keyword - _('the argument to named must be a string'), + _(b'the argument to named must be a string'), ) kind, pattern, matcher = stringutil.stringmatcher(ns) namespaces = set() - if kind == 'literal': + if kind == b'literal': if pattern not in repo.names: - raise error.RepoLookupError(_("namespace '%s' does not exist") % ns) + raise error.RepoLookupError( + _(b"namespace '%s' does not exist") % ns + ) namespaces.add(repo.names[pattern]) else: for name, ns in repo.names.iteritems(): @@ -1617,14 +1625,14 @@ return subset & names -@predicate('id(string)', safe=True) +@predicate(b'id(string)', safe=True) def node_(repo, subset, x): """Revision non-ambiguously specified by the given hex string prefix. """ # i18n: "id" is a keyword - l = getargs(x, 1, 1, _("id requires one argument")) + l = getargs(x, 1, 1, _(b"id requires one argument")) # i18n: "id" is a keyword - n = getstring(l[0], _("id requires a string")) + n = getstring(l[0], _(b"id requires a string")) if len(n) == 40: try: rn = repo.changelog.rev(node.bin(n)) @@ -1649,25 +1657,25 @@ return result & subset -@predicate('none()', safe=True) +@predicate(b'none()', safe=True) def none(repo, subset, x): """No changesets. """ # i18n: "none" is a keyword - getargs(x, 0, 0, _("none takes no arguments")) + getargs(x, 0, 0, _(b"none takes no arguments")) return baseset() -@predicate('obsolete()', safe=True) +@predicate(b'obsolete()', safe=True) def obsolete(repo, subset, x): """Mutable changeset with a newer version.""" # i18n: "obsolete" is a keyword - getargs(x, 0, 0, _("obsolete takes no arguments")) - obsoletes = obsmod.getrevs(repo, 'obsolete') + getargs(x, 0, 0, _(b"obsolete takes no arguments")) + obsoletes = obsmod.getrevs(repo, b'obsolete') return subset & obsoletes -@predicate('only(set, [set])', safe=True) +@predicate(b'only(set, [set])', safe=True) def only(repo, subset, x): """Changesets that are ancestors of the first set that are not ancestors of any other head in the repo. If a second set is specified, the result @@ -1676,7 +1684,7 @@ """ cl = repo.changelog # i18n: "only" is a keyword - args = getargs(x, 1, 2, _('only takes one or two arguments')) + args = getargs(x, 1, 2, _(b'only takes one or two arguments')) include = getset(repo, fullreposet(repo), args[0]) if len(args) == 1: if not include: @@ -1697,7 +1705,7 @@ return subset & results -@predicate('origin([set])', safe=True) +@predicate(b'origin([set])', safe=True) def origin(repo, subset, x): """ Changesets that were specified as a source for the grafts, transplants or @@ -1730,7 +1738,7 @@ return subset & o -@predicate('outgoing([path])', safe=False, weight=10) +@predicate(b'outgoing([path])', safe=False, weight=10) def outgoing(repo, subset, x): """Changesets not found in the specified destination repository, or the default push location. @@ -1742,17 +1750,19 @@ ) # i18n: "outgoing" is a keyword - l = getargs(x, 0, 1, _("outgoing takes one or no arguments")) + l = getargs(x, 0, 1, _(b"outgoing takes one or no arguments")) # i18n: "outgoing" is a keyword - dest = l and getstring(l[0], _("outgoing requires a repository path")) or '' + dest = ( + l and getstring(l[0], _(b"outgoing requires a repository path")) or b'' + ) if not dest: # ui.paths.getpath() explicitly tests for None, not just a boolean dest = None - path = repo.ui.paths.getpath(dest, default=('default-push', 'default')) + path = repo.ui.paths.getpath(dest, default=(b'default-push', b'default')) if not path: raise error.Abort( - _('default repository not configured!'), - hint=_("see 'hg help config.paths'"), + _(b'default repository not configured!'), + hint=_(b"see 'hg help config.paths'"), ) dest = path.pushloc or path.loc branches = path.branch, [] @@ -1769,7 +1779,7 @@ return subset & o -@predicate('p1([set])', safe=True) +@predicate(b'p1([set])', safe=True) def p1(repo, subset, x): """First parent of changesets in set, or the working directory. """ @@ -1792,7 +1802,7 @@ return subset & ps -@predicate('p2([set])', safe=True) +@predicate(b'p2([set])', safe=True) def p2(repo, subset, x): """Second parent of changesets in set, or the working directory. """ @@ -1825,7 +1835,7 @@ return p1(repo, subset, x) -@predicate('parents([set])', safe=True) +@predicate(b'parents([set])', safe=True) def parents(repo, subset, x): """ The set of all parents for all changesets in set, or the working directory. @@ -1851,32 +1861,32 @@ return repo._phasecache.getrevset(repo, targets, subset) -@predicate('_phase(idx)', safe=True) +@predicate(b'_phase(idx)', safe=True) def phase(repo, subset, x): - l = getargs(x, 1, 1, "_phase requires one argument") - target = getinteger(l[0], "_phase expects a number") + l = getargs(x, 1, 1, b"_phase requires one argument") + target = getinteger(l[0], b"_phase expects a number") return _phase(repo, subset, target) -@predicate('draft()', safe=True) +@predicate(b'draft()', safe=True) def draft(repo, subset, x): """Changeset in draft phase.""" # i18n: "draft" is a keyword - getargs(x, 0, 0, _("draft takes no arguments")) + getargs(x, 0, 0, _(b"draft takes no arguments")) target = phases.draft return _phase(repo, subset, target) -@predicate('secret()', safe=True) +@predicate(b'secret()', safe=True) def secret(repo, subset, x): """Changeset in secret phase.""" # i18n: "secret" is a keyword - getargs(x, 0, 0, _("secret takes no arguments")) + getargs(x, 0, 0, _(b"secret takes no arguments")) target = phases.secret return _phase(repo, subset, target) -@predicate('stack([revs])', safe=True) +@predicate(b'stack([revs])', safe=True) def stack(repo, subset, x): """Experimental revset for the stack of changesets or working directory parent. (EXPERIMENTAL) @@ -1903,7 +1913,7 @@ if n not in (0, 1, 2): raise ValueError except (TypeError, ValueError): - raise error.ParseError(_("^ expects a number 0, 1, or 2")) + raise error.ParseError(_(b"^ expects a number 0, 1, or 2")) ps = set() cl = repo.changelog for r in getset(repo, fullreposet(repo), x): @@ -1926,7 +1936,7 @@ return subset & ps -@predicate('present(set)', safe=True, takeorder=True) +@predicate(b'present(set)', safe=True, takeorder=True) def present(repo, subset, x, order): """An empty set, if any revision in set isn't found; otherwise, all revisions in set. @@ -1942,30 +1952,30 @@ # for internal use -@predicate('_notpublic', safe=True) +@predicate(b'_notpublic', safe=True) def _notpublic(repo, subset, x): - getargs(x, 0, 0, "_notpublic takes no arguments") + getargs(x, 0, 0, b"_notpublic takes no arguments") return _phase(repo, subset, phases.draft, phases.secret) # for internal use -@predicate('_phaseandancestors(phasename, set)', safe=True) +@predicate(b'_phaseandancestors(phasename, set)', safe=True) def _phaseandancestors(repo, subset, x): # equivalent to (phasename() & ancestors(set)) but more efficient # phasename could be one of 'draft', 'secret', or '_notpublic' - args = getargs(x, 2, 2, "_phaseandancestors requires two arguments") + args = getargs(x, 2, 2, b"_phaseandancestors requires two arguments") phasename = getsymbol(args[0]) s = getset(repo, fullreposet(repo), args[1]) draft = phases.draft secret = phases.secret phasenamemap = { - '_notpublic': draft, - 'draft': draft, # follow secret's ancestors - 'secret': secret, + b'_notpublic': draft, + b'draft': draft, # follow secret's ancestors + b'secret': secret, } if phasename not in phasenamemap: - raise error.ParseError('%r is not a valid phasename' % phasename) + raise error.ParseError(b'%r is not a valid phasename' % phasename) minimalphase = phasenamemap[phasename] getphase = repo._phasecache.phase @@ -1975,20 +1985,20 @@ revs = dagop.revancestors(repo, s, cutfunc=cutfunc) - if phasename == 'draft': # need to remove secret changesets + if phasename == b'draft': # need to remove secret changesets revs = revs.filter(lambda r: getphase(repo, r) == draft) return subset & revs -@predicate('public()', safe=True) +@predicate(b'public()', safe=True) def public(repo, subset, x): """Changeset in public phase.""" # i18n: "public" is a keyword - getargs(x, 0, 0, _("public takes no arguments")) + getargs(x, 0, 0, _(b"public takes no arguments")) return _phase(repo, subset, phases.public) -@predicate('remote([id [,path]])', safe=False) +@predicate(b'remote([id [,path]])', safe=False) def remote(repo, subset, x): """Local revision that corresponds to the given identifier in a remote repository, if present. Here, the '.' identifier is a @@ -1998,20 +2008,20 @@ from . import hg # avoid start-up nasties # i18n: "remote" is a keyword - l = getargs(x, 0, 2, _("remote takes zero, one, or two arguments")) - - q = '.' + l = getargs(x, 0, 2, _(b"remote takes zero, one, or two arguments")) + + q = b'.' if len(l) > 0: # i18n: "remote" is a keyword - q = getstring(l[0], _("remote requires a string id")) - if q == '.': - q = repo['.'].branch() - - dest = '' + q = getstring(l[0], _(b"remote requires a string id")) + if q == b'.': + q = repo[b'.'].branch() + + dest = b'' if len(l) > 1: # i18n: "remote" is a keyword - dest = getstring(l[1], _("remote requires a repository path")) - dest = repo.ui.expandpath(dest or 'default') + dest = getstring(l[1], _(b"remote requires a repository path")) + dest = repo.ui.expandpath(dest or b'default') dest, branches = hg.parseurl(dest) revs, checkout = hg.addbranchrevs(repo, repo, branches, []) if revs: @@ -2025,7 +2035,7 @@ return baseset() -@predicate('removes(pattern)', safe=True, weight=30) +@predicate(b'removes(pattern)', safe=True, weight=30) def removes(repo, subset, x): """Changesets which remove files matching pattern. @@ -2034,43 +2044,43 @@ directory. """ # i18n: "removes" is a keyword - pat = getstring(x, _("removes requires a pattern")) + pat = getstring(x, _(b"removes requires a pattern")) return checkstatus(repo, subset, pat, 2) -@predicate('rev(number)', safe=True) +@predicate(b'rev(number)', safe=True) def rev(repo, subset, x): """Revision with the given numeric identifier. """ # i18n: "rev" is a keyword - l = getargs(x, 1, 1, _("rev requires one argument")) + l = getargs(x, 1, 1, _(b"rev requires one argument")) try: # i18n: "rev" is a keyword - l = int(getstring(l[0], _("rev requires a number"))) + l = int(getstring(l[0], _(b"rev requires a number"))) except (TypeError, ValueError): # i18n: "rev" is a keyword - raise error.ParseError(_("rev expects a number")) + raise error.ParseError(_(b"rev expects a number")) if l not in repo.changelog and l not in _virtualrevs: return baseset() return subset & baseset([l]) -@predicate('_rev(number)', safe=True) +@predicate(b'_rev(number)', safe=True) def _rev(repo, subset, x): # internal version of "rev(x)" that raise error if "x" is invalid # i18n: "rev" is a keyword - l = getargs(x, 1, 1, _("rev requires one argument")) + l = getargs(x, 1, 1, _(b"rev requires one argument")) try: # i18n: "rev" is a keyword - l = int(getstring(l[0], _("rev requires a number"))) + l = int(getstring(l[0], _(b"rev requires a number"))) except (TypeError, ValueError): # i18n: "rev" is a keyword - raise error.ParseError(_("rev expects a number")) + raise error.ParseError(_(b"rev expects a number")) repo.changelog.node(l) # check that the rev exists return subset & baseset([l]) -@predicate('revset(set)', safe=True, takeorder=True) +@predicate(b'revset(set)', safe=True, takeorder=True) def revsetpredicate(repo, subset, x, order): """Strictly interpret the content as a revset. @@ -2081,7 +2091,7 @@ return getset(repo, subset, x, order) -@predicate('matching(revision [, field])', safe=True) +@predicate(b'matching(revision [, field])', safe=True) def matching(repo, subset, x): """Changesets in which a given set of fields match the set of fields in the selected revision or set. @@ -2107,16 +2117,16 @@ specified. You can match more than one field at a time. """ # i18n: "matching" is a keyword - l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments")) + l = getargs(x, 1, 2, _(b"matching takes 1 or 2 arguments")) revs = getset(repo, fullreposet(repo), l[0]) - fieldlist = ['metadata'] + fieldlist = [b'metadata'] if len(l) > 1: fieldlist = getstring( l[1], # i18n: "matching" is a keyword - _("matching requires a string " "as its second argument"), + _(b"matching requires a string " b"as its second argument"), ).split() # Make sure that there are no repeated fields, @@ -2124,36 +2134,36 @@ # and check the 'files' whenever we check the 'diff' fields = [] for field in fieldlist: - if field == 'metadata': - fields += ['user', 'description', 'date'] - elif field == 'diff': + if field == b'metadata': + fields += [b'user', b'description', b'date'] + elif field == b'diff': # a revision matching the diff must also match the files # since matching the diff is very costly, make sure to # also match the files first - fields += ['files', 'diff'] + fields += [b'files', b'diff'] else: - if field == 'author': - field = 'user' + if field == b'author': + field = b'user' fields.append(field) fields = set(fields) - if 'summary' in fields and 'description' in fields: + if b'summary' in fields and b'description' in fields: # If a revision matches its description it also matches its summary - fields.discard('summary') + fields.discard(b'summary') # We may want to match more than one field # Not all fields take the same amount of time to be matched # Sort the selected fields in order of increasing matching cost fieldorder = [ - 'phase', - 'parents', - 'user', - 'date', - 'branch', - 'summary', - 'files', - 'description', - 'substate', - 'diff', + b'phase', + b'parents', + b'user', + b'date', + b'branch', + b'summary', + b'files', + b'description', + b'substate', + b'diff', ] def fieldkeyfunc(f): @@ -2170,17 +2180,17 @@ # which will be added to the getfieldfuncs array of functions getfieldfuncs = [] _funcs = { - 'user': lambda r: repo[r].user(), - 'branch': lambda r: repo[r].branch(), - 'date': lambda r: repo[r].date(), - 'description': lambda r: repo[r].description(), - 'files': lambda r: repo[r].files(), - 'parents': lambda r: repo[r].parents(), - 'phase': lambda r: repo[r].phase(), - 'substate': lambda r: repo[r].substate, - 'summary': lambda r: repo[r].description().splitlines()[0], - 'diff': lambda r: list( - repo[r].diff(opts=diffutil.diffallopts(repo.ui, {'git': True})) + b'user': lambda r: repo[r].user(), + b'branch': lambda r: repo[r].branch(), + b'date': lambda r: repo[r].date(), + b'description': lambda r: repo[r].description(), + b'files': lambda r: repo[r].files(), + b'parents': lambda r: repo[r].parents(), + b'phase': lambda r: repo[r].phase(), + b'substate': lambda r: repo[r].substate, + b'summary': lambda r: repo[r].description().splitlines()[0], + b'diff': lambda r: list( + repo[r].diff(opts=diffutil.diffallopts(repo.ui, {b'git': True})) ), } for info in fields: @@ -2188,7 +2198,7 @@ if getfield is None: raise error.ParseError( # i18n: "matching" is a keyword - _("unexpected field name passed to matching: %s") + _(b"unexpected field name passed to matching: %s") % info ) getfieldfuncs.append(getfield) @@ -2208,10 +2218,10 @@ return True return False - return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs)) - - -@predicate('reverse(set)', safe=True, takeorder=True, weight=0) + return subset.filter(matches, condrepr=(b'<matching%r %r>', fields, revs)) + + +@predicate(b'reverse(set)', safe=True, takeorder=True, weight=0) def reverse(repo, subset, x, order): """Reverse order of set. """ @@ -2221,7 +2231,7 @@ return l -@predicate('roots(set)', safe=True) +@predicate(b'roots(set)', safe=True) def roots(repo, subset, x): """Changesets in set with no parent changeset in set. """ @@ -2234,66 +2244,66 @@ return False return True - return subset & s.filter(filter, condrepr='<roots>') + return subset & s.filter(filter, condrepr=b'<roots>') _sortkeyfuncs = { - 'rev': lambda c: c.rev(), - 'branch': lambda c: c.branch(), - 'desc': lambda c: c.description(), - 'user': lambda c: c.user(), - 'author': lambda c: c.user(), - 'date': lambda c: c.date()[0], + b'rev': lambda c: c.rev(), + b'branch': lambda c: c.branch(), + b'desc': lambda c: c.description(), + b'user': lambda c: c.user(), + b'author': lambda c: c.user(), + b'date': lambda c: c.date()[0], } def _getsortargs(x): """Parse sort options into (set, [(key, reverse)], opts)""" - args = getargsdict(x, 'sort', 'set keys topo.firstbranch') - if 'set' not in args: + args = getargsdict(x, b'sort', b'set keys topo.firstbranch') + if b'set' not in args: # i18n: "sort" is a keyword - raise error.ParseError(_('sort requires one or two arguments')) - keys = "rev" - if 'keys' in args: + raise error.ParseError(_(b'sort requires one or two arguments')) + keys = b"rev" + if b'keys' in args: # i18n: "sort" is a keyword - keys = getstring(args['keys'], _("sort spec must be a string")) + keys = getstring(args[b'keys'], _(b"sort spec must be a string")) keyflags = [] for k in keys.split(): fk = k - reverse = k.startswith('-') + reverse = k.startswith(b'-') if reverse: k = k[1:] - if k not in _sortkeyfuncs and k != 'topo': + if k not in _sortkeyfuncs and k != b'topo': raise error.ParseError( - _("unknown sort key %r") % pycompat.bytestr(fk) + _(b"unknown sort key %r") % pycompat.bytestr(fk) ) keyflags.append((k, reverse)) - if len(keyflags) > 1 and any(k == 'topo' for k, reverse in keyflags): + if len(keyflags) > 1 and any(k == b'topo' for k, reverse in keyflags): # i18n: "topo" is a keyword raise error.ParseError( - _('topo sort order cannot be combined ' 'with other sort keys') + _(b'topo sort order cannot be combined ' b'with other sort keys') ) opts = {} - if 'topo.firstbranch' in args: - if any(k == 'topo' for k, reverse in keyflags): - opts['topo.firstbranch'] = args['topo.firstbranch'] + if b'topo.firstbranch' in args: + if any(k == b'topo' for k, reverse in keyflags): + opts[b'topo.firstbranch'] = args[b'topo.firstbranch'] else: # i18n: "topo" and "topo.firstbranch" are keywords raise error.ParseError( _( - 'topo.firstbranch can only be used ' - 'when using the topo sort key' + b'topo.firstbranch can only be used ' + b'when using the topo sort key' ) ) - return args['set'], keyflags, opts + return args[b'set'], keyflags, opts @predicate( - 'sort(set[, [-]key... [, ...]])', safe=True, takeorder=True, weight=10 + b'sort(set[, [-]key... [, ...]])', safe=True, takeorder=True, weight=10 ) def sort(repo, subset, x, order): """Sort set by keys. The default sort order is ascending, specify a key @@ -2318,13 +2328,13 @@ if not keyflags or order != defineorder: return revs - if len(keyflags) == 1 and keyflags[0][0] == "rev": + if len(keyflags) == 1 and keyflags[0][0] == b"rev": revs.sort(reverse=keyflags[0][1]) return revs - elif keyflags[0][0] == "topo": + elif keyflags[0][0] == b"topo": firstbranch = () - if 'topo.firstbranch' in opts: - firstbranch = getset(repo, subset, opts['topo.firstbranch']) + if b'topo.firstbranch' in opts: + firstbranch = getset(repo, subset, opts[b'topo.firstbranch']) revs = baseset( dagop.toposort(revs, repo.changelog.parentrevs, firstbranch), istopo=True, @@ -2340,18 +2350,18 @@ return baseset([c.rev() for c in ctxs]) -@predicate('subrepo([pattern])') +@predicate(b'subrepo([pattern])') def subrepo(repo, subset, x): """Changesets that add, modify or remove the given subrepo. If no subrepo pattern is named, any subrepo changes are returned. """ # i18n: "subrepo" is a keyword - args = getargs(x, 0, 1, _('subrepo takes at most one argument')) + args = getargs(x, 0, 1, _(b'subrepo takes at most one argument')) pat = None if len(args) != 0: - pat = getstring(args[0], _("subrepo requires a pattern")) - - m = matchmod.exact(['.hgsubstate']) + pat = getstring(args[0], _(b"subrepo requires a pattern")) + + m = matchmod.exact([b'.hgsubstate']) def submatches(names): k, p, m = stringutil.stringmatcher(pat) @@ -2382,7 +2392,7 @@ return False - return subset.filter(matches, condrepr=('<subrepo %r>', pat)) + return subset.filter(matches, condrepr=(b'<subrepo %r>', pat)) def _mapbynodefunc(repo, s, f): @@ -2400,7 +2410,7 @@ return smartset.baseset(result - repo.changelog.filteredrevs) -@predicate('successors(set)', safe=True) +@predicate(b'successors(set)', safe=True) def successors(repo, subset, x): """All successors for set, including the given set themselves""" s = getset(repo, fullreposet(repo), x) @@ -2413,7 +2423,7 @@ kind, pattern, matcher = stringutil.stringmatcher( pattern, casesensitive=casesensitive ) - if kind == 'literal': + if kind == b'literal': if not casesensitive: pattern = encoding.lower(pattern) matcher = lambda s: pattern in encoding.lower(s) @@ -2422,7 +2432,7 @@ return kind, pattern, matcher -@predicate('tag([name])', safe=True) +@predicate(b'tag([name])', safe=True) def tag(repo, subset, x): """The specified tag by name, or all tagged revisions if no name is given. @@ -2430,46 +2440,46 @@ :hg:`help revisions.patterns`. """ # i18n: "tag" is a keyword - args = getargs(x, 0, 1, _("tag takes one or no arguments")) + args = getargs(x, 0, 1, _(b"tag takes one or no arguments")) cl = repo.changelog if args: pattern = getstring( args[0], # i18n: "tag" is a keyword - _('the argument to tag must be a string'), + _(b'the argument to tag must be a string'), ) kind, pattern, matcher = stringutil.stringmatcher(pattern) - if kind == 'literal': + if kind == b'literal': # avoid resolving all tags tn = repo._tagscache.tags.get(pattern, None) if tn is None: raise error.RepoLookupError( - _("tag '%s' does not exist") % pattern + _(b"tag '%s' does not exist") % pattern ) s = {repo[tn].rev()} else: s = {cl.rev(n) for t, n in repo.tagslist() if matcher(t)} else: - s = {cl.rev(n) for t, n in repo.tagslist() if t != 'tip'} + s = {cl.rev(n) for t, n in repo.tagslist() if t != b'tip'} return subset & s -@predicate('tagged', safe=True) +@predicate(b'tagged', safe=True) def tagged(repo, subset, x): return tag(repo, subset, x) -@predicate('orphan()', safe=True) +@predicate(b'orphan()', safe=True) def orphan(repo, subset, x): """Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL) """ # i18n: "orphan" is a keyword - getargs(x, 0, 0, _("orphan takes no arguments")) - orphan = obsmod.getrevs(repo, 'orphan') + getargs(x, 0, 0, _(b"orphan takes no arguments")) + orphan = obsmod.getrevs(repo, b'orphan') return subset & orphan -@predicate('user(string)', safe=True, weight=10) +@predicate(b'user(string)', safe=True, weight=10) def user(repo, subset, x): """User name contains string. The match is case-insensitive. @@ -2479,18 +2489,18 @@ return author(repo, subset, x) -@predicate('wdir()', safe=True, weight=0) +@predicate(b'wdir()', safe=True, weight=0) def wdir(repo, subset, x): """Working directory. (EXPERIMENTAL)""" # i18n: "wdir" is a keyword - getargs(x, 0, 0, _("wdir takes no arguments")) + getargs(x, 0, 0, _(b"wdir takes no arguments")) if node.wdirrev in subset or isinstance(subset, fullreposet): return baseset([node.wdirrev]) return baseset() def _orderedlist(repo, subset, x): - s = getstring(x, "internal error") + s = getstring(x, b"internal error") if not s: return baseset() # remove duplicates here. it's difficult for caller to deduplicate sets @@ -2498,11 +2508,11 @@ cl = repo.changelog ls = [] seen = set() - for t in s.split('\0'): + for t in s.split(b'\0'): try: # fast path for integer revision r = int(t) - if ('%d' % r) != t or r not in cl: + if (b'%d' % r) != t or r not in cl: raise ValueError revs = [r] except ValueError: @@ -2522,7 +2532,7 @@ # for internal use -@predicate('_list', safe=True, takeorder=True) +@predicate(b'_list', safe=True, takeorder=True) def _list(repo, subset, x, order): if order == followorder: # slow path to take the subset order @@ -2532,16 +2542,16 @@ def _orderedintlist(repo, subset, x): - s = getstring(x, "internal error") + s = getstring(x, b"internal error") if not s: return baseset() - ls = [int(r) for r in s.split('\0')] + ls = [int(r) for r in s.split(b'\0')] s = subset return baseset([r for r in ls if r in s]) # for internal use -@predicate('_intlist', safe=True, takeorder=True, weight=0) +@predicate(b'_intlist', safe=True, takeorder=True, weight=0) def _intlist(repo, subset, x, order): if order == followorder: # slow path to take the subset order @@ -2551,17 +2561,17 @@ def _orderedhexlist(repo, subset, x): - s = getstring(x, "internal error") + s = getstring(x, b"internal error") if not s: return baseset() cl = repo.changelog - ls = [cl.rev(node.bin(r)) for r in s.split('\0')] + ls = [cl.rev(node.bin(r)) for r in s.split(b'\0')] s = subset return baseset([r for r in ls if r in s]) # for internal use -@predicate('_hexlist', safe=True, takeorder=True) +@predicate(b'_hexlist', safe=True, takeorder=True) def _hexlist(repo, subset, x, order): if order == followorder: # slow path to take the subset order @@ -2571,33 +2581,33 @@ methods = { - "range": rangeset, - "rangeall": rangeall, - "rangepre": rangepre, - "rangepost": rangepost, - "dagrange": dagrange, - "string": stringset, - "symbol": stringset, - "and": andset, - "andsmally": andsmallyset, - "or": orset, - "not": notset, - "difference": differenceset, - "relation": relationset, - "relsubscript": relsubscriptset, - "subscript": subscriptset, - "list": listset, - "keyvalue": keyvaluepair, - "func": func, - "ancestor": ancestorspec, - "parent": parentspec, - "parentpost": parentpost, - "smartset": rawsmartset, + b"range": rangeset, + b"rangeall": rangeall, + b"rangepre": rangepre, + b"rangepost": rangepost, + b"dagrange": dagrange, + b"string": stringset, + b"symbol": stringset, + b"and": andset, + b"andsmally": andsmallyset, + b"or": orset, + b"not": notset, + b"difference": differenceset, + b"relation": relationset, + b"relsubscript": relsubscriptset, + b"subscript": subscriptset, + b"list": listset, + b"keyvalue": keyvaluepair, + b"func": func, + b"ancestor": ancestorspec, + b"parent": parentspec, + b"parentpost": parentpost, + b"smartset": rawsmartset, } subscriptrelations = { - "g": generationsrel, - "generations": generationsrel, + b"g": generationsrel, + b"generations": generationsrel, } @@ -2627,19 +2637,19 @@ return mfunc if not all(specs): - raise error.ParseError(_("empty query")) + raise error.ParseError(_(b"empty query")) if len(specs) == 1: tree = revsetlang.parse(specs[0], lookup) else: tree = ( - 'or', - ('list',) + tuple(revsetlang.parse(s, lookup) for s in specs), + b'or', + (b'list',) + tuple(revsetlang.parse(s, lookup) for s in specs), ) aliases = [] warn = None if ui: - aliases.extend(ui.configitems('revsetalias')) + aliases.extend(ui.configitems(b'revsetalias')) warn = ui.warn if localalias: aliases.extend(localalias.items())