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

comparison mercurial/revset.py @ 34280:b0790bebfcf8

revset: move weight information to predicate Previously revset weight is hardcoded and cannot be modified. This patch moves it to predicate so newly registered revsets could define their weight to properly give static optimization some hint. Differential Revision: https://phab.mercurial-scm.org/D657

author	Jun Wu <quark@fb.com>
date	Fri, 01 Sep 2017 19:42:09 -0700
parents	c6c8a52e28c9
children	2c3b8fa3211b

comparison

equal deleted inserted replaced

-:53fb09c73ba8
+:b0790bebfcf8
 #   fn(repo, subset, x)
 # with:
 #   repo - current repository instance
 #   subset - of revisions to be examined
 #   x - argument in tree form
-symbols = {}
+symbols = revsetlang.symbols
 # 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)
 # functions that just return a lot of changesets (like all) don't count here
 safesymbols = set()
 sourceset = None
 if x is not None:
 sourceset = getset(repo, fullreposet(repo), x)
 return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])
-@predicate('adds(pattern)', safe=True)
+@predicate('adds(pattern)', safe=True, weight=30)
 def adds(repo, subset, x):
 """Changesets that add a file matching pattern.
 The pattern without explicit kind like ``glob:`` is expected to be
 relative to the current directory and match against a file or a
 """
 # i18n: "adds" is a keyword
 pat = getstring(x, _("adds requires a pattern"))
 return checkstatus(repo, subset, pat, 1)
-@predicate('ancestor(*changeset)', safe=True)
+@predicate('ancestor(*changeset)', safe=True, weight=0.5)
 def ancestor(repo, subset, x):
 """A greatest common ancestor of the changesets.
 Accepts 0 or more changesets.
 Will return empty list when passed no args.
 except error.WdirUnsupported:
 r = repo[r].parents()[0].rev()
 ps.add(r)
 return subset & ps
-@predicate('author(string)', safe=True)
+@predicate('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"))
 else:
 bms = {repo[r].rev() for r in repo._bookmarks.values()}
 bms -= {node.nullrev}
 return subset & bms
-@predicate('branch(string or set)', safe=True)
+@predicate('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
 changesets.
 """
 s = getset(repo, fullreposet(repo), x)
 cs = _children(repo, subset, s)
 return subset & cs
-@predicate('closed()', safe=True)
+@predicate('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"))
 return subset.filter(lambda r: repo[r].closesbranch(),
 condrepr='<branch closed>')
-@predicate('contains(pattern)')
+@predicate('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.
 The pattern without explicit kind like ``glob:`` is expected to be
 return source is not None and (rev is None or source.startswith(rev))
 return subset.filter(lambda r: _matchvalue(r),
 condrepr=('<converted %r>', rev))
-@predicate('date(interval)', safe=True)
+@predicate('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"))
 dm = util.matchdate(ds)
 return subset.filter(lambda x: dm(repo[x].date()[0]),
 condrepr=('<date %r>', ds))
-@predicate('desc(string)', safe=True)
+@predicate('desc(string)', safe=True, weight=10)
 def desc(repo, subset, x):
 """Search commit message for string. The match is case-insensitive.
 Pattern matching is supported for `string`. See
 :hg:`help revisions.patterns`.
 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)
+@predicate('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
 is the same as passing all().
 """
 # deletion in changelog
 continue
 return subset & s
-@predicate('first(set, [n])', safe=True, takeorder=True)
+@predicate('first(set, [n])', safe=True, takeorder=True, weight=0)
 def first(repo, subset, x, order):
 """An alias for limit().
 """
 return limit(repo, subset, x, order)
 """
 # i18n: "all" is a keyword
 getargs(x, 0, 0, _("all takes no arguments"))
 return subset & spanset(repo)  # drop "null" if any
-@predicate('grep(regex)')
+@predicate('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
 ``keyword(string)``, the match is case-sensitive.
 """
 return subset.filter(matches,
 condrepr=('<matchfiles patterns=%r, include=%r '
 'exclude=%r, default=%r, rev=%r>',
 pats, inc, exc, default, rev))
-@predicate('file(pattern)', safe=True)
+@predicate('file(pattern)', safe=True, weight=10)
 def hasfile(repo, subset, x):
 """Changesets affecting files matched by pattern.
 For a faster but less accurate result, consider using ``filelog()``
 instead.
 # i18n: "hidden" is a keyword
 getargs(x, 0, 0, _("hidden takes no arguments"))
 hiddenrevs = repoview.filterrevs(repo, 'visible')
 return subset & hiddenrevs
-@predicate('keyword(string)', safe=True)
+@predicate('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.
 For a regular expression or case sensitive search of these fields, use
 return any(kw in encoding.lower(t)
 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)
+@predicate('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:
 # 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)
+@predicate('modifies(pattern)', safe=True, weight=30)
 def modifies(repo, subset, x):
 """Changesets modifying files matched by pattern.
 The pattern without explicit kind like ``glob:`` is expected to be
 relative to the current directory and match against a file or a
 o -= {None}
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & o
-@predicate('outgoing([path])', safe=False)
+@predicate('outgoing([path])', safe=False, weight=10)
 def outgoing(repo, subset, x):
 """Changesets not found in the specified destination repository, or the
 default push location.
 """
 # Avoid cycles.
 r = repo[n].rev()
 if r in subset:
 return baseset([r])
 return baseset()
-@predicate('removes(pattern)', safe=True)
+@predicate('removes(pattern)', safe=True, weight=30)
 def removes(repo, subset, x):
 """Changesets which remove files matching pattern.
 The pattern without explicit kind like ``glob:`` is expected to be
 relative to the current directory and match against a file or a
 return True
 return False
 return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
-@predicate('reverse(set)', safe=True, takeorder=True)
+@predicate('reverse(set)', safe=True, takeorder=True, weight=0)
 def reverse(repo, subset, x, order):
 """Reverse order of set.
 """
 l = getset(repo, subset, x, order)
 if order == defineorder:
 raise error.ParseError(_('topo.firstbranch can only be used '
 'when using the topo sort key'))
 return args['set'], keyflags, opts
-@predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True)
+@predicate('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
 as ``-key`` to sort in descending order.
 The keys can be:
 getargs(x, 0, 0, _("orphan takes no arguments"))
 orphan = obsmod.getrevs(repo, 'orphan')
 return subset & orphan
-@predicate('user(string)', safe=True)
+@predicate('user(string)', safe=True, weight=10)
 def user(repo, subset, x):
 """User name contains string. The match is case-insensitive.
 Pattern matching is supported for `string`. See
 :hg:`help revisions.patterns`.
 """
 return author(repo, subset, x)
-@predicate('wdir()', safe=True)
+@predicate('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"))
 if node.wdirrev in subset or isinstance(subset, fullreposet):
 ls = [int(r) for r in s.split('\0')]
 s = subset
 return baseset([r for r in ls if r in s])
 # for internal use
-@predicate('_intlist', safe=True, takeorder=True)
+@predicate('_intlist', safe=True, takeorder=True, weight=0)
 def _intlist(repo, subset, x, order):
 if order == followorder:
 # slow path to take the subset order
 return subset & _orderedintlist(repo, fullreposet(repo), x)
 else:

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revset.py @ 34280:b0790bebfcf8