| hg-reviewers |
A lot of revset functions use return subset.filter(...) which enforces
followorder. This patch changes them to use intersect so order is
handled correctly.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/revset.py (142 lines) | |||
| M | tests/test-revset-ordering.t (15 lines) |
| # helpers | # helpers | ||||
| def getset(repo, subset, x, order=anyorder): | def getset(repo, subset, x, order=anyorder): | ||||
| if not x: | if not x: | ||||
| raise error.ParseError(_("missing argument")) | raise error.ParseError(_("missing argument")) | ||||
| return methods[x[0]](repo, subset, *x[1:], order=order) | return methods[x[0]](repo, subset, *x[1:], order=order) | ||||
| def intersect(subset, newset, order): | def intersect(subset, newset, order, **kwargs): | ||||
| """intersect two revsets with order preserved as requested | """intersect two revsets with order preserved as requested | ||||
| If order is "followorder", preserve subset's order. If order is | If order is "followorder", preserve subset's order. If order is | ||||
| "defineorder", preserve newset's order. | "defineorder", preserve newset's order. | ||||
| A typical use of this function is:: | A typical use of this function is:: | ||||
| @revsetpredicate('myrevset') | @revsetpredicate('myrevset') | ||||
| def myrevset(repo, subset, x, order): | def myrevset(repo, subset, x, order): | ||||
| newset = ... # a smartset that implements "myrevset" | newset = ... # a smartset that implements "myrevset" | ||||
| return revset.intersect(subset, newset, order) | return revset.intersect(subset, newset, order) | ||||
| If newset is a lambda, it will be applied to subset. kwargs will be passed | |||||
| to "subset.filter". If order is "defineorder", the result will be sorted. | |||||
| """ | """ | ||||
| # similar to subset.filter(....), but takes order into consideration | |||||
| if util.safehasattr(newset, '__call__'): | |||||
| s = subset.filter(newset, **kwargs) | |||||
| if order == defineorder: | |||||
| s.sort() | |||||
| return s | |||||
| # some old code does not use smartset, normalize to smartset | # some old code does not use smartset, normalize to smartset | ||||
| if not util.safehasattr(newset, 'isascending'): | if not util.safehasattr(newset, 'isascending'): | ||||
| newset = subset & newset | newset = subset & newset | ||||
| if order == defineorder: | if order == defineorder: | ||||
| newset.sort() | newset.sort() | ||||
| # ordering does not matter if there are at most 1 revision (test quickly) | # ordering does not matter if there are at most 1 revision (test quickly) | ||||
| if isinstance(newset, baseset) and len(newset) <= 1: | if isinstance(newset, baseset) and len(newset) <= 1: | ||||
| def _destmerge(repo, 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 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, order): | ||||
| """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. | ||||
| """ | """ | ||||
| # i18n: "adds" is a keyword | # i18n: "adds" is a keyword | ||||
| pat = getstring(x, _("adds requires a pattern")) | pat = getstring(x, _("adds requires a pattern")) | ||||
| return checkstatus(repo, subset, pat, 1) | return checkstatus(repo, subset, pat, 1, order) | ||||
| @predicate('ancestor(*changeset)', safe=True) | @predicate('ancestor(*changeset)', safe=True) | ||||
| def ancestor(repo, subset, x): | def ancestor(repo, subset, x): | ||||
| """A greatest common ancestor of the changesets. | """A greatest common ancestor of the changesets. | ||||
| Accepts 0 or more changesets. | Accepts 0 or more changesets. | ||||
| Will return empty list when passed no args. | Will return empty list when passed no args. | ||||
| Greatest common ancestor of a single changeset is that changeset. | Greatest common ancestor of a single changeset is that changeset. | ||||
| 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, order): | ||||
| """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 intersect(subset, lambda x: matcher(repo[x].user()), order, | ||||
| condrepr=('<user %r>', n)) | condrepr=('<user %r>', n)) | ||||
| @predicate('bisect(string)', safe=True) | @predicate('bisect(string)', safe=True) | ||||
| def bisect(repo, 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 | ||||
| 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 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, order): | ||||
| """ | """ | ||||
| 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 | ||||
| :hg:`help revisions.patterns`. | :hg:`help revisions.patterns`. | ||||
| """ | """ | ||||
| getbi = repo.revbranchcache().branchinfo | getbi = repo.revbranchcache().branchinfo | ||||
| # not a string, but another revspec, e.g. tip() | # not a string, but another revspec, e.g. tip() | ||||
| pass | pass | ||||
| else: | else: | ||||
| kind, pattern, matcher = util.stringmatcher(b) | kind, pattern, matcher = util.stringmatcher(b) | ||||
| if kind == 'literal': | if kind == 'literal': | ||||
| # note: falls through to the revspec case if no branch with | # note: falls through to the revspec case if no branch with | ||||
| # this name exists and pattern kind is not specified explicitly | # this name exists and pattern kind is not specified explicitly | ||||
| if pattern in repo.branchmap(): | if pattern in repo.branchmap(): | ||||
| return subset.filter(lambda r: matcher(getbranch(r)), | return intersect(subset, lambda r: matcher(getbranch(r)), | ||||
| condrepr=('<branch %r>', b)) | order, condrepr=('<branch %r>', b)) | ||||
| if b.startswith('literal:'): | if b.startswith('literal:'): | ||||
| raise error.RepoLookupError(_("branch '%s' does not exist") | raise error.RepoLookupError(_("branch '%s' does not exist") | ||||
| % pattern) | % pattern) | ||||
| else: | else: | ||||
| return subset.filter(lambda r: matcher(getbranch(r)), | return intersect(subset, lambda r: matcher(getbranch(r)), order, | ||||
| condrepr=('<branch %r>', b)) | condrepr=('<branch %r>', b)) | ||||
| s = getset(repo, fullreposet(repo), x) | s = getset(repo, fullreposet(repo), x) | ||||
| b = set() | b = set() | ||||
| for r in s: | for r in s: | ||||
| b.add(getbranch(r)) | b.add(getbranch(r)) | ||||
| c = s.__contains__ | c = s.__contains__ | ||||
| return subset.filter(lambda r: c(r) or getbranch(r) in b, | return intersect(subset, lambda r: c(r) or getbranch(r) in b, order, | ||||
| condrepr=lambda: '<branch %r>' % sorted(b)) | condrepr=lambda: '<branch %r>' % sorted(b)) | ||||
| @predicate('bumped()', safe=True) | @predicate('bumped()', safe=True) | ||||
| 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) | ||||
| 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 bundlerevs | return bundlerevs | ||||
| def checkstatus(repo, subset, pat, field): | def checkstatus(repo, subset, pat, field, order): | ||||
| 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: | ||||
| mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c) | mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c) | ||||
| m = mcache[0] | m = mcache[0] | ||||
| if fname is not None: | if fname is not None: | ||||
| if fname in files: | if fname in files: | ||||
| return True | return True | ||||
| else: | else: | ||||
| for f in files: | for f in files: | ||||
| if m(f): | if m(f): | ||||
| return True | return True | ||||
| return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat)) | return intersect(subset, matches, order, | ||||
| condrepr=('<status[%r] %r>', field, pat)) | |||||
| def _children(repo, subset, parentset): | def _children(repo, subset, parentset): | ||||
| if not parentset: | if not parentset: | ||||
| return baseset() | return baseset() | ||||
| cs = set() | cs = set() | ||||
| pr = repo.changelog.parentrevs | pr = repo.changelog.parentrevs | ||||
| minrev = parentset.min() | minrev = parentset.min() | ||||
| nullrev = node.nullrev | nullrev = node.nullrev | ||||
| def children(repo, subset, x, order): | def children(repo, subset, x, order): | ||||
| """Child changesets of changesets in set. | """Child changesets of changesets in set. | ||||
| """ | """ | ||||
| s = getset(repo, fullreposet(repo), x) | s = getset(repo, fullreposet(repo), x) | ||||
| cs = _children(repo, subset, s) | cs = _children(repo, subset, s) | ||||
| return intersect(subset, cs, order) | return intersect(subset, cs, order) | ||||
| @predicate('closed()', safe=True) | @predicate('closed()', safe=True) | ||||
| def closed(repo, subset, x): | def closed(repo, subset, x, order): | ||||
| """Changeset is closed. | """Changeset is closed. | ||||
| """ | """ | ||||
| # i18n: "closed" is a keyword | # i18n: "closed" is a keyword | ||||
| getargs(x, 0, 0, _("closed takes no arguments")) | getargs(x, 0, 0, _("closed takes no arguments")) | ||||
| return subset.filter(lambda r: repo[r].closesbranch(), | return intersect(subset, lambda r: repo[r].closesbranch(), order, | ||||
| condrepr='<branch closed>') | condrepr='<branch closed>') | ||||
| @predicate('contains(pattern)') | @predicate('contains(pattern)') | ||||
| def contains(repo, subset, x): | def contains(repo, subset, x, order): | ||||
| """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. | modify it). See :hg:`help patterns` for information about file patterns. | ||||
| 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 exactly | relative to the current directory and match against a file exactly | ||||
| for efficiency. | for efficiency. | ||||
| """ | """ | ||||
| # i18n: "contains" is a keyword | # i18n: "contains" is a keyword | ||||
| pat = getstring(x, _("contains requires a pattern")) | pat = getstring(x, _("contains requires a pattern")) | ||||
| def matches(x): | def matches(x): | ||||
| if not matchmod.patkind(pat): | if not matchmod.patkind(pat): | ||||
| pats = pathutil.canonpath(repo.root, repo.getcwd(), pat) | pats = pathutil.canonpath(repo.root, repo.getcwd(), pat) | ||||
| if pats in repo[x]: | if pats in repo[x]: | ||||
| return True | return True | ||||
| else: | else: | ||||
| c = repo[x] | c = repo[x] | ||||
| m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c) | m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c) | ||||
| for f in c.manifest(): | for f in c.manifest(): | ||||
| if m(f): | if m(f): | ||||
| return True | return True | ||||
| return False | return False | ||||
| return subset.filter(matches, condrepr=('<contains %r>', pat)) | return intersect(subset, matches, order, condrepr=('<contains %r>', pat)) | ||||
| @predicate('converted([id])', safe=True) | @predicate('converted([id])', safe=True) | ||||
| def converted(repo, subset, x): | def converted(repo, subset, x, order): | ||||
| """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. | present, or all converted changesets if no identifier is specified. | ||||
| """ | """ | ||||
| # There is exactly no chance of resolving the revision, so do a simple | # There is exactly no chance of resolving the revision, so do a simple | ||||
| # string compare and hope for the best | # string compare and hope for the best | ||||
| rev = None | rev = None | ||||
| # i18n: "converted" is a keyword | # i18n: "converted" is a keyword | ||||
| l = getargs(x, 0, 1, _('converted takes one or no arguments')) | l = getargs(x, 0, 1, _('converted takes one or no arguments')) | ||||
| if l: | if l: | ||||
| # i18n: "converted" is a keyword | # i18n: "converted" is a keyword | ||||
| rev = getstring(l[0], _('converted requires a revision')) | rev = getstring(l[0], _('converted requires a revision')) | ||||
| def _matchvalue(r): | def _matchvalue(r): | ||||
| source = repo[r].extra().get('convert_revision', None) | source = repo[r].extra().get('convert_revision', None) | ||||
| return source is not None and (rev is None or source.startswith(rev)) | return source is not None and (rev is None or source.startswith(rev)) | ||||
| return subset.filter(lambda r: _matchvalue(r), | return intersect(subset, lambda r: _matchvalue(r), order, | ||||
| condrepr=('<converted %r>', rev)) | condrepr=('<converted %r>', rev)) | ||||
| @predicate('date(interval)', safe=True) | @predicate('date(interval)', safe=True) | ||||
| def date(repo, subset, x): | def date(repo, subset, x, order): | ||||
| """Changesets within the interval, see :hg:`help dates`. | """Changesets within the interval, see :hg:`help dates`. | ||||
| """ | """ | ||||
| # i18n: "date" is a keyword | # i18n: "date" is a keyword | ||||
| ds = getstring(x, _("date requires a string")) | ds = getstring(x, _("date requires a string")) | ||||
| dm = util.matchdate(ds) | dm = util.matchdate(ds) | ||||
| return subset.filter(lambda x: dm(repo[x].date()[0]), | return intersect(subset, lambda x: dm(repo[x].date()[0]), order, | ||||
| condrepr=('<date %r>', ds)) | condrepr=('<date %r>', ds)) | ||||
| @predicate('desc(string)', safe=True) | @predicate('desc(string)', safe=True) | ||||
| def desc(repo, subset, x): | def desc(repo, subset, x, order): | ||||
| """Search commit message for string. The match is case-insensitive. | """Search commit message for 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`. | ||||
| """ | """ | ||||
| # 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 intersect(subset, lambda r: matcher(repo[r].description()), order, | ||||
| condrepr=('<desc %r>', ds)) | condrepr=('<desc %r>', ds)) | ||||
| def _descendants(repo, x, followfirst=False, startdepth=None, stopdepth=None): | def _descendants(repo, x, followfirst=False, startdepth=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 s | return s | ||||
| @predicate('_firstdescendants', safe=True) | @predicate('_firstdescendants', safe=True) | ||||
| def _firstdescendants(repo, 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, 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, order): | ||||
| """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: | ||||
| sources = getset(repo, fullreposet(repo), x) | sources = getset(repo, fullreposet(repo), x) | ||||
| else: | else: | ||||
| sources = fullreposet(repo) | sources = fullreposet(repo) | ||||
| # further. | # further. | ||||
| if src in sources or src in dests: | if src in sources or src in dests: | ||||
| dests.update(lineage) | dests.update(lineage) | ||||
| break | break | ||||
| r = src | r = src | ||||
| src = _getrevsource(repo, r) | src = _getrevsource(repo, r) | ||||
| return subset.filter(dests.__contains__, | return intersect(subset, dests.__contains__, order, | ||||
| condrepr=lambda: '<destination %r>' % sorted(dests)) | condrepr=lambda: '<destination %r>' % sorted(dests)) | ||||
| @predicate('divergent()', safe=True) | @predicate('divergent()', safe=True) | ||||
| 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) | ||||
| """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 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, order): | ||||
| """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`. | ||||
| """ | """ | ||||
| args = getargsdict(x, 'extra', 'label value') | args = getargsdict(x, 'extra', 'label value') | ||||
| if 'label' not in args: | if 'label' not in args: | ||||
| value = getstring(args['value'], _('second argument to extra must be ' | value = getstring(args['value'], _('second argument to extra must be ' | ||||
| 'a string')) | 'a string')) | ||||
| kind, value, matcher = util.stringmatcher(value) | kind, value, matcher = util.stringmatcher(value) | ||||
| 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 intersect(subset, lambda r: _matchvalue(r), order, | ||||
| 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, 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 | ||||
| def getall(repo, 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 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, order): | ||||
| """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: | ||||
| # i18n: "grep" is a keyword | # i18n: "grep" is a keyword | ||||
| gr = re.compile(getstring(x, _("grep requires a string"))) | gr = re.compile(getstring(x, _("grep requires a string"))) | ||||
| except re.error as e: | except re.error as e: | ||||
| raise error.ParseError(_('invalid match pattern: %s') % e) | raise error.ParseError(_('invalid match pattern: %s') % e) | ||||
| def matches(x): | def matches(x): | ||||
| c = repo[x] | c = repo[x] | ||||
| for e in c.files() + [c.user(), c.description()]: | for e in c.files() + [c.user(), c.description()]: | ||||
| if gr.search(e): | if gr.search(e): | ||||
| return True | return True | ||||
| return False | return False | ||||
| return subset.filter(matches, condrepr=('<grep %r>', gr.pattern)) | return intersect(subset, matches, order, condrepr=('<grep %r>', gr.pattern)) | ||||
| @predicate('_matchfiles', safe=True) | @predicate('_matchfiles', safe=True) | ||||
| def _matchfiles(repo, subset, x): | def _matchfiles(repo, subset, x, order): | ||||
| # _matchfiles takes a revset list of prefixed arguments: | # _matchfiles takes a revset list of prefixed arguments: | ||||
| # | # | ||||
| # [p:foo, i:bar, x:baz] | # [p:foo, i:bar, x:baz] | ||||
| # | # | ||||
| # builds a match object from them and filters subset. Allowed | # builds a match object from them and filters subset. Allowed | ||||
| # prefixes are 'p:' for regular patterns, 'i:' for include | # prefixes are 'p:' for regular patterns, 'i:' for include | ||||
| # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass | # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass | ||||
| # a revision identifier, or the empty string to reference the | # a revision identifier, or the empty string to reference the | ||||
| files = repo[x].files() | files = repo[x].files() | ||||
| else: | else: | ||||
| files = getfiles(x) | files = getfiles(x) | ||||
| for f in files: | for f in files: | ||||
| if m(f): | if m(f): | ||||
| return True | return True | ||||
| return False | return False | ||||
| return subset.filter(matches, | return intersect(subset, matches, order, | ||||
| condrepr=('<matchfiles patterns=%r, include=%r ' | condrepr=('<matchfiles patterns=%r, include=%r ' | ||||
| 'exclude=%r, default=%r, rev=%r>', | 'exclude=%r, default=%r, rev=%r>', | ||||
| pats, inc, exc, default, rev)) | pats, inc, exc, default, rev)) | ||||
| @predicate('file(pattern)', safe=True) | @predicate('file(pattern)', safe=True) | ||||
| def hasfile(repo, subset, x): | def hasfile(repo, subset, x, order): | ||||
| """Changesets affecting files matched by pattern. | """Changesets affecting files matched by pattern. | ||||
| For a faster but less accurate result, consider using ``filelog()`` | For a faster but less accurate result, consider using ``filelog()`` | ||||
| instead. | instead. | ||||
| 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), order) | ||||
| @predicate('head()', safe=True) | @predicate('head()', safe=True) | ||||
| def head(repo, 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() | ||||
| """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 hiddenrevs | return hiddenrevs | ||||
| @predicate('keyword(string)', safe=True) | @predicate('keyword(string)', safe=True) | ||||
| def keyword(repo, subset, x): | def keyword(repo, subset, x, order): | ||||
| """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)``. | ||||
| """ | """ | ||||
| # i18n: "keyword" is a keyword | # i18n: "keyword" is a keyword | ||||
| kw = encoding.lower(getstring(x, _("keyword requires a string"))) | kw = encoding.lower(getstring(x, _("keyword requires a string"))) | ||||
| def matches(r): | def matches(r): | ||||
| c = repo[r] | c = repo[r] | ||||
| return any(kw in encoding.lower(t) | return any(kw in encoding.lower(t) | ||||
| for t in c.files() + [c.user(), c.description()]) | for t in c.files() + [c.user(), c.description()]) | ||||
| return subset.filter(matches, condrepr=('<keyword %r>', kw)) | return intersect(subset, matches, order, condrepr=('<keyword %r>', kw)) | ||||
| @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True) | @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True) | ||||
| def limit(repo, subset, x, order): | def limit(repo, subset, x, order): | ||||
| """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') | args = getargsdict(x, 'limit', 'set n offset') | ||||
| if 'set' not in args: | if 'set' not in args: | ||||
| # i18n: "limit" is a keyword | # i18n: "limit" is a keyword | ||||
| return baseset([m], datarepr=('<max %r, %r>', subset, os)) | return baseset([m], datarepr=('<max %r, %r>', subset, os)) | ||||
| except ValueError: | except ValueError: | ||||
| # os.max() throws a ValueError when the collection is empty. | # os.max() throws a ValueError when the collection is empty. | ||||
| # Same as python's max(). | # Same as python's max(). | ||||
| pass | pass | ||||
| return baseset(datarepr=('<max %r, %r>', subset, os)) | return baseset(datarepr=('<max %r, %r>', subset, os)) | ||||
| @predicate('merge()', safe=True) | @predicate('merge()', safe=True) | ||||
| def merge(repo, subset, x): | def merge(repo, subset, x, order): | ||||
| """Changeset is a merge changeset. | """Changeset is a merge changeset. | ||||
| """ | """ | ||||
| # i18n: "merge" is a keyword | # i18n: "merge" is a keyword | ||||
| getargs(x, 0, 0, _("merge takes no arguments")) | getargs(x, 0, 0, _("merge takes no arguments")) | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| return subset.filter(lambda r: cl.parentrevs(r)[1] != -1, | return intersect(subset, lambda r: cl.parentrevs(r)[1] != -1, order, | ||||
| condrepr='<merge>') | condrepr='<merge>') | ||||
| @predicate('branchpoint()', safe=True) | @predicate('branchpoint()', safe=True) | ||||
| def branchpoint(repo, subset, x): | def branchpoint(repo, subset, x, order): | ||||
| """Changesets with more than one child. | """Changesets with more than one child. | ||||
| """ | """ | ||||
| # i18n: "branchpoint" is a keyword | # i18n: "branchpoint" is a keyword | ||||
| getargs(x, 0, 0, _("branchpoint takes no arguments")) | getargs(x, 0, 0, _("branchpoint takes no arguments")) | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| if not subset: | if not subset: | ||||
| return baseset() | return baseset() | ||||
| # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset | # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset | ||||
| # (and if it is not, it should.) | # (and if it is not, it should.) | ||||
| baserev = min(subset) | baserev = min(subset) | ||||
| parentscount = [0]*(len(repo) - baserev) | parentscount = [0]*(len(repo) - baserev) | ||||
| for r in cl.revs(start=baserev + 1): | for r in cl.revs(start=baserev + 1): | ||||
| for p in cl.parentrevs(r): | for p in cl.parentrevs(r): | ||||
| if p >= baserev: | if p >= baserev: | ||||
| parentscount[p - baserev] += 1 | parentscount[p - baserev] += 1 | ||||
| return subset.filter(lambda r: parentscount[r - baserev] > 1, | return intersect(subset, lambda r: parentscount[r - baserev] > 1, order, | ||||
| condrepr='<branchpoint>') | condrepr='<branchpoint>') | ||||
| @predicate('min(set)', safe=True) | @predicate('min(set)', safe=True) | ||||
| def minrev(repo, subset, x): | def minrev(repo, subset, x): | ||||
| """Changeset with lowest revision number in set. | """Changeset with lowest revision number in set. | ||||
| """ | """ | ||||
| os = getset(repo, fullreposet(repo), x) | os = getset(repo, fullreposet(repo), x) | ||||
| try: | try: | ||||
| m = os.min() | m = os.min() | ||||
| if m in subset: | if m in subset: | ||||
| return baseset([m], datarepr=('<min %r, %r>', subset, os)) | return baseset([m], datarepr=('<min %r, %r>', subset, os)) | ||||
| except ValueError: | except ValueError: | ||||
| # os.min() throws a ValueError when the collection is empty. | # os.min() throws a ValueError when the collection is empty. | ||||
| # Same as python's min(). | # Same as python's min(). | ||||
| pass | pass | ||||
| return baseset(datarepr=('<min %r, %r>', subset, os)) | return baseset(datarepr=('<min %r, %r>', subset, os)) | ||||
| @predicate('modifies(pattern)', safe=True) | @predicate('modifies(pattern)', safe=True) | ||||
| def modifies(repo, subset, x): | def modifies(repo, subset, x, order): | ||||
| """Changesets modifying files matched by pattern. | """Changesets modifying files matched by 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. | ||||
| """ | """ | ||||
| # 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, order) | ||||
| @predicate('named(namespace)') | @predicate('named(namespace)') | ||||
| def named(repo, 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`. | ||||
| """ | """ | ||||
| # for internal use | # for internal use | ||||
| @predicate('_notpublic', safe=True) | @predicate('_notpublic', safe=True) | ||||
| def _notpublic(repo, x): | def _notpublic(repo, x): | ||||
| getargs(x, 0, 0, "_notpublic takes no arguments") | getargs(x, 0, 0, "_notpublic takes no arguments") | ||||
| return _phase(repo, 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, order): | ||||
| """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 | ||||
| condition = lambda r: phase(repo, r) == target | condition = lambda r: phase(repo, r) == target | ||||
| return subset.filter(condition, condrepr=('<phase %r>', target), | return intersect(subset, condition, order, | ||||
| cache=False) | condrepr=('<phase %r>', target), cache=False) | ||||
| @predicate('remote([id [,path]])', safe=False) | @predicate('remote([id [,path]])', safe=False) | ||||
| def remote(repo, subset, x): | def remote(repo, subset, x): | ||||
| """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 | remote repository, if present. Here, the '.' identifier is a | ||||
| synonym for the current local branch. | synonym for the current local branch. | ||||
| """ | """ | ||||
| n = other.lookup(q) | n = other.lookup(q) | ||||
| if n in repo: | if n in repo: | ||||
| r = repo[n].rev() | r = repo[n].rev() | ||||
| if r in subset: | if r in subset: | ||||
| return baseset([r]) | return baseset([r]) | ||||
| return baseset() | return baseset() | ||||
| @predicate('removes(pattern)', safe=True) | @predicate('removes(pattern)', safe=True) | ||||
| def removes(repo, subset, x): | def removes(repo, subset, x, order): | ||||
| """Changesets which remove files matching pattern. | """Changesets which remove files 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. | ||||
| """ | """ | ||||
| # 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, order) | ||||
| @predicate('rev(number)', safe=True) | @predicate('rev(number)', safe=True) | ||||
| def rev(repo, 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 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, order): | ||||
| """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``). | ||||
| Valid fields are most regular revision fields and some special fields. | Valid fields are most regular revision fields and some special fields. | ||||
| match = True | match = True | ||||
| for n, f in enumerate(getfieldfuncs): | for n, f in enumerate(getfieldfuncs): | ||||
| if target[n] != f(x): | if target[n] != f(x): | ||||
| match = False | match = False | ||||
| if match: | if match: | ||||
| return True | return True | ||||
| return False | return False | ||||
| return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs)) | return intersect(subset, matches, order, | ||||
| condrepr=('<matching%r %r>', fields, revs)) | |||||
| @predicate('reverse(set)', safe=True, takeorder=True) | @predicate('reverse(set)', safe=True, takeorder=True) | ||||
| 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() | ||||
| # sort() is guaranteed to be stable | # sort() is guaranteed to be stable | ||||
| ctxs = [repo[r] for r in revs] | ctxs = [repo[r] for r in revs] | ||||
| for k, reverse in reversed(keyflags): | for k, reverse in reversed(keyflags): | ||||
| ctxs.sort(key=_sortkeyfuncs[k], reverse=reverse) | ctxs.sort(key=_sortkeyfuncs[k], reverse=reverse) | ||||
| return baseset([c.rev() for c in ctxs]) | return baseset([c.rev() for c in ctxs]) | ||||
| @predicate('subrepo([pattern])') | @predicate('subrepo([pattern])') | ||||
| def subrepo(repo, subset, x): | def subrepo(repo, subset, x, order): | ||||
| """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. | pattern is named, any subrepo changes are returned. | ||||
| """ | """ | ||||
| # i18n: "subrepo" is a keyword | # i18n: "subrepo" is a keyword | ||||
| args = getargs(x, 0, 1, _('subrepo takes at most one argument')) | args = getargs(x, 0, 1, _('subrepo takes at most one argument')) | ||||
| pat = None | pat = None | ||||
| if len(args) != 0: | if len(args) != 0: | ||||
| pat = getstring(args[0], _("subrepo requires a pattern")) | pat = getstring(args[0], _("subrepo requires a pattern")) | ||||
| if c.p1().substate.get(path) != c.substate.get(path): | if c.p1().substate.get(path) != c.substate.get(path): | ||||
| return True | return True | ||||
| if s.removed: | if s.removed: | ||||
| return any(submatches(c.p1().substate.keys())) | return any(submatches(c.p1().substate.keys())) | ||||
| return False | return False | ||||
| return subset.filter(matches, condrepr=('<subrepo %r>', pat)) | return intersect(subset, matches, order, condrepr=('<subrepo %r>', pat)) | ||||
| def _mapbynodefunc(repo, s, f): | def _mapbynodefunc(repo, s, f): | ||||
| """(repo, smartset, [node] -> [node]) -> smartset | """(repo, smartset, [node] -> [node]) -> smartset | ||||
| Helper method to map a smartset to another smartset given a function only | Helper method to map a smartset to another smartset given a function only | ||||
| talking about nodes. Handles converting between rev numbers and nodes, and | talking about nodes. Handles converting between rev numbers and nodes, and | ||||
| filtering. | filtering. | ||||
| """ | """ | ||||
| """ | """ | ||||
| # 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 orphan | return orphan | ||||
| @predicate('user(string)', safe=True) | @predicate('user(string)', safe=True) | ||||
| def user(repo, subset, x): | def user(repo, subset, x, order): | ||||
| """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`. | ||||
| """ | """ | ||||
| return author(repo, subset, x) | return author(repo, subset, x, order) | ||||
| @predicate('wdir()', safe=True) | @predicate('wdir()', safe=True) | ||||
| def wdir(repo, subset, x): | def wdir(repo, subset, x): | ||||
| """Working directory. (EXPERIMENTAL)""" | """Working directory. (EXPERIMENTAL)""" | ||||
| # i18n: "wdir" is a keyword | # i18n: "wdir" is a keyword | ||||
| getargs(x, 0, 0, _("wdir takes no arguments")) | getargs(x, 0, 0, _("wdir takes no arguments")) | ||||
| if node.wdirrev in subset or isinstance(subset, fullreposet): | if node.wdirrev in subset or isinstance(subset, fullreposet): | ||||
| return baseset([node.wdirrev]) | return baseset([node.wdirrev]) | ||||
| $ check '(3+1+2) & (1+3+4)' | $ check '(3+1+2) & (1+3+4)' | ||||
| $ check 'A::E' | $ check 'A::E' | ||||
| $ check 'E:A' | $ check 'E:A' | ||||
| $ check 'E % C' | $ check 'E % C' | ||||
| $ check 'not E' | $ check 'not E' | ||||
| ordering: defineorder not respected | ordering: defineorder not respected | ||||
| $ check 'adds("*")' | $ check 'adds("*")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'all()' | $ check 'all()' | ||||
| $ check 'ancestors(E)' | $ check 'ancestors(E)' | ||||
| $ check 'author(test)' | $ check 'author(test)' | ||||
| ordering: defineorder not respected | |||||
| $ check 'bisect(untested)' | $ check 'bisect(untested)' | ||||
| $ check 'bookmark()' | $ check 'bookmark()' | ||||
| $ check 'branch(default)' | $ check 'branch(default)' | ||||
| ordering: defineorder not respected | |||||
| $ check 'branchpoint()' | $ check 'branchpoint()' | ||||
| ordering: defineorder not respected | |||||
| $ check 'children(A)' | $ check 'children(A)' | ||||
| $ check 'closed()' | $ check 'closed()' | ||||
| ordering: defineorder not respected | |||||
| $ check 'contains(A)' | $ check 'contains(A)' | ||||
| ordering: defineorder not respected | |||||
| $ check 'date("0 0")' | $ check 'date("0 0")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'desc("")' | $ check 'desc("")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'descendants(A)' | $ check 'descendants(A)' | ||||
| $ check 'destination()' | $ check 'destination()' | ||||
| ordering: defineorder not respected | |||||
| $ check 'draft()' | $ check 'draft()' | ||||
| $ check 'file("*")' | $ check 'file("*")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'filelog("A")' | $ check 'filelog("A")' | ||||
| $ check 'follow()' | $ check 'follow()' | ||||
| $ check 'grep("A")' | $ check 'grep("A")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'head()' | $ check 'head()' | ||||
| $ check 'heads(E+C)' | $ check 'heads(E+C)' | ||||
| ordering: followorder not respected | ordering: followorder not respected | ||||
| $ check 'merge()' | $ check 'merge()' | ||||
| ordering: defineorder not respected | |||||
| $ check 'modifies("A")' | $ check 'modifies("A")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'named("tags")' | $ check 'named("tags")' | ||||
| $ check 'origin()' | $ check 'origin()' | ||||
| $ check 'outgoing()' | $ check 'outgoing()' | ||||
| $ check 'p1(B+E+D)' | $ check 'p1(B+E+D)' | ||||
| $ check 'p2(B+E+D)' | $ check 'p2(B+E+D)' | ||||
| $ check 'parents(E)' | $ check 'parents(E)' | ||||
| $ check 'public()' | $ check 'public()' | ||||
| ordering: defineorder not respected | |||||
| $ check 'reverse(B+E+D)' | $ check 'reverse(B+E+D)' | ||||
| $ check 'removes("A")' | $ check 'removes("A")' | ||||
| ordering: defineorder not respected | |||||
| $ check 'roots(B+E+D)' | $ check 'roots(B+E+D)' | ||||
| $ check 'secret()' | $ check 'secret()' | ||||
| $ check 'sort(all())' | $ check 'sort(all())' | ||||
| $ check 'tagged()' | $ check 'tagged()' | ||||