This is an archive of the discontinued Mercurial Phabricator instance.

Differential D453

revset: make subrepo optional in revset predicate functions
AbandonedPublic

Authored by quark on Aug 20 2017, 3:27 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

Before this patch, a revset predicate must take a subset argument. It's
not too hard for an inexperienced developer to make mistakes:

@revsetpredicate('myrevset')
def myrevset(repo, subset, x):
    myset = calculate(repo, x)
    return myset  # INCORRECT: does not take "subset" into consideration

With order concept introduced, it's not obvious that the fix could still
cause issues:

return subset & myset  # SUBOPTIMAL: uses "subset" order blindly

The "most correct" version is:

@revsetpredicate('myrevset', takeorder=True)
def myrevset(repo, subset, x, order):
    myset = calculate(repo, x)
    return revset.intersect(subset, myset, order)

To make the API easier to use correctly, this patch makes subrepo
optional. So people can just write:

@revsetpredicate('myrevset')
def myrevset(repo, x):
    return calculate(repo, x)

which is simple, intuitive, and more importantly, handles ordering
correctly.

.. api:: revset predicate no longer has to take a `subset` argument

The ``subset`` argument is now optional for a revset predicate::

   @revsetpredicate('foo')
   def foo(repo, x):
       revs = calculate(repo, x)
       return smartset.baseset(revs)

If you do need ``subset``, it's recommended to take ``order`` too::

   @revsetpredicate('foo', takeorder=True)
   def foo(repo, subset, x, order):
       revs = calculate(repo, subset, x)
       return revset.intersect(subset, revs, order)

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

quark created this revision.Aug 20 2017, 3:27 AM
quark updated this revision to Diff 1105.Aug 20 2017, 4:43 AM
quark updated this revision to Diff 1113.Aug 20 2017, 4:13 PM
quark edited the summary of this revision. (Show Details)Aug 20 2017, 4:24 PM
quark edited the summary of this revision. (Show Details)
quark edited the summary of this revision. (Show Details)Aug 20 2017, 6:00 PM
quark updated this revision to Diff 1116.
quark abandoned this revision.Aug 25 2017, 1:10 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/registrar.py (25 lines)
Mmercurial/revset.py (209 lines)

Diff 1116

mercurial/registrar.py

# registrar.py - utilities to register function for specific purpose # registrar.py - utilities to register function for specific purpose
# #
# Copyright FUJIWARA Katsunori <foozy@lares.dti.ne.jp> and others # Copyright FUJIWARA Katsunori <foozy@lares.dti.ne.jp> and others
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import inspect
from . import ( from . import (
configitems, configitems,
error, error,
pycompat, pycompat,
util, util,
) )
# unlike the other registered items, config options are neither functions or # unlike the other registered items, config options are neither functions or
The first string argument is used also in online help. The first string argument is used also in online help.
Optional argument 'safe' indicates whether a predicate is safe for Optional argument 'safe' indicates whether a predicate is safe for
DoS attack (False by default). DoS attack (False by default).
Optional argument 'takeorder' indicates whether a predicate function Optional argument 'takeorder' indicates whether a predicate function
takes ordering policy as the last argument. takes ordering policy as the last argument.
Optional argument 'takesubset' indicates whether a predicate function
takes subset as its second argument. By default, takesubset is None and
will be inferred from function signature.
New revset functions are recommended to either take none of subset and
order, or take both (and use ``revset.intersect``) so it can handle
ordering correctly.
'revsetpredicate' instance in example above can be used to 'revsetpredicate' instance in example above can be used to
decorate multiple functions. decorate multiple functions.
Decorated functions are registered automatically at loading Decorated functions are registered automatically at loading
extension, if an instance named as 'revsetpredicate' is used for extension, if an instance named as 'revsetpredicate' is used for
decorating in extension. decorating in extension.
Otherwise, explicit 'revset.loadpredicate()' is needed. Otherwise, explicit 'revset.loadpredicate()' is needed.
""" """
_getname = _funcregistrarbase._parsefuncdecl _getname = _funcregistrarbase._parsefuncdecl
_docformat = "``%s``\n %s" _docformat = "``%s``\n %s"
def _extrasetup(self, name, func, safe=False, takeorder=False): def _extrasetup(self, name, func, safe=False, takeorder=False,
takesubset=None):
if takeorder:
if takesubset is False:
raise error.ProgrammingError(
'takesubset cannot be False when takeorder is True')
takesubset = True
if takesubset is None:
# detect from signature
args = inspect.getargspec(func).args
takesubset = (len(args) >= 3)
func._safe = safe func._safe = safe
func._takeorder = takeorder func._takeorder = takeorder
func._takesubset = takesubset
class filesetpredicate(_funcregistrarbase): class filesetpredicate(_funcregistrarbase):
"""Decorator to register fileset predicate """Decorator to register fileset predicate
Usage:: Usage::
filesetpredicate = registrar.filesetpredicate() filesetpredicate = registrar.filesetpredicate()

mercurial/revset.py

n = getinteger(z, _("relation subscript must be an integer")) n = getinteger(z, _("relation subscript must be an integer"))
# TODO: perhaps this should be a table of relation functions # TODO: perhaps this should be a table of relation functions
if rel in ('g', 'generations'): if rel in ('g', 'generations'):
# TODO: support range, rewrite tests, and drop startdepth argument # TODO: support range, rewrite tests, and drop startdepth argument
# from ancestors() and descendants() predicates # from ancestors() and descendants() predicates
if n <= 0: if n <= 0:
n = -n n = -n
return _ancestors(repo, subset, x, startdepth=n, stopdepth=n + 1) return _ancestors(repo, x, startdepth=n, stopdepth=n + 1)
else: else:
return _descendants(repo, subset, x, startdepth=n, stopdepth=n + 1) return _descendants(repo, x, startdepth=n, stopdepth=n + 1)
raise error.UnknownIdentifier(rel, ['generations']) raise error.UnknownIdentifier(rel, ['generations'])
def subscriptset(repo, subset, x, y, order): def subscriptset(repo, subset, x, y, order):
raise error.ParseError(_("can't use a subscript in this context")) raise error.ParseError(_("can't use a subscript in this context"))
def listset(repo, subset, *xs, **opts): def listset(repo, subset, *xs, **opts):
raise error.ParseError(_("can't use a list in this context"), raise error.ParseError(_("can't use a list in this context"),
hint=_('see hg help "revsets.x or y"')) hint=_('see hg help "revsets.x or y"'))
def keyvaluepair(repo, subset, k, v, order): def keyvaluepair(repo, subset, k, v, order):
raise error.ParseError(_("can't use a key-value pair in this context")) raise error.ParseError(_("can't use a key-value pair in this context"))
def func(repo, subset, a, b, order): def func(repo, subset, a, b, order):
f = getsymbol(a) f = getsymbol(a)
if f in symbols: if f in symbols:
func = symbols[f] func = symbols[f]
if getattr(func, '_takeorder', False): takesubset = getattr(func, '_takesubset', True)
takeorder = getattr(func, '_takeorder', False)
if takesubset:
if takeorder:
return func(repo, subset, b, order) return func(repo, subset, b, order)
else:
# do we want warning since it may have ordering issues?
return func(repo, subset, b) return func(repo, subset, b)
else:
assert not takeorder
newset = func(repo, b)
return intersect(subset, newset, order)
keep = lambda fn: getattr(fn, '__doc__', None) is not None keep = lambda fn: getattr(fn, '__doc__', None) is not None
syms = [s for (s, fn) in symbols.items() if keep(fn)] syms = [s for (s, fn) in symbols.items() if keep(fn)]
raise error.UnknownIdentifier(f, syms) raise error.UnknownIdentifier(f, syms)
# functions # functions
# symbols are callables like: # symbols are callables like:
# fn(repo, subset, x) # fn(repo, subset, x)
# with: # with:
# repo - current repository instance # repo - current repository instance
# subset - of revisions to be examined # subset - of revisions to be examined
# x - argument in tree form # x - argument in tree form
symbols = {} symbols = {}
# symbols which can't be used for a DoS attack for any given input # symbols which can't be used for a DoS attack for any given input
# (e.g. those which accept regexes as plain strings shouldn't be included) # (e.g. those which accept regexes as plain strings shouldn't be included)
# functions that just return a lot of changesets (like all) don't count here # functions that just return a lot of changesets (like all) don't count here
safesymbols = set() safesymbols = set()
predicate = registrar.revsetpredicate() predicate = registrar.revsetpredicate()
@predicate('_destupdate') @predicate('_destupdate')
def _destupdate(repo, subset, x): def _destupdate(repo, x):
# experimental revset for update destination # experimental revset for update destination
args = getargsdict(x, 'limit', 'clean') args = getargsdict(x, 'limit', 'clean')
return subset & baseset([destutil.destupdate(repo, **args)[0]]) return baseset([destutil.destupdate(repo, **args)[0]])
@predicate('_destmerge') @predicate('_destmerge')
def _destmerge(repo, subset, x): def _destmerge(repo, x):
# experimental revset for merge destination # experimental revset for merge destination
sourceset = None sourceset = None
if x is not None: if x is not None:
sourceset = getset(repo, fullreposet(repo), x) sourceset = getset(repo, fullreposet(repo), x)
return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)]) return baseset([destutil.destmerge(repo, sourceset=sourceset)])
@predicate('adds(pattern)', safe=True) @predicate('adds(pattern)', safe=True)
def adds(repo, subset, x): def adds(repo, subset, x):
"""Changesets that add a file matching pattern. """Changesets that add a file matching pattern.
The pattern without explicit kind like ``glob:`` is expected to be The pattern without explicit kind like ``glob:`` is expected to be
relative to the current directory and match against a file or a relative to the current directory and match against a file or a
directory. directory.
anc = repo[r] anc = repo[r]
else: else:
anc = anc.ancestor(repo[r]) anc = anc.ancestor(repo[r])
if anc is not None and anc.rev() in subset: if anc is not None and anc.rev() in subset:
return baseset([anc.rev()]) return baseset([anc.rev()])
return baseset() return baseset()
def _ancestors(repo, subset, x, followfirst=False, startdepth=None, def _ancestors(repo, x, followfirst=False, startdepth=None, stopdepth=None):
stopdepth=None):
heads = getset(repo, fullreposet(repo), x) heads = getset(repo, fullreposet(repo), x)
if not heads: if not heads:
return baseset() return baseset()
s = dagop.revancestors(repo, heads, followfirst, startdepth, stopdepth) s = dagop.revancestors(repo, heads, followfirst, startdepth, stopdepth)
return subset & s return s
@predicate('ancestors(set[, depth])', safe=True) @predicate('ancestors(set[, depth])', safe=True)
def ancestors(repo, subset, x): def ancestors(repo, x):
"""Changesets that are ancestors of changesets in set, including the """Changesets that are ancestors of changesets in set, including the
given changesets themselves. given changesets themselves.
If depth is specified, the result only includes changesets up to If depth is specified, the result only includes changesets up to
the specified generation. the specified generation.
""" """
# startdepth is for internal use only until we can decide the UI # startdepth is for internal use only until we can decide the UI
args = getargsdict(x, 'ancestors', 'set depth startdepth') args = getargsdict(x, 'ancestors', 'set depth startdepth')
if 'set' not in args: if 'set' not in args:
# i18n: "ancestors" is a keyword # i18n: "ancestors" is a keyword
raise error.ParseError(_('ancestors takes at least 1 argument')) raise error.ParseError(_('ancestors takes at least 1 argument'))
startdepth = stopdepth = None startdepth = stopdepth = None
if 'startdepth' in args: if 'startdepth' in args:
n = getinteger(args['startdepth'], n = getinteger(args['startdepth'],
"ancestors expects an integer startdepth") "ancestors expects an integer startdepth")
if n < 0: if n < 0:
raise error.ParseError("negative startdepth") raise error.ParseError("negative startdepth")
startdepth = n startdepth = n
if 'depth' in args: if 'depth' in args:
# i18n: "ancestors" is a keyword # i18n: "ancestors" is a keyword
n = getinteger(args['depth'], _("ancestors expects an integer depth")) n = getinteger(args['depth'], _("ancestors expects an integer depth"))
if n < 0: if n < 0:
raise error.ParseError(_("negative depth")) raise error.ParseError(_("negative depth"))
stopdepth = n + 1 stopdepth = n + 1
return _ancestors(repo, subset, args['set'], return _ancestors(repo, args['set'],
startdepth=startdepth, stopdepth=stopdepth) startdepth=startdepth, stopdepth=stopdepth)
@predicate('_firstancestors', safe=True) @predicate('_firstancestors', safe=True)
def _firstancestors(repo, subset, x): def _firstancestors(repo, x):
# ``_firstancestors(set)`` # ``_firstancestors(set)``
# Like ``ancestors(set)`` but follows only the first parents. # Like ``ancestors(set)`` but follows only the first parents.
return _ancestors(repo, subset, x, followfirst=True) return _ancestors(repo, x, followfirst=True)
def _childrenspec(repo, subset, x, n, order): def _childrenspec(repo, x, n):
"""Changesets that are the Nth child of a changeset """Changesets that are the Nth child of a changeset
in set. in set.
""" """
cs = set() cs = set()
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
for i in range(n): for i in range(n):
c = repo[r].children() c = repo[r].children()
if len(c) == 0: if len(c) == 0:
break break
if len(c) > 1: if len(c) > 1:
raise error.RepoLookupError( raise error.RepoLookupError(
_("revision in set has more than one child")) _("revision in set has more than one child"))
r = c[0].rev() r = c[0].rev()
else: else:
cs.add(r) cs.add(r)
return subset & cs return cs
def ancestorspec(repo, subset, x, n, order): def ancestorspec(repo, subset, x, n, order):
"""``set~n`` """``set~n``
Changesets that are the Nth ancestor (first parents only) of a changeset Changesets that are the Nth ancestor (first parents only) of a changeset
in set. in set.
""" """
n = getinteger(n, _("~ expects a number")) n = getinteger(n, _("~ expects a number"))
if n < 0: if n < 0:
# children lookup # children lookup
return _childrenspec(repo, subset, x, -n, order) return intersect(subset, _childrenspec(repo, x, -n), order)
ps = set() ps = set()
cl = repo.changelog cl = repo.changelog
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
for i in range(n): for i in range(n):
try: try:
r = cl.parentrevs(r)[0] r = cl.parentrevs(r)[0]
except error.WdirUnsupported: except error.WdirUnsupported:
r = repo[r].parents()[0].rev() r = repo[r].parents()[0].rev()
ps.add(r) ps.add(r)
return subset & ps return subset & ps
@predicate('author(string)', safe=True) @predicate('author(string)', safe=True)
def author(repo, subset, x): def author(repo, subset, x):
"""Alias for ``user(string)``. """Alias for ``user(string)``.
""" """
# i18n: "author" is a keyword # i18n: "author" is a keyword
n = getstring(x, _("author requires a string")) n = getstring(x, _("author requires a string"))
kind, pattern, matcher = _substringmatcher(n, casesensitive=False) kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
return subset.filter(lambda x: matcher(repo[x].user()), return subset.filter(lambda x: matcher(repo[x].user()),
condrepr=('<user %r>', n)) condrepr=('<user %r>', n))
@predicate('bisect(string)', safe=True) @predicate('bisect(string)', safe=True)
def bisect(repo, subset, x): def bisect(repo, x):
"""Changesets marked in the specified bisect status: """Changesets marked in the specified bisect status:
- ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
- ``goods``, ``bads`` : csets topologically good/bad - ``goods``, ``bads`` : csets topologically good/bad
- ``range`` : csets taking part in the bisection - ``range`` : csets taking part in the bisection
- ``pruned`` : csets that are goods, bads or skipped - ``pruned`` : csets that are goods, bads or skipped
- ``untested`` : csets whose fate is yet unknown - ``untested`` : csets whose fate is yet unknown
- ``ignored`` : csets ignored due to DAG topology - ``ignored`` : csets ignored due to DAG topology
- ``current`` : the cset currently being bisected - ``current`` : the cset currently being bisected
""" """
# i18n: "bisect" is a keyword # i18n: "bisect" is a keyword
status = getstring(x, _("bisect requires a string")).lower() status = getstring(x, _("bisect requires a string")).lower()
state = set(hbisect.get(repo, status)) state = set(hbisect.get(repo, status))
return subset & state return state
# Backward-compatibility # Backward-compatibility
# - no help entry so that we do not advertise it any more # - no help entry so that we do not advertise it any more
@predicate('bisected', safe=True) @predicate('bisected', safe=True)
def bisected(repo, subset, x): def bisected(repo, x):
return bisect(repo, subset, x) return bisect(repo, x)
@predicate('bookmark([name])', safe=True) @predicate('bookmark([name])', safe=True)
def bookmark(repo, subset, x): def bookmark(repo, x):
"""The named bookmark or all bookmarks. """The named bookmark or all bookmarks.
Pattern matching is supported for `name`. See :hg:`help revisions.patterns`. Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
""" """
# i18n: "bookmark" is a keyword # i18n: "bookmark" is a keyword
args = getargs(x, 0, 1, _('bookmark takes one or no arguments')) args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
if args: if args:
bm = getstring(args[0], bm = getstring(args[0],
if not matchrevs: if not matchrevs:
raise error.RepoLookupError(_("no bookmarks exist" raise error.RepoLookupError(_("no bookmarks exist"
" that match '%s'") % pattern) " that match '%s'") % pattern)
for bmrev in matchrevs: for bmrev in matchrevs:
bms.add(repo[bmrev].rev()) bms.add(repo[bmrev].rev())
else: else:
bms = {repo[r].rev() for r in repo._bookmarks.values()} bms = {repo[r].rev() for r in repo._bookmarks.values()}
bms -= {node.nullrev} bms -= {node.nullrev}
return subset & bms return bms
@predicate('branch(string or set)', safe=True) @predicate('branch(string or set)', safe=True)
def branch(repo, subset, x): def branch(repo, subset, x):
""" """
All changesets belonging to the given branch or the branches of the given All changesets belonging to the given branch or the branches of the given
changesets. changesets.
Pattern matching is supported for `string`. See Pattern matching is supported for `string`. See
def bumped(repo, subset, x): def bumped(repo, subset, x):
msg = ("'bumped()' is deprecated, " msg = ("'bumped()' is deprecated, "
"use 'phasedivergent()'") "use 'phasedivergent()'")
repo.ui.deprecwarn(msg, '4.4') repo.ui.deprecwarn(msg, '4.4')
return phasedivergent(repo, subset, x) return phasedivergent(repo, subset, x)
@predicate('phasedivergent()', safe=True) @predicate('phasedivergent()', safe=True)
def phasedivergent(repo, subset, x): def phasedivergent(repo, x):
"""Mutable changesets marked as successors of public changesets. """Mutable changesets marked as successors of public changesets.
Only non-public and non-obsolete changesets can be `phasedivergent`. Only non-public and non-obsolete changesets can be `phasedivergent`.
(EXPERIMENTAL) (EXPERIMENTAL)
""" """
# i18n: "phasedivergent" is a keyword # i18n: "phasedivergent" is a keyword
getargs(x, 0, 0, _("phasedivergent takes no arguments")) getargs(x, 0, 0, _("phasedivergent takes no arguments"))
phasedivergent = obsmod.getrevs(repo, 'phasedivergent') phasedivergent = obsmod.getrevs(repo, 'phasedivergent')
return subset & phasedivergent return phasedivergent
@predicate('bundle()', safe=True) @predicate('bundle()', safe=True)
def bundle(repo, subset, x): def bundle(repo, x):
"""Changesets in the bundle. """Changesets in the bundle.
Bundle must be specified by the -R option.""" Bundle must be specified by the -R option."""
try: try:
bundlerevs = repo.changelog.bundlerevs bundlerevs = repo.changelog.bundlerevs
except AttributeError: except AttributeError:
raise error.Abort(_("no bundle provided - specify with -R")) raise error.Abort(_("no bundle provided - specify with -R"))
return subset & bundlerevs return bundlerevs
def checkstatus(repo, subset, pat, field): def checkstatus(repo, subset, pat, field):
hasset = matchmod.patkind(pat) == 'set' hasset = matchmod.patkind(pat) == 'set'
mcache = [None] mcache = [None]
def matches(x): def matches(x):
c = repo[x] c = repo[x]
if not mcache[0] or hasset: if not mcache[0] or hasset:
# i18n: "desc" is a keyword # i18n: "desc" is a keyword
ds = getstring(x, _("desc requires a string")) ds = getstring(x, _("desc requires a string"))
kind, pattern, matcher = _substringmatcher(ds, casesensitive=False) kind, pattern, matcher = _substringmatcher(ds, casesensitive=False)
return subset.filter(lambda r: matcher(repo[r].description()), return subset.filter(lambda r: matcher(repo[r].description()),
condrepr=('<desc %r>', ds)) condrepr=('<desc %r>', ds))
def _descendants(repo, subset, x, followfirst=False, startdepth=None, def _descendants(repo, x, followfirst=False, startdepth=None, stopdepth=None):
stopdepth=None):
roots = getset(repo, fullreposet(repo), x) roots = getset(repo, fullreposet(repo), x)
if not roots: if not roots:
return baseset() return baseset()
s = dagop.revdescendants(repo, roots, followfirst, startdepth, stopdepth) s = dagop.revdescendants(repo, roots, followfirst, startdepth, stopdepth)
return subset & s return s
@predicate('descendants(set[, depth])', safe=True) @predicate('descendants(set[, depth])', safe=True)
def descendants(repo, subset, x): def descendants(repo, x):
"""Changesets which are descendants of changesets in set, including the """Changesets which are descendants of changesets in set, including the
given changesets themselves. given changesets themselves.
If depth is specified, the result only includes changesets up to If depth is specified, the result only includes changesets up to
the specified generation. the specified generation.
""" """
# startdepth is for internal use only until we can decide the UI # startdepth is for internal use only until we can decide the UI
args = getargsdict(x, 'descendants', 'set depth startdepth') args = getargsdict(x, 'descendants', 'set depth startdepth')
if 'set' not in args: if 'set' not in args:
# i18n: "descendants" is a keyword # i18n: "descendants" is a keyword
raise error.ParseError(_('descendants takes at least 1 argument')) raise error.ParseError(_('descendants takes at least 1 argument'))
startdepth = stopdepth = None startdepth = stopdepth = None
if 'startdepth' in args: if 'startdepth' in args:
n = getinteger(args['startdepth'], n = getinteger(args['startdepth'],
"descendants expects an integer startdepth") "descendants expects an integer startdepth")
if n < 0: if n < 0:
raise error.ParseError("negative startdepth") raise error.ParseError("negative startdepth")
startdepth = n startdepth = n
if 'depth' in args: if 'depth' in args:
# i18n: "descendants" is a keyword # i18n: "descendants" is a keyword
n = getinteger(args['depth'], _("descendants expects an integer depth")) n = getinteger(args['depth'], _("descendants expects an integer depth"))
if n < 0: if n < 0:
raise error.ParseError(_("negative depth")) raise error.ParseError(_("negative depth"))
stopdepth = n + 1 stopdepth = n + 1
return _descendants(repo, subset, args['set'], return _descendants(repo, args['set'],
startdepth=startdepth, stopdepth=stopdepth) startdepth=startdepth, stopdepth=stopdepth)
@predicate('_firstdescendants', safe=True) @predicate('_firstdescendants', safe=True)
def _firstdescendants(repo, subset, x): def _firstdescendants(repo, x):
# ``_firstdescendants(set)`` # ``_firstdescendants(set)``
# Like ``descendants(set)`` but follows only the first parents. # Like ``descendants(set)`` but follows only the first parents.
return _descendants(repo, subset, x, followfirst=True) return _descendants(repo, x, followfirst=True)
@predicate('destination([set])', safe=True) @predicate('destination([set])', safe=True)
def destination(repo, subset, x): def destination(repo, subset, x):
"""Changesets that were created by a graft, transplant or rebase operation, """Changesets that were created by a graft, transplant or rebase operation,
with the given revisions specified as the source. Omitting the optional set with the given revisions specified as the source. Omitting the optional set
is the same as passing all(). is the same as passing all().
""" """
if x is not None: if x is not None:
def divergent(repo, subset, x): def divergent(repo, subset, x):
msg = ("'divergent()' is deprecated, " msg = ("'divergent()' is deprecated, "
"use 'contentdivergent()'") "use 'contentdivergent()'")
repo.ui.deprecwarn(msg, '4.4') repo.ui.deprecwarn(msg, '4.4')
return contentdivergent(repo, subset, x) return contentdivergent(repo, subset, x)
@predicate('contentdivergent()', safe=True) @predicate('contentdivergent()', safe=True)
def contentdivergent(repo, subset, x): def contentdivergent(repo, x):
""" """
Final successors of changesets with an alternative set of final Final successors of changesets with an alternative set of final
successors. (EXPERIMENTAL) successors. (EXPERIMENTAL)
""" """
# i18n: "contentdivergent" is a keyword # i18n: "contentdivergent" is a keyword
getargs(x, 0, 0, _("contentdivergent takes no arguments")) getargs(x, 0, 0, _("contentdivergent takes no arguments"))
contentdivergent = obsmod.getrevs(repo, 'contentdivergent') contentdivergent = obsmod.getrevs(repo, 'contentdivergent')
return subset & contentdivergent return contentdivergent
@predicate('extinct()', safe=True) @predicate('extinct()', safe=True)
def extinct(repo, subset, x): def extinct(repo, x):
"""Obsolete changesets with obsolete descendants only. """Obsolete changesets with obsolete descendants only.
""" """
# i18n: "extinct" is a keyword # i18n: "extinct" is a keyword
getargs(x, 0, 0, _("extinct takes no arguments")) getargs(x, 0, 0, _("extinct takes no arguments"))
extincts = obsmod.getrevs(repo, 'extinct') extincts = obsmod.getrevs(repo, 'extinct')
return subset & extincts return extincts
@predicate('extra(label, [value])', safe=True) @predicate('extra(label, [value])', safe=True)
def extra(repo, subset, x): def extra(repo, subset, x):
"""Changesets with the given label in the extra metadata, with the given """Changesets with the given label in the extra metadata, with the given
optional value. optional value.
Pattern matching is supported for `value`. See Pattern matching is supported for `value`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.
def _matchvalue(r): def _matchvalue(r):
extra = repo[r].extra() extra = repo[r].extra()
return label in extra and (value is None or matcher(extra[label])) return label in extra and (value is None or matcher(extra[label]))
return subset.filter(lambda r: _matchvalue(r), return subset.filter(lambda r: _matchvalue(r),
condrepr=('<extra[%r] %r>', label, value)) condrepr=('<extra[%r] %r>', label, value))
@predicate('filelog(pattern)', safe=True) @predicate('filelog(pattern)', safe=True)
def filelog(repo, subset, x): def filelog(repo, x):
"""Changesets connected to the specified filelog. """Changesets connected to the specified filelog.
For performance reasons, visits only revisions mentioned in the file-level For performance reasons, visits only revisions mentioned in the file-level
filelog, rather than filtering through all changesets (much faster, but filelog, rather than filtering through all changesets (much faster, but
doesn't include deletes or duplicate changes). For a slower, more accurate doesn't include deletes or duplicate changes). For a slower, more accurate
result, use ``file()``. result, use ``file()``.
The pattern without explicit kind like ``glob:`` is expected to be The pattern without explicit kind like ``glob:`` is expected to be
scanpos = r scanpos = r
break break
else: else:
known[n] = r known[n] = r
except error.ManifestLookupError: except error.ManifestLookupError:
# deletion in changelog # deletion in changelog
continue continue
return subset & s return s
@predicate('first(set, [n])', safe=True, takeorder=True) @predicate('first(set, [n])', safe=True, takeorder=True)
def first(repo, subset, x, order): def first(repo, subset, x, order):
"""An alias for limit(). """An alias for limit().
""" """
return limit(repo, subset, x, order) return limit(repo, subset, x, order)
def _follow(repo, subset, x, name, followfirst=False): def _follow(repo, x, name, followfirst=False):
l = getargs(x, 0, 2, _("%s takes no arguments or a pattern " l = getargs(x, 0, 2, _("%s takes no arguments or a pattern "
"and an optional revset") % name) "and an optional revset") % name)
c = repo['.'] c = repo['.']
if l: if l:
x = getstring(l[0], _("%s expected a pattern") % name) x = getstring(l[0], _("%s expected a pattern") % name)
rev = None rev = None
if len(l) >= 2: if len(l) >= 2:
revs = getset(repo, fullreposet(repo), l[1]) revs = getset(repo, fullreposet(repo), l[1])
for fname in files: for fname in files:
fctx = c[fname] fctx = c[fname]
s = s.union(set(c.rev() for c in fctx.ancestors(followfirst))) s = s.union(set(c.rev() for c in fctx.ancestors(followfirst)))
# include the revision responsible for the most recent version # include the revision responsible for the most recent version
s.add(fctx.introrev()) s.add(fctx.introrev())
else: else:
s = dagop.revancestors(repo, baseset([c.rev()]), followfirst) s = dagop.revancestors(repo, baseset([c.rev()]), followfirst)
return subset & s return s
@predicate('_flipand(x, y)', safe=True, takeorder=True) @predicate('_flipand(x, y)', safe=True, takeorder=True)
def _flipand(repo, subset, args, order): def _flipand(repo, subset, args, order):
"""Equivalent to ``y and x``, but faster when x is small""" """Equivalent to ``y and x``, but faster when x is small"""
x, y = getargs(args, 2, 2, _("missing argument")) x, y = getargs(args, 2, 2, _("missing argument"))
if order == defineorder: if order == defineorder:
# NOTE: In theory this could be "anyorder". But many revsets (ex. # NOTE: In theory this could be "anyorder". But many revsets (ex.
# "contains") do not handle "defineorder" correctly. This has to be # "contains") do not handle "defineorder" correctly. This has to be
# followorder for now to hide those issues. # followorder for now to hide those issues.
xorder = followorder xorder = followorder
else: else:
xorder = order xorder = order
return getset(repo, getset(repo, subset, x, xorder), y, order) return getset(repo, getset(repo, subset, x, xorder), y, order)
@predicate('follow([pattern[, startrev]])', safe=True) @predicate('follow([pattern[, startrev]])', safe=True)
def follow(repo, subset, x): def follow(repo, x):
""" """
An alias for ``::.`` (ancestors of the working directory's first parent). An alias for ``::.`` (ancestors of the working directory's first parent).
If pattern is specified, the histories of files matching given If pattern is specified, the histories of files matching given
pattern in the revision given by startrev are followed, including copies. pattern in the revision given by startrev are followed, including copies.
""" """
return _follow(repo, subset, x, 'follow') return _follow(repo, x, 'follow')
@predicate('_followfirst', safe=True) @predicate('_followfirst', safe=True)
def _followfirst(repo, subset, x): def _followfirst(repo, x):
# ``followfirst([pattern[, startrev]])`` # ``followfirst([pattern[, startrev]])``
# Like ``follow([pattern[, startrev]])`` but follows only the first parent # Like ``follow([pattern[, startrev]])`` but follows only the first parent
# of every revisions or files revisions. # of every revisions or files revisions.
return _follow(repo, subset, x, '_followfirst', followfirst=True) return _follow(repo, x, '_followfirst', followfirst=True)
@predicate('followlines(file, fromline:toline[, startrev=., descend=False])', @predicate('followlines(file, fromline:toline[, startrev=., descend=False])',
safe=True) safe=True)
def followlines(repo, subset, x): def followlines(repo, x):
"""Changesets modifying `file` in line range ('fromline', 'toline'). """Changesets modifying `file` in line range ('fromline', 'toline').
Line range corresponds to 'file' content at 'startrev' and should hence be Line range corresponds to 'file' content at 'startrev' and should hence be
consistent with file size. If startrev is not specified, working directory's consistent with file size. If startrev is not specified, working directory's
parent is used. parent is used.
By default, ancestors of 'startrev' are returned. If 'descend' is True, By default, ancestors of 'startrev' are returned. If 'descend' is True,
descendants of 'startrev' are returned though renames are (currently) not descendants of 'startrev' are returned though renames are (currently) not
(c.rev() for c, _linerange (c.rev() for c, _linerange
in dagop.blockdescendants(fctx, fromline, toline)), in dagop.blockdescendants(fctx, fromline, toline)),
iterasc=True) iterasc=True)
else: else:
rs = generatorset( rs = generatorset(
(c.rev() for c, _linerange (c.rev() for c, _linerange
in dagop.blockancestors(fctx, fromline, toline)), in dagop.blockancestors(fctx, fromline, toline)),
iterasc=False) iterasc=False)
return subset & rs return rs
@predicate('all()', safe=True) @predicate('all()', safe=True)
def getall(repo, subset, x): def getall(repo, x):
"""All changesets, the same as ``0:tip``. """All changesets, the same as ``0:tip``.
""" """
# i18n: "all" is a keyword # i18n: "all" is a keyword
getargs(x, 0, 0, _("all takes no arguments")) getargs(x, 0, 0, _("all takes no arguments"))
return subset & spanset(repo) # drop "null" if any return spanset(repo) # drop "null" if any
@predicate('grep(regex)') @predicate('grep(regex)')
def grep(repo, subset, x): def grep(repo, subset, x):
"""Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')`` """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
to ensure special escape characters are handled correctly. Unlike to ensure special escape characters are handled correctly. Unlike
``keyword(string)``, the match is case-sensitive. ``keyword(string)``, the match is case-sensitive.
""" """
try: try:
This predicate uses ``glob:`` as the default kind of pattern. This predicate uses ``glob:`` as the default kind of pattern.
""" """
# i18n: "file" is a keyword # i18n: "file" is a keyword
pat = getstring(x, _("file requires a pattern")) pat = getstring(x, _("file requires a pattern"))
return _matchfiles(repo, subset, ('string', 'p:' + pat)) return _matchfiles(repo, subset, ('string', 'p:' + pat))
@predicate('head()', safe=True) @predicate('head()', safe=True)
def head(repo, subset, x): def head(repo, x):
"""Changeset is a named branch head. """Changeset is a named branch head.
""" """
# i18n: "head" is a keyword # i18n: "head" is a keyword
getargs(x, 0, 0, _("head takes no arguments")) getargs(x, 0, 0, _("head takes no arguments"))
hs = set() hs = set()
cl = repo.changelog cl = repo.changelog
for ls in repo.branchmap().itervalues(): for ls in repo.branchmap().itervalues():
hs.update(cl.rev(h) for h in ls) hs.update(cl.rev(h) for h in ls)
return subset & baseset(hs) return baseset(hs)
@predicate('heads(set)', safe=True) @predicate('heads(set)', safe=True)
def heads(repo, subset, x): def heads(repo, subset, x):
"""Members of set with no children in set. """Members of set with no children in set.
""" """
s = getset(repo, subset, x) s = getset(repo, subset, x)
ps = parents(repo, subset, x) ps = parents(repo, subset, x)
return s - ps return s - ps
@predicate('hidden()', safe=True) @predicate('hidden()', safe=True)
def hidden(repo, subset, x): def hidden(repo, x):
"""Hidden changesets. """Hidden changesets.
""" """
# i18n: "hidden" is a keyword # i18n: "hidden" is a keyword
getargs(x, 0, 0, _("hidden takes no arguments")) getargs(x, 0, 0, _("hidden takes no arguments"))
hiddenrevs = repoview.filterrevs(repo, 'visible') hiddenrevs = repoview.filterrevs(repo, 'visible')
return subset & hiddenrevs return hiddenrevs
@predicate('keyword(string)', safe=True) @predicate('keyword(string)', safe=True)
def keyword(repo, subset, x): def keyword(repo, subset, x):
"""Search commit message, user name, and names of changed files for """Search commit message, user name, and names of changed files for
string. The match is case-insensitive. string. The match is case-insensitive.
For a regular expression or case sensitive search of these fields, use For a regular expression or case sensitive search of these fields, use
``grep(regex)``. ``grep(regex)``.
relative to the current directory and match against a file or a relative to the current directory and match against a file or a
directory. directory.
""" """
# i18n: "modifies" is a keyword # i18n: "modifies" is a keyword
pat = getstring(x, _("modifies requires a pattern")) pat = getstring(x, _("modifies requires a pattern"))
return checkstatus(repo, subset, pat, 0) return checkstatus(repo, subset, pat, 0)
@predicate('named(namespace)') @predicate('named(namespace)')
def named(repo, subset, x): def named(repo, x):
"""The changesets in a given namespace. """The changesets in a given namespace.
Pattern matching is supported for `namespace`. See Pattern matching is supported for `namespace`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.
""" """
# i18n: "named" is a keyword # i18n: "named" is a keyword
args = getargs(x, 1, 1, _('named requires a namespace argument')) args = getargs(x, 1, 1, _('named requires a namespace argument'))
names = set() names = set()
for ns in namespaces: for ns in namespaces:
for name in ns.listnames(repo): for name in ns.listnames(repo):
if name not in ns.deprecated: if name not in ns.deprecated:
names.update(repo[n].rev() for n in ns.nodes(repo, name)) names.update(repo[n].rev() for n in ns.nodes(repo, name))
names -= {node.nullrev} names -= {node.nullrev}
return subset & names return names
@predicate('id(string)', safe=True) @predicate('id(string)', safe=True)
def node_(repo, subset, x): def node_(repo, subset, x):
"""Revision non-ambiguously specified by the given hex string prefix. """Revision non-ambiguously specified by the given hex string prefix.
""" """
# i18n: "id" is a keyword # i18n: "id" is a keyword
l = getargs(x, 1, 1, _("id requires one argument")) l = getargs(x, 1, 1, _("id requires one argument"))
# i18n: "id" is a keyword # i18n: "id" is a keyword
rn = node.wdirrev rn = node.wdirrev
if rn is None: if rn is None:
return baseset() return baseset()
result = baseset([rn]) result = baseset([rn])
return result & subset return result & subset
@predicate('obsolete()', safe=True) @predicate('obsolete()', safe=True)
def obsolete(repo, subset, x): def obsolete(repo, x):
"""Mutable changeset with a newer version.""" """Mutable changeset with a newer version."""
# i18n: "obsolete" is a keyword # i18n: "obsolete" is a keyword
getargs(x, 0, 0, _("obsolete takes no arguments")) getargs(x, 0, 0, _("obsolete takes no arguments"))
obsoletes = obsmod.getrevs(repo, 'obsolete') obsoletes = obsmod.getrevs(repo, 'obsolete')
return subset & obsoletes return obsoletes
@predicate('only(set, [set])', safe=True) @predicate('only(set, [set])', safe=True)
def only(repo, subset, x): def only(repo, x):
"""Changesets that are ancestors of the first set that are not ancestors """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 of any other head in the repo. If a second set is specified, the result
is ancestors of the first set that are not ancestors of the second set is ancestors of the first set that are not ancestors of the second set
(i.e. ::<set1> - ::<set2>). (i.e. ::<set1> - ::<set2>).
""" """
cl = repo.changelog cl = repo.changelog
# i18n: "only" is a keyword # i18n: "only" is a keyword
args = getargs(x, 1, 2, _('only takes one or two arguments')) args = getargs(x, 1, 2, _('only takes one or two arguments'))
include = getset(repo, fullreposet(repo), args[0]) include = getset(repo, fullreposet(repo), args[0])
if len(args) == 1: if len(args) == 1:
if not include: if not include:
return baseset() return baseset()
descendants = set(dagop.revdescendants(repo, include, False)) descendants = set(dagop.revdescendants(repo, include, False))
exclude = [rev for rev in cl.headrevs() exclude = [rev for rev in cl.headrevs()
if not rev in descendants and not rev in include] if not rev in descendants and not rev in include]
else: else:
exclude = getset(repo, fullreposet(repo), args[1]) exclude = getset(repo, fullreposet(repo), args[1])
results = set(cl.findmissingrevs(common=exclude, heads=include)) results = set(cl.findmissingrevs(common=exclude, heads=include))
# XXX we should turn this into a baseset instead of a set, smartset may do return baseset(results)
# some optimizations from the fact this is a baseset.
return subset & results
@predicate('origin([set])', safe=True) @predicate('origin([set])', safe=True)
def origin(repo, subset, x): def origin(repo, x):
""" """
Changesets that were specified as a source for the grafts, transplants or Changesets that were specified as a source for the grafts, transplants or
rebases that created the given revisions. Omitting the optional set is the rebases that created the given revisions. Omitting the optional set is the
same as passing all(). If a changeset created by these operations is itself same as passing all(). If a changeset created by these operations is itself
specified as a source for one of these operations, only the source changeset specified as a source for one of these operations, only the source changeset
for the first operation is selected. for the first operation is selected.
""" """
if x is not None: if x is not None:
prev = _getrevsource(repo, src) prev = _getrevsource(repo, src)
if prev is None: if prev is None:
return src return src
src = prev src = prev
o = {_firstsrc(r) for r in dests} o = {_firstsrc(r) for r in dests}
o -= {None} o -= {None}
# XXX we should turn this into a baseset instead of a set, smartset may do return baseset(o)
# some optimizations from the fact this is a baseset.
return subset & o
@predicate('outgoing([path])', safe=False) @predicate('outgoing([path])', safe=False)
def outgoing(repo, subset, x): def outgoing(repo, x):
"""Changesets not found in the specified destination repository, or the """Changesets not found in the specified destination repository, or the
default push location. default push location.
""" """
# Avoid cycles. # Avoid cycles.
from . import ( from . import (
discovery, discovery,
hg, hg,
) )
# i18n: "outgoing" is a keyword # i18n: "outgoing" is a keyword
l = getargs(x, 0, 1, _("outgoing takes one or no arguments")) l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
# i18n: "outgoing" is a keyword # i18n: "outgoing" is a keyword
dest = l and getstring(l[0], _("outgoing requires a repository path")) or '' dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
dest = repo.ui.expandpath(dest or 'default-push', dest or 'default') dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
dest, branches = hg.parseurl(dest) dest, branches = hg.parseurl(dest)
revs, checkout = hg.addbranchrevs(repo, repo, branches, []) revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
if revs: if revs:
revs = [repo.lookup(rev) for rev in revs] revs = [repo.lookup(rev) for rev in revs]
other = hg.peer(repo, {}, dest) other = hg.peer(repo, {}, dest)
repo.ui.pushbuffer() repo.ui.pushbuffer()
outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs) outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
repo.ui.popbuffer() repo.ui.popbuffer()
cl = repo.changelog cl = repo.changelog
o = {cl.rev(r) for r in outgoing.missing} o = {cl.rev(r) for r in outgoing.missing}
return subset & o return o
@predicate('p1([set])', safe=True) @predicate('p1([set])', safe=True)
def p1(repo, subset, x): def p1(repo, x):
"""First parent of changesets in set, or the working directory. """First parent of changesets in set, or the working directory.
""" """
if x is None: if x is None:
p = repo[x].p1().rev() p = repo[x].p1().rev()
if p >= 0: if p >= 0:
return subset & baseset([p]) return baseset([p])
return baseset() return baseset()
ps = set() ps = set()
cl = repo.changelog cl = repo.changelog
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
ps.add(cl.parentrevs(r)[0]) ps.add(cl.parentrevs(r)[0])
except error.WdirUnsupported: except error.WdirUnsupported:
ps.add(repo[r].parents()[0].rev()) ps.add(repo[r].parents()[0].rev())
ps -= {node.nullrev} ps -= {node.nullrev}
# XXX we should turn this into a baseset instead of a set, smartset may do return baseset(ps)
# some optimizations from the fact this is a baseset.
return subset & ps
@predicate('p2([set])', safe=True) @predicate('p2([set])', safe=True)
def p2(repo, subset, x): def p2(repo, x):
"""Second parent of changesets in set, or the working directory. """Second parent of changesets in set, or the working directory.
""" """
if x is None: if x is None:
ps = repo[x].parents() ps = repo[x].parents()
try: try:
p = ps[1].rev() p = ps[1].rev()
if p >= 0: if p >= 0:
return subset & baseset([p]) return baseset([p])
return baseset() return baseset()
except IndexError: except IndexError:
return baseset() return baseset()
ps = set() ps = set()
cl = repo.changelog cl = repo.changelog
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
ps.add(cl.parentrevs(r)[1]) ps.add(cl.parentrevs(r)[1])
except error.WdirUnsupported: except error.WdirUnsupported:
parents = repo[r].parents() parents = repo[r].parents()
if len(parents) == 2: if len(parents) == 2:
ps.add(parents[1]) ps.add(parents[1])
ps -= {node.nullrev} ps -= {node.nullrev}
# XXX we should turn this into a baseset instead of a set, smartset may do return baseset(ps)
# some optimizations from the fact this is a baseset.
return subset & ps
def parentpost(repo, subset, x, order): def parentpost(repo, subset, x, order):
return p1(repo, subset, x) return intersect(subset, p1(repo, x), order)
@predicate('parents([set])', safe=True, takeorder=True) @predicate('parents([set])', safe=True, takeorder=True)
def parents(repo, subset, x, order=anyorder): def parents(repo, subset, x, order=anyorder):
""" """
The set of all parents for all changesets in set, or the working directory. The set of all parents for all changesets in set, or the working directory.
""" """
if x is None: if x is None:
ps = set(p.rev() for p in repo[x].parents()) ps = set(p.rev() for p in repo[x].parents())
else: else:
ps = set() ps = set()
cl = repo.changelog cl = repo.changelog
up = ps.update up = ps.update
parentrevs = cl.parentrevs parentrevs = cl.parentrevs
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
up(parentrevs(r)) up(parentrevs(r))
except error.WdirUnsupported: except error.WdirUnsupported:
up(p.rev() for p in repo[r].parents()) up(p.rev() for p in repo[r].parents())
ps -= {node.nullrev} ps -= {node.nullrev}
return intersect(subset, ps, order) return intersect(subset, ps, order)
def _phase(repo, subset, *targets): def _phase(repo, *targets):
"""helper to select all rev in <targets> phases""" """helper to select all rev in <targets> phases"""
s = repo._phasecache.getrevset(repo, targets) s = repo._phasecache.getrevset(repo, targets)
return subset & s return s
@predicate('draft()', safe=True) @predicate('draft()', safe=True)
def draft(repo, subset, x): def draft(repo, x):
"""Changeset in draft phase.""" """Changeset in draft phase."""
# i18n: "draft" is a keyword # i18n: "draft" is a keyword
getargs(x, 0, 0, _("draft takes no arguments")) getargs(x, 0, 0, _("draft takes no arguments"))
target = phases.draft target = phases.draft
return _phase(repo, subset, target) return _phase(repo, target)
@predicate('secret()', safe=True) @predicate('secret()', safe=True)
def secret(repo, subset, x): def secret(repo, x):
"""Changeset in secret phase.""" """Changeset in secret phase."""
# i18n: "secret" is a keyword # i18n: "secret" is a keyword
getargs(x, 0, 0, _("secret takes no arguments")) getargs(x, 0, 0, _("secret takes no arguments"))
target = phases.secret target = phases.secret
return _phase(repo, subset, target) return _phase(repo, target)
def parentspec(repo, subset, x, n, order): def parentspec(repo, subset, x, n, order):
"""``set^0`` """``set^0``
The set. The set.
``set^1`` (or ``set^``), ``set^2`` ``set^1`` (or ``set^``), ``set^2``
First or second parent, respectively, of all changesets in set. First or second parent, respectively, of all changesets in set.
""" """
try: try:
""" """
try: try:
return getset(repo, subset, x, order) return getset(repo, subset, x, order)
except error.RepoLookupError: except error.RepoLookupError:
return baseset() return baseset()
# for internal use # for internal use
@predicate('_notpublic', safe=True) @predicate('_notpublic', safe=True)
def _notpublic(repo, subset, x): def _notpublic(repo, x):
getargs(x, 0, 0, "_notpublic takes no arguments") getargs(x, 0, 0, "_notpublic takes no arguments")
return _phase(repo, subset, phases.draft, phases.secret) return _phase(repo, phases.draft, phases.secret)
@predicate('public()', safe=True) @predicate('public()', safe=True)
def public(repo, subset, x): def public(repo, subset, x):
"""Changeset in public phase.""" """Changeset in public phase."""
# i18n: "public" is a keyword # i18n: "public" is a keyword
getargs(x, 0, 0, _("public takes no arguments")) getargs(x, 0, 0, _("public takes no arguments"))
phase = repo._phasecache.phase phase = repo._phasecache.phase
target = phases.public target = phases.public
relative to the current directory and match against a file or a relative to the current directory and match against a file or a
directory. directory.
""" """
# i18n: "removes" is a keyword # i18n: "removes" is a keyword
pat = getstring(x, _("removes requires a pattern")) pat = getstring(x, _("removes requires a pattern"))
return checkstatus(repo, subset, pat, 2) return checkstatus(repo, subset, pat, 2)
@predicate('rev(number)', safe=True) @predicate('rev(number)', safe=True)
def rev(repo, subset, x): def rev(repo, x):
"""Revision with the given numeric identifier. """Revision with the given numeric identifier.
""" """
# i18n: "rev" is a keyword # i18n: "rev" is a keyword
l = getargs(x, 1, 1, _("rev requires one argument")) l = getargs(x, 1, 1, _("rev requires one argument"))
try: try:
# i18n: "rev" is a keyword # i18n: "rev" is a keyword
l = int(getstring(l[0], _("rev requires a number"))) l = int(getstring(l[0], _("rev requires a number")))
except (TypeError, ValueError): except (TypeError, ValueError):
# i18n: "rev" is a keyword # i18n: "rev" is a keyword
raise error.ParseError(_("rev expects a number")) raise error.ParseError(_("rev expects a number"))
if l not in repo.changelog and l not in (node.nullrev, node.wdirrev): if l not in repo.changelog and l not in (node.nullrev, node.wdirrev):
return baseset() return baseset()
return subset & baseset([l]) return baseset([l])
@predicate('matching(revision [, field])', safe=True) @predicate('matching(revision [, field])', safe=True)
def matching(repo, subset, x): def matching(repo, subset, x):
"""Changesets in which a given set of fields match the set of fields in the """Changesets in which a given set of fields match the set of fields in the
selected revision or set. selected revision or set.
To match more than one field pass the list of fields to match separated To match more than one field pass the list of fields to match separated
by spaces (e.g. ``author description``). by spaces (e.g. ``author description``).
def reverse(repo, subset, x, order): def reverse(repo, subset, x, order):
"""Reverse order of set. """Reverse order of set.
""" """
l = getset(repo, subset, x, order) l = getset(repo, subset, x, order)
if order == defineorder: if order == defineorder:
l.reverse() l.reverse()
return l return l
@predicate('roots(set)', safe=True) @predicate('roots(set)', safe=True, takeorder=True)
def roots(repo, subset, x): def roots(repo, subset, x, order):
"""Changesets in set with no parent changeset in set. """Changesets in set with no parent changeset in set.
""" """
s = getset(repo, fullreposet(repo), x) s = getset(repo, fullreposet(repo), x)
parents = repo.changelog.parentrevs parents = repo.changelog.parentrevs
def filter(r): def filter(r):
for p in parents(r): for p in parents(r):
if 0 <= p and p in s: if 0 <= p and p in s:
return False return False
return True return True
return subset & s.filter(filter, condrepr='<roots>') if order == defineorder:
s.sort()
return intersect(subset, s.filter(filter, condrepr='<roots>'), order)
_sortkeyfuncs = { _sortkeyfuncs = {
'rev': lambda c: c.rev(), 'rev': lambda c: c.rev(),
'branch': lambda c: c.branch(), 'branch': lambda c: c.branch(),
'desc': lambda c: c.description(), 'desc': lambda c: c.description(),
'user': lambda c: c.user(), 'user': lambda c: c.user(),
'author': lambda c: c.user(), 'author': lambda c: c.user(),
'date': lambda c: c.date()[0], 'date': lambda c: c.date()[0],
cl = repo.unfiltered().changelog cl = repo.unfiltered().changelog
torev = cl.rev torev = cl.rev
tonode = cl.node tonode = cl.node
nodemap = cl.nodemap nodemap = cl.nodemap
result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap) result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap)
return smartset.baseset(result - repo.changelog.filteredrevs) return smartset.baseset(result - repo.changelog.filteredrevs)
@predicate('successors(set)', safe=True) @predicate('successors(set)', safe=True)
def successors(repo, subset, x): def successors(repo, x):
"""All successors for set, including the given set themselves""" """All successors for set, including the given set themselves"""
s = getset(repo, fullreposet(repo), x) s = getset(repo, fullreposet(repo), x)
f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes) f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes)
d = _mapbynodefunc(repo, s, f) d = _mapbynodefunc(repo, s, f)
return subset & d return d
def _substringmatcher(pattern, casesensitive=True): def _substringmatcher(pattern, casesensitive=True):
kind, pattern, matcher = util.stringmatcher(pattern, kind, pattern, matcher = util.stringmatcher(pattern,
casesensitive=casesensitive) casesensitive=casesensitive)
if kind == 'literal': if kind == 'literal':
if not casesensitive: if not casesensitive:
pattern = encoding.lower(pattern) pattern = encoding.lower(pattern)
matcher = lambda s: pattern in encoding.lower(s) matcher = lambda s: pattern in encoding.lower(s)
else: else:
matcher = lambda s: pattern in s matcher = lambda s: pattern in s
return kind, pattern, matcher return kind, pattern, matcher
@predicate('tag([name])', safe=True) @predicate('tag([name])', safe=True)
def tag(repo, subset, x): def tag(repo, x):
"""The specified tag by name, or all tagged revisions if no name is given. """The specified tag by name, or all tagged revisions if no name is given.
Pattern matching is supported for `name`. See Pattern matching is supported for `name`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.
""" """
# i18n: "tag" is a keyword # i18n: "tag" is a keyword
args = getargs(x, 0, 1, _("tag takes one or no arguments")) args = getargs(x, 0, 1, _("tag takes one or no arguments"))
cl = repo.changelog cl = repo.changelog
if args: if args:
pattern = getstring(args[0], pattern = getstring(args[0],
# i18n: "tag" is a keyword # i18n: "tag" is a keyword
_('the argument to tag must be a string')) _('the argument to tag must be a string'))
kind, pattern, matcher = util.stringmatcher(pattern) kind, pattern, matcher = util.stringmatcher(pattern)
if kind == 'literal': if kind == 'literal':
# avoid resolving all tags # avoid resolving all tags
tn = repo._tagscache.tags.get(pattern, None) tn = repo._tagscache.tags.get(pattern, None)
if tn is None: if tn is None:
raise error.RepoLookupError(_("tag '%s' does not exist") raise error.RepoLookupError(_("tag '%s' does not exist")
% pattern) % pattern)
s = {repo[tn].rev()} s = {repo[tn].rev()}
else: else:
s = {cl.rev(n) for t, n in repo.tagslist() if matcher(t)} s = {cl.rev(n) for t, n in repo.tagslist() if matcher(t)}
else: 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 != 'tip'}
return subset & s return s
@predicate('tagged', safe=True) @predicate('tagged', safe=True)
def tagged(repo, subset, x): def tagged(repo, x):
return tag(repo, subset, x) return tag(repo, x)
@predicate('unstable()', safe=True) @predicate('unstable()', safe=True)
def unstable(repo, subset, x): def unstable(repo, x):
msg = ("'unstable()' is deprecated, " msg = ("'unstable()' is deprecated, "
"use 'orphan()'") "use 'orphan()'")
repo.ui.deprecwarn(msg, '4.4') repo.ui.deprecwarn(msg, '4.4')
return orphan(repo, subset, x) return orphan(repo, x)
@predicate('orphan()', safe=True) @predicate('orphan()', safe=True)
def orphan(repo, subset, x): def orphan(repo, x):
"""Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL) """Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
""" """
# i18n: "orphan" is a keyword # i18n: "orphan" is a keyword
getargs(x, 0, 0, _("orphan takes no arguments")) getargs(x, 0, 0, _("orphan takes no arguments"))
orphan = obsmod.getrevs(repo, 'orphan') orphan = obsmod.getrevs(repo, 'orphan')
return subset & orphan return orphan
@predicate('user(string)', safe=True) @predicate('user(string)', safe=True)
def user(repo, subset, x): def user(repo, subset, x):
"""User name contains string. The match is case-insensitive. """User name contains string. The match is case-insensitive.
Pattern matching is supported for `string`. See Pattern matching is supported for `string`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.