| hg-reviewers |
The code to handle order is a bit repetitive and error prone (dagrange
is an example). This patch adds an revset.intersect helper function to
make related area cleaner.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/revset.py (63 lines) | |||
| M | tests/test-revset.t (16 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): | |||||
| """intersect two revsets with order preserved as requested | |||||
| If order is "followorder", preserve subset's order. If order is | |||||
| "defineorder", preserve newset's order. | |||||
| A typical use of this function is:: | |||||
| @revsetpredicate('myrevset', takeorder=True) | |||||
| def myrevset(repo, subset, x, order): | |||||
| newset = ... # a smartset that implements "myrevset" | |||||
| return revset.intersect(subset, newset, order) | |||||
| """ | |||||
| # some old code does not use smartset, normalize to smartset | |||||
| if not util.safehasattr(newset, 'isascending'): | |||||
| newset = subset & newset | |||||
| if order == defineorder: | |||||
| newset.sort() | |||||
| # ordering does not matter if there are at most 1 revision (test quickly) | |||||
| if isinstance(newset, baseset) and len(newset) <= 1: | |||||
| return newset & subset | |||||
| if order == followorder: | |||||
| return subset & newset | |||||
| elif order == defineorder: | |||||
| return newset & subset | |||||
| assert order == anyorder | |||||
| # newset is usually smaller, prefer it on the left | |||||
| return newset & subset | |||||
| def _getrevsource(repo, r): | def _getrevsource(repo, r): | ||||
| extra = repo[r].extra() | extra = repo[r].extra() | ||||
| for label in ('source', 'transplant_source', 'rebase_source'): | for label in ('source', 'transplant_source', 'rebase_source'): | ||||
| if label in extra: | if label in extra: | ||||
| try: | try: | ||||
| return repo[extra[label]].rev() | return repo[extra[label]].rev() | ||||
| except error.RepoLookupError: | except error.RepoLookupError: | ||||
| pass | pass | ||||
| r = spanset(repo, m, len(repo)) + baseset([n]) | r = spanset(repo, m, len(repo)) + baseset([n]) | ||||
| elif m == node.wdirrev: | elif m == node.wdirrev: | ||||
| r = baseset([m]) + spanset(repo, len(repo) - 1, n - 1) | r = baseset([m]) + spanset(repo, len(repo) - 1, n - 1) | ||||
| elif m < n: | elif m < n: | ||||
| r = spanset(repo, m, n + 1) | r = spanset(repo, m, n + 1) | ||||
| else: | else: | ||||
| r = spanset(repo, m, n - 1) | r = spanset(repo, m, n - 1) | ||||
| if order == defineorder: | return intersect(subset, r, order) | ||||
| return r & subset | |||||
| else: | |||||
| # carrying the sorting over when possible would be more efficient | |||||
| return subset & r | |||||
| def dagrange(repo, subset, x, y, order): | def dagrange(repo, subset, x, y, order): | ||||
| r = fullreposet(repo) | r = fullreposet(repo) | ||||
| xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y), | xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y), | ||||
| includepath=True) | includepath=True) | ||||
| return subset & xs | return intersect(subset, xs, order) | ||||
| def andset(repo, subset, x, y, order): | def andset(repo, subset, x, y, order): | ||||
| if order == anyorder: | if order == anyorder: | ||||
| yorder = anyorder | yorder = anyorder | ||||
| else: | else: | ||||
| yorder = followorder | yorder = followorder | ||||
| return getset(repo, getset(repo, subset, x, order), y, yorder) | return getset(repo, getset(repo, subset, x, order), y, yorder) | ||||
| continue | continue | ||||
| p1, p2 = pr(r) | p1, p2 = pr(r) | ||||
| if p1 in parentset: | if p1 in parentset: | ||||
| cs.add(r) | cs.add(r) | ||||
| if p2 != nullrev and p2 in parentset: | if p2 != nullrev and p2 in parentset: | ||||
| cs.add(r) | cs.add(r) | ||||
| return baseset(cs) | return baseset(cs) | ||||
| @predicate('children(set)', safe=True) | @predicate('children(set)', safe=True, takeorder=True) | ||||
| def children(repo, subset, x): | 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 subset & cs | return intersect(subset, cs, order) | ||||
| @predicate('closed()', safe=True) | @predicate('closed()', safe=True) | ||||
| def closed(repo, subset, x): | def closed(repo, subset, x): | ||||
| """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 subset.filter(lambda r: repo[r].closesbranch(), | ||||
| if lim < 0: | if lim < 0: | ||||
| raise error.ParseError(_("negative number to select")) | raise error.ParseError(_("negative number to select")) | ||||
| # i18n: "limit" is a keyword | # i18n: "limit" is a keyword | ||||
| ofs = getinteger(args.get('offset'), _("limit expects a number"), default=0) | ofs = getinteger(args.get('offset'), _("limit expects a number"), default=0) | ||||
| if ofs < 0: | if ofs < 0: | ||||
| raise error.ParseError(_("negative offset")) | raise error.ParseError(_("negative offset")) | ||||
| os = getset(repo, fullreposet(repo), args['set'], defineorder) | os = getset(repo, fullreposet(repo), args['set'], defineorder) | ||||
| ls = os.slice(ofs, ofs + lim) | ls = os.slice(ofs, ofs + lim) | ||||
| if order == followorder and lim > 1: | return intersect(subset, ls, order) | ||||
| return subset & ls | |||||
| return ls & subset | |||||
| @predicate('last(set, [n])', safe=True, takeorder=True) | @predicate('last(set, [n])', safe=True, takeorder=True) | ||||
| def last(repo, subset, x, order): | def last(repo, subset, x, order): | ||||
| """Last n members of set, defaulting to 1. | """Last n members of set, defaulting to 1. | ||||
| """ | """ | ||||
| # i18n: "last" is a keyword | # i18n: "last" is a keyword | ||||
| l = getargs(x, 1, 2, _("last requires one or two arguments")) | l = getargs(x, 1, 2, _("last requires one or two arguments")) | ||||
| lim = 1 | lim = 1 | ||||
| if len(l) == 2: | if len(l) == 2: | ||||
| # i18n: "last" is a keyword | # i18n: "last" is a keyword | ||||
| lim = getinteger(l[1], _("last expects a number")) | lim = getinteger(l[1], _("last expects a number")) | ||||
| if lim < 0: | if lim < 0: | ||||
| raise error.ParseError(_("negative number to select")) | raise error.ParseError(_("negative number to select")) | ||||
| os = getset(repo, fullreposet(repo), l[0], defineorder) | os = getset(repo, fullreposet(repo), l[0], defineorder) | ||||
| os.reverse() | os.reverse() | ||||
| ls = os.slice(0, lim) | ls = os.slice(0, lim) | ||||
| if order == followorder and lim > 1: | |||||
| return subset & ls | |||||
| ls.reverse() | ls.reverse() | ||||
| return ls & subset | return intersect(subset, ls, order) | ||||
| @predicate('max(set)', safe=True) | @predicate('max(set)', safe=True) | ||||
| def maxrev(repo, subset, x): | def maxrev(repo, subset, x): | ||||
| """Changeset with highest revision number in set. | """Changeset with highest revision number in set. | ||||
| """ | """ | ||||
| os = getset(repo, fullreposet(repo), x) | os = getset(repo, fullreposet(repo), x) | ||||
| try: | try: | ||||
| m = os.max() | m = os.max() | ||||
| ps -= {node.nullrev} | ps -= {node.nullrev} | ||||
| # XXX we should turn this into a baseset instead of a set, smartset may do | # XXX we should turn this into a baseset instead of a set, smartset may do | ||||
| # some optimizations from the fact this is a baseset. | # some optimizations from the fact this is a baseset. | ||||
| return subset & ps | return subset & ps | ||||
| def parentpost(repo, subset, x, order): | def parentpost(repo, subset, x, order): | ||||
| return p1(repo, subset, x) | return p1(repo, subset, x) | ||||
| @predicate('parents([set])', safe=True) | @predicate('parents([set])', safe=True, takeorder=True) | ||||
| def parents(repo, subset, x): | 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 subset & ps | return intersect(subset, ps, order) | ||||
| def _phase(repo, subset, *targets): | def _phase(repo, subset, *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 subset & s | ||||
| @predicate('draft()', safe=True) | @predicate('draft()', safe=True) | ||||
| def draft(repo, subset, x): | def draft(repo, subset, x): | ||||
| try: | try: | ||||
| parents = cl.parentrevs(r) | parents = cl.parentrevs(r) | ||||
| if parents[1] != node.nullrev: | if parents[1] != node.nullrev: | ||||
| ps.add(parents[1]) | ps.add(parents[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].rev()) | ps.add(parents[1].rev()) | ||||
| return subset & ps | return intersect(subset, ps, order) | ||||
| @predicate('present(set)', safe=True, takeorder=True) | @predicate('present(set)', safe=True, takeorder=True) | ||||
| def present(repo, subset, x, order): | def present(repo, subset, x, order): | ||||
| """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. | all revisions in set. | ||||
| If any of specified revisions is not present in the local repository, | If any of specified revisions is not present in the local repository, | ||||
| the query is normally aborted. But this predicate allows the query | the query is normally aborted. But this predicate allows the query | ||||
| <spanset+ 0:2>> | <spanset+ 0:2>> | ||||
| 1 | 1 | ||||
| 0 | 0 | ||||
| $ hg debugrevspec -s ':1 & last(4:0, 3)' | $ hg debugrevspec -s ':1 & last(4:0, 3)' | ||||
| * set: | * set: | ||||
| <filteredset | <filteredset | ||||
| <spanset+ 0:2>, | <spanset+ 0:2>, | ||||
| <spanset+ 0:3>> | <spanset- 0:3>> | ||||
| 0 | 0 | ||||
| 1 | 1 | ||||
| Test scmutil.revsingle() should return the last revision | Test scmutil.revsingle() should return the last revision | ||||
| $ hg debugrevspec -s 'last(0::)' | $ hg debugrevspec -s 'last(0::)' | ||||
| * set: | * set: | ||||
| <baseset slice=0:1 | <baseset slice=0:1 | ||||
| ('symbol', '2') | ('symbol', '2') | ||||
| ('symbol', '1'))) | ('symbol', '1'))) | ||||
| * set: | * set: | ||||
| <filteredset | <filteredset | ||||
| <filteredset | <filteredset | ||||
| <spanset- 0:4>, | <spanset- 0:4>, | ||||
| <spanset+ 0:4>>, | <spanset+ 0:4>>, | ||||
| <not | <not | ||||
| <spanset+ 1:3>>> | <spanset- 1:3>>> | ||||
| 3 | 3 | ||||
| 0 | 0 | ||||
| 'a + b', which is optimized to '_list(a b)', should take the ordering of | 'a + b', which is optimized to '_list(a b)', should take the ordering of | ||||
| the left expression: | the left expression: | ||||
| $ try --optimize '2:0 & (0 + 1 + 2)' | $ try --optimize '2:0 & (0 + 1 + 2)' | ||||
| (and | (and | ||||
| (func | (func | ||||
| ('symbol', '_list') | ('symbol', '_list') | ||||
| ('string', '1\x000\x002')) | ('string', '1\x000\x002')) | ||||
| (func | (func | ||||
| ('symbol', '_list') | ('symbol', '_list') | ||||
| ('string', '0\x002\x001')))) | ('string', '0\x002\x001')))) | ||||
| * set: | * set: | ||||
| <filteredset | <filteredset | ||||
| <spanset- 0:3>, | <baseset [1]>, | ||||
| <baseset [1]>> | <spanset- 0:3>> | ||||
| 1 | 1 | ||||
| 'A & B' can be rewritten as 'B & A' by weight. When ordering needs to be | 'A & B' can be rewritten as 'B & A' by weight. When ordering needs to be | ||||
| preserved (ex. taking the order of A), rewrite as '_flipand(B, A)'. | preserved (ex. taking the order of A), rewrite as '_flipand(B, A)'. | ||||
| $ try --optimize 'contains("glob:*") & (2 + 0 + 1)' | $ try --optimize 'contains("glob:*") & (2 + 0 + 1)' | ||||
| (and | (and | ||||
| (func | (func | ||||
| ('symbol', '0') | ('symbol', '0') | ||||
| ('symbol', '2') | ('symbol', '2') | ||||
| ('symbol', '1')))) | ('symbol', '1')))) | ||||
| (dagrange | (dagrange | ||||
| ('symbol', '0') | ('symbol', '0') | ||||
| ('symbol', '2')))))) | ('symbol', '2')))))) | ||||
| * set: | * set: | ||||
| <filteredset | <filteredset | ||||
| <baseset [0, 2, 1]>, | <baseset+ [0, 1, 2]>, | ||||
| <baseset+ [0, 1, 2]>> | <baseset [0, 2, 1]>> | ||||
| 0 | 0 | ||||
| 2 | |||||
| 1 | 1 | ||||
| 2 | |||||
| WRONG: should take dagrange order (0, 1, 2) | |||||
| 'A + B' can be rewritten to 'B + A' by weight only when the order doesn't | 'A + B' can be rewritten to 'B + A' by weight only when the order doesn't | ||||
| matter (e.g. 'X & (A + B)' can be 'X & (B + A)', but '(A + B) & X' can't): | matter (e.g. 'X & (A + B)' can be 'X & (B + A)', but '(A + B) & X' can't): | ||||
| $ try -p optimized '0:2 & (reverse(contains("a")) + 2)' | $ try -p optimized '0:2 & (reverse(contains("a")) + 2)' | ||||
| * optimized: | * optimized: | ||||
| (and | (and | ||||
| (range | (range | ||||