diff -r 37d50250b696 -r fc7c8cac6a4b mercurial/revset.py --- a/mercurial/revset.py Tue Dec 29 23:58:30 2015 +0900 +++ b/mercurial/revset.py Tue Dec 29 23:58:30 2015 +0900 @@ -22,6 +22,7 @@ parser, pathutil, phases, + registrar, repoview, util, ) @@ -465,19 +466,47 @@ # functions +# symbols are callables like: +# fn(repo, subset, x) +# with: +# repo - current repository instance +# subset - of revisions to be examined +# x - argument in tree form +symbols = {} + +class predicate(registrar.funcregistrar): + """Decorator to register revset predicate + + Usage:: + + @predicate('mypredicate(arg1, arg2[, arg3])') + def mypredicatefunc(repo, subset, x): + '''Explanation of this revset predicate .... + ''' + pass + + The first string argument of the constructor is used also in + online help. + """ + table = symbols + formatdoc = "``%s``\n %s" + getname = registrar.funcregistrar.parsefuncdecl + +@predicate('_destupdate') def _destupdate(repo, subset, x): # experimental revset for update destination args = getargsdict(x, 'limit', 'clean check') return subset & baseset([destutil.destupdate(repo, **args)[0]]) +@predicate('_destmerge') def _destmerge(repo, subset, x): # experimental revset for merge destination getargs(x, 0, 0, _("_mergedefaultdest takes no arguments")) return subset & baseset([destutil.destmerge(repo)]) +@predicate('adds(pattern)') def adds(repo, subset, x): - """``adds(pattern)`` - 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 relative to the current directory and match against a file or a @@ -487,9 +516,9 @@ pat = getstring(x, _("adds requires a pattern")) return checkstatus(repo, subset, pat, 1) +@predicate('ancestor(*changeset)') def ancestor(repo, subset, x): - """``ancestor(*changeset)`` - A greatest common ancestor of the changesets. + """A greatest common ancestor of the changesets. Accepts 0 or more changesets. Will return empty list when passed no args. @@ -519,12 +548,13 @@ s = _revancestors(repo, heads, followfirst) return subset & s +@predicate('ancestors(set)') def ancestors(repo, subset, x): - """``ancestors(set)`` - Changesets that are ancestors of a changeset in set. + """Changesets that are ancestors of a changeset in set. """ return _ancestors(repo, subset, x) +@predicate('_firstancestors') def _firstancestors(repo, subset, x): # ``_firstancestors(set)`` # Like ``ancestors(set)`` but follows only the first parents. @@ -547,18 +577,18 @@ ps.add(r) return subset & ps +@predicate('author(string)') def author(repo, subset, x): - """``author(string)`` - Alias for ``user(string)``. + """Alias for ``user(string)``. """ # i18n: "author" is a keyword n = encoding.lower(getstring(x, _("author requires a string"))) kind, pattern, matcher = _substringmatcher(n) return subset.filter(lambda x: matcher(encoding.lower(repo[x].user()))) +@predicate('bisect(string)') def bisect(repo, subset, x): - """``bisect(string)`` - Changesets marked in the specified bisect status: + """Changesets marked in the specified bisect status: - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip - ``goods``, ``bads`` : csets topologically good/bad @@ -575,12 +605,13 @@ # Backward-compatibility # - no help entry so that we do not advertise it any more +@predicate('bisected') def bisected(repo, subset, x): return bisect(repo, subset, x) +@predicate('bookmark([name])') def bookmark(repo, subset, x): - """``bookmark([name])`` - The named bookmark or all bookmarks. + """The named bookmark or all bookmarks. If `name` starts with `re:`, the remainder of the name is treated as a regular expression. To match a bookmark that actually starts with `re:`, @@ -616,8 +647,9 @@ bms -= set([node.nullrev]) return subset & bms +@predicate('branch(string or set)') def branch(repo, subset, x): - """``branch(string or set)`` + """ All changesets belonging to the given branch or the branches of the given changesets. @@ -652,9 +684,9 @@ c = s.__contains__ return subset.filter(lambda r: c(r) or getbi(r)[0] in b) +@predicate('bumped()') def bumped(repo, subset, x): - """``bumped()`` - 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 `bumped`. """ @@ -663,9 +695,9 @@ bumped = obsmod.getrevs(repo, 'bumped') return subset & bumped +@predicate('bundle()') def bundle(repo, subset, x): - """``bundle()`` - Changesets in the bundle. + """Changesets in the bundle. Bundle must be specified by the -R option.""" @@ -723,25 +755,25 @@ # This does not break because of other fullreposet misbehavior. return baseset(cs) +@predicate('children(set)') def children(repo, subset, x): - """``children(set)`` - Child changesets of changesets in set. + """Child changesets of changesets in set. """ s = getset(repo, fullreposet(repo), x) cs = _children(repo, subset, s) return subset & cs +@predicate('closed()') def closed(repo, subset, x): - """``closed()`` - Changeset is closed. + """Changeset is closed. """ # i18n: "closed" is a keyword getargs(x, 0, 0, _("closed takes no arguments")) return subset.filter(lambda r: repo[r].closesbranch()) +@predicate('contains(pattern)') def contains(repo, subset, x): - """``contains(pattern)`` - The revision's manifest contains a file matching pattern (but might not + """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 @@ -766,9 +798,9 @@ return subset.filter(matches) +@predicate('converted([id])') def converted(repo, subset, x): - """``converted([id])`` - Changesets converted from the given identifier in the old repository if + """Changesets converted from the given identifier in the old repository if present, or all converted changesets if no identifier is specified. """ @@ -788,18 +820,18 @@ return subset.filter(lambda r: _matchvalue(r)) +@predicate('date(interval)') def date(repo, subset, x): - """``date(interval)`` - Changesets within the interval, see :hg:`help dates`. + """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])) +@predicate('desc(string)') def desc(repo, subset, x): - """``desc(string)`` - Search commit message for string. The match is case-insensitive. + """Search commit message for string. The match is case-insensitive. """ # i18n: "desc" is a keyword ds = encoding.lower(getstring(x, _("desc requires a string"))) @@ -829,20 +861,21 @@ result = subset & result return result +@predicate('descendants(set)') def descendants(repo, subset, x): - """``descendants(set)`` - Changesets which are descendants of changesets in set. + """Changesets which are descendants of changesets in set. """ return _descendants(repo, subset, x) +@predicate('_firstdescendants') 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])') def destination(repo, subset, x): - """``destination([set])`` - 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 is the same as passing all(). """ @@ -884,8 +917,9 @@ return subset.filter(dests.__contains__) +@predicate('divergent()') def divergent(repo, subset, x): - """``divergent()`` + """ Final successors of changesets with an alternative set of final successors. """ # i18n: "divergent" is a keyword @@ -893,18 +927,18 @@ divergent = obsmod.getrevs(repo, 'divergent') return subset & divergent +@predicate('extinct()') def extinct(repo, subset, x): - """``extinct()`` - Obsolete changesets with obsolete descendants only. + """Obsolete changesets with obsolete descendants only. """ # i18n: "extinct" is a keyword getargs(x, 0, 0, _("extinct takes no arguments")) extincts = obsmod.getrevs(repo, 'extinct') return subset & extincts +@predicate('extra(label, [value])') def extra(repo, subset, x): - """``extra(label, [value])`` - 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. If `value` starts with `re:`, the remainder of the value is treated as @@ -932,9 +966,9 @@ return subset.filter(lambda r: _matchvalue(r)) +@predicate('filelog(pattern)') def filelog(repo, subset, x): - """``filelog(pattern)`` - Changesets connected to the specified filelog. + """Changesets connected to the specified filelog. For performance reasons, visits only revisions mentioned in the file-level filelog, rather than filtering through all changesets (much faster, but @@ -1047,9 +1081,9 @@ return subset & s +@predicate('first(set, [n])') def first(repo, subset, x): - """``first(set, [n])`` - An alias for limit(). + """An alias for limit(). """ return limit(repo, subset, x) @@ -1073,31 +1107,33 @@ return subset & s +@predicate('follow([pattern])') def follow(repo, subset, x): - """``follow([pattern])`` + """ An alias for ``::.`` (ancestors of the working directory's first parent). If pattern is specified, the histories of files matching given pattern is followed, including copies. """ return _follow(repo, subset, x, 'follow') +@predicate('_followfirst') def _followfirst(repo, subset, x): # ``followfirst([pattern])`` # Like ``follow([pattern])`` but follows only the first parent of # every revisions or files revisions. return _follow(repo, subset, x, '_followfirst', followfirst=True) +@predicate('all()') def getall(repo, subset, x): - """``all()`` - All changesets, the same as ``0:tip``. + """All changesets, the same as ``0:tip``. """ # i18n: "all" is a keyword getargs(x, 0, 0, _("all takes no arguments")) return subset & spanset(repo) # drop "null" if any +@predicate('grep(regex)') def grep(repo, subset, x): - """``grep(regex)`` - 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 ``keyword(string)``, the match is case-sensitive. """ @@ -1116,6 +1152,7 @@ return subset.filter(matches) +@predicate('_matchfiles') def _matchfiles(repo, subset, x): # _matchfiles takes a revset list of prefixed arguments: # @@ -1181,9 +1218,9 @@ return subset.filter(matches) +@predicate('file(pattern)') def hasfile(repo, subset, x): - """``file(pattern)`` - Changesets affecting files matched by pattern. + """Changesets affecting files matched by pattern. For a faster but less accurate result, consider using ``filelog()`` instead. @@ -1194,9 +1231,9 @@ pat = getstring(x, _("file requires a pattern")) return _matchfiles(repo, subset, ('string', 'p:' + pat)) +@predicate('head()') def head(repo, subset, x): - """``head()`` - Changeset is a named branch head. + """Changeset is a named branch head. """ # i18n: "head" is a keyword getargs(x, 0, 0, _("head takes no arguments")) @@ -1210,26 +1247,26 @@ # necessary to ensure we preserve the order in subset. return baseset(hs) & subset +@predicate('heads(set)') def heads(repo, subset, x): - """``heads(set)`` - Members of set with no children in set. + """Members of set with no children in set. """ s = getset(repo, subset, x) ps = parents(repo, subset, x) return s - ps +@predicate('hidden()') def hidden(repo, subset, x): - """``hidden()`` - Hidden changesets. + """Hidden changesets. """ # i18n: "hidden" is a keyword getargs(x, 0, 0, _("hidden takes no arguments")) hiddenrevs = repoview.filterrevs(repo, 'visible') return subset & hiddenrevs +@predicate('keyword(string)') def keyword(repo, subset, x): - """``keyword(string)`` - 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. """ # i18n: "keyword" is a keyword @@ -1242,9 +1279,9 @@ return subset.filter(matches) +@predicate('limit(set[, n[, offset]])') def limit(repo, subset, x): - """``limit(set[, n[, offset]])`` - First n members of set, defaulting to 1, starting from offset. + """First n members of set, defaulting to 1, starting from offset. """ args = getargsdict(x, 'limit', 'set n offset') if 'set' not in args: @@ -1278,9 +1315,9 @@ result.append(y) return baseset(result) +@predicate('last(set, [n])') def last(repo, subset, x): - """``last(set, [n])`` - Last n members of set, defaulting to 1. + """Last n members of set, defaulting to 1. """ # i18n: "last" is a keyword l = getargs(x, 1, 2, _("last requires one or two arguments")) @@ -1304,9 +1341,9 @@ result.append(y) return baseset(result) +@predicate('max(set)') def maxrev(repo, subset, x): - """``max(set)`` - Changeset with highest revision number in set. + """Changeset with highest revision number in set. """ os = getset(repo, fullreposet(repo), x) try: @@ -1319,18 +1356,18 @@ pass return baseset() +@predicate('merge()') def merge(repo, subset, x): - """``merge()`` - Changeset is a merge changeset. + """Changeset is a merge changeset. """ # i18n: "merge" is a keyword getargs(x, 0, 0, _("merge takes no arguments")) cl = repo.changelog return subset.filter(lambda r: cl.parentrevs(r)[1] != -1) +@predicate('branchpoint()') def branchpoint(repo, subset, x): - """``branchpoint()`` - Changesets with more than one child. + """Changesets with more than one child. """ # i18n: "branchpoint" is a keyword getargs(x, 0, 0, _("branchpoint takes no arguments")) @@ -1347,9 +1384,9 @@ parentscount[p - baserev] += 1 return subset.filter(lambda r: parentscount[r - baserev] > 1) +@predicate('min(set)') def minrev(repo, subset, x): - """``min(set)`` - Changeset with lowest revision number in set. + """Changeset with lowest revision number in set. """ os = getset(repo, fullreposet(repo), x) try: @@ -1362,9 +1399,9 @@ pass return baseset() +@predicate('modifies(pattern)') def modifies(repo, subset, x): - """``modifies(pattern)`` - Changesets modifying files matched by pattern. + """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 @@ -1374,9 +1411,9 @@ pat = getstring(x, _("modifies requires a pattern")) return checkstatus(repo, subset, pat, 0) +@predicate('named(namespace)') def named(repo, subset, x): - """``named(namespace)`` - The changesets in a given namespace. + """The changesets in a given namespace. If `namespace` starts with `re:`, the remainder of the string is treated as a regular expression. To match a namespace that actually starts with `re:`, @@ -1412,9 +1449,9 @@ names -= set([node.nullrev]) return subset & names +@predicate('id(string)') def node_(repo, subset, x): - """``id(string)`` - 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 l = getargs(x, 1, 1, _("id requires one argument")) @@ -1436,17 +1473,17 @@ result = baseset([rn]) return result & subset +@predicate('obsolete()') def obsolete(repo, subset, x): - """``obsolete()`` - Mutable changeset with a newer version.""" + """Mutable changeset with a newer version.""" # i18n: "obsolete" is a keyword getargs(x, 0, 0, _("obsolete takes no arguments")) obsoletes = obsmod.getrevs(repo, 'obsolete') return subset & obsoletes +@predicate('only(set, [set])') def only(repo, subset, x): - """``only(set, [set])`` - 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 is ancestors of the first set that are not ancestors of the second set (i.e. :: - ::). @@ -1470,8 +1507,9 @@ # some optimisations from the fact this is a baseset. return subset & results +@predicate('origin([set])') def origin(repo, subset, x): - """``origin([set])`` + """ Changesets that were specified as a source for the grafts, transplants or 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 @@ -1501,9 +1539,9 @@ # some optimisations from the fact this is a baseset. return subset & o +@predicate('outgoing([path])') def outgoing(repo, subset, x): - """``outgoing([path])`` - Changesets not found in the specified destination repository, or the + """Changesets not found in the specified destination repository, or the default push location. """ # Avoid cycles. @@ -1528,9 +1566,9 @@ o = set([cl.rev(r) for r in outgoing.missing]) return subset & o +@predicate('p1([set])') def p1(repo, subset, x): - """``p1([set])`` - First parent of changesets in set, or the working directory. + """First parent of changesets in set, or the working directory. """ if x is None: p = repo[x].p1().rev() @@ -1547,9 +1585,9 @@ # some optimisations from the fact this is a baseset. return subset & ps +@predicate('p2([set])') def p2(repo, subset, x): - """``p2([set])`` - Second parent of changesets in set, or the working directory. + """Second parent of changesets in set, or the working directory. """ if x is None: ps = repo[x].parents() @@ -1570,8 +1608,9 @@ # some optimisations from the fact this is a baseset. return subset & ps +@predicate('parents([set])') def parents(repo, subset, x): - """``parents([set])`` + """ The set of all parents for all changesets in set, or the working directory. """ if x is None: @@ -1602,17 +1641,17 @@ condition = lambda r: phase(repo, r) == target return subset.filter(condition, cache=False) +@predicate('draft()') def draft(repo, subset, x): - """``draft()`` - Changeset in draft phase.""" + """Changeset in draft phase.""" # i18n: "draft" is a keyword getargs(x, 0, 0, _("draft takes no arguments")) target = phases.draft return _phase(repo, subset, target) +@predicate('secret()') def secret(repo, subset, x): - """``secret()`` - Changeset in secret phase.""" + """Changeset in secret phase.""" # i18n: "secret" is a keyword getargs(x, 0, 0, _("secret takes no arguments")) target = phases.secret @@ -1643,9 +1682,9 @@ ps.add(parents[1]) return subset & ps +@predicate('present(set)') def present(repo, subset, x): - """``present(set)`` - An empty set, if any revision in set isn't found; otherwise, + """An empty set, if any revision in set isn't found; otherwise, all revisions in set. If any of specified revisions is not present in the local repository, @@ -1658,6 +1697,7 @@ return baseset() # for internal use +@predicate('_notpublic') def _notpublic(repo, subset, x): getargs(x, 0, 0, "_notpublic takes no arguments") repo._phasecache.loadphaserevs(repo) # ensure phase's sets are loaded @@ -1674,9 +1714,9 @@ condition = lambda r: phase(repo, r) != target return subset.filter(condition, cache=False) +@predicate('public()') def public(repo, subset, x): - """``public()`` - Changeset in public phase.""" + """Changeset in public phase.""" # i18n: "public" is a keyword getargs(x, 0, 0, _("public takes no arguments")) phase = repo._phasecache.phase @@ -1684,9 +1724,9 @@ condition = lambda r: phase(repo, r) == target return subset.filter(condition, cache=False) +@predicate('remote([id [,path]])') def remote(repo, subset, x): - """``remote([id [,path]])`` - Local revision that corresponds to the given identifier in a + """Local revision that corresponds to the given identifier in a remote repository, if present. Here, the '.' identifier is a synonym for the current local branch. """ @@ -1719,9 +1759,9 @@ return baseset([r]) return baseset() +@predicate('removes(pattern)') def removes(repo, subset, x): - """``removes(pattern)`` - Changesets which remove files matching pattern. + """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 @@ -1731,9 +1771,9 @@ pat = getstring(x, _("removes requires a pattern")) return checkstatus(repo, subset, pat, 2) +@predicate('rev(number)') def rev(repo, subset, x): - """``rev(number)`` - Revision with the given numeric identifier. + """Revision with the given numeric identifier. """ # i18n: "rev" is a keyword l = getargs(x, 1, 1, _("rev requires one argument")) @@ -1747,9 +1787,9 @@ return baseset() return subset & baseset([l]) +@predicate('matching(revision [, field])') def matching(repo, subset, x): - """``matching(revision [, field])`` - 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. To match more than one field pass the list of fields to match separated @@ -1859,17 +1899,17 @@ return subset.filter(matches) +@predicate('reverse(set)') def reverse(repo, subset, x): - """``reverse(set)`` - Reverse order of set. + """Reverse order of set. """ l = getset(repo, subset, x) l.reverse() return l +@predicate('roots(set)') def roots(repo, subset, x): - """``roots(set)`` - Changesets in set with no parent changeset in set. + """Changesets in set with no parent changeset in set. """ s = getset(repo, fullreposet(repo), x) parents = repo.changelog.parentrevs @@ -1880,9 +1920,9 @@ return True return subset & s.filter(filter) +@predicate('sort(set[, [-]key...])') def sort(repo, subset, x): - """``sort(set[, [-]key...])`` - Sort set by keys. The default sort order is ascending, specify a key + """Sort set by keys. The default sort order is ascending, specify a key as ``-key`` to sort in descending order. The keys can be: @@ -1943,9 +1983,9 @@ l.sort() return baseset([e[-1] for e in l]) +@predicate('subrepo([pattern])') def subrepo(repo, subset, x): - """``subrepo([pattern])`` - Changesets that add, modify or remove the given subrepo. If no subrepo + """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 @@ -1992,9 +2032,9 @@ matcher = lambda s: pattern in s return kind, pattern, matcher +@predicate('tag([name])') def tag(repo, subset, x): - """``tag([name])`` - 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. If `name` starts with `re:`, the remainder of the name is treated as a regular expression. To match a tag that actually starts with `re:`, @@ -2021,12 +2061,13 @@ s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip']) return subset & s +@predicate('tagged') def tagged(repo, subset, x): return tag(repo, subset, x) +@predicate('unstable()') def unstable(repo, subset, x): - """``unstable()`` - Non-obsolete changesets with obsolete ancestors. + """Non-obsolete changesets with obsolete ancestors. """ # i18n: "unstable" is a keyword getargs(x, 0, 0, _("unstable takes no arguments")) @@ -2034,9 +2075,9 @@ return subset & unstables +@predicate('user(string)') def user(repo, subset, x): - """``user(string)`` - User name contains string. The match is case-insensitive. + """User name contains string. The match is case-insensitive. If `string` starts with `re:`, the remainder of the string is treated as a regular expression. To match a user that actually contains `re:`, use @@ -2045,6 +2086,7 @@ return author(repo, subset, x) # experimental +@predicate('wdir') def wdir(repo, subset, x): # i18n: "wdir" is a keyword getargs(x, 0, 0, _("wdir takes no arguments")) @@ -2053,6 +2095,7 @@ return baseset() # for internal use +@predicate('_list') def _list(repo, subset, x): s = getstring(x, "internal error") if not s: @@ -2082,6 +2125,7 @@ return baseset(ls) # for internal use +@predicate('_intlist') def _intlist(repo, subset, x): s = getstring(x, "internal error") if not s: @@ -2091,6 +2135,7 @@ return baseset([r for r in ls if r in s]) # for internal use +@predicate('_hexlist') def _hexlist(repo, subset, x): s = getstring(x, "internal error") if not s: @@ -2100,83 +2145,6 @@ s = subset return baseset([r for r in ls if r in s]) -symbols = { - "_destupdate": _destupdate, - "_destmerge": _destmerge, - "adds": adds, - "all": getall, - "ancestor": ancestor, - "ancestors": ancestors, - "_firstancestors": _firstancestors, - "author": author, - "bisect": bisect, - "bisected": bisected, - "bookmark": bookmark, - "branch": branch, - "branchpoint": branchpoint, - "bumped": bumped, - "bundle": bundle, - "children": children, - "closed": closed, - "contains": contains, - "converted": converted, - "date": date, - "desc": desc, - "descendants": descendants, - "_firstdescendants": _firstdescendants, - "destination": destination, - "divergent": divergent, - "draft": draft, - "extinct": extinct, - "extra": extra, - "file": hasfile, - "filelog": filelog, - "first": first, - "follow": follow, - "_followfirst": _followfirst, - "grep": grep, - "head": head, - "heads": heads, - "hidden": hidden, - "id": node_, - "keyword": keyword, - "last": last, - "limit": limit, - "_matchfiles": _matchfiles, - "max": maxrev, - "merge": merge, - "min": minrev, - "modifies": modifies, - "named": named, - "obsolete": obsolete, - "only": only, - "origin": origin, - "outgoing": outgoing, - "p1": p1, - "p2": p2, - "parents": parents, - "present": present, - "public": public, - "_notpublic": _notpublic, - "remote": remote, - "removes": removes, - "rev": rev, - "reverse": reverse, - "roots": roots, - "sort": sort, - "secret": secret, - "subrepo": subrepo, - "matching": matching, - "tag": tag, - "tagged": tagged, - "user": user, - "unstable": unstable, - "wdir": wdir, - "_list": _list, - "_intlist": _intlist, - "_hexlist": _hexlist, -} - # 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