This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8394

revset: implement a simple 'foo#generations' expression
ClosedPublic

Authored by av6 on Apr 10 2020, 1:02 PM.

Details

Reviewers
yuja
Group Reviewers
hg-reviewers
Commits
rHGeca82eb9d777: revset: implement a simple 'foo#generations' expression
Summary

The result of this expression is equivalent to 'foo#g[:]': all reachable
ancestors and descendants of a revset foo.

While not very useful functionality on its own, its implementation can be
tested and revset.relations dict can be easily used by extensions to add other
non-subscript relations.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

av6 created this revision.Apr 10 2020, 1:02 PM
av6 added a commit: rHGeca82eb9d777: revset: implement a simple 'foo#generations' expression.Apr 15 2020, 11:18 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGeca82eb9d777: revset: implement a simple 'foo#generations' expression (authored by av6). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revset.py (20 lines)
Mtests/test-revset.t (30 lines)

Diff 21101

mercurial/revset.py

return _orsetlist(repo, subset, xs, order) return _orsetlist(repo, subset, xs, order)
def notset(repo, subset, x, order): def notset(repo, subset, x, order):
return subset - getset(repo, subset, x, anyorder) return subset - getset(repo, subset, x, anyorder)
def relationset(repo, subset, x, y, order): def relationset(repo, subset, x, y, order):
raise error.ParseError(_(b"can't use a relation in this context")) # this is pretty basic implementation of 'x#y' operator, still
# experimental so undocumented. see the wiki for further ideas.
# https://www.mercurial-scm.org/wiki/RevsetOperatorPlan
rel = getsymbol(y)
if rel in relations:
return relations[rel](repo, subset, x, rel, order)
relnames = [r for r in relations.keys() if len(r) > 1]
raise error.UnknownIdentifier(rel, relnames)
def _splitrange(a, b): def _splitrange(a, b):
"""Split range with bounds a and b into two ranges at 0 and return two """Split range with bounds a and b into two ranges at 0 and return two
tuples of numbers for use as startdepth and stopdepth arguments of tuples of numbers for use as startdepth and stopdepth arguments of
revancestors and revdescendants. revancestors and revdescendants.
>>> _splitrange(-10, -5) # [-10:-5] >>> _splitrange(-10, -5) # [-10:-5]
ancdepths = (0, 1) ancdepths = (0, 1)
if a < 0: if a < 0:
ancdepths = (-min(b, 0), -a + 1) ancdepths = (-min(b, 0), -a + 1)
if b > 0: if b > 0:
descdepths = (max(a, 0), b + 1) descdepths = (max(a, 0), b + 1)
return ancdepths, descdepths return ancdepths, descdepths
def generationsrel(repo, subset, x, rel, order):
z = (b'rangeall', None)
return generationssubrel(repo, subset, x, rel, z, order)
def generationssubrel(repo, subset, x, rel, z, order): def generationssubrel(repo, subset, x, rel, z, order):
# TODO: rewrite tests, and drop startdepth argument from ancestors() and # TODO: rewrite tests, and drop startdepth argument from ancestors() and
# descendants() predicates # descendants() predicates
a, b = getintrange( a, b = getintrange(
z, z,
_(b'relation subscript must be an integer or a range'), _(b'relation subscript must be an integer or a range'),
_(b'relation subscript bounds must be integers'), _(b'relation subscript bounds must be integers'),
deffirst=-(dagop.maxlogdepth - 1), deffirst=-(dagop.maxlogdepth - 1),
b"keyvalue": keyvaluepair, b"keyvalue": keyvaluepair,
b"func": func, b"func": func,
b"ancestor": ancestorspec, b"ancestor": ancestorspec,
b"parent": parentspec, b"parent": parentspec,
b"parentpost": parentpost, b"parentpost": parentpost,
b"smartset": rawsmartset, b"smartset": rawsmartset,
} }
relations = {
b"g": generationsrel,
b"generations": generationsrel,
}
subscriptrelations = { subscriptrelations = {
b"g": generationssubrel, b"g": generationssubrel,
b"generations": generationssubrel, b"generations": generationssubrel,
} }
def lookupfn(repo): def lookupfn(repo):
return lambda symbol: scmutil.isrevsymbol(repo, symbol) return lambda symbol: scmutil.isrevsymbol(repo, symbol)

tests/test-revset.t

$ log 'descendants(0+6, depth=3, startdepth=1)' $ log 'descendants(0+6, depth=3, startdepth=1)'
1 1
2 2
3 3
4 4
5 5
7 7
test ancestors/descendants relation:
$ log 'tip#generations'
0
1
2
4
8
9
$ log '3#g'
0
1
3
5
6
7
$ hg debugrevspec -p parsed 'tip#g'
* parsed:
(relation
(symbol 'tip')
(symbol 'g'))
0
1
2
4
8
9
test ancestors/descendants relation subscript: test ancestors/descendants relation subscript:
$ log 'tip#generations[0]' $ log 'tip#generations[0]'
9 9
$ log '.#generations[-1]' $ log '.#generations[-1]'
8 8
$ log '.#g[(-1)]' $ log '.#g[(-1)]'
8 8