Mercurial > public > mercurial-scm > hg

annotate mercurial/revset.py @ 42648:d80edcb0b30c stable

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
automation: make Windows base image name configurable Since automation broke in the middle of the 5.0 release cycle, there's a good chance it will break again in the future. While a robust solution might be to search for all available images and choose the newest one, it does seem useful to be able to explicitly choose the name of the image to find and use so users can opt in to using a different image. This commit implements that functionality. Differential Revision: https://phab.mercurial-scm.org/D6673
author Gregory Szorc <gregory.szorc@gmail.com>
date Mon, 22 Jul 2019 19:06:20 -0700
parents 43c8f72184f4
children 911e25dc9d8c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1 # revset.py - revision set queries for mercurial
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2 #
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
3 # Copyright 2010 Matt Mackall <mpm@selenic.com>
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
4 #
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
5 # This software may be used and distributed according to the terms of the
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
6 # GNU General Public License version 2 or any later version.
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
7
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
8 from __future__ import absolute_import
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
9
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
10 import re
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
11
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
12 from .i18n import _
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
13 from . import (
32903
27932a76a88d dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents: 32885
diff changeset
14 dagop,
26713
a271925699d6 revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26638
diff changeset
15 destutil,
38588
1c93e0237a24 diffutil: move the module out of utils package
Yuya Nishihara <yuya@tcha.org>
parents: 38587
diff changeset
16 diffutil,
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
17 encoding,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
18 error,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
19 hbisect,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
20 match as matchmod,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
21 node,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
22 obsolete as obsmod,
33377
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
23 obsutil,
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
24 pathutil,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
25 phases,
35367
6eee2bcc57c4 py3: handle keyword arguments correctly in revset.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 35330
diff changeset
26 pycompat,
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
27 registrar,
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
28 repoview,
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
29 revsetlang,
32661
a3064fe3e495 revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents: 32442
diff changeset
30 scmutil,
30881
1be65deb3d54 smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 30850
diff changeset
31 smartset,
37389
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
32 stack as stackmod,
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
33 util,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
34 )
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
35 from .utils import (
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
36 dateutil,
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
37 stringutil,
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
38 )
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
39
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
40 # helpers for processing parsed tree
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
41 getsymbol = revsetlang.getsymbol
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
42 getstring = revsetlang.getstring
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
43 getinteger = revsetlang.getinteger
31998
83527d9f1f13 revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents: 31938
diff changeset
44 getboolean = revsetlang.getboolean
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
45 getlist = revsetlang.getlist
41561
59638c6fcb70 revset: extract a helper to parse integer range
Yuya Nishihara <yuya@tcha.org>
parents: 41397
diff changeset
46 getintrange = revsetlang.getintrange
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
47 getargs = revsetlang.getargs
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
48 getargsdict = revsetlang.getargsdict
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
49
30881
1be65deb3d54 smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 30850
diff changeset
50 baseset = smartset.baseset
1be65deb3d54 smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 30850
diff changeset
51 generatorset = smartset.generatorset
1be65deb3d54 smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 30850
diff changeset
52 spanset = smartset.spanset
1be65deb3d54 smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 30850
diff changeset
53 fullreposet = smartset.fullreposet
1be65deb3d54 smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 30850
diff changeset
54
42262
a0c5e06e9b1a revset: extract private constant of {nullrev, wdirrev} set
Yuya Nishihara <yuya@tcha.org>
parents: 42104
diff changeset
55 # revisions not included in all(), but populated if specified
a0c5e06e9b1a revset: extract private constant of {nullrev, wdirrev} set
Yuya Nishihara <yuya@tcha.org>
parents: 42104
diff changeset
56 _virtualrevs = (node.nullrev, node.wdirrev)
a0c5e06e9b1a revset: extract private constant of {nullrev, wdirrev} set
Yuya Nishihara <yuya@tcha.org>
parents: 42104
diff changeset
57
34016
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
58 # Constants for ordering requirement, used in getset():
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
59 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
60 # If 'define', any nested functions and operations MAY change the ordering of
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
61 # the entries in the set (but if changes the ordering, it MUST ALWAYS change
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
62 # it). If 'follow', any nested functions and operations MUST take the ordering
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
63 # specified by the first operand to the '&' operator.
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
64 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
65 # For instance,
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
66 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
67 # X & (Y | Z)
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
68 # ^ ^^^^^^^
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
69 # | follow
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
70 # define
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
71 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
72 # will be evaluated as 'or(y(x()), z(x()))', where 'x()' can change the order
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
73 # of the entries in the set, but 'y()', 'z()' and 'or()' shouldn't.
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
74 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
75 # 'any' means the order doesn't matter. For instance,
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
76 #
34017
62cc1f17c571 revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents: 34016
diff changeset
77 # (X & !Y) | ancestors(Z)
62cc1f17c571 revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents: 34016
diff changeset
78 # ^ ^
62cc1f17c571 revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents: 34016
diff changeset
79 # any any
34016
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
80 #
34017
62cc1f17c571 revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents: 34016
diff changeset
81 # For 'X & !Y', 'X' decides the order and 'Y' is subtracted from 'X', so the
62cc1f17c571 revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents: 34016
diff changeset
82 # order of 'Y' does not matter. For 'ancestors(Z)', Z's order does not matter
62cc1f17c571 revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents: 34016
diff changeset
83 # since 'ancestors' does not care about the order of its argument.
34016
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
84 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
85 # Currently, most revsets do not care about the order, so 'define' is
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
86 # equivalent to 'follow' for them, and the resulting order is based on the
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
87 # 'subset' parameter passed down to them:
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
88 #
34018
de286200f722 revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents: 34017
diff changeset
89 # m = revset.match(...)
de286200f722 revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents: 34017
diff changeset
90 # m(repo, subset, order=defineorder)
34016
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
91 # ^^^^^^
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
92 # For most revsets, 'define' means using the order this subset provides
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
93 #
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
94 # There are a few revsets that always redefine the order if 'define' is
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
95 # specified: 'sort(X)', 'reverse(X)', 'x:y'.
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
96 anyorder = 'any' # don't care the order, could be even random-shuffled
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
97 defineorder = 'define' # ALWAYS redefine, or ALWAYS follow the current order
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
98 followorder = 'follow' # MUST follow the current order
96f249dce03e revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents: 34011
diff changeset
99
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
100 # helpers
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
101
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
102 def getset(repo, subset, x, order=defineorder):
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
103 if not x:
11383
de544774ebea revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents: 11349
diff changeset
104 raise error.ParseError(_("missing argument"))
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
105 return methods[x[0]](repo, subset, *x[1:], order=order)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
106
17003
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
107 def _getrevsource(repo, r):
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
108 extra = repo[r].extra()
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
109 for label in ('source', 'transplant_source', 'rebase_source'):
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
110 if label in extra:
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
111 try:
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
112 return repo[extra[label]].rev()
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
113 except error.RepoLookupError:
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
114 pass
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
115 return None
42c472877825 revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents: 17002
diff changeset
116
35904
fc44c2657dc5 py3: drop b'' from repr() of smartset
Yuya Nishihara <yuya@tcha.org>
parents: 35892
diff changeset
117 def _sortedb(xs):
38575
152f4822d210 pycompat: move rapply() from util
Yuya Nishihara <yuya@tcha.org>
parents: 38565
diff changeset
118 return sorted(pycompat.rapply(pycompat.maybebytestr, xs))
35904
fc44c2657dc5 py3: drop b'' from repr() of smartset
Yuya Nishihara <yuya@tcha.org>
parents: 35892
diff changeset
119
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
120 # operator methods
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
121
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
122 def stringset(repo, subset, x, order):
37264
d2c912836465 revset: drop support for '' as alias for '.'
Martin von Zweigbergk <martinvonz@google.com>
parents: 37084
diff changeset
123 if not x:
d2c912836465 revset: drop support for '' as alias for '.'
Martin von Zweigbergk <martinvonz@google.com>
parents: 37084
diff changeset
124 raise error.ParseError(_("empty string is not a valid revision"))
37271
0194dac77c93 scmutil: add method for looking up a context given a revision symbol
Martin von Zweigbergk <martinvonz@google.com>
parents: 37264
diff changeset
125 x = scmutil.intrev(scmutil.revsymbol(repo, x))
42264
6bc1245cd598 revset: populate wdir() by its hash or revision number
Yuya Nishihara <yuya@tcha.org>
parents: 42262
diff changeset
126 if x in subset or x in _virtualrevs and isinstance(subset, fullreposet):
20364
a6cf48b2880d revset: added baseset class (still empty) to improve revset performance
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20289
diff changeset
127 return baseset([x])
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
128 return baseset()
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
129
41222
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
130 def rawsmartset(repo, subset, x, order):
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
131 """argument is already a smartset, use that directly"""
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
132 if order == followorder:
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
133 return subset & x
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
134 else:
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
135 return x & subset
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
136
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
137 def rangeset(repo, subset, x, y, order):
23162
69524a05a7fa revset-rangeset: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23139
diff changeset
138 m = getset(repo, fullreposet(repo), x)
69524a05a7fa revset-rangeset: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23139
diff changeset
139 n = getset(repo, fullreposet(repo), y)
11456
88abbb046e66 revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents: 11446
diff changeset
140
88abbb046e66 revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents: 11446
diff changeset
141 if not m or not n:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
142 return baseset()
30043
49d5434d68fb revset: extract function that creates range set from computed revisions
Yuya Nishihara <yuya@tcha.org>
parents: 29955
diff changeset
143 return _makerangeset(repo, subset, m.first(), n.last(), order)
49d5434d68fb revset: extract function that creates range set from computed revisions
Yuya Nishihara <yuya@tcha.org>
parents: 29955
diff changeset
144
30803
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
145 def rangeall(repo, subset, x, order):
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
146 assert x is None
35673
134ef400cb11 revset: use 'tiprev' when appropriate
Boris Feld <boris.feld@octobus.net>
parents: 35438
diff changeset
147 return _makerangeset(repo, subset, 0, repo.changelog.tiprev(), order)
30803
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
148
30044
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
149 def rangepre(repo, subset, y, order):
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
150 # ':y' can't be rewritten to '0:y' since '0' may be hidden
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
151 n = getset(repo, fullreposet(repo), y)
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
152 if not n:
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
153 return baseset()
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
154 return _makerangeset(repo, subset, 0, n.last(), order)
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
155
30803
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
156 def rangepost(repo, subset, x, order):
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
157 m = getset(repo, fullreposet(repo), x)
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
158 if not m:
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
159 return baseset()
35673
134ef400cb11 revset: use 'tiprev' when appropriate
Boris Feld <boris.feld@octobus.net>
parents: 35438
diff changeset
160 return _makerangeset(repo, subset, m.first(), repo.changelog.tiprev(),
134ef400cb11 revset: use 'tiprev' when appropriate
Boris Feld <boris.feld@octobus.net>
parents: 35438
diff changeset
161 order)
30803
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
162
30043
49d5434d68fb revset: extract function that creates range set from computed revisions
Yuya Nishihara <yuya@tcha.org>
parents: 29955
diff changeset
163 def _makerangeset(repo, subset, m, n, order):
25766
d51dac68ec98 revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents: 25765
diff changeset
164 if m == n:
d51dac68ec98 revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents: 25765
diff changeset
165 r = baseset([m])
d51dac68ec98 revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents: 25765
diff changeset
166 elif n == node.wdirrev:
d51dac68ec98 revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents: 25765
diff changeset
167 r = spanset(repo, m, len(repo)) + baseset([n])
d51dac68ec98 revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents: 25765
diff changeset
168 elif m == node.wdirrev:
35673
134ef400cb11 revset: use 'tiprev' when appropriate
Boris Feld <boris.feld@octobus.net>
parents: 35438
diff changeset
169 r = baseset([m]) + spanset(repo, repo.changelog.tiprev(), n - 1)
25766
d51dac68ec98 revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents: 25765
diff changeset
170 elif m < n:
20526
9ad6dae67845 revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20525
diff changeset
171 r = spanset(repo, m, n + 1)
11456
88abbb046e66 revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents: 11446
diff changeset
172 else:
20526
9ad6dae67845 revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20525
diff changeset
173 r = spanset(repo, m, n - 1)
29944
5f56a3b9675e revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29943
diff changeset
174
5f56a3b9675e revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29943
diff changeset
175 if order == defineorder:
5f56a3b9675e revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29943
diff changeset
176 return r & subset
5f56a3b9675e revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29943
diff changeset
177 else:
5f56a3b9675e revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29943
diff changeset
178 # carrying the sorting over when possible would be more efficient
5f56a3b9675e revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29943
diff changeset
179 return subset & r
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
180
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
181 def dagrange(repo, subset, x, y, order):
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
182 r = fullreposet(repo)
32903
27932a76a88d dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents: 32885
diff changeset
183 xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y),
27932a76a88d dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents: 32885
diff changeset
184 includepath=True)
29139
64c1955a0461 revset: make dagrange preserve order of input set
Yuya Nishihara <yuya@tcha.org>
parents: 29119
diff changeset
185 return subset & xs
16860
e1aa1ed30030 revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents: 16859
diff changeset
186
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
187 def andset(repo, subset, x, y, order):
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
188 if order == anyorder:
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
189 yorder = anyorder
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
190 else:
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
191 yorder = followorder
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
192 return getset(repo, getset(repo, subset, x, order), y, yorder)
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
193
34020
37b82485097f revset: do not flip "and" arguments when optimizing
Jun Wu <quark@fb.com>
parents: 34019
diff changeset
194 def andsmallyset(repo, subset, x, y, order):
37b82485097f revset: do not flip "and" arguments when optimizing
Jun Wu <quark@fb.com>
parents: 34019
diff changeset
195 # 'andsmally(x, y)' is equivalent to 'and(x, y)', but faster when y is small
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
196 if order == anyorder:
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
197 yorder = anyorder
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
198 else:
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
199 yorder = followorder
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
200 return getset(repo, getset(repo, subset, y, yorder), x, order)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
201
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
202 def differenceset(repo, subset, x, y, order):
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
203 return getset(repo, subset, x, order) - getset(repo, subset, y, anyorder)
28217
d2ac8b57a75d revset: use smartset minus operator
Durham Goode <durham@fb.com>
parents: 28139
diff changeset
204
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
205 def _orsetlist(repo, subset, xs, order):
25929
289149111d46 revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents: 25927
diff changeset
206 assert xs
289149111d46 revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents: 25927
diff changeset
207 if len(xs) == 1:
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
208 return getset(repo, subset, xs[0], order)
25929
289149111d46 revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents: 25927
diff changeset
209 p = len(xs) // 2
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
210 a = _orsetlist(repo, subset, xs[:p], order)
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
211 b = _orsetlist(repo, subset, xs[p:], order)
25929
289149111d46 revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents: 25927
diff changeset
212 return a + b
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
213
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
214 def orset(repo, subset, x, order):
29934
2c6a05b938d8 revset: fix order of nested 'or' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29933
diff changeset
215 xs = getlist(x)
38489
626d29c6e987 revset: leverage orset() to flatten ancestor() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 38488
diff changeset
216 if not xs:
626d29c6e987 revset: leverage orset() to flatten ancestor() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 38488
diff changeset
217 return baseset()
29934
2c6a05b938d8 revset: fix order of nested 'or' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29933
diff changeset
218 if order == followorder:
2c6a05b938d8 revset: fix order of nested 'or' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29933
diff changeset
219 # slow path to take the subset order
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
220 return subset & _orsetlist(repo, fullreposet(repo), xs, anyorder)
29934
2c6a05b938d8 revset: fix order of nested 'or' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29933
diff changeset
221 else:
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
222 return _orsetlist(repo, subset, xs, order)
29929
b3845cab4ddc revset: wrap arguments of 'or' by 'list' node
Yuya Nishihara <yuya@tcha.org>
parents: 29922
diff changeset
223
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
224 def notset(repo, subset, x, order):
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
225 return subset - getset(repo, subset, x, anyorder)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
226
33416
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
227 def relationset(repo, subset, x, y, order):
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
228 raise error.ParseError(_("can't use a relation in this context"))
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
229
41359
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
230 def _splitrange(a, b):
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
231 """Split range with bounds a and b into two ranges at 0 and return two
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
232 tuples of numbers for use as startdepth and stopdepth arguments of
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
233 revancestors and revdescendants.
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
234
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
235 >>> _splitrange(-10, -5) # [-10:-5]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
236 ((5, 11), (None, None))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
237 >>> _splitrange(5, 10) # [5:10]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
238 ((None, None), (5, 11))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
239 >>> _splitrange(-10, 10) # [-10:10]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
240 ((0, 11), (0, 11))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
241 >>> _splitrange(-10, 0) # [-10:0]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
242 ((0, 11), (None, None))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
243 >>> _splitrange(0, 10) # [0:10]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
244 ((None, None), (0, 11))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
245 >>> _splitrange(0, 0) # [0:0]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
246 ((0, 1), (None, None))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
247 >>> _splitrange(1, -1) # [1:-1]
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
248 ((None, None), (None, None))
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
249 """
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
250 ancdepths = (None, None)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
251 descdepths = (None, None)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
252 if a == b == 0:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
253 ancdepths = (0, 1)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
254 if a < 0:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
255 ancdepths = (-min(b, 0), -a + 1)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
256 if b > 0:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
257 descdepths = (max(a, 0), b + 1)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
258 return ancdepths, descdepths
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
259
41563
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
260 def generationsrel(repo, subset, x, rel, z, order):
41359
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
261 # TODO: rewrite tests, and drop startdepth argument from ancestors() and
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
262 # descendants() predicates
41563
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
263 a, b = getintrange(z,
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
264 _('relation subscript must be an integer or a range'),
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
265 _('relation subscript bounds must be integers'),
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
266 deffirst=-(dagop.maxlogdepth - 1),
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
267 deflast=+(dagop.maxlogdepth - 1))
41359
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
268 (ancstart, ancstop), (descstart, descstop) = _splitrange(a, b)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
269
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
270 if ancstart is None and descstart is None:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
271 return baseset()
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
272
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
273 revs = getset(repo, fullreposet(repo), x)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
274 if not revs:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
275 return baseset()
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
276
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
277 if ancstart is not None and descstart is not None:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
278 s = dagop.revancestors(repo, revs, False, ancstart, ancstop)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
279 s += dagop.revdescendants(repo, revs, False, descstart, descstop)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
280 elif ancstart is not None:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
281 s = dagop.revancestors(repo, revs, False, ancstart, ancstop)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
282 elif descstart is not None:
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
283 s = dagop.revdescendants(repo, revs, False, descstart, descstop)
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
284
431cf2c8c839 revset: support ranges in #generations relation
Anton Shestakov <av6@dwimlabs.net>
parents: 41297
diff changeset
285 return subset & s
40931
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
286
33416
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
287 def relsubscriptset(repo, subset, x, y, z, order):
33417
d1b13d4995ed revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents: 33416
diff changeset
288 # this is pretty basic implementation of 'x#y[z]' operator, still
d1b13d4995ed revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents: 33416
diff changeset
289 # experimental so undocumented. see the wiki for further ideas.
d1b13d4995ed revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents: 33416
diff changeset
290 # https://www.mercurial-scm.org/wiki/RevsetOperatorPlan
d1b13d4995ed revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents: 33416
diff changeset
291 rel = getsymbol(y)
40931
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
292 if rel in subscriptrelations:
41563
13f7a6a4f0db revset: leverage getintrange() helper in relation-subscript operation (API)
Yuya Nishihara <yuya@tcha.org>
parents: 41562
diff changeset
293 return subscriptrelations[rel](repo, subset, x, rel, z, order)
33417
d1b13d4995ed revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents: 33416
diff changeset
294
40931
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
295 relnames = [r for r in subscriptrelations.keys() if len(r) > 1]
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
296 raise error.UnknownIdentifier(rel, relnames)
33416
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
297
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
298 def subscriptset(repo, subset, x, y, order):
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
299 raise error.ParseError(_("can't use a subscript in this context"))
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
300
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
301 def listset(repo, subset, *xs, **opts):
27517
c60a9c16ae25 revset: add hint for list error to use or
timeless <timeless@mozdev.org>
parents: 27440
diff changeset
302 raise error.ParseError(_("can't use a list in this context"),
38810
4fe8d1f077b8 help: add quotes to a few commands we point to
Martin von Zweigbergk <martinvonz@google.com>
parents: 38705
diff changeset
303 hint=_('see \'hg help "revsets.x or y"\''))
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
304
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
305 def keyvaluepair(repo, subset, k, v, order):
25704
70a2082f855a revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents: 25689
diff changeset
306 raise error.ParseError(_("can't use a key-value pair in this context"))
70a2082f855a revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents: 25689
diff changeset
307
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
308 def func(repo, subset, a, b, order):
29441
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly
Yuya Nishihara <yuya@tcha.org>
parents: 29425
diff changeset
309 f = getsymbol(a)
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly
Yuya Nishihara <yuya@tcha.org>
parents: 29425
diff changeset
310 if f in symbols:
30392
155d7ea98085 revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents: 30332
diff changeset
311 func = symbols[f]
155d7ea98085 revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents: 30332
diff changeset
312 if getattr(func, '_takeorder', False):
155d7ea98085 revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents: 30332
diff changeset
313 return func(repo, subset, b, order)
155d7ea98085 revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents: 30332
diff changeset
314 return func(repo, subset, b)
25632
015c0d1087a3 revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents: 25630
diff changeset
315
015c0d1087a3 revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents: 25630
diff changeset
316 keep = lambda fn: getattr(fn, '__doc__', None) is not None
015c0d1087a3 revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents: 25630
diff changeset
317
015c0d1087a3 revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents: 25630
diff changeset
318 syms = [s for (s, fn) in symbols.items() if keep(fn)]
29441
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly
Yuya Nishihara <yuya@tcha.org>
parents: 29425
diff changeset
319 raise error.UnknownIdentifier(f, syms)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
320
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
321 # functions
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
322
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
323 # symbols are callables like:
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
324 # fn(repo, subset, x)
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
325 # with:
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
326 # repo - current repository instance
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
327 # subset - of revisions to be examined
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
328 # x - argument in tree form
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
329 symbols = revsetlang.symbols
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
330
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
331 # symbols which can't be used for a DoS attack for any given input
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
332 # (e.g. those which accept regexes as plain strings shouldn't be included)
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
333 # functions that just return a lot of changesets (like all) don't count here
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
334 safesymbols = set()
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
335
28395
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28393
diff changeset
336 predicate = registrar.revsetpredicate()
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
337
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
338 @predicate('_destupdate')
26713
a271925699d6 revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26638
diff changeset
339 def _destupdate(repo, subset, x):
a271925699d6 revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26638
diff changeset
340 # experimental revset for update destination
30962
11c253997b0e destutil: drop now-unused "check" parameter from destupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents: 30881
diff changeset
341 args = getargsdict(x, 'limit', 'clean')
35367
6eee2bcc57c4 py3: handle keyword arguments correctly in revset.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 35330
diff changeset
342 return subset & baseset([destutil.destupdate(repo,
6eee2bcc57c4 py3: handle keyword arguments correctly in revset.py
Pulkit Goyal <7895pulkit@gmail.com>
parents: 35330
diff changeset
343 **pycompat.strkwargs(args))[0]])
26713
a271925699d6 revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26638
diff changeset
344
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
345 @predicate('_destmerge')
26716
c027641f8a83 revset: rename and test '_destmerge'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26714
diff changeset
346 def _destmerge(repo, subset, x):
c027641f8a83 revset: rename and test '_destmerge'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26714
diff changeset
347 # experimental revset for merge destination
28139
5476a7a039c0 destutil: allow to specify an explicit source for the merge
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 28015
diff changeset
348 sourceset = None
5476a7a039c0 destutil: allow to specify an explicit source for the merge
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 28015
diff changeset
349 if x is not None:
5476a7a039c0 destutil: allow to specify an explicit source for the merge
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 28015
diff changeset
350 sourceset = getset(repo, fullreposet(repo), x)
5476a7a039c0 destutil: allow to specify an explicit source for the merge
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 28015
diff changeset
351 return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])
26303
c99b4d6efdd8 merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26232
diff changeset
352
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
353 @predicate('adds(pattern)', safe=True, weight=30)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
354 def adds(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
355 """Changesets that add a file matching pattern.
20289
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
356
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
357 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
358 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
359 directory.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
360 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
361 # i18n: "adds" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
362 pat = getstring(x, _("adds requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
363 return checkstatus(repo, subset, pat, 1)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
364
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
365 @predicate('ancestor(*changeset)', safe=True, weight=0.5)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
366 def ancestor(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
367 """A greatest common ancestor of the changesets.
18536
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents: 18495
diff changeset
368
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents: 18495
diff changeset
369 Accepts 0 or more changesets.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents: 18495
diff changeset
370 Will return empty list when passed no args.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents: 18495
diff changeset
371 Greatest common ancestor of a single changeset is that changeset.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
372 """
38490
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
373 reviter = iter(orset(repo, fullreposet(repo), x, order=anyorder))
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
374 try:
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
375 anc = repo[next(reviter)]
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
376 except StopIteration:
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
377 return baseset()
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
378 for r in reviter:
5d88fd1bc2af revset: move lookup of first ancestor() candidate out of the loop
Yuya Nishihara <yuya@tcha.org>
parents: 38489
diff changeset
379 anc = anc.ancestor(repo[r])
20991
a05d694599f9 revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents: 20895
diff changeset
380
38522
54d7aaa243cc revset: add partial support for ancestor(wdir())
Yuya Nishihara <yuya@tcha.org>
parents: 38519
diff changeset
381 r = scmutil.intrev(anc)
54d7aaa243cc revset: add partial support for ancestor(wdir())
Yuya Nishihara <yuya@tcha.org>
parents: 38519
diff changeset
382 if r in subset:
54d7aaa243cc revset: add partial support for ancestor(wdir())
Yuya Nishihara <yuya@tcha.org>
parents: 38519
diff changeset
383 return baseset([r])
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
384 return baseset()
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
385
33003
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
386 def _ancestors(repo, subset, x, followfirst=False, startdepth=None,
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
387 stopdepth=None):
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
388 heads = getset(repo, fullreposet(repo), x)
22944
5aae3dea8044 revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents: 22891
diff changeset
389 if not heads:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
390 return baseset()
33003
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
391 s = dagop.revancestors(repo, heads, followfirst, startdepth, stopdepth)
23003
62d19ce9d7b6 revset-_ancestor: use & instead of filter
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22999
diff changeset
392 return subset & s
16409
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
393
33002
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
394 @predicate('ancestors(set[, depth])', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
395 def ancestors(repo, subset, x):
32905
2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594)
Yuya Nishihara <yuya@tcha.org>
parents: 32904
diff changeset
396 """Changesets that are ancestors of changesets in set, including the
2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594)
Yuya Nishihara <yuya@tcha.org>
parents: 32904
diff changeset
397 given changesets themselves.
33002
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
398
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
399 If depth is specified, the result only includes changesets up to
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
400 the specified generation.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
401 """
33003
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
402 # startdepth is for internal use only until we can decide the UI
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
403 args = getargsdict(x, 'ancestors', 'set depth startdepth')
32914
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants()
Yuya Nishihara <yuya@tcha.org>
parents: 32905
diff changeset
404 if 'set' not in args:
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants()
Yuya Nishihara <yuya@tcha.org>
parents: 32905
diff changeset
405 # i18n: "ancestors" is a keyword
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants()
Yuya Nishihara <yuya@tcha.org>
parents: 32905
diff changeset
406 raise error.ParseError(_('ancestors takes at least 1 argument'))
33003
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
407 startdepth = stopdepth = None
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
408 if 'startdepth' in args:
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
409 n = getinteger(args['startdepth'],
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
410 "ancestors expects an integer startdepth")
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
411 if n < 0:
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
412 raise error.ParseError("negative startdepth")
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
413 startdepth = n
33002
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
414 if 'depth' in args:
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
415 # i18n: "ancestors" is a keyword
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
416 n = getinteger(args['depth'], _("ancestors expects an integer depth"))
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
417 if n < 0:
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
418 raise error.ParseError(_("negative depth"))
272a44cac57e revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 32914
diff changeset
419 stopdepth = n + 1
33003
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
420 return _ancestors(repo, subset, args['set'],
f63d111258da revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents: 33002
diff changeset
421 startdepth=startdepth, stopdepth=stopdepth)
16409
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
422
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
423 @predicate('_firstancestors', safe=True)
16409
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
424 def _firstancestors(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
425 # ``_firstancestors(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
426 # Like ``ancestors(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
427 return _ancestors(repo, subset, x, followfirst=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
428
32699
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
429 def _childrenspec(repo, subset, x, n, order):
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
430 """Changesets that are the Nth child of a changeset
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
431 in set.
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
432 """
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
433 cs = set()
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
434 for r in getset(repo, fullreposet(repo), x):
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
435 for i in range(n):
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
436 c = repo[r].children()
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
437 if len(c) == 0:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
438 break
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
439 if len(c) > 1:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
440 raise error.RepoLookupError(
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
441 _("revision in set has more than one child"))
32885
8e02829bec61 revset: fix negative ancestor spec to not return changectx objects
Yuya Nishihara <yuya@tcha.org>
parents: 32819
diff changeset
442 r = c[0].rev()
32699
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
443 else:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
444 cs.add(r)
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
445 return subset & cs
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
446
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
447 def ancestorspec(repo, subset, x, n, order):
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
448 """``set~n``
16683
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16661
diff changeset
449 Changesets that are the Nth ancestor (first parents only) of a changeset
525fdb738975 cleanup: eradicate long lines
Brodie Rao <brodie@sf.io>
parents: 16661
diff changeset
450 in set.
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
451 """
30801
67ee7874e53b revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30800
diff changeset
452 n = getinteger(n, _("~ expects a number"))
32699
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
453 if n < 0:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
454 # children lookup
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents: 32684
diff changeset
455 return _childrenspec(repo, subset, x, -n, order)
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
456 ps = set()
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
457 cl = repo.changelog
23163
6f1b8b3f12fd revset-ancestorspec: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23162
diff changeset
458 for r in getset(repo, fullreposet(repo), x):
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
459 for i in range(n):
32441
018f638ad88e revset: add support for using ~ operator on wdir() predicate
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32440
diff changeset
460 try:
018f638ad88e revset: add support for using ~ operator on wdir() predicate
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32440
diff changeset
461 r = cl.parentrevs(r)[0]
018f638ad88e revset: add support for using ~ operator on wdir() predicate
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32440
diff changeset
462 except error.WdirUnsupported:
41397
0bd56c291359 cleanup: use p1() and p2() instead of parents()[0] and parents()[1]
Martin von Zweigbergk <martinvonz@google.com>
parents: 41388
diff changeset
463 r = repo[r].p1().rev()
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
464 ps.add(r)
22531
22ba2c0825da revset: use `subset &` in `ancestorspec`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22530
diff changeset
465 return subset & ps
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
466
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
467 @predicate('author(string)', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
468 def author(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
469 """Alias for ``user(string)``.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
470 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
471 # i18n: "author" is a keyword
30782
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
472 n = getstring(x, _("author requires a string"))
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
473 kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
474 return subset.filter(lambda x: matcher(repo[x].user()),
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
475 condrepr=('<user %r>', n))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
476
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
477 @predicate('bisect(string)', safe=True)
15134
81adf7777f8f revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15133
diff changeset
478 def bisect(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
479 """Changesets marked in the specified bisect status:
15136
18219c0789ae revset.bisect: add new 'range' set to the bisect keyword
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15135
diff changeset
480
15153
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15147
diff changeset
481 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
17424
e7cfe3587ea4 fix trivial spelling errors
Mads Kiilerich <mads@kiilerich.com>
parents: 17390
diff changeset
482 - ``goods``, ``bads`` : csets topologically good/bad
15153
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15147
diff changeset
483 - ``range`` : csets taking part in the bisection
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15147
diff changeset
484 - ``pruned`` : csets that are goods, bads or skipped
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15147
diff changeset
485 - ``untested`` : csets whose fate is yet unknown
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15147
diff changeset
486 - ``ignored`` : csets ignored due to DAG topology
16647
14913fcb30c6 bisect: track the current changeset (issue3382)
Bryan O'Sullivan <bryano@fb.com>
parents: 16640
diff changeset
487 - ``current`` : the cset currently being bisected
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
488 """
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
489 # i18n: "bisect" is a keyword
15135
f19de58af225 revset.bisect: move bisect() code to hbisect.py
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15134
diff changeset
490 status = getstring(x, _("bisect requires a string")).lower()
16467
7f59900e3f8b revset: fix O(n**2) behaviour of bisect() (issue3381)
Bryan O'Sullivan <bryano@fb.com>
parents: 16453
diff changeset
491 state = set(hbisect.get(repo, status))
22532
0cf46b8298fe revset: use `subset &` in `bisect`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22531
diff changeset
492 return subset & state
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
493
15134
81adf7777f8f revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15133
diff changeset
494 # Backward-compatibility
81adf7777f8f revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15133
diff changeset
495 # - no help entry so that we do not advertise it any more
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
496 @predicate('bisected', safe=True)
15134
81adf7777f8f revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15133
diff changeset
497 def bisected(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15133
diff changeset
498 return bisect(repo, subset, x)
81adf7777f8f revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents: 15133
diff changeset
499
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
500 @predicate('bookmark([name])', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
501 def bookmark(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
502 """The named bookmark or all bookmarks.
16822
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
503
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
504 Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
505 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
506 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
507 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
508 if args:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
509 bm = getstring(args[0],
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
510 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
511 _('the argument to bookmark must be a string'))
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
512 kind, pattern, matcher = stringutil.stringmatcher(bm)
22499
8c9f9e346acc revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22498
diff changeset
513 bms = set()
16822
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
514 if kind == 'literal':
39303
1eb370761fa0 revset: expand bookmark(.) to the active bookmark
Yuya Nishihara <yuya@tcha.org>
parents: 39274
diff changeset
515 if bm == pattern:
1eb370761fa0 revset: expand bookmark(.) to the active bookmark
Yuya Nishihara <yuya@tcha.org>
parents: 39274
diff changeset
516 pattern = repo._bookmarks.expandname(pattern)
22105
3efe3c2609e0 revset: bookmark revset interprets 'literal:' prefix correctly (issue4329)
Michael O'Connor <mkoconnor@gmail.com>
parents: 21939
diff changeset
517 bmrev = repo._bookmarks.get(pattern, None)
16822
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
518 if not bmrev:
23978
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 23956
diff changeset
519 raise error.RepoLookupError(_("bookmark '%s' does not exist")
26538
5c9ec1cc671a revset: strip off "literal:" prefix from bookmark not found error
Yuya Nishihara <yuya@tcha.org>
parents: 26537
diff changeset
520 % pattern)
22499
8c9f9e346acc revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22498
diff changeset
521 bms.add(repo[bmrev].rev())
16822
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
522 else:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
523 matchrevs = set()
18495
8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations
Kevin Bullock <kbullock@ringworld.org>
parents: 18473
diff changeset
524 for name, bmrev in repo._bookmarks.iteritems():
16822
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
525 if matcher(name):
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
526 matchrevs.add(bmrev)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents: 16821
diff changeset
527 for bmrev in matchrevs:
22499
8c9f9e346acc revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22498
diff changeset
528 bms.add(repo[bmrev].rev())
8c9f9e346acc revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22498
diff changeset
529 else:
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
530 bms = {repo[r].rev() for r in repo._bookmarks.values()}
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
531 bms -= {node.nullrev}
22530
faf4f63533ff revset: use `subset &` in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22529
diff changeset
532 return subset & bms
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
533
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
534 @predicate('branch(string or set)', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
535 def branch(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
536 """
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
537 All changesets belonging to the given branch or the branches of the given
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
538 changesets.
16821
0946502fd3d5 revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents: 16820
diff changeset
539
30784
5dd67f0993ce help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents: 30783
diff changeset
540 Pattern matching is supported for `string`. See
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
541 :hg:`help revisions.patterns`.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
542 """
24374
77fd1fb538cd revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents: 24366
diff changeset
543 getbi = repo.revbranchcache().branchinfo
32683
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
544 def getbranch(r):
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
545 try:
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
546 return getbi(r)[0]
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
547 except error.WdirUnsupported:
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
548 return repo[r].branch()
23787
678f53865c68 revset: use localrepo revbranchcache for branch name filtering
Mads Kiilerich <madski@unity3d.com>
parents: 23765
diff changeset
549
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
550 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
551 b = getstring(x, '')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
552 except error.ParseError:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
553 # not a string, but another revspec, e.g. tip()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
554 pass
16821
0946502fd3d5 revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents: 16820
diff changeset
555 else:
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
556 kind, pattern, matcher = stringutil.stringmatcher(b)
16821
0946502fd3d5 revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents: 16820
diff changeset
557 if kind == 'literal':
0946502fd3d5 revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents: 16820
diff changeset
558 # note: falls through to the revspec case if no branch with
26537
832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838)
Yuya Nishihara <yuya@tcha.org>
parents: 26481
diff changeset
559 # this name exists and pattern kind is not specified explicitly
42004
0bd730fbcc2b branchcache: introduce hasbranch()
Pulkit Goyal <pulkit@yandex-team.ru>
parents: 42002
diff changeset
560 if repo.branchmap().hasbranch(pattern):
32683
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
561 return subset.filter(lambda r: matcher(getbranch(r)),
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
562 condrepr=('<branch %r>', b))
26537
832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838)
Yuya Nishihara <yuya@tcha.org>
parents: 26481
diff changeset
563 if b.startswith('literal:'):
832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838)
Yuya Nishihara <yuya@tcha.org>
parents: 26481
diff changeset
564 raise error.RepoLookupError(_("branch '%s' does not exist")
832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838)
Yuya Nishihara <yuya@tcha.org>
parents: 26481
diff changeset
565 % pattern)
16821
0946502fd3d5 revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents: 16820
diff changeset
566 else:
32683
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
567 return subset.filter(lambda r: matcher(getbranch(r)),
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
568 condrepr=('<branch %r>', b))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
569
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
570 s = getset(repo, fullreposet(repo), x)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
571 b = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
572 for r in s:
32683
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
573 b.add(getbranch(r))
22867
5ee9b78ce805 revset-branch: remove usage of `set()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22866
diff changeset
574 c = s.__contains__
32683
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents: 32661
diff changeset
575 return subset.filter(lambda r: c(r) or getbranch(r) in b,
35904
fc44c2657dc5 py3: drop b'' from repr() of smartset
Yuya Nishihara <yuya@tcha.org>
parents: 35892
diff changeset
576 condrepr=lambda: '<branch %r>' % _sortedb(b))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
577
33776
ed99d3afef88 revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents: 33775
diff changeset
578 @predicate('phasedivergent()', safe=True)
ed99d3afef88 revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents: 33775
diff changeset
579 def phasedivergent(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
580 """Mutable changesets marked as successors of public changesets.
17829
c73f7a28953c revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17825
diff changeset
581
33776
ed99d3afef88 revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents: 33775
diff changeset
582 Only non-public and non-obsolete changesets can be `phasedivergent`.
33855
457d1ebf151b revset: mark evolution-related revsets as experimental
Boris Feld <boris.feld@octobus.net>
parents: 33779
diff changeset
583 (EXPERIMENTAL)
17829
c73f7a28953c revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17825
diff changeset
584 """
33776
ed99d3afef88 revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents: 33775
diff changeset
585 # i18n: "phasedivergent" is a keyword
ed99d3afef88 revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents: 33775
diff changeset
586 getargs(x, 0, 0, _("phasedivergent takes no arguments"))
33779
9fa874fb34e1 obsolete: rename bumped volatile set into phasedivergent volatile set
Boris Feld <boris.feld@octobus.net>
parents: 33778
diff changeset
587 phasedivergent = obsmod.getrevs(repo, 'phasedivergent')
9fa874fb34e1 obsolete: rename bumped volatile set into phasedivergent volatile set
Boris Feld <boris.feld@octobus.net>
parents: 33778
diff changeset
588 return subset & phasedivergent
17829
c73f7a28953c revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17825
diff changeset
589
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
590 @predicate('bundle()', safe=True)
17913
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
591 def bundle(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
592 """Changesets in the bundle.
17913
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
593
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
594 Bundle must be specified by the -R option."""
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
595
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
596 try:
18411
8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents: 18382
diff changeset
597 bundlerevs = repo.changelog.bundlerevs
17913
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
598 except AttributeError:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26571
diff changeset
599 raise error.Abort(_("no bundle provided - specify with -R"))
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
600 return subset & bundlerevs
17913
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents: 17886
diff changeset
601
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
602 def checkstatus(repo, subset, pat, field):
42104
4b86f4f199a9 revset: short docstring for checkstatus
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 42039
diff changeset
603 """Helper for status-related revsets (adds, removes, modifies).
4b86f4f199a9 revset: short docstring for checkstatus
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 42039
diff changeset
604 The field parameter says which kind is desired:
4b86f4f199a9 revset: short docstring for checkstatus
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 42039
diff changeset
605 0: modified
4b86f4f199a9 revset: short docstring for checkstatus
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 42039
diff changeset
606 1: added
4b86f4f199a9 revset: short docstring for checkstatus
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 42039
diff changeset
607 2: removed
4b86f4f199a9 revset: short docstring for checkstatus
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 42039
diff changeset
608 """
16521
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents: 16467
diff changeset
609 hasset = matchmod.patkind(pat) == 'set'
20457
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
610
23115
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
611 mcache = [None]
20457
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
612 def matches(x):
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
613 c = repo[x]
23115
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
614 if not mcache[0] or hasset:
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
615 mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
616 m = mcache[0]
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
617 fname = None
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
618 if not m.anypats() and len(m.files()) == 1:
c23c03605c59 revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents: 23100
diff changeset
619 fname = m.files()[0]
16521
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents: 16467
diff changeset
620 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents: 16467
diff changeset
621 if fname not in c.files():
20457
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
622 return False
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
623 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
624 for f in c.files():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
625 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
626 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
627 else:
20457
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
628 return False
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
629 files = repo.status(c.p1().node(), c.node())[field]
16521
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents: 16467
diff changeset
630 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents: 16467
diff changeset
631 if fname in files:
20457
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
632 return True
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
633 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
634 for f in files:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
635 if m(f):
20457
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
636 return True
ed7b674824a3 revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20456
diff changeset
637
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
638 return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
639
29406
c2193e59ef9f revsets: passing a set to baseset() is not wrong
Martin von Zweigbergk <martinvonz@google.com>
parents: 29389
diff changeset
640 def _children(repo, subset, parentset):
25550
3e9049876ace revset: gratuitous code move in '_children'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25549
diff changeset
641 if not parentset:
3e9049876ace revset: gratuitous code move in '_children'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25549
diff changeset
642 return baseset()
15899
476a981fdf34 revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents: 15898
diff changeset
643 cs = set()
476a981fdf34 revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents: 15898
diff changeset
644 pr = repo.changelog.parentrevs
25567
f140d6207cca revset: use parentsets.min in _children
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25566
diff changeset
645 minrev = parentset.min()
30699
5bda147c3139 revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents: 30392
diff changeset
646 nullrev = node.nullrev
29406
c2193e59ef9f revsets: passing a set to baseset() is not wrong
Martin von Zweigbergk <martinvonz@google.com>
parents: 29389
diff changeset
647 for r in subset:
18063
34a1a639d835 revset.children: ignore rev numbers that are too low
Siddharth Agarwal <sid0@fb.com>
parents: 17980
diff changeset
648 if r <= minrev:
34a1a639d835 revset.children: ignore rev numbers that are too low
Siddharth Agarwal <sid0@fb.com>
parents: 17980
diff changeset
649 continue
30699
5bda147c3139 revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents: 30392
diff changeset
650 p1, p2 = pr(r)
5bda147c3139 revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents: 30392
diff changeset
651 if p1 in parentset:
5bda147c3139 revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents: 30392
diff changeset
652 cs.add(r)
5bda147c3139 revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents: 30392
diff changeset
653 if p2 != nullrev and p2 in parentset:
5bda147c3139 revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents: 30392
diff changeset
654 cs.add(r)
20709
71df845d86cf revsets: backout d04aac468bf4 due to performance regressions
Matt Mackall <mpm@selenic.com>
parents: 20708
diff changeset
655 return baseset(cs)
15899
476a981fdf34 revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents: 15898
diff changeset
656
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
657 @predicate('children(set)', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
658 def children(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
659 """Child changesets of changesets in set.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
660 """
23164
7a42e5d4c418 revset-children: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23163
diff changeset
661 s = getset(repo, fullreposet(repo), x)
15899
476a981fdf34 revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents: 15898
diff changeset
662 cs = _children(repo, subset, s)
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
663 return subset & cs
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
664
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
665 @predicate('closed()', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
666 def closed(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
667 """Changeset is closed.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
668 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
669 # i18n: "closed" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
670 getargs(x, 0, 0, _("closed takes no arguments"))
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
671 return subset.filter(lambda r: repo[r].closesbranch(),
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
672 condrepr='<branch closed>')
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
673
38625
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
674 # for internal use
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
675 @predicate('_commonancestorheads(set)', safe=True)
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
676 def _commonancestorheads(repo, subset, x):
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
677 # This is an internal method is for quickly calculating "heads(::x and
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
678 # ::y)"
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
679
39805
823f34acfd46 revset: make heads(commonancestors(x + x^)) be x^, not x
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 39803
diff changeset
680 # These greatest common ancestors are the same ones that the consensus bid
38625
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
681 # merge will find.
39805
823f34acfd46 revset: make heads(commonancestors(x + x^)) be x^, not x
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 39803
diff changeset
682 startrevs = getset(repo, fullreposet(repo), x, order=anyorder)
38625
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
683
39805
823f34acfd46 revset: make heads(commonancestors(x + x^)) be x^, not x
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 39803
diff changeset
684 ancs = repo.changelog._commonancestorsheads(*list(startrevs))
38625
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
685 return subset & baseset(ancs)
52f19a840543 revset: add optimization for heads(commonancestors())
Sean Farley <sean@farley.io>
parents: 38624
diff changeset
686
38624
5460926352ee revsets: add commonancestors revset
Sean Farley <sean@farley.io>
parents: 38588
diff changeset
687 @predicate('commonancestors(set)', safe=True)
5460926352ee revsets: add commonancestors revset
Sean Farley <sean@farley.io>
parents: 38588
diff changeset
688 def commonancestors(repo, subset, x):
39803
0561e69ed9f1 revset: reword commonancestor()'s help
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 39802
diff changeset
689 """Changesets that are ancestors of every changeset in set.
38624
5460926352ee revsets: add commonancestors revset
Sean Farley <sean@farley.io>
parents: 38588
diff changeset
690 """
39801
cb5134f2318a revset: make commonancestors(x + x^) be ::(x^), not ::x
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 38705
diff changeset
691 startrevs = getset(repo, fullreposet(repo), x, order=anyorder)
cb5134f2318a revset: make commonancestors(x + x^) be ::(x^), not ::x
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 38705
diff changeset
692 if not startrevs:
38705
e4b270a32ba8 revset: special case commonancestors(none()) to be empty set
Yuya Nishihara <yuya@tcha.org>
parents: 38704
diff changeset
693 return baseset()
39801
cb5134f2318a revset: make commonancestors(x + x^) be ::(x^), not ::x
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents: 38705
diff changeset
694 for r in startrevs:
38624
5460926352ee revsets: add commonancestors revset
Sean Farley <sean@farley.io>
parents: 38588
diff changeset
695 subset &= dagop.revancestors(repo, baseset([r]))
5460926352ee revsets: add commonancestors revset
Sean Farley <sean@farley.io>
parents: 38588
diff changeset
696 return subset
5460926352ee revsets: add commonancestors revset
Sean Farley <sean@farley.io>
parents: 38588
diff changeset
697
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
698 @predicate('contains(pattern)', weight=100)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
699 def contains(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
700 """The revision's manifest contains a file matching pattern (but might not
21199
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents: 21173
diff changeset
701 modify it). See :hg:`help patterns` for information about file patterns.
20289
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
702
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
703 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
704 relative to the current directory and match against a file exactly
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
705 for efficiency.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
706 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
707 # i18n: "contains" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
708 pat = getstring(x, _("contains requires a pattern"))
20461
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
709
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
710 def matches(x):
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
711 if not matchmod.patkind(pat):
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
712 pats = pathutil.canonpath(repo.root, repo.getcwd(), pat)
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
713 if pats in repo[x]:
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
714 return True
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
715 else:
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
716 c = repo[x]
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
717 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
15964
6e37b8282aa2 revsets: provide contexts for filesets
Matt Mackall <mpm@selenic.com>
parents: 15949
diff changeset
718 for f in c.manifest():
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
719 if m(f):
20461
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
720 return True
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
721 return False
abd8e56a1038 revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20460
diff changeset
722
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
723 return subset.filter(matches, condrepr=('<contains %r>', pat))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
724
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
725 @predicate('converted([id])', safe=True)
17002
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
726 def converted(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
727 """Changesets converted from the given identifier in the old repository if
17002
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
728 present, or all converted changesets if no identifier is specified.
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
729 """
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
730
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
731 # There is exactly no chance of resolving the revision, so do a simple
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
732 # string compare and hope for the best
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
733
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
734 rev = None
17002
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
735 # i18n: "converted" is a keyword
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
736 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
737 if l:
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
738 # i18n: "converted" is a keyword
17002
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
739 rev = getstring(l[0], _('converted requires a revision'))
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
740
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
741 def _matchvalue(r):
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
742 source = repo[r].extra().get('convert_revision', None)
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
743 return source is not None and (rev is None or source.startswith(rev))
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
744
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
745 return subset.filter(lambda r: _matchvalue(r),
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
746 condrepr=('<converted %r>', rev))
17002
0eb522625eb2 revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents: 16862
diff changeset
747
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
748 @predicate('date(interval)', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
749 def date(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
750 """Changesets within the interval, see :hg:`help dates`.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
751 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
752 # i18n: "date" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
753 ds = getstring(x, _("date requires a string"))
36607
c6061cadb400 util: extract all date-related utils in utils/dateutil module
Boris Feld <boris.feld@octobus.net>
parents: 36581
diff changeset
754 dm = dateutil.matchdate(ds)
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
755 return subset.filter(lambda x: dm(repo[x].date()[0]),
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
756 condrepr=('<date %r>', ds))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
757
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
758 @predicate('desc(string)', safe=True, weight=10)
14650
93731b3efd0d revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents: 14649
diff changeset
759 def desc(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
760 """Search commit message for string. The match is case-insensitive.
30783
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
761
30784
5dd67f0993ce help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents: 30783
diff changeset
762 Pattern matching is supported for `string`. See
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
763 :hg:`help revisions.patterns`.
14650
93731b3efd0d revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents: 14649
diff changeset
764 """
93731b3efd0d revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents: 14649
diff changeset
765 # i18n: "desc" is a keyword
30783
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
766 ds = getstring(x, _("desc requires a string"))
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
767
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
768 kind, pattern, matcher = _substringmatcher(ds, casesensitive=False)
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
769
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
770 return subset.filter(lambda r: matcher(repo[r].description()),
931a60880df4 revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30782
diff changeset
771 condrepr=('<desc %r>', ds))
14650
93731b3efd0d revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents: 14649
diff changeset
772
33080
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
773 def _descendants(repo, subset, x, followfirst=False, startdepth=None,
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
774 stopdepth=None):
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
775 roots = getset(repo, fullreposet(repo), x)
22944
5aae3dea8044 revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents: 22891
diff changeset
776 if not roots:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
777 return baseset()
33080
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
778 s = dagop.revdescendants(repo, roots, followfirst, startdepth, stopdepth)
33075
d83b189aef83 dagop: change revdescendants() to include all root revisions
Yuya Nishihara <yuya@tcha.org>
parents: 33003
diff changeset
779 return subset & s
16409
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
780
33080
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
781 @predicate('descendants(set[, depth])', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
782 def descendants(repo, subset, x):
32905
2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594)
Yuya Nishihara <yuya@tcha.org>
parents: 32904
diff changeset
783 """Changesets which are descendants of changesets in set, including the
2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594)
Yuya Nishihara <yuya@tcha.org>
parents: 32904
diff changeset
784 given changesets themselves.
33080
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
785
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
786 If depth is specified, the result only includes changesets up to
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
787 the specified generation.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
788 """
33080
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
789 # startdepth is for internal use only until we can decide the UI
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
790 args = getargsdict(x, 'descendants', 'set depth startdepth')
32914
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants()
Yuya Nishihara <yuya@tcha.org>
parents: 32905
diff changeset
791 if 'set' not in args:
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants()
Yuya Nishihara <yuya@tcha.org>
parents: 32905
diff changeset
792 # i18n: "descendants" is a keyword
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants()
Yuya Nishihara <yuya@tcha.org>
parents: 32905
diff changeset
793 raise error.ParseError(_('descendants takes at least 1 argument'))
33080
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
794 startdepth = stopdepth = None
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
795 if 'startdepth' in args:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
796 n = getinteger(args['startdepth'],
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
797 "descendants expects an integer startdepth")
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
798 if n < 0:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
799 raise error.ParseError("negative startdepth")
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
800 startdepth = n
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
801 if 'depth' in args:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
802 # i18n: "descendants" is a keyword
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
803 n = getinteger(args['depth'], _("descendants expects an integer depth"))
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
804 if n < 0:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
805 raise error.ParseError(_("negative depth"))
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
806 stopdepth = n + 1
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
807 return _descendants(repo, subset, args['set'],
a53bfc2845f2 revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents: 33075
diff changeset
808 startdepth=startdepth, stopdepth=stopdepth)
16409
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
809
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
810 @predicate('_firstdescendants', safe=True)
16409
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
811 def _firstdescendants(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
812 # ``_firstdescendants(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
813 # Like ``descendants(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents: 16402
diff changeset
814 return _descendants(repo, subset, x, followfirst=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
815
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
816 @predicate('destination([set])', safe=True, weight=10)
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
817 def destination(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
818 """Changesets that were created by a graft, transplant or rebase operation,
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
819 with the given revisions specified as the source. Omitting the optional set
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
820 is the same as passing all().
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
821 """
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
822 if x is not None:
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
823 sources = getset(repo, fullreposet(repo), x)
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
824 else:
24201
77ef059b3317 revset: drop unnecessary calls of getall() with empty argument
Yuya Nishihara <yuya@tcha.org>
parents: 24163
diff changeset
825 sources = fullreposet(repo)
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
826
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
827 dests = set()
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
828
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
829 # subset contains all of the possible destinations that can be returned, so
22944
5aae3dea8044 revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents: 22891
diff changeset
830 # iterate over them and see if their source(s) were provided in the arg set.
5aae3dea8044 revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents: 22891
diff changeset
831 # Even if the immediate src of r is not in the arg set, src's source (or
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
832 # further back) may be. Scanning back further than the immediate src allows
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
833 # transitive transplants and rebases to yield the same results as transitive
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
834 # grafts.
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
835 for r in subset:
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
836 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
837 lineage = None
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
838
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
839 while src is not None:
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
840 if lineage is None:
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
841 lineage = list()
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
842
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
843 lineage.append(r)
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
844
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
845 # The visited lineage is a match if the current source is in the arg
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
846 # set. Since every candidate dest is visited by way of iterating
17494
74801685aaa2 spelling: further
timeless@mozdev.org
parents: 17291
diff changeset
847 # subset, any dests further back in the lineage will be tested by a
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
848 # different iteration over subset. Likewise, if the src was already
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
849 # selected, the current lineage can be selected without going back
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
850 # further.
22944
5aae3dea8044 revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents: 22891
diff changeset
851 if src in sources or src in dests:
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
852 dests.update(lineage)
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
853 break
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
854
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
855 r = src
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
856 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
857
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
858 return subset.filter(dests.__contains__,
35904
fc44c2657dc5 py3: drop b'' from repr() of smartset
Yuya Nishihara <yuya@tcha.org>
parents: 35892
diff changeset
859 condrepr=lambda: '<destination %r>' % _sortedb(dests))
17186
a3da6f298592 revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17185
diff changeset
860
33775
f078d7358e90 revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents: 33774
diff changeset
861 @predicate('contentdivergent()', safe=True)
f078d7358e90 revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents: 33774
diff changeset
862 def contentdivergent(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
863 """
33855
457d1ebf151b revset: mark evolution-related revsets as experimental
Boris Feld <boris.feld@octobus.net>
parents: 33779
diff changeset
864 Final successors of changesets with an alternative set of final
457d1ebf151b revset: mark evolution-related revsets as experimental
Boris Feld <boris.feld@octobus.net>
parents: 33779
diff changeset
865 successors. (EXPERIMENTAL)
18071
bea754715961 obsolete: add revset and test for divergent changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18063
diff changeset
866 """
33775
f078d7358e90 revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents: 33774
diff changeset
867 # i18n: "contentdivergent" is a keyword
f078d7358e90 revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents: 33774
diff changeset
868 getargs(x, 0, 0, _("contentdivergent takes no arguments"))
33778
f3f06c260e9e obsolete: rename divergent volatile set into contentdivergent volatile set
Boris Feld <boris.feld@octobus.net>
parents: 33777
diff changeset
869 contentdivergent = obsmod.getrevs(repo, 'contentdivergent')
f3f06c260e9e obsolete: rename divergent volatile set into contentdivergent volatile set
Boris Feld <boris.feld@octobus.net>
parents: 33777
diff changeset
870 return subset & contentdivergent
18071
bea754715961 obsolete: add revset and test for divergent changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18063
diff changeset
871
41680
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
872 @predicate('expectsize(set[, size])', safe=True, takeorder=True)
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
873 def expectsize(repo, subset, x, order):
41698
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
874 """Return the given revset if size matches the revset size.
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
875 Abort if the revset doesn't expect given size.
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
876 size can either be an integer range or an integer.
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
877
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
878 For example, ``expectsize(0:1, 3:5)`` will abort as revset size is 2 and
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
879 2 is not between 3 and 5 inclusive."""
5fe4de392edb revset: improve documentation on expectsize()
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41680
diff changeset
880
41680
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
881 args = getargsdict(x, 'expectsize', 'set size')
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
882 minsize = 0
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
883 maxsize = len(repo) + 1
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
884 err = ''
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
885 if 'size' not in args or 'set' not in args:
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
886 raise error.ParseError(_('invalid set of arguments'))
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
887 minsize, maxsize = getintrange(args['size'],
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
888 _('expectsize requires a size range'
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
889 ' or a positive integer'),
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
890 _('size range bounds must be integers'),
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
891 minsize, maxsize)
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
892 if minsize < 0 or maxsize < 0:
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
893 raise error.ParseError(_('negative size'))
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
894 rev = getset(repo, fullreposet(repo), args['set'], order=order)
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
895 if minsize != maxsize and (len(rev) < minsize or len(rev) > maxsize):
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
896 err = _('revset size mismatch.'
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
897 ' expected between %d and %d, got %d') % (minsize, maxsize,
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
898 len(rev))
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
899 elif minsize == maxsize and len(rev) != minsize:
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
900 err = _('revset size mismatch.'
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
901 ' expected %d, got %d') % (minsize, len(rev))
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
902 if err:
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
903 raise error.RepoLookupError(err)
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
904 if order == followorder:
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
905 return subset & rev
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
906 else:
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
907 return rev & subset
8185c8abce87 revset: add expectsize to check the size of a set
Navaneeth Suresh <navaneeths1998@gmail.com>
parents: 41676
diff changeset
908
34457
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
909 @predicate('extdata(source)', safe=False, weight=100)
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
910 def extdata(repo, subset, x):
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
911 """Changesets in the specified extdata source. (EXPERIMENTAL)"""
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
912 # i18n: "extdata" is a keyword
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
913 args = getargsdict(x, 'extdata', 'source')
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
914 source = getstring(args.get('source'),
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
915 # i18n: "extdata" is a keyword
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
916 _('extdata takes at least 1 string argument'))
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
917 data = scmutil.extdatasource(repo, source)
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
918 return subset & baseset(data)
2c3b8fa3211b revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents: 34273
diff changeset
919
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
920 @predicate('extinct()', safe=True)
17173
c621f84dbb35 obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17171
diff changeset
921 def extinct(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
922 """Obsolete changesets with obsolete descendants only.
17291
2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets
Patrick Mezard <patrick@mezard.eu>
parents: 17272
diff changeset
923 """
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
924 # i18n: "extinct" is a keyword
17258
5822345e9e46 revset: use appropriate predicate name in error messages
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17244
diff changeset
925 getargs(x, 0, 0, _("extinct takes no arguments"))
17825
3cc06457f15e obsolete: rename `getobscache` into `getrevs`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17804
diff changeset
926 extincts = obsmod.getrevs(repo, 'extinct')
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
927 return subset & extincts
17173
c621f84dbb35 obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17171
diff changeset
928
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
929 @predicate('extra(label, [value])', safe=True)
16661
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
930 def extra(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
931 """Changesets with the given label in the extra metadata, with the given
16824
f3b8c82a559c revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents: 16823
diff changeset
932 optional value.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents: 16823
diff changeset
933
30784
5dd67f0993ce help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents: 30783
diff changeset
934 Pattern matching is supported for `value`. See
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
935 :hg:`help revisions.patterns`.
16824
f3b8c82a559c revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents: 16823
diff changeset
936 """
25767
026105c442d7 revset: rename getkwargs() to getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 25766
diff changeset
937 args = getargsdict(x, 'extra', 'label value')
25706
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
938 if 'label' not in args:
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
939 # i18n: "extra" is a keyword
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
940 raise error.ParseError(_('extra takes at least 1 argument'))
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
941 # i18n: "extra" is a keyword
25706
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
942 label = getstring(args['label'], _('first argument to extra must be '
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
943 'a string'))
16661
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
944 value = None
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
945
25706
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
946 if 'value' in args:
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
947 # i18n: "extra" is a keyword
25706
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
948 value = getstring(args['value'], _('second argument to extra must be '
b7f53c474e2c revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 25705
diff changeset
949 'a string'))
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
950 kind, value, matcher = stringutil.stringmatcher(value)
16661
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
951
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
952 def _matchvalue(r):
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
953 extra = repo[r].extra()
16824
f3b8c82a559c revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents: 16823
diff changeset
954 return label in extra and (value is None or matcher(extra[label]))
16661
de4b42daf396 revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents: 16657
diff changeset
955
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
956 return subset.filter(lambda r: _matchvalue(r),
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
957 condrepr=('<extra[%r] %r>', label, value))
15819
33ca11b010e2 phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15791
diff changeset
958
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
959 @predicate('filelog(pattern)', safe=True)
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
960 def filelog(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
961 """Changesets connected to the specified filelog.
17244
483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()'
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17186
diff changeset
962
21199
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents: 21173
diff changeset
963 For performance reasons, visits only revisions mentioned in the file-level
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents: 21173
diff changeset
964 filelog, rather than filtering through all changesets (much faster, but
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents: 21173
diff changeset
965 doesn't include deletes or duplicate changes). For a slower, more accurate
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents: 21173
diff changeset
966 result, use ``file()``.
20289
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
967
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
968 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
969 relative to the current directory and match against a file exactly
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
970 for efficiency.
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
971 """
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
972
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
973 # i18n: "filelog" is a keyword
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
974 pat = getstring(x, _("filelog requires a pattern"))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
975 s = set()
23719
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
976 cl = repo.changelog
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
977
15964
6e37b8282aa2 revsets: provide contexts for filesets
Matt Mackall <mpm@selenic.com>
parents: 15949
diff changeset
978 if not matchmod.patkind(pat):
20288
b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20287
diff changeset
979 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
23719
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
980 files = [f]
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
981 else:
20288
b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20287
diff changeset
982 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
23719
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
983 files = (f for f in repo[None] if m(f))
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
984
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
985 for f in files:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
986 fl = repo.file(f)
27945
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
987 known = {}
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
988 scanpos = 0
23719
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23704
diff changeset
989 for fr in list(fl):
27945
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
990 fn = fl.node(fr)
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
991 if fn in known:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
992 s.add(known[fn])
23821
7a7f437ab63d filelog: remove trailing "form feed" character
Martin von Zweigbergk <martinvonz@google.com>
parents: 23820
diff changeset
993 continue
27945
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
994
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
995 lr = fl.linkrev(fr)
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
996 if lr in cl:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
997 s.add(lr)
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
998 elif scanpos is not None:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
999 # lowest matching changeset is filtered, scan further
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1000 # ahead in changelog
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1001 start = max(lr, scanpos) + 1
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1002 scanpos = None
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1003 for r in cl.revs(start):
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1004 # minimize parsing of non-matching entries
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1005 if f in cl.revision(r) and f in cl.readfiles(r):
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1006 try:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1007 # try to use manifest delta fastpath
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1008 n = repo[r].filenode(f)
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1009 if n not in known:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1010 if n == fn:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1011 s.add(r)
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1012 scanpos = r
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1013 break
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1014 else:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1015 known[n] = r
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1016 except error.ManifestLookupError:
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1017 # deletion in changelog
4186d359046a log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents: 27637
diff changeset
1018 continue
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
1019
22534
6261b9c549a2 revset: use `subset &` in `filelog`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22533
diff changeset
1020 return subset & s
14342
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents: 14318
diff changeset
1021
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1022 @predicate('first(set, [n])', safe=True, takeorder=True, weight=0)
32801
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1023 def first(repo, subset, x, order):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1024 """An alias for limit().
15117
0ab1c3a1f3b2 revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents: 15116
diff changeset
1025 """
32801
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1026 return limit(repo, subset, x, order)
15117
0ab1c3a1f3b2 revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents: 15116
diff changeset
1027
16185
352053e6cd8e context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents: 16181
diff changeset
1028 def _follow(repo, subset, x, name, followfirst=False):
35299
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1029 args = getargsdict(x, name, 'file startrev')
35300
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1030 revs = None
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1031 if 'startrev' in args:
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1032 revs = getset(repo, fullreposet(repo), args['startrev'])
35299
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1033 if 'file' in args:
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1034 x = getstring(args['file'], _("%s expected a pattern") % name)
35300
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1035 if revs is None:
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1036 revs = [None]
35298
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1037 fctxs = []
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1038 for r in revs:
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1039 ctx = mctx = repo[r]
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1040 if r is None:
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1041 ctx = repo['.']
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1042 m = matchmod.match(repo.root, repo.getcwd(), [x],
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1043 ctx=mctx, default='path')
921680c3e2ea revset: make follow() accept multiple startrevs
Yuya Nishihara <yuya@tcha.org>
parents: 35296
diff changeset
1044 fctxs.extend(ctx[f].introfilectx() for f in ctx.manifest().walk(m))
35296
2cb05e6043be dagop: add smartset interface to filectxancestors()
Yuya Nishihara <yuya@tcha.org>
parents: 35276
diff changeset
1045 s = dagop.filerevancestors(fctxs, followfirst)
16185
352053e6cd8e context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents: 16181
diff changeset
1046 else:
35300
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1047 if revs is None:
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1048 revs = baseset([repo['.'].rev()])
d36eda8896cc revset: alias follow(startrev=rev) to ancestors(rev)
Yuya Nishihara <yuya@tcha.org>
parents: 35299
diff changeset
1049 s = dagop.revancestors(repo, revs, followfirst)
16185
352053e6cd8e context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents: 16181
diff changeset
1050
22535
44f471102f3a revset: use `subset &` in `follow`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22534
diff changeset
1051 return subset & s
16185
352053e6cd8e context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents: 16181
diff changeset
1052
35299
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1053 @predicate('follow([file[, startrev]])', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1054 def follow(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1055 """
24366
e8ea31131705 revset: replace "working copy" with "working directory" in function help
Yuya Nishihara <yuya@tcha.org>
parents: 24306
diff changeset
1056 An alias for ``::.`` (ancestors of the working directory's first parent).
35299
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1057 If file pattern is specified, the histories of files matching given
29814
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
G?bor Stefanik <gabor.stefanik@nng.com>
parents: 29780
diff changeset
1058 pattern in the revision given by startrev are followed, including copies.
14343
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies
Matt Mackall <mpm@selenic.com>
parents: 14342
diff changeset
1059 """
16185
352053e6cd8e context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents: 16181
diff changeset
1060 return _follow(repo, subset, x, 'follow')
14343
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies
Matt Mackall <mpm@selenic.com>
parents: 14342
diff changeset
1061
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1062 @predicate('_followfirst', safe=True)
16174
0a73c4bd9f47 graphlog: implement --follow-first
Patrick Mezard <patrick@mezard.eu>
parents: 16161
diff changeset
1063 def _followfirst(repo, subset, x):
35299
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1064 # ``followfirst([file[, startrev]])``
89b5c2ae1980 revset: make follow() accept keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 35298
diff changeset
1065 # Like ``follow([file[, startrev]])`` but follows only the first parent
29814
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
G?bor Stefanik <gabor.stefanik@nng.com>
parents: 29780
diff changeset
1066 # of every revisions or files revisions.
16185
352053e6cd8e context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents: 16181
diff changeset
1067 return _follow(repo, subset, x, '_followfirst', followfirst=True)
14343
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies
Matt Mackall <mpm@selenic.com>
parents: 14342
diff changeset
1068
31938
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1069 @predicate('followlines(file, fromline:toline[, startrev=., descend=False])',
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1070 safe=True)
30719
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1071 def followlines(repo, subset, x):
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1072 """Changesets modifying `file` in line range ('fromline', 'toline').
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1073
30800
cd23879cbac7 revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents: 30799
diff changeset
1074 Line range corresponds to 'file' content at 'startrev' and should hence be
cd23879cbac7 revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents: 30799
diff changeset
1075 consistent with file size. If startrev is not specified, working directory's
30719
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1076 parent is used.
31938
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1077
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1078 By default, ancestors of 'startrev' are returned. If 'descend' is True,
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1079 descendants of 'startrev' are returned though renames are (currently) not
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1080 followed in this direction.
30719
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1081 """
31938
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1082 args = getargsdict(x, 'followlines', 'file *lines startrev descend')
30804
4227f80f72b2 revset: abuse x:y syntax to specify line range of followlines()
Yuya Nishihara <yuya@tcha.org>
parents: 30803
diff changeset
1083 if len(args['lines']) != 1:
4227f80f72b2 revset: abuse x:y syntax to specify line range of followlines()
Yuya Nishihara <yuya@tcha.org>
parents: 30803
diff changeset
1084 raise error.ParseError(_("followlines requires a line range"))
30719
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1085
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1086 rev = '.'
30800
cd23879cbac7 revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents: 30799
diff changeset
1087 if 'startrev' in args:
cd23879cbac7 revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents: 30799
diff changeset
1088 revs = getset(repo, fullreposet(repo), args['startrev'])
30754
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 30753
diff changeset
1089 if len(revs) != 1:
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 30753
diff changeset
1090 raise error.ParseError(
32085
2a2744dffecf revset: add i18n comments to error messages for followlines predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 31998
diff changeset
1091 # i18n: "followlines" is a keyword
30754
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 30753
diff changeset
1092 _("followlines expects exactly one revision"))
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 30753
diff changeset
1093 rev = revs.last()
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 30753
diff changeset
1094
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents: 30753
diff changeset
1095 pat = getstring(args['file'], _("followlines requires a pattern"))
34854
39b094e4ae2c revset: extract a parsefollowlinespattern helper function
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 34457
diff changeset
1096 # i18n: "followlines" is a keyword
39b094e4ae2c revset: extract a parsefollowlinespattern helper function
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 34457
diff changeset
1097 msg = _("followlines expects exactly one file")
39b094e4ae2c revset: extract a parsefollowlinespattern helper function
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 34457
diff changeset
1098 fname = scmutil.parsefollowlinespattern(repo, rev, pat, msg)
41561
59638c6fcb70 revset: extract a helper to parse integer range
Yuya Nishihara <yuya@tcha.org>
parents: 41397
diff changeset
1099 fromline, toline = util.processlinerange(
59638c6fcb70 revset: extract a helper to parse integer range
Yuya Nishihara <yuya@tcha.org>
parents: 41397
diff changeset
1100 *getintrange(args['lines'][0],
59638c6fcb70 revset: extract a helper to parse integer range
Yuya Nishihara <yuya@tcha.org>
parents: 41397
diff changeset
1101 # i18n: "followlines" is a keyword
41562
1c04894e8fe1 revset: allow to parse single integer as a range
Yuya Nishihara <yuya@tcha.org>
parents: 41561
diff changeset
1102 _("followlines expects a line number or a range"),
41561
59638c6fcb70 revset: extract a helper to parse integer range
Yuya Nishihara <yuya@tcha.org>
parents: 41397
diff changeset
1103 _("line range bounds must be integers")))
30719
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1104
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1105 fctx = repo[rev].filectx(fname)
31998
83527d9f1f13 revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents: 31938
diff changeset
1106 descend = False
83527d9f1f13 revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents: 31938
diff changeset
1107 if 'descend' in args:
83527d9f1f13 revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents: 31938
diff changeset
1108 descend = getboolean(args['descend'],
32085
2a2744dffecf revset: add i18n comments to error messages for followlines predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 31998
diff changeset
1109 # i18n: "descend" is a keyword
2a2744dffecf revset: add i18n comments to error messages for followlines predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 31998
diff changeset
1110 _("descend argument must be a boolean"))
31998
83527d9f1f13 revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents: 31938
diff changeset
1111 if descend:
31938
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1112 rs = generatorset(
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1113 (c.rev() for c, _linerange
32904
582080a4a812 dagop: move blockancestors() and blockdescendants() from context
Yuya Nishihara <yuya@tcha.org>
parents: 32903
diff changeset
1114 in dagop.blockdescendants(fctx, fromline, toline)),
31938
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1115 iterasc=True)
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1116 else:
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1117 rs = generatorset(
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1118 (c.rev() for c, _linerange
32904
582080a4a812 dagop: move blockancestors() and blockdescendants() from context
Yuya Nishihara <yuya@tcha.org>
parents: 32903
diff changeset
1119 in dagop.blockancestors(fctx, fromline, toline)),
31938
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1120 iterasc=False)
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 31810
diff changeset
1121 return subset & rs
30719
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents: 30702
diff changeset
1122
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1123 @predicate('all()', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1124 def getall(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1125 """All changesets, the same as ``0:tip``.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1126 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1127 # i18n: "all" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1128 getargs(x, 0, 0, _("all takes no arguments"))
24202
2de9ee016425 revset: have all() filter out null revision
Yuya Nishihara <yuya@tcha.org>
parents: 24201
diff changeset
1129 return subset & spanset(repo) # drop "null" if any
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1130
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1131 @predicate('grep(regex)', weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1132 def grep(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1133 """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
14357
cb4ff8ef466b merge with stable
Martin Geisler <mg@aragost.com>
parents: 14343 14356
diff changeset
1134 to ensure special escape characters are handled correctly. Unlike
cb4ff8ef466b merge with stable
Martin Geisler <mg@aragost.com>
parents: 14343 14356
diff changeset
1135 ``keyword(string)``, the match is case-sensitive.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1136 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1137 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1138 # i18n: "grep" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1139 gr = re.compile(getstring(x, _("grep requires a string")))
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25654
diff changeset
1140 except re.error as e:
36580
04e50037d957 revset: use {force,}bytestr to fix some %r formatting issues
Augie Fackler <augie@google.com>
parents: 35914
diff changeset
1141 raise error.ParseError(
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
1142 _('invalid match pattern: %s') % stringutil.forcebytestr(e))
20453
6aa7dcae6bd8 revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20452
diff changeset
1143
6aa7dcae6bd8 revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20452
diff changeset
1144 def matches(x):
6aa7dcae6bd8 revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20452
diff changeset
1145 c = repo[x]
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1146 for e in c.files() + [c.user(), c.description()]:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1147 if gr.search(e):
20453
6aa7dcae6bd8 revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20452
diff changeset
1148 return True
6aa7dcae6bd8 revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20452
diff changeset
1149 return False
6aa7dcae6bd8 revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20452
diff changeset
1150
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1151 return subset.filter(matches, condrepr=('<grep %r>', gr.pattern))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1152
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1153 @predicate('_matchfiles', safe=True)
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1154 def _matchfiles(repo, subset, x):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1155 # _matchfiles takes a revset list of prefixed arguments:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1156 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1157 # [p:foo, i:bar, x:baz]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1158 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1159 # builds a match object from them and filters subset. Allowed
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1160 # prefixes are 'p:' for regular patterns, 'i:' for include
16181
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents: 16174
diff changeset
1161 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents: 16174
diff changeset
1162 # a revision identifier, or the empty string to reference the
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents: 16174
diff changeset
1163 # working directory, from which the match object is
16411
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1164 # initialized. Use 'd:' to set the default matching mode, default
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1165 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1166
28271
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1167 l = getargs(x, 1, -1, "_matchfiles requires at least one argument")
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1168 pats, inc, exc = [], [], []
16411
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1169 rev, default = None, None
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1170 for arg in l:
28271
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1171 s = getstring(arg, "_matchfiles requires string arguments")
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1172 prefix, value = s[:2], s[2:]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1173 if prefix == 'p:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1174 pats.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1175 elif prefix == 'i:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1176 inc.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1177 elif prefix == 'x:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1178 exc.append(value)
16181
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents: 16174
diff changeset
1179 elif prefix == 'r:':
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents: 16174
diff changeset
1180 if rev is not None:
28271
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1181 raise error.ParseError('_matchfiles expected at most one '
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1182 'revision')
35816
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1183 if value == '': # empty means working directory
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1184 rev = node.wdirrev
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1185 else:
23950
caff3675cba5 log: evaluate filesets on working copy, not its parent
Martin von Zweigbergk <martinvonz@google.com>
parents: 23847
diff changeset
1186 rev = value
16411
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1187 elif prefix == 'd:':
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1188 if default is not None:
28271
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1189 raise error.ParseError('_matchfiles expected at most one '
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1190 'default mode')
16411
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1191 default = value
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1192 else:
28271
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents: 28217
diff changeset
1193 raise error.ParseError('invalid _matchfiles prefix: %s' % prefix)
16411
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1194 if not default:
4c2edcd84175 graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents: 16409
diff changeset
1195 default = 'glob'
35816
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1196 hasset = any(matchmod.patkind(p) == 'set' for p in pats + inc + exc)
20458
8dabcc889e33 revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20457
diff changeset
1197
35816
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1198 mcache = [None]
23061
f2aeff8a87b6 revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents: 23019
diff changeset
1199
27028
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1200 # This directly read the changelog data as creating changectx for all
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1201 # revisions is quite expensive.
27440
ff305ab2e0d7 log: speed up hg log <file|folder>
Laurent Charignon <lcharignon@fb.com>
parents: 27293
diff changeset
1202 getfiles = repo.changelog.readfiles
27028
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1203 wdirrev = node.wdirrev
20458
8dabcc889e33 revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20457
diff changeset
1204 def matches(x):
27028
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1205 if x == wdirrev:
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1206 files = repo[x].files()
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1207 else:
27440
ff305ab2e0d7 log: speed up hg log <file|folder>
Laurent Charignon <lcharignon@fb.com>
parents: 27293
diff changeset
1208 files = getfiles(x)
35816
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1209
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1210 if not mcache[0] or (hasset and rev is None):
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1211 r = x if rev is None else rev
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1212 mcache[0] = matchmod.match(repo.root, repo.getcwd(), pats,
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1213 include=inc, exclude=exc, ctx=repo[r],
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1214 default=default)
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1215 m = mcache[0]
f6ca1e11d8b4 revset: evaluate filesets against each revision for 'file()' (issue5778)
Matt Harbison <matt_harbison@yahoo.com>
parents: 35673
diff changeset
1216
27028
f92053df8f0b revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26778
diff changeset
1217 for f in files:
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1218 if m(f):
20458
8dabcc889e33 revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20457
diff changeset
1219 return True
8dabcc889e33 revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20457
diff changeset
1220 return False
8dabcc889e33 revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20457
diff changeset
1221
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1222 return subset.filter(matches,
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1223 condrepr=('<matchfiles patterns=%r, include=%r '
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1224 'exclude=%r, default=%r, rev=%r>',
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1225 pats, inc, exc, default, rev))
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1226
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1227 @predicate('file(pattern)', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1228 def hasfile(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1229 """Changesets affecting files matched by pattern.
17244
483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()'
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17186
diff changeset
1230
17265
c30307eeec4b revset: polish explanation of the difference between file() and filelog()
Greg Ward <greg@gerg.ca>
parents: 17259
diff changeset
1231 For a faster but less accurate result, consider using ``filelog()``
c30307eeec4b revset: polish explanation of the difference between file() and filelog()
Greg Ward <greg@gerg.ca>
parents: 17259
diff changeset
1232 instead.
20289
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1233
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1234 This predicate uses ``glob:`` as the default kind of pattern.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1235 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1236 # i18n: "file" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1237 pat = getstring(x, _("file requires a pattern"))
16161
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents: 16096
diff changeset
1238 return _matchfiles(repo, subset, ('string', 'p:' + pat))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1239
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1240 @predicate('head()', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1241 def head(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1242 """Changeset is a named branch head.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1243 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1244 # i18n: "head" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1245 getargs(x, 0, 0, _("head takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1246 hs = set()
25620
5f87f2305ad0 revset: translate node directly with changelog in 'head'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25619
diff changeset
1247 cl = repo.changelog
42002
662ffdde5adf branchcache: rename itervalues() to iterheads()
Pulkit Goyal <pulkit@yandex-team.ru>
parents: 41698
diff changeset
1248 for ls in repo.branchmap().iterheads():
25620
5f87f2305ad0 revset: translate node directly with changelog in 'head'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25619
diff changeset
1249 hs.update(cl.rev(h) for h in ls)
29408
785cadec2091 revset: make head() honor order of subset
Martin von Zweigbergk <martinvonz@google.com>
parents: 29407
diff changeset
1250 return subset & baseset(hs)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1251
38479
72621094505f revset: fix heads() order to always follow the input set (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 38275
diff changeset
1252 @predicate('heads(set)', safe=True, takeorder=True)
72621094505f revset: fix heads() order to always follow the input set (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 38275
diff changeset
1253 def heads(repo, subset, x, order):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1254 """Members of set with no children in set.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1255 """
38479
72621094505f revset: fix heads() order to always follow the input set (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 38275
diff changeset
1256 # argument set should never define order
72621094505f revset: fix heads() order to always follow the input set (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 38275
diff changeset
1257 if order == defineorder:
72621094505f revset: fix heads() order to always follow the input set (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 38275
diff changeset
1258 order = followorder
41274
4c6fdc7e2e7d revset: inline parents computation to reuse the input argument
Boris Feld <boris.feld@octobus.net>
parents: 41222
diff changeset
1259 inputset = getset(repo, fullreposet(repo), x, order=order)
41276
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1260 wdirparents = None
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1261 if node.wdirrev in inputset:
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1262 # a bit slower, but not common so good enough for now
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1263 wdirparents = [p.rev() for p in repo[None].parents()]
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1264 inputset = set(inputset)
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1265 inputset.discard(node.wdirrev)
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1266 heads = repo.changelog.headrevs(inputset)
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1267 if wdirparents is not None:
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1268 heads.difference_update(wdirparents)
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1269 heads.add(node.wdirrev)
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1270 heads = baseset(heads)
5affe1583e1d revset: use changelog's `headrevs` method to compute heads
Boris Feld <boris.feld@octobus.net>
parents: 41274
diff changeset
1271 return subset & heads
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1272
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1273 @predicate('hidden()', safe=True)
17390
74b44f25b4b1 revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents: 17291
diff changeset
1274 def hidden(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1275 """Hidden changesets.
17390
74b44f25b4b1 revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents: 17291
diff changeset
1276 """
74b44f25b4b1 revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents: 17291
diff changeset
1277 # i18n: "hidden" is a keyword
74b44f25b4b1 revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents: 17291
diff changeset
1278 getargs(x, 0, 0, _("hidden takes no arguments"))
18382
f3b21beb9802 filtering: rename filters to their antonyms
Kevin Bullock <kbullock@ringworld.org>
parents: 18251
diff changeset
1279 hiddenrevs = repoview.filterrevs(repo, 'visible')
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
1280 return subset & hiddenrevs
17390
74b44f25b4b1 revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents: 17291
diff changeset
1281
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1282 @predicate('keyword(string)', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1283 def keyword(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1284 """Search commit message, user name, and names of changed files for
14357
cb4ff8ef466b merge with stable
Martin Geisler <mg@aragost.com>
parents: 14343 14356
diff changeset
1285 string. The match is case-insensitive.
30772
b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches
Matt Harbison <matt_harbison@yahoo.com>
parents: 30754
diff changeset
1286
b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches
Matt Harbison <matt_harbison@yahoo.com>
parents: 30754
diff changeset
1287 For a regular expression or case sensitive search of these fields, use
b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches
Matt Harbison <matt_harbison@yahoo.com>
parents: 30754
diff changeset
1288 ``grep(regex)``.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1289 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1290 # i18n: "keyword" is a keyword
15726
9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15596
diff changeset
1291 kw = encoding.lower(getstring(x, _("keyword requires a string")))
20447
abb91b74f758 revset: added lazyset implementation to keyword revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20446
diff changeset
1292
abb91b74f758 revset: added lazyset implementation to keyword revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20446
diff changeset
1293 def matches(r):
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1294 c = repo[r]
25551
c1d163ce7394 revset: gratuitous formating fix in keyword
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25550
diff changeset
1295 return any(kw in encoding.lower(t)
c1d163ce7394 revset: gratuitous formating fix in keyword
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25550
diff changeset
1296 for t in c.files() + [c.user(), c.description()])
20447
abb91b74f758 revset: added lazyset implementation to keyword revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20446
diff changeset
1297
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1298 return subset.filter(matches, condrepr=('<keyword %r>', kw))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1299
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1300 @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0)
32801
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1301 def limit(repo, subset, x, order):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1302 """First n members of set, defaulting to 1, starting from offset.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1303 """
26638
7afaf2566e25 revset: add optional offset argument to limit() predicate
Yuya Nishihara <yuya@tcha.org>
parents: 26637
diff changeset
1304 args = getargsdict(x, 'limit', 'set n offset')
26637
179764469754 revset: port limit() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 26636
diff changeset
1305 if 'set' not in args:
179764469754 revset: port limit() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 26636
diff changeset
1306 # i18n: "limit" is a keyword
26638
7afaf2566e25 revset: add optional offset argument to limit() predicate
Yuya Nishihara <yuya@tcha.org>
parents: 26637
diff changeset
1307 raise error.ParseError(_("limit requires one to three arguments"))
30802
5eb3e4568c94 revset: add default value to getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30801
diff changeset
1308 # i18n: "limit" is a keyword
5eb3e4568c94 revset: add default value to getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30801
diff changeset
1309 lim = getinteger(args.get('n'), _("limit expects a number"), default=1)
32799
b36ec65ea583 revset: reject negative number to select first/last n members
Yuya Nishihara <yuya@tcha.org>
parents: 32798
diff changeset
1310 if lim < 0:
b36ec65ea583 revset: reject negative number to select first/last n members
Yuya Nishihara <yuya@tcha.org>
parents: 32798
diff changeset
1311 raise error.ParseError(_("negative number to select"))
30802
5eb3e4568c94 revset: add default value to getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30801
diff changeset
1312 # i18n: "limit" is a keyword
5eb3e4568c94 revset: add default value to getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30801
diff changeset
1313 ofs = getinteger(args.get('offset'), _("limit expects a number"), default=0)
30801
67ee7874e53b revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30800
diff changeset
1314 if ofs < 0:
67ee7874e53b revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30800
diff changeset
1315 raise error.ParseError(_("negative offset"))
26637
179764469754 revset: port limit() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents: 26636
diff changeset
1316 os = getset(repo, fullreposet(repo), args['set'])
32819
4710cc4dac99 smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents: 32801
diff changeset
1317 ls = os.slice(ofs, ofs + lim)
32801
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1318 if order == followorder and lim > 1:
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1319 return subset & ls
32800
3e6f9bff7e3f revset: filter first/last members by __and__ operation
Yuya Nishihara <yuya@tcha.org>
parents: 32799
diff changeset
1320 return ls & subset
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1321
32801
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1322 @predicate('last(set, [n])', safe=True, takeorder=True)
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1323 def last(repo, subset, x, order):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1324 """Last n members of set, defaulting to 1.
14061
611d2f8a4ba2 revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents: 14057
diff changeset
1325 """
611d2f8a4ba2 revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents: 14057
diff changeset
1326 # i18n: "last" is a keyword
15116
d8501bcbb221 revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents: 14901
diff changeset
1327 l = getargs(x, 1, 2, _("last requires one or two arguments"))
30801
67ee7874e53b revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30800
diff changeset
1328 lim = 1
67ee7874e53b revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30800
diff changeset
1329 if len(l) == 2:
14061
611d2f8a4ba2 revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents: 14057
diff changeset
1330 # i18n: "last" is a keyword
30801
67ee7874e53b revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents: 30800
diff changeset
1331 lim = getinteger(l[1], _("last expects a number"))
32799
b36ec65ea583 revset: reject negative number to select first/last n members
Yuya Nishihara <yuya@tcha.org>
parents: 32798
diff changeset
1332 if lim < 0:
b36ec65ea583 revset: reject negative number to select first/last n members
Yuya Nishihara <yuya@tcha.org>
parents: 32798
diff changeset
1333 raise error.ParseError(_("negative number to select"))
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1334 os = getset(repo, fullreposet(repo), l[0])
20534
4849f574aa24 revset: changed last implementation to use lazy classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20527
diff changeset
1335 os.reverse()
32819
4710cc4dac99 smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents: 32801
diff changeset
1336 ls = os.slice(0, lim)
32801
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1337 if order == followorder and lim > 1:
348b491c0934 revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 32800
diff changeset
1338 return subset & ls
32800
3e6f9bff7e3f revset: filter first/last members by __and__ operation
Yuya Nishihara <yuya@tcha.org>
parents: 32799
diff changeset
1339 ls.reverse()
3e6f9bff7e3f revset: filter first/last members by __and__ operation
Yuya Nishihara <yuya@tcha.org>
parents: 32799
diff changeset
1340 return ls & subset
14061
611d2f8a4ba2 revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents: 14057
diff changeset
1341
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1342 @predicate('max(set)', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1343 def maxrev(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1344 """Changeset with highest revision number in set.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1345 """
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1346 os = getset(repo, fullreposet(repo), x)
26305
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1347 try:
20754
f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20753
diff changeset
1348 m = os.max()
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1349 if m in subset:
28427
969a4615c4c4 revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents: 28426
diff changeset
1350 return baseset([m], datarepr=('<max %r, %r>', subset, os))
26305
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1351 except ValueError:
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1352 # os.max() throws a ValueError when the collection is empty.
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1353 # Same as python's max().
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1354 pass
28427
969a4615c4c4 revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents: 28426
diff changeset
1355 return baseset(datarepr=('<max %r, %r>', subset, os))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1356
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1357 @predicate('merge()', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1358 def merge(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1359 """Changeset is a merge changeset.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1360 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1361 # i18n: "merge" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1362 getargs(x, 0, 0, _("merge takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1363 cl = repo.changelog
42440
d279e4f453c4 revset: use nullrev constant in merge()
Yuya Nishihara <yuya@tcha.org>
parents: 42264
diff changeset
1364 nullrev = node.nullrev
42441
43c8f72184f4 revset: fix merge() to fall back to changectx API if wdir specified
Yuya Nishihara <yuya@tcha.org>
parents: 42440
diff changeset
1365 def ismerge(r):
43c8f72184f4 revset: fix merge() to fall back to changectx API if wdir specified
Yuya Nishihara <yuya@tcha.org>
parents: 42440
diff changeset
1366 try:
43c8f72184f4 revset: fix merge() to fall back to changectx API if wdir specified
Yuya Nishihara <yuya@tcha.org>
parents: 42440
diff changeset
1367 return cl.parentrevs(r)[1] != nullrev
43c8f72184f4 revset: fix merge() to fall back to changectx API if wdir specified
Yuya Nishihara <yuya@tcha.org>
parents: 42440
diff changeset
1368 except error.WdirUnsupported:
43c8f72184f4 revset: fix merge() to fall back to changectx API if wdir specified
Yuya Nishihara <yuya@tcha.org>
parents: 42440
diff changeset
1369 return bool(repo[r].p2())
43c8f72184f4 revset: fix merge() to fall back to changectx API if wdir specified
Yuya Nishihara <yuya@tcha.org>
parents: 42440
diff changeset
1370 return subset.filter(ismerge, condrepr='<merge>')
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1371
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1372 @predicate('branchpoint()', safe=True)
17753
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1373 def branchpoint(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1374 """Changesets with more than one child.
17753
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1375 """
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1376 # i18n: "branchpoint" is a keyword
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1377 getargs(x, 0, 0, _("branchpoint takes no arguments"))
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1378 cl = repo.changelog
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1379 if not subset:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
1380 return baseset()
25549
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25548
diff changeset
1381 # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25548
diff changeset
1382 # (and if it is not, it should.)
17753
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1383 baserev = min(subset)
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1384 parentscount = [0]*(len(repo) - baserev)
17785
ac5c9c8046f7 clfilter: use changelog to iterate over the repo in branchpoint
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17753
diff changeset
1385 for r in cl.revs(start=baserev + 1):
17753
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1386 for p in cl.parentrevs(r):
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1387 if p >= baserev:
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1388 parentscount[p - baserev] += 1
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1389 return subset.filter(lambda r: parentscount[r - baserev] > 1,
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1390 condrepr='<branchpoint>')
17753
69d5078d760d revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents: 17675
diff changeset
1391
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1392 @predicate('min(set)', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1393 def minrev(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1394 """Changeset with lowest revision number in set.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1395 """
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1396 os = getset(repo, fullreposet(repo), x)
26305
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1397 try:
20754
f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20753
diff changeset
1398 m = os.min()
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1399 if m in subset:
28427
969a4615c4c4 revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents: 28426
diff changeset
1400 return baseset([m], datarepr=('<min %r, %r>', subset, os))
26305
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1401 except ValueError:
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1402 # os.min() throws a ValueError when the collection is empty.
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1403 # Same as python's min().
ade5c488d622 revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents: 26304
diff changeset
1404 pass
28427
969a4615c4c4 revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents: 28426
diff changeset
1405 return baseset(datarepr=('<min %r, %r>', subset, os))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1406
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1407 @predicate('modifies(pattern)', safe=True, weight=30)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1408 def modifies(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1409 """Changesets modifying files matched by pattern.
20289
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1410
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1411 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1412 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1413 directory.
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1414 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1415 # i18n: "modifies" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1416 pat = getstring(x, _("modifies requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1417 return checkstatus(repo, subset, pat, 0)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1418
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1419 @predicate('named(namespace)')
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1420 def named(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1421 """The changesets in a given namespace.
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1422
30784
5dd67f0993ce help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents: 30783
diff changeset
1423 Pattern matching is supported for `namespace`. See
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
1424 :hg:`help revisions.patterns`.
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1425 """
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1426 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1427 args = getargs(x, 1, 1, _('named requires a namespace argument'))
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1428
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1429 ns = getstring(args[0],
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1430 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1431 _('the argument to named must be a string'))
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
1432 kind, pattern, matcher = stringutil.stringmatcher(ns)
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1433 namespaces = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1434 if kind == 'literal':
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1435 if pattern not in repo.names:
23978
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 23956
diff changeset
1436 raise error.RepoLookupError(_("namespace '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 23956
diff changeset
1437 % ns)
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1438 namespaces.add(repo.names[pattern])
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1439 else:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1440 for name, ns in repo.names.iteritems():
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1441 if matcher(name):
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1442 namespaces.add(ns)
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1443
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1444 names = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1445 for ns in namespaces:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1446 for name in ns.listnames(repo):
24151
38824c53c2f1 revset: mask specific names for named() predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 24008
diff changeset
1447 if name not in ns.deprecated:
38824c53c2f1 revset: mask specific names for named() predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 24008
diff changeset
1448 names.update(repo[n].rev() for n in ns.nodes(repo, name))
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1449
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1450 names -= {node.nullrev}
23836
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1451 return subset & names
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents: 23833
diff changeset
1452
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1453 @predicate('id(string)', safe=True)
16417
b4b0c6931e11 revset: avoid demandimport bug
Matt Mackall <mpm@selenic.com>
parents: 16415
diff changeset
1454 def node_(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1455 """Revision non-ambiguously specified by the given hex string prefix.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1456 """
12815
079a618ea89d revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents: 12786
diff changeset
1457 # i18n: "id" is a keyword
12736
7e14e67e6622 revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 12733
diff changeset
1458 l = getargs(x, 1, 1, _("id requires one argument"))
12815
079a618ea89d revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents: 12786
diff changeset
1459 # i18n: "id" is a keyword
12736
7e14e67e6622 revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 12733
diff changeset
1460 n = getstring(l[0], _("id requires a string"))
12716
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents: 12715
diff changeset
1461 if len(n) == 40:
24904
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings
Alexander Drozdov <al.drozdov@gmail.com>
parents: 24777
diff changeset
1462 try:
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings
Alexander Drozdov <al.drozdov@gmail.com>
parents: 24777
diff changeset
1463 rn = repo.changelog.rev(node.bin(n))
32661
a3064fe3e495 revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents: 32442
diff changeset
1464 except error.WdirUnsupported:
a3064fe3e495 revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents: 32442
diff changeset
1465 rn = node.wdirrev
24904
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings
Alexander Drozdov <al.drozdov@gmail.com>
parents: 24777
diff changeset
1466 except (LookupError, TypeError):
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings
Alexander Drozdov <al.drozdov@gmail.com>
parents: 24777
diff changeset
1467 rn = None
12716
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents: 12715
diff changeset
1468 else:
16735
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev)
Matt Harbison <matt_harbison@yahoo.com>
parents: 16640
diff changeset
1469 rn = None
32684
af854b1b36f8 revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents: 32683
diff changeset
1470 try:
37867
0a79fb64118e revset: use resolvehexnodeidprefix() in id() predicate (BC)
Martin von Zweigbergk <martinvonz@google.com>
parents: 37866
diff changeset
1471 pm = scmutil.resolvehexnodeidprefix(repo, n)
32684
af854b1b36f8 revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents: 32683
diff changeset
1472 if pm is not None:
32661
a3064fe3e495 revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents: 32442
diff changeset
1473 rn = repo.changelog.rev(pm)
37866
37e7ae332e90 revset: make id() an empty set for ambiguous nodeid (BC)
Martin von Zweigbergk <martinvonz@google.com>
parents: 37674
diff changeset
1474 except LookupError:
37e7ae332e90 revset: make id() an empty set for ambiguous nodeid (BC)
Martin von Zweigbergk <martinvonz@google.com>
parents: 37674
diff changeset
1475 pass
32684
af854b1b36f8 revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents: 32683
diff changeset
1476 except error.WdirUnsupported:
af854b1b36f8 revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents: 32683
diff changeset
1477 rn = node.wdirrev
16735
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev)
Matt Harbison <matt_harbison@yahoo.com>
parents: 16640
diff changeset
1478
23005
9bfe68357c01 revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23004
diff changeset
1479 if rn is None:
9bfe68357c01 revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23004
diff changeset
1480 return baseset()
9bfe68357c01 revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23004
diff changeset
1481 result = baseset([rn])
9bfe68357c01 revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23004
diff changeset
1482 return result & subset
12716
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents: 12715
diff changeset
1483
38275
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1484 @predicate('none()', safe=True)
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1485 def none(repo, subset, x):
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1486 """No changesets.
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1487 """
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1488 # i18n: "none" is a keyword
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1489 getargs(x, 0, 0, _("none takes no arguments"))
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1490 return baseset()
f1d55ae2c5c8 revsets: define a none() revset
Martin von Zweigbergk <martinvonz@google.com>
parents: 38239
diff changeset
1491
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1492 @predicate('obsolete()', safe=True)
17170
63a4a3871607 revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17102
diff changeset
1493 def obsolete(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1494 """Mutable changeset with a newer version."""
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
1495 # i18n: "obsolete" is a keyword
17170
63a4a3871607 revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17102
diff changeset
1496 getargs(x, 0, 0, _("obsolete takes no arguments"))
17825
3cc06457f15e obsolete: rename `getobscache` into `getrevs`
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17804
diff changeset
1497 obsoletes = obsmod.getrevs(repo, 'obsolete')
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
1498 return subset & obsoletes
17170
63a4a3871607 revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17102
diff changeset
1499
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1500 @predicate('only(set, [set])', safe=True)
23466
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1501 def only(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1502 """Changesets that are ancestors of the first set that are not ancestors
23466
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1503 of any other head in the repo. If a second set is specified, the result
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1504 is ancestors of the first set that are not ancestors of the second set
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1505 (i.e. ::<set1> - ::<set2>).
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1506 """
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1507 cl = repo.changelog
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1508 # i18n: "only" is a keyword
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1509 args = getargs(x, 1, 2, _('only takes one or two arguments'))
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1510 include = getset(repo, fullreposet(repo), args[0])
23466
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1511 if len(args) == 1:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1512 if not include:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1513 return baseset()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1514
32903
27932a76a88d dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents: 32885
diff changeset
1515 descendants = set(dagop.revdescendants(repo, include, False))
23466
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1516 exclude = [rev for rev in cl.headrevs()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1517 if not rev in descendants and not rev in include]
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1518 else:
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1519 exclude = getset(repo, fullreposet(repo), args[1])
23466
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1520
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1521 results = set(cl.findmissingrevs(common=exclude, heads=include))
25554
94441df6206c revset: mark spots that use 'set' instead of 'smartset'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25553
diff changeset
1522 # XXX we should turn this into a baseset instead of a set, smartset may do
30332
318a24b52eeb spelling: fixes of non-dictionary words
Mads Kiilerich <madski@unity3d.com>
parents: 30227
diff changeset
1523 # some optimizations from the fact this is a baseset.
23466
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1524 return subset & results
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents: 23426
diff changeset
1525
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1526 @predicate('origin([set])', safe=True)
17185
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1527 def origin(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1528 """
17185
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1529 Changesets that were specified as a source for the grafts, transplants or
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1530 rebases that created the given revisions. Omitting the optional set is the
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1531 same as passing all(). If a changeset created by these operations is itself
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1532 specified as a source for one of these operations, only the source changeset
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1533 for the first operation is selected.
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1534 """
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1535 if x is not None:
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1536 dests = getset(repo, fullreposet(repo), x)
17185
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1537 else:
24201
77ef059b3317 revset: drop unnecessary calls of getall() with empty argument
Yuya Nishihara <yuya@tcha.org>
parents: 24163
diff changeset
1538 dests = fullreposet(repo)
17185
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1539
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1540 def _firstsrc(rev):
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1541 src = _getrevsource(repo, rev)
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1542 if src is None:
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1543 return None
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1544
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1545 while True:
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1546 prev = _getrevsource(repo, src)
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1547
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1548 if prev is None:
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1549 return src
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1550 src = prev
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1551
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1552 o = {_firstsrc(r) for r in dests}
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1553 o -= {None}
25554
94441df6206c revset: mark spots that use 'set' instead of 'smartset'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25553
diff changeset
1554 # XXX we should turn this into a baseset instead of a set, smartset may do
30332
318a24b52eeb spelling: fixes of non-dictionary words
Mads Kiilerich <madski@unity3d.com>
parents: 30227
diff changeset
1555 # some optimizations from the fact this is a baseset.
22536
8040a44aab1c revset: use `subset &` in `origin`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22535
diff changeset
1556 return subset & o
17185
2c7c4824969e revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents: 17173
diff changeset
1557
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1558 @predicate('outgoing([path])', safe=False, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1559 def outgoing(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1560 """Changesets not found in the specified destination repository, or the
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1561 default push location.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1562 """
24722
02a5618e2fbf revset: don't import discovery at module level
Gregory Szorc <gregory.szorc@gmail.com>
parents: 24708
diff changeset
1563 # Avoid cycles.
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
1564 from . import (
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
1565 discovery,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
1566 hg,
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
1567 )
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1568 # i18n: "outgoing" is a keyword
14717
c8ee2729e89f revset and fileset: fix typos in parser error messages
Mads Kiilerich <mads@kiilerich.com>
parents: 14715
diff changeset
1569 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1570 # i18n: "outgoing" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1571 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
35438
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1572 if not dest:
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1573 # ui.paths.getpath() explicitly tests for None, not just a boolean
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1574 dest = None
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1575 path = repo.ui.paths.getpath(dest, default=('default-push', 'default'))
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1576 if not path:
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1577 raise error.Abort(_('default repository not configured!'),
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1578 hint=_("see 'hg help config.paths'"))
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1579 dest = path.pushloc or path.loc
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1580 branches = path.branch, []
0ebd94ac56d1 outgoing: respect ":pushurl" paths (issue5365)
Hollis Blanchard <hollis_blanchard@mentor.com>
parents: 35367
diff changeset
1581
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1582 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1583 if revs:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1584 revs = [repo.lookup(rev) for rev in revs]
14556
517e1d88bf7e hg: change various repository() users to use peer() where appropriate
Matt Mackall <mpm@selenic.com>
parents: 14509
diff changeset
1585 other = hg.peer(repo, {}, dest)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1586 repo.ui.pushbuffer()
15837
cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15819
diff changeset
1587 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1588 repo.ui.popbuffer()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1589 cl = repo.changelog
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1590 o = {cl.rev(r) for r in outgoing.missing}
22529
5c53d7888aef revset: use `subset &` in `outgoing`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22528
diff changeset
1591 return subset & o
12716
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents: 12715
diff changeset
1592
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1593 @predicate('p1([set])', safe=True)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1594 def p1(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1595 """First parent of changesets in set, or the working directory.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1596 """
12928
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1597 if x is None:
13878
a8d13ee0ce68 misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents: 13873
diff changeset
1598 p = repo[x].p1().rev()
22538
a428db9ab61d revset: use `subset &` in bare `p1()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22537
diff changeset
1599 if p >= 0:
a428db9ab61d revset: use `subset &` in bare `p1()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22537
diff changeset
1600 return subset & baseset([p])
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
1601 return baseset()
12928
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1602
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1603 ps = set()
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1604 cl = repo.changelog
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1605 for r in getset(repo, fullreposet(repo), x):
32404
e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905)
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32291
diff changeset
1606 try:
e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905)
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32291
diff changeset
1607 ps.add(cl.parentrevs(r)[0])
e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905)
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32291
diff changeset
1608 except error.WdirUnsupported:
41397
0bd56c291359 cleanup: use p1() and p2() instead of parents()[0] and parents()[1]
Martin von Zweigbergk <martinvonz@google.com>
parents: 41388
diff changeset
1609 ps.add(repo[r].p1().rev())
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1610 ps -= {node.nullrev}
25554
94441df6206c revset: mark spots that use 'set' instead of 'smartset'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25553
diff changeset
1611 # XXX we should turn this into a baseset instead of a set, smartset may do
30332
318a24b52eeb spelling: fixes of non-dictionary words
Mads Kiilerich <madski@unity3d.com>
parents: 30227
diff changeset
1612 # some optimizations from the fact this is a baseset.
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
1613 return subset & ps
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1614
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1615 @predicate('p2([set])', safe=True)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1616 def p2(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1617 """Second parent of changesets in set, or the working directory.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1618 """
12928
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1619 if x is None:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1620 ps = repo[x].parents()
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1621 try:
12935
98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e)
Patrick Mezard <pmezard@gmail.com>
parents: 12929
diff changeset
1622 p = ps[1].rev()
22539
6f434ef54222 revset: use `subset &` in bare `p2()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22538
diff changeset
1623 if p >= 0:
6f434ef54222 revset: use `subset &` in bare `p2()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22538
diff changeset
1624 return subset & baseset([p])
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
1625 return baseset()
12928
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1626 except IndexError:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
1627 return baseset()
12928
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12859
diff changeset
1628
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1629 ps = set()
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1630 cl = repo.changelog
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1631 for r in getset(repo, fullreposet(repo), x):
32440
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32439
diff changeset
1632 try:
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32439
diff changeset
1633 ps.add(cl.parentrevs(r)[1])
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32439
diff changeset
1634 except error.WdirUnsupported:
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32439
diff changeset
1635 parents = repo[r].parents()
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32439
diff changeset
1636 if len(parents) == 2:
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32439
diff changeset
1637 ps.add(parents[1])
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1638 ps -= {node.nullrev}
25554
94441df6206c revset: mark spots that use 'set' instead of 'smartset'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25553
diff changeset
1639 # XXX we should turn this into a baseset instead of a set, smartset may do
30332
318a24b52eeb spelling: fixes of non-dictionary words
Mads Kiilerich <madski@unity3d.com>
parents: 30227
diff changeset
1640 # some optimizations from the fact this is a baseset.
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
1641 return subset & ps
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1642
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
1643 def parentpost(repo, subset, x, order):
29931
d2d1be3009ca revset: add stub to handle parentpost operation
Yuya Nishihara <yuya@tcha.org>
parents: 29930
diff changeset
1644 return p1(repo, subset, x)
d2d1be3009ca revset: add stub to handle parentpost operation
Yuya Nishihara <yuya@tcha.org>
parents: 29930
diff changeset
1645
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1646 @predicate('parents([set])', safe=True)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1647 def parents(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1648 """
12929
515c2786e1cf revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12928
diff changeset
1649 The set of all parents for all changesets in set, or the working directory.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1650 """
12929
515c2786e1cf revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents: 12928
diff changeset
1651 if x is None:
22496
35af9361a049 revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22495
diff changeset
1652 ps = set(p.rev() for p in repo[x].parents())
35af9361a049 revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22495
diff changeset
1653 else:
35af9361a049 revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22495
diff changeset
1654 ps = set()
35af9361a049 revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22495
diff changeset
1655 cl = repo.changelog
25716
d50677c3bf44 revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25706
diff changeset
1656 up = ps.update
d50677c3bf44 revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25706
diff changeset
1657 parentrevs = cl.parentrevs
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
1658 for r in getset(repo, fullreposet(repo), x):
32439
e72c5263ccaf revset: use try-except instead of if-else because of perf
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32438
diff changeset
1659 try:
e72c5263ccaf revset: use try-except instead of if-else because of perf
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32438
diff changeset
1660 up(parentrevs(r))
e72c5263ccaf revset: use try-except instead of if-else because of perf
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32438
diff changeset
1661 except error.WdirUnsupported:
25716
d50677c3bf44 revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25706
diff changeset
1662 up(p.rev() for p in repo[r].parents())
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
1663 ps -= {node.nullrev}
22712
093df3b77f27 revert: bring back usage of `subset & ps` in `parents`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22692
diff changeset
1664 return subset & ps
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1665
31017
17b5cda5a84a revset: use phasecache.getrevset
Jun Wu <quark@fb.com>
parents: 30962
diff changeset
1666 def _phase(repo, subset, *targets):
17b5cda5a84a revset: use phasecache.getrevset
Jun Wu <quark@fb.com>
parents: 30962
diff changeset
1667 """helper to select all rev in <targets> phases"""
35330
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35301
diff changeset
1668 return repo._phasecache.getrevset(repo, targets, subset)
25621
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1669
39274
31c0ee6eb0ac phase: expose a `_phase(idx)` revset
Boris Feld <boris.feld@octobus.net>
parents: 38810
diff changeset
1670 @predicate('_phase(idx)', safe=True)
31c0ee6eb0ac phase: expose a `_phase(idx)` revset
Boris Feld <boris.feld@octobus.net>
parents: 38810
diff changeset
1671 def phase(repo, subset, x):
31c0ee6eb0ac phase: expose a `_phase(idx)` revset
Boris Feld <boris.feld@octobus.net>
parents: 38810
diff changeset
1672 l = getargs(x, 1, 1, ("_phase requires one argument"))
31c0ee6eb0ac phase: expose a `_phase(idx)` revset
Boris Feld <boris.feld@octobus.net>
parents: 38810
diff changeset
1673 target = getinteger(l[0], ("_phase expects a number"))
31c0ee6eb0ac phase: expose a `_phase(idx)` revset
Boris Feld <boris.feld@octobus.net>
parents: 38810
diff changeset
1674 return _phase(repo, subset, target)
31c0ee6eb0ac phase: expose a `_phase(idx)` revset
Boris Feld <boris.feld@octobus.net>
parents: 38810
diff changeset
1675
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1676 @predicate('draft()', safe=True)
25621
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1677 def draft(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1678 """Changeset in draft phase."""
25621
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1679 # i18n: "draft" is a keyword
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1680 getargs(x, 0, 0, _("draft takes no arguments"))
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1681 target = phases.draft
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1682 return _phase(repo, subset, target)
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1683
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1684 @predicate('secret()', safe=True)
25621
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1685 def secret(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1686 """Changeset in secret phase."""
25621
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1687 # i18n: "secret" is a keyword
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1688 getargs(x, 0, 0, _("secret takes no arguments"))
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1689 target = phases.secret
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1690 return _phase(repo, subset, target)
21a874693619 revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25620
diff changeset
1691
37001
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1692 @predicate('stack([revs])', safe=True)
37389
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1693 def stack(repo, subset, x):
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1694 """Experimental revset for the stack of changesets or working directory
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1695 parent. (EXPERIMENTAL)
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1696 """
37001
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1697 if x is None:
37389
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1698 stacks = stackmod.getstack(repo, x)
37001
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1699 else:
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1700 stacks = smartset.baseset([])
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1701 for revision in getset(repo, fullreposet(repo), x):
37389
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1702 currentstack = stackmod.getstack(repo, revision)
37001
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1703 stacks = stacks + currentstack
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1704
37389
bef863a09acd stack: follow-up on the stack revset
Boris Feld <boris.feld@octobus.net>
parents: 37350
diff changeset
1705 return subset & stacks
37001
407934a97bc7 stack: import Evolve stack test file
Boris Feld <boris.feld@octobus.net>
parents: 36607
diff changeset
1706
29932
09a84e747c88 revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents: 29931
diff changeset
1707 def parentspec(repo, subset, x, n, order):
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1708 """``set^0``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1709 The set.
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1710 ``set^1`` (or ``set^``), ``set^2``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1711 First or second parent, respectively, of all changesets in set.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1712 """
12320
40c40c6f20b8 revset: handle re.compile() errors in grep()
Brodie Rao <brodie@bitheap.org>
parents: 11882
diff changeset
1713 try:
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1714 n = int(n[1])
14072
2e4d79dcc0a0 revset: add missing whitespace
Kevin Gessner <kevin@kevingessner.com>
parents: 14070
diff changeset
1715 if n not in (0, 1, 2):
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1716 raise ValueError
14851
f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884)
Matt Mackall <mpm@selenic.com>
parents: 14842
diff changeset
1717 except (TypeError, ValueError):
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1718 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1719 ps = set()
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1720 cl = repo.changelog
23165
7e8737e6ab08 revset-parentspec: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23164
diff changeset
1721 for r in getset(repo, fullreposet(repo), x):
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1722 if n == 0:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1723 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
1724 elif n == 1:
32436
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1725 try:
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1726 ps.add(cl.parentrevs(r)[0])
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1727 except error.WdirUnsupported:
41397
0bd56c291359 cleanup: use p1() and p2() instead of parents()[0] and parents()[1]
Martin von Zweigbergk <martinvonz@google.com>
parents: 41388
diff changeset
1728 ps.add(repo[r].p1().rev())
32438
14482f8e6ce6 revset: remove redundant condition and change to else from elif
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32436
diff changeset
1729 else:
32436
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1730 try:
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1731 parents = cl.parentrevs(r)
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1732 if parents[1] != node.nullrev:
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1733 ps.add(parents[1])
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1734 except error.WdirUnsupported:
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1735 parents = repo[r].parents()
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1736 if len(parents) == 2:
f064e2f72c49 revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32435
diff changeset
1737 ps.add(parents[1].rev())
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
1738 return subset & ps
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1739
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
1740 @predicate('present(set)', safe=True, takeorder=True)
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
1741 def present(repo, subset, x, order):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1742 """An empty set, if any revision in set isn't found; otherwise,
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1743 all revisions in set.
16748
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16735
diff changeset
1744
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16735
diff changeset
1745 If any of specified revisions is not present in the local repository,
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16735
diff changeset
1746 the query is normally aborted. But this predicate allows the query
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16735
diff changeset
1747 to continue even in such cases.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1748 """
11944
df52ff0980fe revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents: 11886
diff changeset
1749 try:
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
1750 return getset(repo, subset, x, order)
11944
df52ff0980fe revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents: 11886
diff changeset
1751 except error.RepoLookupError:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
1752 return baseset()
11944
df52ff0980fe revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents: 11886
diff changeset
1753
25224
d032f57936f5 revset: drop docstring from internal _notpublic() function
Yuya Nishihara <yuya@tcha.org>
parents: 25191
diff changeset
1754 # for internal use
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1755 @predicate('_notpublic', safe=True)
25191
08d1ef09ed37 revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents: 25149
diff changeset
1756 def _notpublic(repo, subset, x):
25225
57fae767c52b revset: drop translation marker from error message of _notpublic()
Yuya Nishihara <yuya@tcha.org>
parents: 25224
diff changeset
1757 getargs(x, 0, 0, "_notpublic takes no arguments")
31017
17b5cda5a84a revset: use phasecache.getrevset
Jun Wu <quark@fb.com>
parents: 30962
diff changeset
1758 return _phase(repo, subset, phases.draft, phases.secret)
25191
08d1ef09ed37 revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents: 25149
diff changeset
1759
34065
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1760 # for internal use
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1761 @predicate('_phaseandancestors(phasename, set)', safe=True)
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1762 def _phaseandancestors(repo, subset, x):
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1763 # equivalent to (phasename() & ancestors(set)) but more efficient
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1764 # phasename could be one of 'draft', 'secret', or '_notpublic'
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1765 args = getargs(x, 2, 2, "_phaseandancestors requires two arguments")
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1766 phasename = getsymbol(args[0])
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1767 s = getset(repo, fullreposet(repo), args[1])
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1768
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1769 draft = phases.draft
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1770 secret = phases.secret
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1771 phasenamemap = {
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1772 '_notpublic': draft,
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1773 'draft': draft, # follow secret's ancestors
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1774 'secret': secret,
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1775 }
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1776 if phasename not in phasenamemap:
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1777 raise error.ParseError('%r is not a valid phasename' % phasename)
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1778
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1779 minimalphase = phasenamemap[phasename]
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1780 getphase = repo._phasecache.phase
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1781
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1782 def cutfunc(rev):
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1783 return getphase(repo, rev) < minimalphase
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1784
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1785 revs = dagop.revancestors(repo, s, cutfunc=cutfunc)
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1786
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1787 if phasename == 'draft': # need to remove secret changesets
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1788 revs = revs.filter(lambda r: getphase(repo, r) == draft)
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1789 return subset & revs
c6c8a52e28c9 revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents: 34020
diff changeset
1790
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1791 @predicate('public()', safe=True)
15819
33ca11b010e2 phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15791
diff changeset
1792 def public(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1793 """Changeset in public phase."""
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
1794 # i18n: "public" is a keyword
15819
33ca11b010e2 phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15791
diff changeset
1795 getargs(x, 0, 0, _("public takes no arguments"))
35330
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35301
diff changeset
1796 return _phase(repo, subset, phases.public)
15819
33ca11b010e2 phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15791
diff changeset
1797
30850
41e31a6f5296 revset: prevent using outgoing() and remote() in hgweb session (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 30804
diff changeset
1798 @predicate('remote([id [,path]])', safe=False)
15936
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1799 def remote(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1800 """Local revision that corresponds to the given identifier in a
15936
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1801 remote repository, if present. Here, the '.' identifier is a
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1802 synonym for the current local branch.
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1803 """
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1804
25971
e9cd028f2dff revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25929
diff changeset
1805 from . import hg # avoid start-up nasties
15936
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1806 # i18n: "remote" is a keyword
27293
9e06e7fb037d grammar: favor zero, one, two over ... or no
timeless <timeless@mozdev.org>
parents: 27028
diff changeset
1807 l = getargs(x, 0, 2, _("remote takes zero, one, or two arguments"))
15936
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1808
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1809 q = '.'
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1810 if len(l) > 0:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1811 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1812 q = getstring(l[0], _("remote requires a string id"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1813 if q == '.':
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1814 q = repo['.'].branch()
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1815
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1816 dest = ''
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1817 if len(l) > 1:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1818 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1819 dest = getstring(l[1], _("remote requires a repository path"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1820 dest = repo.ui.expandpath(dest or 'default')
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1821 dest, branches = hg.parseurl(dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1822 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1823 if revs:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1824 revs = [repo.lookup(rev) for rev in revs]
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1825 other = hg.peer(repo, {}, dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1826 n = other.lookup(q)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1827 if n in repo:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1828 r = repo[n].rev()
16006
39e60576ac98 revset: fix 'remote()' failure when remote repo has more revs than local
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 15966
diff changeset
1829 if r in subset:
20364
a6cf48b2880d revset: added baseset class (still empty) to improve revset performance
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20289
diff changeset
1830 return baseset([r])
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
1831 return baseset()
15936
878bc4a62a73 revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents: 15903
diff changeset
1832
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1833 @predicate('removes(pattern)', safe=True, weight=30)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1834 def removes(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1835 """Changesets which remove files matching pattern.
20289
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1836
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1837 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1838 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 20288
diff changeset
1839 directory.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1840 """
12815
079a618ea89d revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents: 12786
diff changeset
1841 # i18n: "removes" is a keyword
12736
7e14e67e6622 revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 12733
diff changeset
1842 pat = getstring(x, _("removes requires a pattern"))
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1843 return checkstatus(repo, subset, pat, 2)
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1844
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1845 @predicate('rev(number)', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1846 def rev(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1847 """Revision with the given numeric identifier.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
1848 """
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1849 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1850 l = getargs(x, 1, 1, _("rev requires one argument"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1851 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1852 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1853 l = int(getstring(l[0], _("rev requires a number")))
14851
f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884)
Matt Mackall <mpm@selenic.com>
parents: 14842
diff changeset
1854 except (TypeError, ValueError):
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1855 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
1856 raise error.ParseError(_("rev expects a number"))
42262
a0c5e06e9b1a revset: extract private constant of {nullrev, wdirrev} set
Yuya Nishihara <yuya@tcha.org>
parents: 42104
diff changeset
1857 if l not in repo.changelog and l not in _virtualrevs:
23062
ba89f7b542c9 revset: have rev() drop out-of-range or filtered rev explicitly (issue4396)
Yuya Nishihara <yuya@tcha.org>
parents: 23061
diff changeset
1858 return baseset()
22537
bbf4f3dfd700 revset: use `subset &` in `rev`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22536
diff changeset
1859 return subset & baseset([l])
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
1860
41297
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1861 @predicate('_rev(number)', safe=True)
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1862 def _rev(repo, subset, x):
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1863 # internal version of "rev(x)" that raise error if "x" is invalid
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1864 # i18n: "rev" is a keyword
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1865 l = getargs(x, 1, 1, _("rev requires one argument"))
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1866 try:
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1867 # i18n: "rev" is a keyword
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1868 l = int(getstring(l[0], _("rev requires a number")))
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1869 except (TypeError, ValueError):
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1870 # i18n: "rev" is a keyword
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1871 raise error.ParseError(_("rev expects a number"))
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1872 repo.changelog.node(l) # check that the rev exists
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1873 return subset & baseset([l])
b1ea90613af3 revset: introduce an internal `_rev` predicate for '%d' usage
Boris Feld <boris.feld@octobus.net>
parents: 41276
diff changeset
1874
40310
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1875 @predicate('revset(set)', safe=True, takeorder=True)
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1876 def revsetpredicate(repo, subset, x, order):
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1877 """Strictly interpret the content as a revset.
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1878
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1879 The content of this special predicate will be strictly interpreted as a
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1880 revset. For example, ``revset(id(0))`` will be interpreted as "id(0)"
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1881 without possible ambiguity with a "id(0)" bookmark or tag.
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1882 """
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1883 return getset(repo, subset, x, order)
d894d2372ffe revset: document the `revset(...)` syntax
Boris Feld <boris.feld@octobus.net>
parents: 39832
diff changeset
1884
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
1885 @predicate('matching(revision [, field])', safe=True)
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1886 def matching(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
1887 """Changesets in which a given set of fields match the set of fields in the
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1888 selected revision or set.
16528
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1889
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1890 To match more than one field pass the list of fields to match separated
16528
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1891 by spaces (e.g. ``author description``).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1892
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1893 Valid fields are most regular revision fields and some special fields.
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1894
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1895 Regular revision fields are ``description``, ``author``, ``branch``,
17102
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1896 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1897 and ``diff``.
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1898 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1899 contents of the revision. Two revisions matching their ``diff`` will
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1900 also match their ``files``.
16528
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1901
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1902 Special fields are ``summary`` and ``metadata``:
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1903 ``summary`` matches the first line of the description.
16639
00290bd359fe revset: documentation typo "metatadata"
Jesse Glick <jesse.glick@oracle.com>
parents: 16528
diff changeset
1904 ``metadata`` is equivalent to matching ``description user date``
16528
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1905 (i.e. it matches the main metadata fields).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1906
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1907 ``metadata`` is the default field which is used when no fields are
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 16521
diff changeset
1908 specified. You can match more than one field at a time.
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1909 """
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
1910 # i18n: "matching" is a keyword
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1911 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1912
23166
30e0dcd7c5ff revset-matching: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23165
diff changeset
1913 revs = getset(repo, fullreposet(repo), l[0])
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1914
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1915 fieldlist = ['metadata']
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1916 if len(l) > 1:
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1917 fieldlist = getstring(l[1],
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
1918 # i18n: "matching" is a keyword
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1919 _("matching requires a string "
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1920 "as its second argument")).split()
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1921
17102
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1922 # Make sure that there are no repeated fields,
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1923 # expand the 'special' 'metadata' field type
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1924 # and check the 'files' whenever we check the 'diff'
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1925 fields = []
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1926 for field in fieldlist:
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1927 if field == 'metadata':
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1928 fields += ['user', 'description', 'date']
17102
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1929 elif field == 'diff':
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1930 # a revision matching the diff must also match the files
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1931 # since matching the diff is very costly, make sure to
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1932 # also match the files first
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1933 fields += ['files', 'diff']
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1934 else:
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1935 if field == 'author':
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1936 field = 'user'
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1937 fields.append(field)
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1938 fields = set(fields)
16444
432f198600c6 revset: make matching keyword not match summary when matching for description
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16417
diff changeset
1939 if 'summary' in fields and 'description' in fields:
432f198600c6 revset: make matching keyword not match summary when matching for description
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16417
diff changeset
1940 # If a revision matches its description it also matches its summary
432f198600c6 revset: make matching keyword not match summary when matching for description
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16417
diff changeset
1941 fields.discard('summary')
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1942
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1943 # We may want to match more than one field
16446
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1944 # Not all fields take the same amount of time to be matched
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1945 # Sort the selected fields in order of increasing matching cost
16453
d2a865d4b963 revset: make matching() work on python 2.4
Patrick Mezard <patrick@mezard.eu>
parents: 16452
diff changeset
1946 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
17102
d9a046ae4d8e revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 17100
diff changeset
1947 'files', 'description', 'substate', 'diff']
16446
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1948 def fieldkeyfunc(f):
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1949 try:
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1950 return fieldorder.index(f)
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1951 except ValueError:
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1952 # assume an unknown field is very costly
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1953 return len(fieldorder)
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1954 fields = list(fields)
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1955 fields.sort(key=fieldkeyfunc)
984e0412e82b revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16445
diff changeset
1956
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1957 # Each field will be matched with its own "getfield" function
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1958 # which will be added to the getfieldfuncs array of functions
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1959 getfieldfuncs = []
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1960 _funcs = {
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1961 'user': lambda r: repo[r].user(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1962 'branch': lambda r: repo[r].branch(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1963 'date': lambda r: repo[r].date(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1964 'description': lambda r: repo[r].description(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1965 'files': lambda r: repo[r].files(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1966 'parents': lambda r: repo[r].parents(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1967 'phase': lambda r: repo[r].phase(),
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1968 'substate': lambda r: repo[r].substate,
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1969 'summary': lambda r: repo[r].description().splitlines()[0],
38565
6ec996e8c9bc revset: pass an explicit `diffopts` objet to context.diff
Boris Feld <boris.feld@octobus.net>
parents: 38522
diff changeset
1970 'diff': lambda r: list(repo[r].diff(
38587
b62000a28812 diffutil: remove diffopts() in favor of diffallopts()
Yuya Nishihara <yuya@tcha.org>
parents: 38575
diff changeset
1971 opts=diffutil.diffallopts(repo.ui, {'git': True}))),
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1972 }
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1973 for info in fields:
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1974 getfield = _funcs.get(info, None)
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1975 if getfield is None:
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1976 raise error.ParseError(
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
1977 # i18n: "matching" is a keyword
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1978 _("unexpected field name passed to matching: %s") % info)
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1979 getfieldfuncs.append(getfield)
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1980 # convert the getfield array of functions into a "getinfo" function
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1981 # which returns an array of field values (or a single value if there
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1982 # is only one field to match)
16445
453c8670566c revset: speedup matching() by stopping the match early if a field does not match
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16444
diff changeset
1983 getinfo = lambda r: [f(r) for f in getfieldfuncs]
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1984
20459
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1985 def matches(x):
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1986 for rev in revs:
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1987 target = getinfo(rev)
16445
453c8670566c revset: speedup matching() by stopping the match early if a field does not match
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16444
diff changeset
1988 match = True
453c8670566c revset: speedup matching() by stopping the match early if a field does not match
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16444
diff changeset
1989 for n, f in enumerate(getfieldfuncs):
20459
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1990 if target[n] != f(x):
16445
453c8670566c revset: speedup matching() by stopping the match early if a field does not match
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16444
diff changeset
1991 match = False
453c8670566c revset: speedup matching() by stopping the match early if a field does not match
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16444
diff changeset
1992 if match:
20459
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1993 return True
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1994 return False
51890507c6b3 revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20458
diff changeset
1995
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
1996 return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
16402
1fb2f1400ea8 revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 16218
diff changeset
1997
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
1998 @predicate('reverse(set)', safe=True, takeorder=True, weight=0)
29945
89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29944
diff changeset
1999 def reverse(repo, subset, x, order):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
2000 """Reverse order of set.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2001 """
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
2002 l = getset(repo, subset, x, order)
29945
89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29944
diff changeset
2003 if order == defineorder:
89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29944
diff changeset
2004 l.reverse()
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2005 return l
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2006
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
2007 @predicate('roots(set)', safe=True)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
2008 def roots(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
2009 """Changesets in set with no parent changeset in set.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2010 """
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
2011 s = getset(repo, fullreposet(repo), x)
25647
46a96dd4d976 revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25634
diff changeset
2012 parents = repo.changelog.parentrevs
46a96dd4d976 revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25634
diff changeset
2013 def filter(r):
46a96dd4d976 revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25634
diff changeset
2014 for p in parents(r):
46a96dd4d976 revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25634
diff changeset
2015 if 0 <= p and p in s:
46a96dd4d976 revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25634
diff changeset
2016 return False
46a96dd4d976 revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25634
diff changeset
2017 return True
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
2018 return subset & s.filter(filter, condrepr='<roots>')
11944
df52ff0980fe revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents: 11886
diff changeset
2019
29265
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2020 _sortkeyfuncs = {
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2021 'rev': lambda c: c.rev(),
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2022 'branch': lambda c: c.branch(),
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2023 'desc': lambda c: c.description(),
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2024 'user': lambda c: c.user(),
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2025 'author': lambda c: c.user(),
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2026 'date': lambda c: c.date()[0],
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2027 }
3f9e68864ccc revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents: 29264
diff changeset
2028
29365
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2029 def _getsortargs(x):
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2030 """Parse sort options into (set, [(key, reverse)], opts)"""
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2031 args = getargsdict(x, 'sort', 'set keys topo.firstbranch')
29238
e150c1d5f262 revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents: 29216
diff changeset
2032 if 'set' not in args:
e150c1d5f262 revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents: 29216
diff changeset
2033 # i18n: "sort" is a keyword
e150c1d5f262 revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents: 29216
diff changeset
2034 raise error.ParseError(_('sort requires one or two arguments'))
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2035 keys = "rev"
29238
e150c1d5f262 revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents: 29216
diff changeset
2036 if 'keys' in args:
17259
e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 17258
diff changeset
2037 # i18n: "sort" is a keyword
29238
e150c1d5f262 revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents: 29216
diff changeset
2038 keys = getstring(args['keys'], _("sort spec must be a string"))
e150c1d5f262 revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents: 29216
diff changeset
2039
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2040 keyflags = []
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2041 for k in keys.split():
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2042 fk = k
35914
7a991241f586 py3: use .startswith() instead of bytes[0]
Pulkit Goyal <7895pulkit@gmail.com>
parents: 35904
diff changeset
2043 reverse = (k.startswith('-'))
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2044 if reverse:
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2045 k = k[1:]
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2046 if k not in _sortkeyfuncs and k != 'topo':
36580
04e50037d957 revset: use {force,}bytestr to fix some %r formatting issues
Augie Fackler <augie@google.com>
parents: 35914
diff changeset
2047 raise error.ParseError(
04e50037d957 revset: use {force,}bytestr to fix some %r formatting issues
Augie Fackler <augie@google.com>
parents: 35914
diff changeset
2048 _("unknown sort key %r") % pycompat.bytestr(fk))
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2049 keyflags.append((k, reverse))
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2050
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2051 if len(keyflags) > 1 and any(k == 'topo' for k, reverse in keyflags):
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2052 # i18n: "topo" is a keyword
29646
a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29441
diff changeset
2053 raise error.ParseError(_('topo sort order cannot be combined '
a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29441
diff changeset
2054 'with other sort keys'))
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2055
29364
76a1a703e23d revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents: 29363
diff changeset
2056 opts = {}
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2057 if 'topo.firstbranch' in args:
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2058 if any(k == 'topo' for k, reverse in keyflags):
29364
76a1a703e23d revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents: 29363
diff changeset
2059 opts['topo.firstbranch'] = args['topo.firstbranch']
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2060 else:
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2061 # i18n: "topo" and "topo.firstbranch" are keywords
29646
a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29441
diff changeset
2062 raise error.ParseError(_('topo.firstbranch can only be used '
a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 29441
diff changeset
2063 'when using the topo sort key'))
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2064
29365
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2065 return args['set'], keyflags, opts
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2066
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
2067 @predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True,
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
2068 weight=10)
29946
285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29945
diff changeset
2069 def sort(repo, subset, x, order):
29365
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2070 """Sort set by keys. The default sort order is ascending, specify a key
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2071 as ``-key`` to sort in descending order.
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2072
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2073 The keys can be:
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2074
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2075 - ``rev`` for the revision number,
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2076 - ``branch`` for the branch name,
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2077 - ``desc`` for the commit message (description),
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2078 - ``user`` for user name (``author`` can be used as an alias),
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2079 - ``date`` for the commit date
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2080 - ``topo`` for a reverse topographical sort
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2081
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2082 The ``topo`` sort order cannot be combined with other sort keys. This sort
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2083 takes one optional argument, ``topo.firstbranch``, which takes a revset that
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2084 specifies what topographical branches to prioritize in the sort.
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2085
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2086 """
f652e84f23f2 revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents: 29364
diff changeset
2087 s, keyflags, opts = _getsortargs(x)
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
2088 revs = getset(repo, subset, s, order)
29364
76a1a703e23d revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents: 29363
diff changeset
2089
29946
285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29945
diff changeset
2090 if not keyflags or order != defineorder:
20719
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20718
diff changeset
2091 return revs
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2092 if len(keyflags) == 1 and keyflags[0][0] == "rev":
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2093 revs.sort(reverse=keyflags[0][1])
20719
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20718
diff changeset
2094 return revs
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2095 elif keyflags[0][0] == "topo":
29364
76a1a703e23d revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents: 29363
diff changeset
2096 firstbranch = ()
76a1a703e23d revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents: 29363
diff changeset
2097 if 'topo.firstbranch' in opts:
76a1a703e23d revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents: 29363
diff changeset
2098 firstbranch = getset(repo, subset, opts['topo.firstbranch'])
32903
27932a76a88d dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents: 32885
diff changeset
2099 revs = baseset(dagop.toposort(revs, repo.changelog.parentrevs,
27932a76a88d dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents: 32885
diff changeset
2100 firstbranch),
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2101 istopo=True)
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2102 if keyflags[0][1]:
29348
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2103 revs.reverse()
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2104 return revs
2188f170f5b6 revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents: 29347
diff changeset
2105
29001
923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218)
Yuya Nishihara <yuya@tcha.org>
parents: 28910
diff changeset
2106 # sort() is guaranteed to be stable
923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218)
Yuya Nishihara <yuya@tcha.org>
parents: 28910
diff changeset
2107 ctxs = [repo[r] for r in revs]
29363
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2108 for k, reverse in reversed(keyflags):
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents: 29362
diff changeset
2109 ctxs.sort(key=_sortkeyfuncs[k], reverse=reverse)
29001
923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218)
Yuya Nishihara <yuya@tcha.org>
parents: 28910
diff changeset
2110 return baseset([c.rev() for c in ctxs])
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2111
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
2112 @predicate('subrepo([pattern])')
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2113 def subrepo(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
2114 """Changesets that add, modify or remove the given subrepo. If no subrepo
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2115 pattern is named, any subrepo changes are returned.
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2116 """
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2117 # i18n: "subrepo" is a keyword
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2118 args = getargs(x, 0, 1, _('subrepo takes at most one argument'))
28272
760f9d04842a revset: define "pat" variable unconditionally in subrepo()
Yuya Nishihara <yuya@tcha.org>
parents: 28271
diff changeset
2119 pat = None
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2120 if len(args) != 0:
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2121 pat = getstring(args[0], _("subrepo requires a pattern"))
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2122
41676
0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 41563
diff changeset
2123 m = matchmod.exact(['.hgsubstate'])
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2124
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2125 def submatches(names):
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
2126 k, p, m = stringutil.stringmatcher(pat)
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2127 for name in names:
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2128 if m(name):
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2129 yield name
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2130
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2131 def matches(x):
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2132 c = repo[x]
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2133 s = repo.status(c.p1().node(), c.node(), match=m)
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2134
28272
760f9d04842a revset: define "pat" variable unconditionally in subrepo()
Yuya Nishihara <yuya@tcha.org>
parents: 28271
diff changeset
2135 if pat is None:
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2136 return s.added or s.modified or s.removed
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2137
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2138 if s.added:
25149
3f0744eeaeaf cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents: 25146
diff changeset
2139 return any(submatches(c.substate.keys()))
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2140
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2141 if s.modified:
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2142 subs = set(c.p1().substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2143 subs.update(c.substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2144
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2145 for path in submatches(subs):
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2146 if c.p1().substate.get(path) != c.substate.get(path):
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2147 return True
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2148
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2149 if s.removed:
25149
3f0744eeaeaf cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents: 25146
diff changeset
2150 return any(submatches(c.p1().substate.keys()))
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2151
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2152 return False
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2153
28424
534f968d33e5 revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents: 28423
diff changeset
2154 return subset.filter(matches, condrepr=('<subrepo %r>', pat))
24446
582cfcc843c7 revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents: 24419
diff changeset
2155
33377
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2156 def _mapbynodefunc(repo, s, f):
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2157 """(repo, smartset, [node] -> [node]) -> smartset
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2158
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2159 Helper method to map a smartset to another smartset given a function only
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2160 talking about nodes. Handles converting between rev numbers and nodes, and
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2161 filtering.
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2162 """
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2163 cl = repo.unfiltered().changelog
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2164 torev = cl.rev
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2165 tonode = cl.node
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2166 nodemap = cl.nodemap
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2167 result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap)
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2168 return smartset.baseset(result - repo.changelog.filteredrevs)
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2169
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2170 @predicate('successors(set)', safe=True)
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2171 def successors(repo, subset, x):
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2172 """All successors for set, including the given set themselves"""
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2173 s = getset(repo, fullreposet(repo), x)
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2174 f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes)
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2175 d = _mapbynodefunc(repo, s, f)
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2176 return subset & d
5d63e5f40bea revset: define successors revset
Jun Wu <quark@fb.com>
parents: 33336
diff changeset
2177
30782
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
2178 def _substringmatcher(pattern, casesensitive=True):
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
2179 kind, pattern, matcher = stringutil.stringmatcher(
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
2180 pattern, casesensitive=casesensitive)
16823
b23bacb230c9 revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents: 16822
diff changeset
2181 if kind == 'literal':
30782
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
2182 if not casesensitive:
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
2183 pattern = encoding.lower(pattern)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
2184 matcher = lambda s: pattern in encoding.lower(s)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
2185 else:
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents: 30772
diff changeset
2186 matcher = lambda s: pattern in s
16823
b23bacb230c9 revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents: 16822
diff changeset
2187 return kind, pattern, matcher
16819
5260a9e93113 revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents: 16803
diff changeset
2188
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
2189 @predicate('tag([name])', safe=True)
12715
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents: 12616
diff changeset
2190 def tag(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
2191 """The specified tag by name, or all tagged revisions if no name is given.
20824
c57c9cece645 revset: document the regular expression support for tag(name)
Matt Harbison <matt_harbison@yahoo.com>
parents: 20289
diff changeset
2192
30784
5dd67f0993ce help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents: 30783
diff changeset
2193 Pattern matching is supported for `name`. See
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
2194 :hg:`help revisions.patterns`.
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2195 """
12815
079a618ea89d revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents: 12786
diff changeset
2196 # i18n: "tag" is a keyword
12715
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents: 12616
diff changeset
2197 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
11280
a5eb0bf7e158 revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents: 11279
diff changeset
2198 cl = repo.changelog
12715
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents: 12616
diff changeset
2199 if args:
16820
20f55613fb2a revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents: 16819
diff changeset
2200 pattern = getstring(args[0],
20f55613fb2a revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents: 16819
diff changeset
2201 # i18n: "tag" is a keyword
20f55613fb2a revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents: 16819
diff changeset
2202 _('the argument to tag must be a string'))
37084
f0b6fbea00cf stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents: 37001
diff changeset
2203 kind, pattern, matcher = stringutil.stringmatcher(pattern)
16820
20f55613fb2a revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents: 16819
diff changeset
2204 if kind == 'literal':
16825
b6ef1395d77f revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents: 16824
diff changeset
2205 # avoid resolving all tags
b6ef1395d77f revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents: 16824
diff changeset
2206 tn = repo._tagscache.tags.get(pattern, None)
b6ef1395d77f revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents: 16824
diff changeset
2207 if tn is None:
23978
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 23956
diff changeset
2208 raise error.RepoLookupError(_("tag '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 23956
diff changeset
2209 % pattern)
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
2210 s = {repo[tn].rev()}
16820
20f55613fb2a revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents: 16819
diff changeset
2211 else:
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
2212 s = {cl.rev(n) for t, n in repo.tagslist() if matcher(t)}
12715
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents: 12616
diff changeset
2213 else:
32291
bd872f64a8ba cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents: 32085
diff changeset
2214 s = {cl.rev(n) for t, n in repo.tagslist() if t != 'tip'}
20367
2ac278aab2b4 revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20366
diff changeset
2215 return subset & s
11280
a5eb0bf7e158 revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents: 11279
diff changeset
2216
27587
c8dc480142a8 revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27586
diff changeset
2217 @predicate('tagged', safe=True)
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2218 def tagged(repo, subset, x):
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2219 return tag(repo, subset, x)
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2220
33774
9dcc3529e002 revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents: 33417
diff changeset
2221 @predicate('orphan()', safe=True)
9dcc3529e002 revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents: 33417
diff changeset
2222 def orphan(repo, subset, x):
33855
457d1ebf151b revset: mark evolution-related revsets as experimental
Boris Feld <boris.feld@octobus.net>
parents: 33779
diff changeset
2223 """Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
17291
2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets
Patrick Mezard <patrick@mezard.eu>
parents: 17272
diff changeset
2224 """
33774
9dcc3529e002 revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents: 33417
diff changeset
2225 # i18n: "orphan" is a keyword
9dcc3529e002 revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents: 33417
diff changeset
2226 getargs(x, 0, 0, _("orphan takes no arguments"))
33777
d4b7496f7d0b obsolete: rename unstable volatile set into orphan volatile set
Boris Feld <boris.feld@octobus.net>
parents: 33776
diff changeset
2227 orphan = obsmod.getrevs(repo, 'orphan')
d4b7496f7d0b obsolete: rename unstable volatile set into orphan volatile set
Boris Feld <boris.feld@octobus.net>
parents: 33776
diff changeset
2228 return subset & orphan
17171
9c750c3e4fac obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17170
diff changeset
2229
9c750c3e4fac obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 17170
diff changeset
2230
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
2231 @predicate('user(string)', safe=True, weight=10)
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
2232 def user(repo, subset, x):
27584
fc7c8cac6a4b revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 27517
diff changeset
2233 """User name contains string. The match is case-insensitive.
16823
b23bacb230c9 revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents: 16822
diff changeset
2234
30784
5dd67f0993ce help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents: 30783
diff changeset
2235 Pattern matching is supported for `string`. See
30799
0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents: 30784
diff changeset
2236 :hg:`help revisions.patterns`.
13359
87f248e78173 bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents: 13031
diff changeset
2237 """
13915
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents: 13914
diff changeset
2238 return author(repo, subset, x)
13359
87f248e78173 bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents: 13031
diff changeset
2239
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
2240 @predicate('wdir()', safe=True, weight=0)
24419
0e41f110e69e revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents: 24374
diff changeset
2241 def wdir(repo, subset, x):
30701
8b1d87243710 revset: document wdir() as an experimental function
Yuya Nishihara <yuya@tcha.org>
parents: 30700
diff changeset
2242 """Working directory. (EXPERIMENTAL)"""
24419
0e41f110e69e revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents: 24374
diff changeset
2243 # i18n: "wdir" is a keyword
0e41f110e69e revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents: 24374
diff changeset
2244 getargs(x, 0, 0, _("wdir takes no arguments"))
25765
5e1b0739611c revset: use integer representation of wdir() in revset
Yuya Nishihara <yuya@tcha.org>
parents: 25716
diff changeset
2245 if node.wdirrev in subset or isinstance(subset, fullreposet):
5e1b0739611c revset: use integer representation of wdir() in revset
Yuya Nishihara <yuya@tcha.org>
parents: 25716
diff changeset
2246 return baseset([node.wdirrev])
24419
0e41f110e69e revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents: 24374
diff changeset
2247 return baseset()
0e41f110e69e revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents: 24374
diff changeset
2248
29935
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2249 def _orderedlist(repo, subset, x):
15898
6902e13ddd03 revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents: 15837
diff changeset
2250 s = getstring(x, "internal error")
6902e13ddd03 revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents: 15837
diff changeset
2251 if not s:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
2252 return baseset()
25341
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25309
diff changeset
2253 # remove duplicates here. it's difficult for caller to deduplicate sets
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25309
diff changeset
2254 # because different symbols can point to the same rev.
25344
ceaf04bb14ff revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25343
diff changeset
2255 cl = repo.changelog
25341
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25309
diff changeset
2256 ls = []
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25309
diff changeset
2257 seen = set()
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25309
diff changeset
2258 for t in s.split('\0'):
25344
ceaf04bb14ff revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25343
diff changeset
2259 try:
ceaf04bb14ff revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25343
diff changeset
2260 # fast path for integer revision
ceaf04bb14ff revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25343
diff changeset
2261 r = int(t)
36581
b755eab7e677 revset: use %d to turn an int into a bytestr
Augie Fackler <augie@google.com>
parents: 36580
diff changeset
2262 if ('%d' % r) != t or r not in cl:
25344
ceaf04bb14ff revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25343
diff changeset
2263 raise ValueError
26143
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2264 revs = [r]
25344
ceaf04bb14ff revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25343
diff changeset
2265 except ValueError:
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
2266 revs = stringset(repo, subset, t, defineorder)
26143
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2267
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2268 for r in revs:
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2269 if r in seen:
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2270 continue
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2271 if (r in subset
42264
6bc1245cd598 revset: populate wdir() by its hash or revision number
Yuya Nishihara <yuya@tcha.org>
parents: 42262
diff changeset
2272 or r in _virtualrevs and isinstance(subset, fullreposet)):
26143
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2273 ls.append(r)
42bb1812686f revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents: 26102
diff changeset
2274 seen.add(r)
25341
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents: 25309
diff changeset
2275 return baseset(ls)
15898
6902e13ddd03 revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents: 15837
diff changeset
2276
20566
98024950ade0 revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20552
diff changeset
2277 # for internal use
29935
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2278 @predicate('_list', safe=True, takeorder=True)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2279 def _list(repo, subset, x, order):
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2280 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2281 # slow path to take the subset order
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2282 return subset & _orderedlist(repo, fullreposet(repo), x)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2283 else:
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2284 return _orderedlist(repo, subset, x)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2285
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2286 def _orderedintlist(repo, subset, x):
20566
98024950ade0 revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20552
diff changeset
2287 s = getstring(x, "internal error")
98024950ade0 revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20552
diff changeset
2288 if not s:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
2289 return baseset()
20566
98024950ade0 revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20552
diff changeset
2290 ls = [int(r) for r in s.split('\0')]
22876
d52ca940c665 revset-_intlist: remove usage of `set()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22875
diff changeset
2291 s = subset
20566
98024950ade0 revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20552
diff changeset
2292 return baseset([r for r in ls if r in s])
98024950ade0 revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20552
diff changeset
2293
20569
0d4be103c734 revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20566
diff changeset
2294 # for internal use
34273
b0790bebfcf8 revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents: 34065
diff changeset
2295 @predicate('_intlist', safe=True, takeorder=True, weight=0)
29935
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2296 def _intlist(repo, subset, x, order):
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2297 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2298 # slow path to take the subset order
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2299 return subset & _orderedintlist(repo, fullreposet(repo), x)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2300 else:
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2301 return _orderedintlist(repo, subset, x)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2302
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2303 def _orderedhexlist(repo, subset, x):
20569
0d4be103c734 revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20566
diff changeset
2304 s = getstring(x, "internal error")
0d4be103c734 revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20566
diff changeset
2305 if not s:
22802
1fcd361efaf4 baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22801
diff changeset
2306 return baseset()
20569
0d4be103c734 revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20566
diff changeset
2307 cl = repo.changelog
0d4be103c734 revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20566
diff changeset
2308 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
22877
489d2f3688c9 revset-_hexlist: remove usage of `set()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22876
diff changeset
2309 s = subset
20569
0d4be103c734 revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents: 20566
diff changeset
2310 return baseset([r for r in ls if r in s])
15898
6902e13ddd03 revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents: 15837
diff changeset
2311
29935
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2312 # for internal use
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2313 @predicate('_hexlist', safe=True, takeorder=True)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2314 def _hexlist(repo, subset, x, order):
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2315 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2316 # slow path to take the subset order
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2317 return subset & _orderedhexlist(repo, fullreposet(repo), x)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2318 else:
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2319 return _orderedhexlist(repo, subset, x)
e34cd85dc5b1 revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents: 29934
diff changeset
2320
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2321 methods = {
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2322 "range": rangeset,
30803
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
2323 "rangeall": rangeall,
30044
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents: 30043
diff changeset
2324 "rangepre": rangepre,
30803
d389f19f14aa revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents: 30802
diff changeset
2325 "rangepost": rangepost,
16860
e1aa1ed30030 revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents: 16859
diff changeset
2326 "dagrange": dagrange,
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2327 "string": stringset,
24932
022282152632 revset: don't error out if tokens parse as existing symbols
Jordi Guti?rrez Hermoso <jordigh@octave.org>
parents: 24923
diff changeset
2328 "symbol": stringset,
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2329 "and": andset,
34020
37b82485097f revset: do not flip "and" arguments when optimizing
Jun Wu <quark@fb.com>
parents: 34019
diff changeset
2330 "andsmally": andsmallyset,
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2331 "or": orset,
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2332 "not": notset,
28217
d2ac8b57a75d revset: use smartset minus operator
Durham Goode <durham@fb.com>
parents: 28139
diff changeset
2333 "difference": differenceset,
33416
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
2334 "relation": relationset,
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
2335 "relsubscript": relsubscriptset,
9467d5337292 revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents: 33377
diff changeset
2336 "subscript": subscriptset,
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2337 "list": listset,
25704
70a2082f855a revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents: 25689
diff changeset
2338 "keyvalue": keyvaluepair,
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2339 "func": func,
14070
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
2340 "ancestor": ancestorspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents: 14061
diff changeset
2341 "parent": parentspec,
29931
d2d1be3009ca revset: add stub to handle parentpost operation
Yuya Nishihara <yuya@tcha.org>
parents: 29930
diff changeset
2342 "parentpost": parentpost,
41222
8aca89a694d4 revset: introduce an API that avoids `formatspec` input serialization
Boris Feld <boris.feld@octobus.net>
parents: 40931
diff changeset
2343 "smartset": rawsmartset,
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2344 }
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2345
40931
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
2346 subscriptrelations = {
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
2347 "g": generationsrel,
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
2348 "generations": generationsrel,
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
2349 }
e54bfde922f2 revset: move subscript relation functions to its own dict
Anton Shestakov <av6@dwimlabs.net>
parents: 40534
diff changeset
2350
37350
e32dfff71529 revset: use revsymbol() for checking if a symbol is valid
Martin von Zweigbergk <martinvonz@google.com>
parents: 37271
diff changeset
2351 def lookupfn(repo):
e32dfff71529 revset: use revsymbol() for checking if a symbol is valid
Martin von Zweigbergk <martinvonz@google.com>
parents: 37271
diff changeset
2352 return lambda symbol: scmutil.isrevsymbol(repo, symbol)
e32dfff71529 revset: use revsymbol() for checking if a symbol is valid
Martin von Zweigbergk <martinvonz@google.com>
parents: 37271
diff changeset
2353
37674
f83cb91b052e revset: pass in lookup function instead of repo (API)
Yuya Nishihara <yuya@tcha.org>
parents: 37673
diff changeset
2354 def match(ui, spec, lookup=None):
34018
de286200f722 revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents: 34017
diff changeset
2355 """Create a matcher for a single revision spec"""
37854
edb28a6d95b7 revset: pass in lookup function to matchany() (issue5879)
Yuya Nishihara <yuya@tcha.org>
parents: 37674
diff changeset
2356 return matchany(ui, [spec], lookup=lookup)
29955
1b5931604a5a revset: add option to make matcher takes the ordering of the input set
Yuya Nishihara <yuya@tcha.org>
parents: 29946
diff changeset
2357
37674
f83cb91b052e revset: pass in lookup function instead of repo (API)
Yuya Nishihara <yuya@tcha.org>
parents: 37673
diff changeset
2358 def matchany(ui, specs, lookup=None, localalias=None):
25927
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2359 """Create a matcher that will include any revisions matching one of the
29955
1b5931604a5a revset: add option to make matcher takes the ordering of the input set
Yuya Nishihara <yuya@tcha.org>
parents: 29946
diff changeset
2360 given specs
1b5931604a5a revset: add option to make matcher takes the ordering of the input set
Yuya Nishihara <yuya@tcha.org>
parents: 29946
diff changeset
2361
37674
f83cb91b052e revset: pass in lookup function instead of repo (API)
Yuya Nishihara <yuya@tcha.org>
parents: 37673
diff changeset
2362 If lookup function is not None, the parser will first attempt to handle
f83cb91b052e revset: pass in lookup function instead of repo (API)
Yuya Nishihara <yuya@tcha.org>
parents: 37673
diff changeset
2363 old-style ranges, which may contain operator characters.
f83cb91b052e revset: pass in lookup function instead of repo (API)
Yuya Nishihara <yuya@tcha.org>
parents: 37673
diff changeset
2364
33336
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2365 If localalias is not None, it is a dict {name: definitionstring}. It takes
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2366 precedence over [revsetalias] config section.
29955
1b5931604a5a revset: add option to make matcher takes the ordering of the input set
Yuya Nishihara <yuya@tcha.org>
parents: 29946
diff changeset
2367 """
25927
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2368 if not specs:
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2369 def mfunc(repo, subset=None):
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2370 return baseset()
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2371 return mfunc
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2372 if not all(specs):
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2373 raise error.ParseError(_("empty query"))
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2374 if len(specs) == 1:
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
2375 tree = revsetlang.parse(specs[0], lookup)
25927
44da63623fca revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents: 25926
diff changeset
2376 else:
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
2377 tree = ('or',
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
2378 ('list',) + tuple(revsetlang.parse(s, lookup) for s in specs))
29906
41491cf936f2 revset: add public function to create matcher from evaluatable tree
Yuya Nishihara <yuya@tcha.org>
parents: 29905
diff changeset
2379
33336
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2380 aliases = []
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2381 warn = None
14900
fc3d6f300d7d revset: allow bypassing alias expansion
Matt Mackall <mpm@selenic.com>
parents: 14851
diff changeset
2382 if ui:
33336
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2383 aliases.extend(ui.configitems('revsetalias'))
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2384 warn = ui.warn
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2385 if localalias:
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2386 aliases.extend(localalias.items())
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2387 if aliases:
4672db164c98 revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents: 33080
diff changeset
2388 tree = revsetlang.expandaliases(tree, aliases, warn=warn)
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
2389 tree = revsetlang.foldconcat(tree)
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
2390 tree = revsetlang.analyze(tree)
31024
0b8356705de6 revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents: 31017
diff changeset
2391 tree = revsetlang.optimize(tree)
34018
de286200f722 revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents: 34017
diff changeset
2392 return makematcher(tree)
29906
41491cf936f2 revset: add public function to create matcher from evaluatable tree
Yuya Nishihara <yuya@tcha.org>
parents: 29905
diff changeset
2393
34018
de286200f722 revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents: 34017
diff changeset
2394 def makematcher(tree):
29906
41491cf936f2 revset: add public function to create matcher from evaluatable tree
Yuya Nishihara <yuya@tcha.org>
parents: 29905
diff changeset
2395 """Create a matcher from an evaluatable tree"""
34019
205c47e30a93 revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents: 34018
diff changeset
2396 def mfunc(repo, subset=None, order=None):
205c47e30a93 revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents: 34018
diff changeset
2397 if order is None:
205c47e30a93 revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents: 34018
diff changeset
2398 if subset is None:
205c47e30a93 revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents: 34018
diff changeset
2399 order = defineorder # 'x'
205c47e30a93 revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents: 34018
diff changeset
2400 else:
205c47e30a93 revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents: 34018
diff changeset
2401 order = followorder # 'subset & x'
24114
fafd9a1284cf revset: make match function initiate query from full set by default
Yuya Nishihara <yuya@tcha.org>
parents: 24031
diff changeset
2402 if subset is None:
24115
ff24af40728b revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents: 24114
diff changeset
2403 subset = fullreposet(repo)
34011
1b28525e6698 revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents: 33855
diff changeset
2404 return getset(repo, subset, tree, order)
11275
c9ce8ecd6ca1 revset: introduce revset core
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
2405 return mfunc
12821
165079e564f0 revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents: 12815
diff changeset
2406
28393
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2407 def loadpredicate(ui, extname, registrarobj):
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2408 """Load revset predicates from specified registrarobj
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2409 """
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2410 for name, func in registrarobj._table.iteritems():
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2411 symbols[name] = func
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2412 if func._safe:
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2413 safesymbols.add(name)
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28272
diff changeset
2414
28395
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28393
diff changeset
2415 # load built-in predicates explicitly to setup safesymbols
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28393
diff changeset
2416 loadpredicate(None, None, predicate)
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28393
diff changeset
2417
12823
80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents: 12821
diff changeset
2418 # tell hggettext to extract docstrings from these functions:
80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents: 12821
diff changeset
2419 i18nfunctions = symbols.values()