This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3639

remotenames: add names argument to remotenames revset
ClosedPublic

Authored by pulkit on May 20 2018, 5:22 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGfda1df3d4e06: remotenames: add names argument to remotenames revset
rHG6638bd3f061b: remotenames: add names argument to remotenames revset
Summary

This patch adds names argument to the revsets provided by the remotenames
extension. The revsets are remotenames(), remotebranches() and
remotebookmarks(). names can be a single names, list of names or can be empty too
which means it's an optional argument.

If names is/are passed, changesets which have those remotenames will be
returned.
If names are not passed, changesets from all the remotenames are shown.

Passing an invalid remotename does not throw error.

The name argument also supports pattern matching.

Tests are added for the argument in tests/test-logexchange.t

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

pulkit created this revision.May 20 2018, 5:22 PM
yuja added a subscriber: yuja.May 24 2018, 9:13 AM

+def _parsepaths(x):
+ """parses the argument passed in revsets as paths and return
+ them as a set or returns None if no path is specified"""
+
+ if not x:
+ return None
+
+ paths = set()
+ if x[0] in ('symbol', 'string'):
+ paths.add(x[1])
+ elif x[0] == 'list':
+ for t, p in x[1:]:
+ paths.add(p)
+ return paths

Use revsetlang.getlist() and apply .getstring() to each element, which
is more robust.

That said, the common idiom is to accept a literal/re pattern. See
revset.bookmark() for example.

durin42 added a subscriber: durin42.May 31 2018, 3:21 PM

I like the literal/re pattern idea. I think if this lands I can stop maintaining remotebranches, so I'd very much like to see it land.

yuja added a comment.Jun 27 2018, 9:09 AM

+@revsetpredicate('remotenames([path, ...])')

My proposal was remotenames([pattern]), just like bookmark(), tag(),
branch(), etc. If we want a convenient way to specify path prefix, we can
add it to the stringmatcher (e.g. 'remotenames("path:server2")'.) And
multiple paths can be specified as 'remotenames(x) + remotenames(y)', though
it isn't exactly the same as 'remotenames("re:<x>|<y>")'.

Does it make sense?

pulkit added a comment.Jun 28 2018, 4:37 PM
In D3639#60108, @yuja wrote:

+@revsetpredicate('remotenames([path, ...])')

My proposal was remotenames([pattern]), just like bookmark(), tag(),
branch(), etc.
If we want a convenient way to specify path prefix, we can
add it to the stringmatcher (e.g. 'remotenames("path:server2")'.)

No, I don't want to specify a path prefix. remotenames() will take a path only. Do you want to say that we should allow passing full remotenames instead of just path?

yuja added a comment.Jun 29 2018, 8:55 AM
> > +@revsetpredicate('remotenames([path, ...])')
>
> My proposal was `remotenames([pattern])`, just like bookmark(), tag(),
>  branch(), etc.
>  If we want a convenient way to specify path prefix, we can
>  add it to the stringmatcher (e.g. 'remotenames("path:server2")'.)
No, I don't want to specify a path prefix. remotenames() will take a path only. Do you want to say that we should allow passing full remotenames instead of just path?

Yes, because a remote branch is merely a branch pulled from peer for example,
and we'll probably want to select it by -r remotebranch("foo/bar") just like
-r branch("foo/bar") for normal branches. Do I get it wrong? Why is it so
important to filter by a peer path, not by a branch name itself?

pulkit added a comment.Jul 1 2018, 5:13 PM
In D3639#60247, @yuja wrote:
> > +@revsetpredicate('remotenames([path, ...])')
>
> My proposal was `remotenames([pattern])`, just like bookmark(), tag(),
>  branch(), etc.
>  If we want a convenient way to specify path prefix, we can
>  add it to the stringmatcher (e.g. 'remotenames("path:server2")'.)
No, I don't want to specify a path prefix. remotenames() will take a path only. Do you want to say that we should allow passing full remotenames instead of just path?

Yes, because a remote branch is merely a branch pulled from peer for example,
and we'll probably want to select it by -r remotebranch("foo/bar") just like
-r branch("foo/bar") for normal branches. Do I get it wrong? Why is it so
important to filter by a peer path, not by a branch name itself?

You definitely get it right. I was unable to think that before your last comment because this path approach was motivated from upstream() revsets which I was trying to get rid off. And I like your 'path:' idea too. Thanks!

pulkit edited the summary of this revision. (Show Details)Jul 28 2018, 4:45 PM
pulkit retitled this revision from remotenames: add paths argument to remotenames revset to remotenames: add names argument to remotenames revset.
pulkit updated this revision to Diff 9669.
yuja added a comment.Aug 3 2018, 10:17 AM

+@revsetpredicate('remotebranches([name, ...])')

Can you start with a single "name" argument?

It doesn't make sense that remotebranches() accepts many OR patterns but
branch() doesn't.

durin42 added a comment.Aug 3 2018, 10:34 AM
In D3639#63068, @yuja wrote:

+@revsetpredicate('remotebranches([name, ...])')

Can you start with a single "name" argument?
It doesn't make sense that remotebranches() accepts many OR patterns but
branch() doesn't.

I concur - if you can pass a regex (which you can), that's fine for my use case, let's see how far that gets us.

Closed by commit rHG6638bd3f061b: remotenames: add names argument to remotenames revset (authored by pulkit). · Explain WhyOct 5 2018, 7:45 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/remotenames.py (89 lines)
Mtests/test-logexchange.t (185 lines)

Diff 11694

hgext/remotenames.py

namespaces, namespaces,
pycompat, pycompat,
registrar, registrar,
revsetlang, revsetlang,
smartset, smartset,
templateutil, templateutil,
) )
from mercurial.utils import (
stringutil,
)
if pycompat.ispy3: if pycompat.ispy3:
import collections.abc import collections.abc
mutablemapping = collections.abc.MutableMapping mutablemapping = collections.abc.MutableMapping
else: else:
import collections import collections
mutablemapping = collections.MutableMapping mutablemapping = collections.MutableMapping
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
remotebranches = [] remotebranches = []
if 'remotebranches' in repo.names: if 'remotebranches' in repo.names:
remotebranches = repo.names['remotebranches'].names(repo, ctx.node()) remotebranches = repo.names['remotebranches'].names(repo, ctx.node())
return templateutil.compatlist(context, mapping, 'remotebranch', return templateutil.compatlist(context, mapping, 'remotebranch',
remotebranches, plural='remotebranches') remotebranches, plural='remotebranches')
def _revsetutil(repo, subset, x, rtypes): def _revsetutil(repo, subset, x, rtypes, args):
"""utility function to return a set of revs based on the rtypes""" """utility function to return a set of revs based on the rtypes"""
revs = set() revs = set()
cl = repo.changelog cl = repo.changelog
literals, matchers = args
# whether arguments were passed or not
argspassed = bool(literals or matchers)
for rtype in rtypes: for rtype in rtypes:
if rtype in repo.names: if rtype in repo.names:
ns = repo.names[rtype] ns = repo.names[rtype]
for name in ns.listnames(repo): for name in ns.listnames(repo):
if argspassed:
if name in literals:
revs.update(ns.nodes(repo, name))
continue
for matcher in matchers:
if matcher(name):
revs.update(ns.nodes(repo, name))
break
else:
revs.update(ns.nodes(repo, name)) revs.update(ns.nodes(repo, name))
results = (cl.rev(n) for n in revs if cl.hasnode(n)) results = (cl.rev(n) for n in revs if cl.hasnode(n))
return subset & smartset.baseset(sorted(results)) return subset & smartset.baseset(sorted(results))
@revsetpredicate('remotenames()') def _parseargs(x):
"""parses the argument passed in revsets
returns (literals, matchers) where,
literals is a set of literals passed by user
matchers is a list of matcher objects for patterns passed by user
"""
# set of paths passed as literals
literals = set()
# list of matcher to match the patterns passed as names
matchers = []
if not x:
return literals, matchers
args = set()
lx = revsetlang.getlist(x)
err = _('the argument must be a string')
for entry in lx:
args.add(revsetlang.getstring(entry, err))
for p in args:
kind, pattern, matcher = stringutil.stringmatcher(p)
if kind == 'literal':
literals.add(pattern)
else:
matchers.append(matcher)
return literals, matchers
@revsetpredicate('remotenames([name, ...])')
def remotenamesrevset(repo, subset, x): def remotenamesrevset(repo, subset, x):
"""All changesets which have a remotename on them.""" """All changesets which have a remotename on them. If paths are specified,
revsetlang.getargs(x, 0, 0, _("remotenames takes no arguments")) remotenames of those remote paths are only considered.
return _revsetutil(repo, subset, x, ('remotebookmarks', 'remotebranches'))
Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
"""
@revsetpredicate('remotebranches()') args = _parseargs(x)
return _revsetutil(repo, subset, x, ('remotebookmarks', 'remotebranches'),
args)
@revsetpredicate('remotebranches([name, ...])')
def remotebranchesrevset(repo, subset, x): def remotebranchesrevset(repo, subset, x):
"""All changesets which are branch heads on remotes.""" """All changesets which are branch heads on remotes. If paths are specified,
revsetlang.getargs(x, 0, 0, _("remotebranches takes no arguments")) only those remotes paths are considered.
return _revsetutil(repo, subset, x, ('remotebranches',))
Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
"""
args = _parseargs(x)
return _revsetutil(repo, subset, x, ('remotebranches',), args)
@revsetpredicate('remotebookmarks()') @revsetpredicate('remotebookmarks([name, ...])')
def remotebmarksrevset(repo, subset, x): def remotebmarksrevset(repo, subset, x):
"""All changesets which have bookmarks on remotes.""" """All changesets which have bookmarks on remotes. If paths are specified,
revsetlang.getargs(x, 0, 0, _("remotebookmarks takes no arguments")) only those remote paths are considered.
return _revsetutil(repo, subset, x, ('remotebookmarks',))
Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
"""
args = _parseargs(x)
return _revsetutil(repo, subset, x, ('remotebookmarks',), args)

tests/test-logexchange.t

$ hg log -r "remotebookmarks()" -GT "{rev}:{node|short} {remotenames}\n" $ hg log -r "remotebookmarks()" -GT "{rev}:{node|short} {remotenames}\n"
o 6:87d6d6676308 $TESTTMP/server2/bar default/bar o 6:87d6d6676308 $TESTTMP/server2/bar default/bar
: :
o 3:62615734edd5 $TESTTMP/server2/foo default/foo o 3:62615734edd5 $TESTTMP/server2/foo default/foo
| |
~ ~
Updating to revision using hoisted name Updating to revision using hoisted name
---------------------------------------
Deleting local bookmark to make sure we update to hoisted name only Deleting local bookmark to make sure we update to hoisted name only
$ hg bookmark -d bar $ hg bookmark -d bar
$ hg up bar $ hg up bar
2 files updated, 0 files merged, 1 files removed, 0 files unresolved 2 files updated, 0 files merged, 1 files removed, 0 files unresolved
summary: Added d summary: Added d
$ hg bookmarks $ hg bookmarks
$TESTTMP/server2/bar 6:87d6d6676308 $TESTTMP/server2/bar 6:87d6d6676308
$TESTTMP/server2/foo 3:62615734edd5 $TESTTMP/server2/foo 3:62615734edd5
default/bar 6:87d6d6676308 default/bar 6:87d6d6676308
default/foo 8:3e1487808078 default/foo 8:3e1487808078
* foo 8:3e1487808078 * foo 8:3e1487808078
Testing the names argument to remotenames, remotebranches and remotebookmarks revsets
--------------------------------------------------------------------------------------
$ cd ..
$ hg clone ssh://user@dummy/server client2
requesting all changes
adding changesets
adding manifests
adding file changes
added 9 changesets with 9 changes to 9 files (+1 heads)
new changesets 18d04c59bb5d:3e1487808078
updating to branch default
8 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd server2
$ hg up wat
6 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ echo foo > watwat
$ hg ci -Aqm "added watwat"
$ hg bookmark bar
abort: bookmark 'bar' already exists (use -f to force)
[255]
$ hg up ec24
3 files updated, 0 files merged, 2 files removed, 0 files unresolved
$ echo i > i
$ hg ci -Aqm "added i"
$ cd ../client2
$ echo "[paths]" >> .hg/hgrc
$ echo "server2 = $TESTTMP/server2" >> .hg/hgrc
$ hg pull server2
pulling from $TESTTMP/server2
searching for changes
adding changesets
adding manifests
adding file changes
added 2 changesets with 2 changes to 2 files
new changesets f34adec73c21:bf433e48adea
(run 'hg update' to get a working copy)
$ hg log -Gr 'remotenames()' -T '{rev}:{node|short} {desc}\n({remotebranches}) [{remotebookmarks}]\n\n'
o 10:bf433e48adea added i
| (server2/default) []
|
| o 9:f34adec73c21 added watwat
| | (server2/wat) []
| |
| o 8:3e1487808078 added bar
| : (default/wat) [default/foo]
| :
@ : 7:ec2426147f0e Added h
| : (default/default) []
| :
o : 6:87d6d6676308 Added g
:/ () [default/bar server2/bar]
:
o 3:62615734edd5 Added d
| () [server2/foo]
~
Testing for a single remote name which exists
$ hg log -r 'remotebranches("default/wat")' -GT "{rev}:{node|short} {remotebranches}\n"
o 8:3e1487808078 default/wat
|
~
$ hg log -r 'remotebookmarks("server2/foo")' -GT "{rev}:{node|short} {remotebookmarks}\n"
o 3:62615734edd5 server2/foo
|
~
$ hg log -r 'remotenames("re:default")' -GT "{rev}:{node|short} {remotenames}\n"
o 10:bf433e48adea server2/default
|
| o 8:3e1487808078 default/foo default/wat
| |
| ~
@ 7:ec2426147f0e default/default
|
o 6:87d6d6676308 default/bar server2/bar
|
~
Testing for a single name which does not exists
$ hg log -r 'remotebranches(def)' -GT "{rev}:{node|short} {remotenames}\n"
$ hg log -r 'remotebookmarks("server3")' -GT "{rev}:{node|short} {remotenames}\n"
$ hg log -r 'remotenames("server3")' -GT "{rev}:{node|short} {remotenames}\n"
Testing for multiple names where all of them exists
$ hg log -r 'remotenames("re:default", "re:server2")' -GT "{rev}:{node|short} {remotenames}\n"
o 10:bf433e48adea server2/default
|
| o 9:f34adec73c21 server2/wat
| |
| o 8:3e1487808078 default/foo default/wat
| :
@ : 7:ec2426147f0e default/default
| :
o : 6:87d6d6676308 default/bar server2/bar
:/
o 3:62615734edd5 server2/foo
|
~
$ hg log -r 'remotebranches("default/wat", "server2/wat")' -GT "{rev}:{node|short} {remotebranches}\n"
o 9:f34adec73c21 server2/wat
|
o 8:3e1487808078 default/wat
|
~
$ hg log -r 'remotebookmarks("default/foo", "server2/foo")' -GT "{rev}:{node|short} {remotebookmarks}\n"
o 8:3e1487808078 default/foo
:
o 3:62615734edd5 server2/foo
|
~
Testing for multipe names where some exists and some not
$ hg log -r 'remotenames(def, "re:server2")' -GT "{rev}:{node|short} {remotenames}\n"
o 10:bf433e48adea server2/default
:
: o 9:f34adec73c21 server2/wat
: :
o : 6:87d6d6676308 default/bar server2/bar
:/
o 3:62615734edd5 server2/foo
|
~
$ hg log -r 'remotebranches("default/default", server)' -GT "{rev}:{node|short} {remotebranches}\n"
@ 7:ec2426147f0e default/default
|
~
$ hg log -r 'remotebookmarks("default/foo", serv)' -GT "{rev}:{node|short} {remotebookmarks}\n"
o 8:3e1487808078 default/foo
|
~
Where multiple names specified and None of them exists
$ hg log -r 'remotenames(def, serv2)' -GT "{rev}:{node|short} {remotenames}\n"
$ hg log -r 'remotebranches(defu, server)' -GT "{rev}:{node|short} {remotebranches}\n"
$ hg log -r 'remotebookmarks(delt, serv)' -GT "{rev}:{node|short} {remotebookmarks}\n"
Testing pattern matching
$ hg log -r 'remotenames("re:def")' -GT "{rev}:{node|short} {remotenames}\n"
o 10:bf433e48adea server2/default
|
| o 8:3e1487808078 default/foo default/wat
| |
| ~
@ 7:ec2426147f0e default/default
|
o 6:87d6d6676308 default/bar server2/bar
|
~
$ hg log -r 'remotebranches("re:ser.*2")' -GT "{rev}:{node|short} {remotebranches}\n"
o 10:bf433e48adea server2/default
|
~
o 9:f34adec73c21 server2/wat
|
~
$ hg log -r 'remotebookmarks("re:def", "re:.*2")' -GT "{rev}:{node|short} {remotebookmarks}\n"
o 8:3e1487808078 default/foo
:
: o 6:87d6d6676308 default/bar server2/bar
:/
o 3:62615734edd5 server2/foo
|
~