Mercurial > hg
annotate mercurial/revset.py @ 35270:0d27685b4a2f
dagop: copy basefilectx.ancestors() to free function
The primary goal of this series is to make follow() support multiple start
revisions.
dagop.filectxancestors() will be extended to take multiple filectxs.
basefilectx.ancestors() is not forwarded to this function because doing that
would resurrect the performance issue fixed by 24b57c3899f8.
author | Yuya Nishihara <yuya@tcha.org> |
---|---|
date | Thu, 22 Sep 2016 17:16:53 +0900 |
parents | 39b094e4ae2c |
children | 70e86db6a913 |
rev | line source |
---|---|
11275 | 1 # revset.py - revision set queries for mercurial |
2 # | |
3 # Copyright 2010 Matt Mackall <mpm@selenic.com> | |
4 # | |
5 # This software may be used and distributed according to the terms of the | |
6 # GNU General Public License version 2 or any later version. | |
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, |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
16 encoding, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
17 error, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
18 hbisect, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
19 match as matchmod, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
20 node, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
21 obsolete as obsmod, |
33377 | 22 obsutil, |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
23 pathutil, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
24 phases, |
27584
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
25 registrar, |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
26 repoview, |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
27 revsetlang, |
32661
a3064fe3e495
revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents:
32442
diff
changeset
|
28 scmutil, |
30881
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
29 smartset, |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
30 util, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
31 ) |
11275 | 32 |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
33 # helpers for processing parsed tree |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
34 getsymbol = revsetlang.getsymbol |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
35 getstring = revsetlang.getstring |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
36 getinteger = revsetlang.getinteger |
31998
83527d9f1f13
revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents:
31938
diff
changeset
|
37 getboolean = revsetlang.getboolean |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
38 getlist = revsetlang.getlist |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
39 getrange = revsetlang.getrange |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
40 getargs = revsetlang.getargs |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
41 getargsdict = revsetlang.getargsdict |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
42 |
30881
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
43 baseset = smartset.baseset |
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
44 generatorset = smartset.generatorset |
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
45 spanset = smartset.spanset |
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
46 fullreposet = smartset.fullreposet |
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
47 |
34016
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
48 # Constants for ordering requirement, used in getset(): |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
49 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
50 # 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
|
51 # 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
|
52 # 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
|
53 # specified by the first operand to the '&' operator. |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
54 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
55 # For instance, |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
56 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
57 # X & (Y | Z) |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
58 # ^ ^^^^^^^ |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
59 # | follow |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
60 # define |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
61 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
62 # 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
|
63 # 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
|
64 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
65 # '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
|
66 # |
34017
62cc1f17c571
revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents:
34016
diff
changeset
|
67 # (X & !Y) | ancestors(Z) |
62cc1f17c571
revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents:
34016
diff
changeset
|
68 # ^ ^ |
62cc1f17c571
revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents:
34016
diff
changeset
|
69 # any any |
34016
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
70 # |
34017
62cc1f17c571
revset: fix example describing how ordering is determined
Yuya Nishihara <yuya@tcha.org>
parents:
34016
diff
changeset
|
71 # 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
|
72 # 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
|
73 # 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
|
74 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
75 # 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
|
76 # 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
|
77 # 'subset' parameter passed down to them: |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
78 # |
34018
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
79 # m = revset.match(...) |
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
80 # m(repo, subset, order=defineorder) |
34016
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
81 # ^^^^^^ |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
82 # 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
|
83 # |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
84 # 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
|
85 # specified: 'sort(X)', 'reverse(X)', 'x:y'. |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
86 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
|
87 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
|
88 followorder = 'follow' # MUST follow the current order |
96f249dce03e
revset: move order constants from revsetlang
Yuya Nishihara <yuya@tcha.org>
parents:
34011
diff
changeset
|
89 |
11275 | 90 # helpers |
91 | |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
92 def getset(repo, subset, x, order=defineorder): |
11275 | 93 if not x: |
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
94 raise error.ParseError(_("missing argument")) |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
95 return methods[x[0]](repo, subset, *x[1:], order=order) |
11275 | 96 |
17003
42c472877825
revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents:
17002
diff
changeset
|
97 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
|
98 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
|
99 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
|
100 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
|
101 try: |
42c472877825
revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents:
17002
diff
changeset
|
102 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
|
103 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
|
104 pass |
42c472877825
revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents:
17002
diff
changeset
|
105 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
|
106 |
11275 | 107 # operator methods |
108 | |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
109 def stringset(repo, subset, x, order): |
32661
a3064fe3e495
revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents:
32442
diff
changeset
|
110 x = scmutil.intrev(repo[x]) |
25265
e16456831516
revset: drop magic of fullreposet membership test (issue4682)
Yuya Nishihara <yuya@tcha.org>
parents:
25094
diff
changeset
|
111 if (x in subset |
e16456831516
revset: drop magic of fullreposet membership test (issue4682)
Yuya Nishihara <yuya@tcha.org>
parents:
25094
diff
changeset
|
112 or x == node.nullrev 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
|
113 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
|
114 return baseset() |
11275 | 115 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
116 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
|
117 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
|
118 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
|
119 |
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
120 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
|
121 return baseset() |
30043
49d5434d68fb
revset: extract function that creates range set from computed revisions
Yuya Nishihara <yuya@tcha.org>
parents:
29955
diff
changeset
|
122 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
|
123 |
30803
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
124 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
|
125 assert x is None |
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
126 return _makerangeset(repo, subset, 0, len(repo) - 1, order) |
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
127 |
30044
69b61d0bb008
revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents:
30043
diff
changeset
|
128 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
|
129 # ':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
|
130 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
|
131 if not n: |
69b61d0bb008
revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents:
30043
diff
changeset
|
132 return baseset() |
69b61d0bb008
revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents:
30043
diff
changeset
|
133 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
|
134 |
30803
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
135 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
|
136 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
|
137 if not m: |
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
138 return baseset() |
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
139 return _makerangeset(repo, subset, m.first(), len(repo) - 1, order) |
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
140 |
30043
49d5434d68fb
revset: extract function that creates range set from computed revisions
Yuya Nishihara <yuya@tcha.org>
parents:
29955
diff
changeset
|
141 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
|
142 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
|
143 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
|
144 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
|
145 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
|
146 elif m == node.wdirrev: |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
147 r = baseset([m]) + spanset(repo, len(repo) - 1, n - 1) |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
148 elif m < n: |
20526
9ad6dae67845
revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20525
diff
changeset
|
149 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
|
150 else: |
20526
9ad6dae67845
revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20525
diff
changeset
|
151 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
|
152 |
5f56a3b9675e
revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29943
diff
changeset
|
153 if order == defineorder: |
5f56a3b9675e
revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29943
diff
changeset
|
154 return r & subset |
5f56a3b9675e
revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29943
diff
changeset
|
155 else: |
5f56a3b9675e
revset: fix order of nested 'range' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29943
diff
changeset
|
156 # 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
|
157 return subset & r |
11275 | 158 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
159 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
|
160 r = fullreposet(repo) |
32903
27932a76a88d
dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents:
32885
diff
changeset
|
161 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
|
162 includepath=True) |
29139
64c1955a0461
revset: make dagrange preserve order of input set
Yuya Nishihara <yuya@tcha.org>
parents:
29119
diff
changeset
|
163 return subset & xs |
16860
e1aa1ed30030
revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents:
16859
diff
changeset
|
164 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
165 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
|
166 if order == anyorder: |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
167 yorder = anyorder |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
168 else: |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
169 yorder = followorder |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
170 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
|
171 |
34020
37b82485097f
revset: do not flip "and" arguments when optimizing
Jun Wu <quark@fb.com>
parents:
34019
diff
changeset
|
172 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
|
173 # '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
|
174 if order == anyorder: |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
175 yorder = anyorder |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
176 else: |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
177 yorder = followorder |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
178 return getset(repo, getset(repo, subset, y, yorder), x, order) |
11275 | 179 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
180 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
|
181 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
|
182 |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
183 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
|
184 assert xs |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
185 if len(xs) == 1: |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
186 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
|
187 p = len(xs) // 2 |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
188 a = _orsetlist(repo, subset, xs[:p], order) |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
189 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
|
190 return a + b |
11275 | 191 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
192 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
|
193 xs = getlist(x) |
2c6a05b938d8
revset: fix order of nested 'or' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29933
diff
changeset
|
194 if order == followorder: |
2c6a05b938d8
revset: fix order of nested 'or' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29933
diff
changeset
|
195 # 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
|
196 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
|
197 else: |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
198 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
|
199 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
200 def notset(repo, subset, x, order): |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
201 return subset - getset(repo, subset, x, anyorder) |
11275 | 202 |
33416
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
203 def relationset(repo, subset, x, y, order): |
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
204 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
|
205 |
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
206 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
|
207 # 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
|
208 # 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
|
209 # https://www.mercurial-scm.org/wiki/RevsetOperatorPlan |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
210 rel = getsymbol(y) |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
211 n = getinteger(z, _("relation subscript must be an integer")) |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
212 |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
213 # TODO: perhaps this should be a table of relation functions |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
214 if rel in ('g', 'generations'): |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
215 # TODO: support range, rewrite tests, and drop startdepth argument |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
216 # from ancestors() and descendants() predicates |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
217 if n <= 0: |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
218 n = -n |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
219 return _ancestors(repo, subset, x, startdepth=n, stopdepth=n + 1) |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
220 else: |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
221 return _descendants(repo, subset, x, startdepth=n, stopdepth=n + 1) |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
222 |
d1b13d4995ed
revset: add experimental ancestors/descendants relation subscript
Yuya Nishihara <yuya@tcha.org>
parents:
33416
diff
changeset
|
223 raise error.UnknownIdentifier(rel, ['generations']) |
33416
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
224 |
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
225 def subscriptset(repo, subset, x, y, order): |
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
226 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
|
227 |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
228 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
|
229 raise error.ParseError(_("can't use a list in this context"), |
c60a9c16ae25
revset: add hint for list error to use or
timeless <timeless@mozdev.org>
parents:
27440
diff
changeset
|
230 hint=_('see hg help "revsets.x or y"')) |
11275 | 231 |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
232 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
|
233 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
|
234 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
235 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
|
236 f = getsymbol(a) |
9e8d258708bb
revset: check invalid function syntax "func-name"() explicitly
Yuya Nishihara <yuya@tcha.org>
parents:
29425
diff
changeset
|
237 if f in symbols: |
30392
155d7ea98085
revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents:
30332
diff
changeset
|
238 func = symbols[f] |
155d7ea98085
revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents:
30332
diff
changeset
|
239 if getattr(func, '_takeorder', False): |
155d7ea98085
revset: avoid shadowing a variable with a list comprehension
Augie Fackler <augie@google.com>
parents:
30332
diff
changeset
|
240 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
|
241 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
|
242 |
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
243 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
|
244 |
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
245 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
|
246 raise error.UnknownIdentifier(f, syms) |
11275 | 247 |
248 # functions | |
249 | |
27584
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
250 # 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
|
251 # 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
|
252 # with: |
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
253 # 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
|
254 # 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
|
255 # x - argument in tree form |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
256 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
|
257 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
258 # 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
|
259 # (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
|
260 # 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
|
261 safesymbols = set() |
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
262 |
28395
0383f7a5e86c
revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28393
diff
changeset
|
263 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
|
264 |
27584
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
265 @predicate('_destupdate') |
26713
a271925699d6
revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26638
diff
changeset
|
266 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
|
267 # 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
|
268 args = getargsdict(x, 'limit', 'clean') |
26713
a271925699d6
revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26638
diff
changeset
|
269 return subset & baseset([destutil.destupdate(repo, **args)[0]]) |
a271925699d6
revset: reintroduce and experimental revset for update destination
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26638
diff
changeset
|
270 |
27584
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
271 @predicate('_destmerge') |
26716
c027641f8a83
revset: rename and test '_destmerge'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26714
diff
changeset
|
272 def _destmerge(repo, subset, x): |
c027641f8a83
revset: rename and test '_destmerge'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26714
diff
changeset
|
273 # 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
|
274 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
|
275 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
|
276 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
|
277 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
|
278 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
279 @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
|
280 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
|
281 """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
|
282 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
283 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
|
284 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
|
285 directory. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
286 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
287 # i18n: "adds" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
288 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
|
289 return checkstatus(repo, subset, pat, 1) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
290 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
291 @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
|
292 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
|
293 """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
|
294 |
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
295 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
|
296 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
|
297 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
|
298 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
299 # i18n: "ancestor" is a keyword |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
300 l = getlist(x) |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
301 rl = fullreposet(repo) |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
302 anc = None |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
303 |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
304 # (getset(repo, rl, i) for i in l) generates a list of lists |
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
305 for revs in (getset(repo, rl, i) for i in l): |
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
306 for r in revs: |
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
307 if anc is None: |
20991
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
308 anc = repo[r] |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
309 else: |
20991
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
310 anc = anc.ancestor(repo[r]) |
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
311 |
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
312 if anc is not None and anc.rev() in subset: |
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
313 return baseset([anc.rev()]) |
22802
1fcd361efaf4
baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22801
diff
changeset
|
314 return baseset() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
315 |
33003
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
316 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
|
317 stopdepth=None): |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
318 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
|
319 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
|
320 return baseset() |
33003
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
321 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
|
322 return subset & s |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
323 |
33002
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
324 @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
|
325 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
|
326 """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
|
327 given changesets themselves. |
33002
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
328 |
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
329 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
|
330 the specified generation. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
331 """ |
33003
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
332 # 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
|
333 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
|
334 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
|
335 # 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
|
336 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
|
337 startdepth = stopdepth = None |
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
338 if 'startdepth' in args: |
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
339 n = getinteger(args['startdepth'], |
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
340 "ancestors expects an integer startdepth") |
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
341 if n < 0: |
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
342 raise error.ParseError("negative startdepth") |
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
343 startdepth = n |
33002
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
344 if 'depth' in args: |
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
345 # i18n: "ancestors" is a keyword |
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
346 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
|
347 if n < 0: |
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
348 raise error.ParseError(_("negative depth")) |
272a44cac57e
revset: add depth limit to ancestors()
Yuya Nishihara <yuya@tcha.org>
parents:
32914
diff
changeset
|
349 stopdepth = n + 1 |
33003
f63d111258da
revset: add startdepth limit to ancestors() as internal option
Yuya Nishihara <yuya@tcha.org>
parents:
33002
diff
changeset
|
350 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
|
351 startdepth=startdepth, stopdepth=stopdepth) |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
352 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
353 @predicate('_firstancestors', safe=True) |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
354 def _firstancestors(repo, subset, x): |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
355 # ``_firstancestors(set)`` |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
356 # 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
|
357 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
|
358 |
32699
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
359 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
|
360 """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
|
361 in set. |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
362 """ |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
363 cs = set() |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
364 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
|
365 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
|
366 c = repo[r].children() |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
367 if len(c) == 0: |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
368 break |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
369 if len(c) > 1: |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
370 raise error.RepoLookupError( |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
371 _("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
|
372 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
|
373 else: |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
374 cs.add(r) |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
375 return subset & cs |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
376 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
377 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
|
378 """``set~n`` |
16683 | 379 Changesets that are the Nth ancestor (first parents only) of a changeset |
380 in set. | |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
381 """ |
30801
67ee7874e53b
revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30800
diff
changeset
|
382 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
|
383 if n < 0: |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
384 # children lookup |
f75d0aa5dc83
revset: lookup descendents for negative arguments to ancestor operator
David Soria Parra <davidsp@fb.com>
parents:
32684
diff
changeset
|
385 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
|
386 ps = set() |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
387 cl = repo.changelog |
23163
6f1b8b3f12fd
revset-ancestorspec: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23162
diff
changeset
|
388 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
|
389 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
|
390 try: |
018f638ad88e
revset: add support for using ~ operator on wdir() predicate
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32440
diff
changeset
|
391 r = cl.parentrevs(r)[0] |
018f638ad88e
revset: add support for using ~ operator on wdir() predicate
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32440
diff
changeset
|
392 except error.WdirUnsupported: |
018f638ad88e
revset: add support for using ~ operator on wdir() predicate
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32440
diff
changeset
|
393 r = repo[r].parents()[0].rev() |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
394 ps.add(r) |
22531
22ba2c0825da
revset: use `subset &` in `ancestorspec`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22530
diff
changeset
|
395 return subset & ps |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
396 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
397 @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
|
398 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
|
399 """Alias for ``user(string)``. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
400 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
401 # 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
|
402 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
|
403 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
|
404 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
|
405 condrepr=('<user %r>', n)) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
406 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
407 @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
|
408 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
|
409 """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
|
410 |
15153
fa0a464e4ca5
hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15147
diff
changeset
|
411 - ``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
|
412 - ``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
|
413 - ``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
|
414 - ``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
|
415 - ``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
|
416 - ``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
|
417 - ``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
|
418 """ |
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
|
419 # 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
|
420 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
|
421 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
|
422 return subset & state |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
423 |
15134
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
424 # Backward-compatibility |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
425 # - 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
|
426 @predicate('bisected', safe=True) |
15134
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
427 def bisected(repo, subset, x): |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
428 return bisect(repo, subset, x) |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
429 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
430 @predicate('bookmark([name])', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
431 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
|
432 """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
|
433 |
30799
0b49449a01f4
help: use :hg: role and canonical name to point to revset string patterns
Yuya Nishihara <yuya@tcha.org>
parents:
30784
diff
changeset
|
434 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
|
435 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
436 # i18n: "bookmark" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
437 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
|
438 if args: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
439 bm = getstring(args[0], |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
440 # i18n: "bookmark" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
441 _('the argument to bookmark must be a string')) |
26481
7d132557e44a
util: extract stringmatcher() from revset
Matt Harbison <matt_harbison@yahoo.com>
parents:
26307
diff
changeset
|
442 kind, pattern, matcher = util.stringmatcher(bm) |
22499
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
443 bms = set() |
16822
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
444 if kind == 'literal': |
22105
3efe3c2609e0
revset: bookmark revset interprets 'literal:' prefix correctly (issue4329)
Michael O'Connor <mkoconnor@gmail.com>
parents:
21939
diff
changeset
|
445 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
|
446 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
|
447 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
|
448 % pattern) |
22499
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
449 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
|
450 else: |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
451 matchrevs = set() |
18495
8260fa9f30b9
bookmarks: don't use bookmarks.listbookmarks in local computations
Kevin Bullock <kbullock@ringworld.org>
parents:
18473
diff
changeset
|
452 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
|
453 if matcher(name): |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
454 matchrevs.add(bmrev) |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
455 if not matchrevs: |
23978
eeb5d5ab14a6
revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23956
diff
changeset
|
456 raise error.RepoLookupError(_("no bookmarks exist" |
eeb5d5ab14a6
revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23956
diff
changeset
|
457 " that match '%s'") % pattern) |
16822
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
458 for bmrev in matchrevs: |
22499
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
459 bms.add(repo[bmrev].rev()) |
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
460 else: |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
461 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
|
462 bms -= {node.nullrev} |
22530
faf4f63533ff
revset: use `subset &` in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22529
diff
changeset
|
463 return subset & bms |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
464 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
465 @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
|
466 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
|
467 """ |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
468 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
|
469 changesets. |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
470 |
30784
5dd67f0993ce
help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents:
30783
diff
changeset
|
471 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
|
472 :hg:`help revisions.patterns`. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
473 """ |
24374
77fd1fb538cd
revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents:
24366
diff
changeset
|
474 getbi = repo.revbranchcache().branchinfo |
32683
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
475 def getbranch(r): |
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
476 try: |
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
477 return getbi(r)[0] |
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
478 except error.WdirUnsupported: |
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
479 return repo[r].branch() |
23787
678f53865c68
revset: use localrepo revbranchcache for branch name filtering
Mads Kiilerich <madski@unity3d.com>
parents:
23765
diff
changeset
|
480 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
481 try: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
482 b = getstring(x, '') |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
483 except error.ParseError: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
484 # 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
|
485 pass |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
486 else: |
26481
7d132557e44a
util: extract stringmatcher() from revset
Matt Harbison <matt_harbison@yahoo.com>
parents:
26307
diff
changeset
|
487 kind, pattern, matcher = util.stringmatcher(b) |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
488 if kind == 'literal': |
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
489 # 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
|
490 # this name exists and pattern kind is not specified explicitly |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
491 if pattern in repo.branchmap(): |
32683
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
492 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
|
493 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
|
494 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
|
495 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
|
496 % pattern) |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
497 else: |
32683
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
498 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
|
499 condrepr=('<branch %r>', b)) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
500 |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
501 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
|
502 b = set() |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
503 for r in s: |
32683
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
504 b.add(getbranch(r)) |
22867
5ee9b78ce805
revset-branch: remove usage of `set()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22866
diff
changeset
|
505 c = s.__contains__ |
32683
9f840d99054c
revset: add support for branch(wdir()) and wdir() & branch()
Yuya Nishihara <yuya@tcha.org>
parents:
32661
diff
changeset
|
506 return subset.filter(lambda r: c(r) or getbranch(r) in b, |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
507 condrepr=lambda: '<branch %r>' % sorted(b)) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
508 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
509 @predicate('bumped()', safe=True) |
17829
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
510 def bumped(repo, subset, x): |
33776
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
511 msg = ("'bumped()' is deprecated, " |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
512 "use 'phasedivergent()'") |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
513 repo.ui.deprecwarn(msg, '4.4') |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
514 |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
515 return phasedivergent(repo, subset, x) |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
516 |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
517 @predicate('phasedivergent()', safe=True) |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
518 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
|
519 """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
|
520 |
33776
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
521 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
|
522 (EXPERIMENTAL) |
17829
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
523 """ |
33776
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
524 # i18n: "phasedivergent" is a keyword |
ed99d3afef88
revset: rename bumped into phasedivergent
Boris Feld <boris.feld@octobus.net>
parents:
33775
diff
changeset
|
525 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
|
526 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
|
527 return subset & phasedivergent |
17829
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
528 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
529 @predicate('bundle()', safe=True) |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
530 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
|
531 """Changesets in the bundle. |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
532 |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
533 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
|
534 |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
535 try: |
18411
8b0f0dd56cec
bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents:
18382
diff
changeset
|
536 bundlerevs = repo.changelog.bundlerevs |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
537 except AttributeError: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26571
diff
changeset
|
538 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
|
539 return subset & bundlerevs |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
540 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
541 def checkstatus(repo, subset, pat, field): |
16521
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
542 hasset = matchmod.patkind(pat) == 'set' |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
543 |
23115
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
544 mcache = [None] |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
545 def matches(x): |
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
546 c = repo[x] |
23115
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
547 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
|
548 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
|
549 m = mcache[0] |
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
550 fname = None |
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
551 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
|
552 fname = m.files()[0] |
16521
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
553 if fname is not None: |
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
554 if fname not in c.files(): |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
555 return False |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
556 else: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
557 for f in c.files(): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
558 if m(f): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
559 break |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
560 else: |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
561 return False |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
562 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
|
563 if fname is not None: |
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
564 if fname in files: |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
565 return True |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
566 else: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
567 for f in files: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
568 if m(f): |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
569 return True |
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
570 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
571 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
|
572 |
29406
c2193e59ef9f
revsets: passing a set to baseset() is not wrong
Martin von Zweigbergk <martinvonz@google.com>
parents:
29389
diff
changeset
|
573 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
|
574 if not parentset: |
3e9049876ace
revset: gratuitous code move in '_children'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25549
diff
changeset
|
575 return baseset() |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
576 cs = set() |
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
577 pr = repo.changelog.parentrevs |
25567
f140d6207cca
revset: use parentsets.min in _children
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25566
diff
changeset
|
578 minrev = parentset.min() |
30699
5bda147c3139
revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents:
30392
diff
changeset
|
579 nullrev = node.nullrev |
29406
c2193e59ef9f
revsets: passing a set to baseset() is not wrong
Martin von Zweigbergk <martinvonz@google.com>
parents:
29389
diff
changeset
|
580 for r in subset: |
18063
34a1a639d835
revset.children: ignore rev numbers that are too low
Siddharth Agarwal <sid0@fb.com>
parents:
17980
diff
changeset
|
581 if r <= minrev: |
34a1a639d835
revset.children: ignore rev numbers that are too low
Siddharth Agarwal <sid0@fb.com>
parents:
17980
diff
changeset
|
582 continue |
30699
5bda147c3139
revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents:
30392
diff
changeset
|
583 p1, p2 = pr(r) |
5bda147c3139
revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents:
30392
diff
changeset
|
584 if p1 in parentset: |
5bda147c3139
revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents:
30392
diff
changeset
|
585 cs.add(r) |
5bda147c3139
revset: make children() not look at p2 if null (issue5439)
Yuya Nishihara <yuya@tcha.org>
parents:
30392
diff
changeset
|
586 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
|
587 cs.add(r) |
20709
71df845d86cf
revsets: backout d04aac468bf4 due to performance regressions
Matt Mackall <mpm@selenic.com>
parents:
20708
diff
changeset
|
588 return baseset(cs) |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
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('children(set)', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
591 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
|
592 """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
|
593 """ |
23164
7a42e5d4c418
revset-children: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23163
diff
changeset
|
594 s = getset(repo, fullreposet(repo), x) |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
595 cs = _children(repo, subset, s) |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
596 return subset & cs |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
597 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
598 @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
|
599 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
|
600 """Changeset is closed. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
601 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
602 # i18n: "closed" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
603 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
|
604 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
|
605 condrepr='<branch closed>') |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
606 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
607 @predicate('contains(pattern)', weight=100) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
608 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
|
609 """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
|
610 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
|
611 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
612 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
|
613 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
|
614 for efficiency. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
615 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
616 # i18n: "contains" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
617 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
|
618 |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
619 def matches(x): |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
620 if not matchmod.patkind(pat): |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
621 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
|
622 if pats in repo[x]: |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
623 return True |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
624 else: |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
625 c = repo[x] |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
626 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
|
627 for f in c.manifest(): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
628 if m(f): |
20461
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
629 return True |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
630 return False |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
631 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
632 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
|
633 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
634 @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
|
635 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
|
636 """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
|
637 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
|
638 """ |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
639 |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
640 # 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
|
641 # 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
|
642 |
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
|
643 rev = None |
17002
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
644 # i18n: "converted" is a keyword |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
645 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
|
646 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
|
647 # 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
|
648 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
|
649 |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
650 def _matchvalue(r): |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
651 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
|
652 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
|
653 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
654 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
|
655 condrepr=('<converted %r>', rev)) |
17002
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
656 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
657 @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
|
658 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
|
659 """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
|
660 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
661 # i18n: "date" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
662 ds = getstring(x, _("date requires a string")) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
663 dm = util.matchdate(ds) |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
664 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
|
665 condrepr=('<date %r>', ds)) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
666 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
667 @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
|
668 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
|
669 """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
|
670 |
30784
5dd67f0993ce
help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents:
30783
diff
changeset
|
671 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
|
672 :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
|
673 """ |
93731b3efd0d
revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14649
diff
changeset
|
674 # i18n: "desc" is a keyword |
30783
931a60880df4
revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30782
diff
changeset
|
675 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
|
676 |
931a60880df4
revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30782
diff
changeset
|
677 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
|
678 |
931a60880df4
revset: add regular expression support to 'desc'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30782
diff
changeset
|
679 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
|
680 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
|
681 |
33080
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
682 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
|
683 stopdepth=None): |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
684 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
|
685 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
|
686 return baseset() |
33080
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
687 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
|
688 return subset & s |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
689 |
33080
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
690 @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
|
691 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
|
692 """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
|
693 given changesets themselves. |
33080
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
694 |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
695 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
|
696 the specified generation. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
697 """ |
33080
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
698 # 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
|
699 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
|
700 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
|
701 # 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
|
702 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
|
703 startdepth = stopdepth = None |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
704 if 'startdepth' in args: |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
705 n = getinteger(args['startdepth'], |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
706 "descendants expects an integer startdepth") |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
707 if n < 0: |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
708 raise error.ParseError("negative startdepth") |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
709 startdepth = n |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
710 if 'depth' in args: |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
711 # i18n: "descendants" is a keyword |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
712 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
|
713 if n < 0: |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
714 raise error.ParseError(_("negative depth")) |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
715 stopdepth = n + 1 |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
716 return _descendants(repo, subset, args['set'], |
a53bfc2845f2
revset: add depth limit to descendants() (issue5374)
Yuya Nishihara <yuya@tcha.org>
parents:
33075
diff
changeset
|
717 startdepth=startdepth, stopdepth=stopdepth) |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
718 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
719 @predicate('_firstdescendants', safe=True) |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
720 def _firstdescendants(repo, subset, x): |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
721 # ``_firstdescendants(set)`` |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
722 # 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
|
723 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
|
724 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
725 @predicate('destination([set])', safe=True, weight=10) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
726 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
|
727 """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
|
728 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
|
729 is the same as passing all(). |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
730 """ |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
731 if x is not None: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
732 sources = getset(repo, fullreposet(repo), x) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
733 else: |
24201
77ef059b3317
revset: drop unnecessary calls of getall() with empty argument
Yuya Nishihara <yuya@tcha.org>
parents:
24163
diff
changeset
|
734 sources = fullreposet(repo) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
735 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
736 dests = set() |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
737 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
738 # 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
|
739 # 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
|
740 # 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
|
741 # 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
|
742 # 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
|
743 # grafts. |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
744 for r in subset: |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
745 src = _getrevsource(repo, r) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
746 lineage = None |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
747 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
748 while src is not None: |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
749 if lineage is None: |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
750 lineage = list() |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
751 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
752 lineage.append(r) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
753 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
754 # 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
|
755 # set. Since every candidate dest is visited by way of iterating |
17494 | 756 # 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
|
757 # 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
|
758 # 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
|
759 # further. |
22944
5aae3dea8044
revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents:
22891
diff
changeset
|
760 if src in sources or src in dests: |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
761 dests.update(lineage) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
762 break |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
763 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
764 r = src |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
765 src = _getrevsource(repo, r) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
766 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
767 return subset.filter(dests.__contains__, |
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
768 condrepr=lambda: '<destination %r>' % sorted(dests)) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
769 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
770 @predicate('divergent()', safe=True) |
18071
bea754715961
obsolete: add revset and test for divergent changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18063
diff
changeset
|
771 def divergent(repo, subset, x): |
33775
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
772 msg = ("'divergent()' is deprecated, " |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
773 "use 'contentdivergent()'") |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
774 repo.ui.deprecwarn(msg, '4.4') |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
775 |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
776 return contentdivergent(repo, subset, x) |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
777 |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
778 @predicate('contentdivergent()', safe=True) |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
779 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
|
780 """ |
33855
457d1ebf151b
revset: mark evolution-related revsets as experimental
Boris Feld <boris.feld@octobus.net>
parents:
33779
diff
changeset
|
781 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
|
782 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
|
783 """ |
33775
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
784 # i18n: "contentdivergent" is a keyword |
f078d7358e90
revset: remane divergent into contentdivergent
Boris Feld <boris.feld@octobus.net>
parents:
33774
diff
changeset
|
785 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
|
786 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
|
787 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
|
788 |
34457
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
789 @predicate('extdata(source)', safe=False, weight=100) |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
790 def extdata(repo, subset, x): |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
791 """Changesets in the specified extdata source. (EXPERIMENTAL)""" |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
792 # i18n: "extdata" is a keyword |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
793 args = getargsdict(x, 'extdata', 'source') |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
794 source = getstring(args.get('source'), |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
795 # i18n: "extdata" is a keyword |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
796 _('extdata takes at least 1 string argument')) |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
797 data = scmutil.extdatasource(repo, source) |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
798 return subset & baseset(data) |
2c3b8fa3211b
revset: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34273
diff
changeset
|
799 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
800 @predicate('extinct()', safe=True) |
17173
c621f84dbb35
obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17171
diff
changeset
|
801 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
|
802 """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
|
803 """ |
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
|
804 # 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
|
805 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
|
806 extincts = obsmod.getrevs(repo, 'extinct') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
807 return subset & extincts |
17173
c621f84dbb35
obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17171
diff
changeset
|
808 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
809 @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
|
810 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
|
811 """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
|
812 optional value. |
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
813 |
30784
5dd67f0993ce
help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents:
30783
diff
changeset
|
814 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
|
815 :hg:`help revisions.patterns`. |
16824
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
816 """ |
25767
026105c442d7
revset: rename getkwargs() to getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
25766
diff
changeset
|
817 args = getargsdict(x, 'extra', 'label value') |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
818 if 'label' not in args: |
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
819 # i18n: "extra" is a keyword |
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
820 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
|
821 # i18n: "extra" is a keyword |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
822 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
|
823 'a string')) |
16661
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
824 value = None |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
825 |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
826 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
|
827 # i18n: "extra" is a keyword |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
828 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
|
829 'a string')) |
26481
7d132557e44a
util: extract stringmatcher() from revset
Matt Harbison <matt_harbison@yahoo.com>
parents:
26307
diff
changeset
|
830 kind, value, matcher = util.stringmatcher(value) |
16661
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
831 |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
832 def _matchvalue(r): |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
833 extra = repo[r].extra() |
16824
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
834 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
|
835 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
836 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
|
837 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
|
838 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
839 @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
|
840 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
|
841 """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
|
842 |
21199
e9c2f76be74b
help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents:
21173
diff
changeset
|
843 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
|
844 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
|
845 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
|
846 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
|
847 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
848 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
|
849 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
|
850 for efficiency. |
23719
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
851 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
852 If some linkrev points to revisions filtered by the current repoview, we'll |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
853 work around it to return a non-filtered value. |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
854 """ |
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
855 |
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
|
856 # 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
|
857 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
|
858 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
|
859 cl = repo.changelog |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
860 |
15964
6e37b8282aa2
revsets: provide contexts for filesets
Matt Mackall <mpm@selenic.com>
parents:
15949
diff
changeset
|
861 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
|
862 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
|
863 files = [f] |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
864 else: |
20288
b61ad01c4e73
revset: use "canonpath()" for "filelog()" pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20287
diff
changeset
|
865 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
|
866 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
|
867 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
868 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
|
869 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
|
870 known = {} |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
871 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
|
872 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
|
873 fn = fl.node(fr) |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
874 if fn in known: |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
875 s.add(known[fn]) |
23821
7a7f437ab63d
filelog: remove trailing "form feed" character
Martin von Zweigbergk <martinvonz@google.com>
parents:
23820
diff
changeset
|
876 continue |
27945
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
877 |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
878 lr = fl.linkrev(fr) |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
879 if lr in cl: |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
880 s.add(lr) |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
881 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
|
882 # 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
|
883 # ahead in changelog |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
884 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
|
885 scanpos = None |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
886 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
|
887 # 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
|
888 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
|
889 try: |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
890 # 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
|
891 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
|
892 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
|
893 if n == fn: |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
894 s.add(r) |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
895 scanpos = r |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
896 break |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
897 else: |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
898 known[n] = r |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
899 except error.ManifestLookupError: |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
900 # deletion in changelog |
4186d359046a
log: speed up single file log with hidden revs (issue4747)
Matt Mackall <mpm@selenic.com>
parents:
27637
diff
changeset
|
901 continue |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
902 |
22534
6261b9c549a2
revset: use `subset &` in `filelog`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22533
diff
changeset
|
903 return subset & s |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
904 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
905 @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
|
906 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
|
907 """An alias for limit(). |
15117
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
908 """ |
32801
348b491c0934
revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
32800
diff
changeset
|
909 return limit(repo, subset, x, order) |
15117
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
910 |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
911 def _follow(repo, subset, x, name, followfirst=False): |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
912 l = getargs(x, 0, 2, _("%s takes no arguments or a pattern " |
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
913 "and an optional revset") % name) |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
914 c = repo['.'] |
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
915 if l: |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
916 x = getstring(l[0], _("%s expected a pattern") % name) |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
917 rev = None |
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
918 if len(l) >= 2: |
30178
d61c42c1a35c
revset: make follow() reject more than one start revisions
Yuya Nishihara <yuya@tcha.org>
parents:
30071
diff
changeset
|
919 revs = getset(repo, fullreposet(repo), l[1]) |
d61c42c1a35c
revset: make follow() reject more than one start revisions
Yuya Nishihara <yuya@tcha.org>
parents:
30071
diff
changeset
|
920 if len(revs) != 1: |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
921 raise error.RepoLookupError( |
30178
d61c42c1a35c
revset: make follow() reject more than one start revisions
Yuya Nishihara <yuya@tcha.org>
parents:
30071
diff
changeset
|
922 _("%s expected one starting revision") % name) |
d61c42c1a35c
revset: make follow() reject more than one start revisions
Yuya Nishihara <yuya@tcha.org>
parents:
30071
diff
changeset
|
923 rev = revs.last() |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
924 c = repo[rev] |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
925 matcher = matchmod.match(repo.root, repo.getcwd(), [x], |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
926 ctx=repo[rev], default='path') |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
927 |
28008
86c4cbdaffee
revset: use manifest.matches in _follow revset
Durham Goode <durham@fb.com>
parents:
27945
diff
changeset
|
928 files = c.manifest().walk(matcher) |
86c4cbdaffee
revset: use manifest.matches in _follow revset
Durham Goode <durham@fb.com>
parents:
27945
diff
changeset
|
929 |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
930 s = set() |
28008
86c4cbdaffee
revset: use manifest.matches in _follow revset
Durham Goode <durham@fb.com>
parents:
27945
diff
changeset
|
931 for fname in files: |
86c4cbdaffee
revset: use manifest.matches in _follow revset
Durham Goode <durham@fb.com>
parents:
27945
diff
changeset
|
932 fctx = c[fname] |
35270
0d27685b4a2f
dagop: copy basefilectx.ancestors() to free function
Yuya Nishihara <yuya@tcha.org>
parents:
34854
diff
changeset
|
933 a = dagop.filectxancestors(fctx, followfirst) |
0d27685b4a2f
dagop: copy basefilectx.ancestors() to free function
Yuya Nishihara <yuya@tcha.org>
parents:
34854
diff
changeset
|
934 s = s.union(set(c.rev() for c in a)) |
28008
86c4cbdaffee
revset: use manifest.matches in _follow revset
Durham Goode <durham@fb.com>
parents:
27945
diff
changeset
|
935 # include the revision responsible for the most recent version |
86c4cbdaffee
revset: use manifest.matches in _follow revset
Durham Goode <durham@fb.com>
parents:
27945
diff
changeset
|
936 s.add(fctx.introrev()) |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
937 else: |
32903
27932a76a88d
dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents:
32885
diff
changeset
|
938 s = dagop.revancestors(repo, baseset([c.rev()]), followfirst) |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
939 |
22535
44f471102f3a
revset: use `subset &` in `follow`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22534
diff
changeset
|
940 return subset & s |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
941 |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
942 @predicate('follow([pattern[, startrev]])', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
943 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
|
944 """ |
24366
e8ea31131705
revset: replace "working copy" with "working directory" in function help
Yuya Nishihara <yuya@tcha.org>
parents:
24306
diff
changeset
|
945 An alias for ``::.`` (ancestors of the working directory's first parent). |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
946 If 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
|
947 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
|
948 """ |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
949 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
|
950 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
951 @predicate('_followfirst', safe=True) |
16174
0a73c4bd9f47
graphlog: implement --follow-first
Patrick Mezard <patrick@mezard.eu>
parents:
16161
diff
changeset
|
952 def _followfirst(repo, subset, x): |
29814
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
953 # ``followfirst([pattern[, startrev]])`` |
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
954 # Like ``follow([pattern[, startrev]])`` but follows only the first parent |
cbf9984a7957
revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
29780
diff
changeset
|
955 # 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
|
956 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
|
957 |
31938
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
958 @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
|
959 safe=True) |
30719
42c75b4fa46a
revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
30702
diff
changeset
|
960 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
|
961 """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
|
962 |
30800
cd23879cbac7
revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents:
30799
diff
changeset
|
963 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
|
964 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
|
965 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
|
966 |
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
967 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
|
968 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
|
969 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
|
970 """ |
31938
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
971 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
|
972 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
|
973 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
|
974 |
42c75b4fa46a
revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
30702
diff
changeset
|
975 rev = '.' |
30800
cd23879cbac7
revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents:
30799
diff
changeset
|
976 if 'startrev' in args: |
cd23879cbac7
revset: rename rev argument of followlines() to startrev
Yuya Nishihara <yuya@tcha.org>
parents:
30799
diff
changeset
|
977 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
|
978 if len(revs) != 1: |
26209cb7184e
revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
30753
diff
changeset
|
979 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
|
980 # 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
|
981 _("followlines expects exactly one revision")) |
26209cb7184e
revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
30753
diff
changeset
|
982 rev = revs.last() |
26209cb7184e
revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
30753
diff
changeset
|
983 |
26209cb7184e
revset: parse variable-length arguments of followlines() by getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
30753
diff
changeset
|
984 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
|
985 # i18n: "followlines" is a keyword |
39b094e4ae2c
revset: extract a parsefollowlinespattern helper function
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
34457
diff
changeset
|
986 msg = _("followlines expects exactly one file") |
39b094e4ae2c
revset: extract a parsefollowlinespattern helper function
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
34457
diff
changeset
|
987 fname = scmutil.parsefollowlinespattern(repo, rev, pat, msg) |
32085
2a2744dffecf
revset: add i18n comments to error messages for followlines predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31998
diff
changeset
|
988 # i18n: "followlines" is a keyword |
30804
4227f80f72b2
revset: abuse x:y syntax to specify line range of followlines()
Yuya Nishihara <yuya@tcha.org>
parents:
30803
diff
changeset
|
989 lr = getrange(args['lines'][0], _("followlines expects a line range")) |
30801
67ee7874e53b
revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30800
diff
changeset
|
990 fromline, toline = [getinteger(a, _("line range bounds must be integers")) |
30804
4227f80f72b2
revset: abuse x:y syntax to specify line range of followlines()
Yuya Nishihara <yuya@tcha.org>
parents:
30803
diff
changeset
|
991 for a in lr] |
31662
080734cd2440
revset: factor out linerange processing into a utility function
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31076
diff
changeset
|
992 fromline, toline = util.processlinerange(fromline, toline) |
30719
42c75b4fa46a
revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
30702
diff
changeset
|
993 |
42c75b4fa46a
revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
30702
diff
changeset
|
994 fctx = repo[rev].filectx(fname) |
31998
83527d9f1f13
revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents:
31938
diff
changeset
|
995 descend = False |
83527d9f1f13
revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents:
31938
diff
changeset
|
996 if 'descend' in args: |
83527d9f1f13
revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents:
31938
diff
changeset
|
997 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
|
998 # 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
|
999 _("descend argument must be a boolean")) |
31998
83527d9f1f13
revset: properly parse "descend" argument of followlines()
Denis Laxalde <denis@laxalde.org>
parents:
31938
diff
changeset
|
1000 if descend: |
31938
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
1001 rs = generatorset( |
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
1002 (c.rev() for c, _linerange |
32904
582080a4a812
dagop: move blockancestors() and blockdescendants() from context
Yuya Nishihara <yuya@tcha.org>
parents:
32903
diff
changeset
|
1003 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
|
1004 iterasc=True) |
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
1005 else: |
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
1006 rs = generatorset( |
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
1007 (c.rev() for c, _linerange |
32904
582080a4a812
dagop: move blockancestors() and blockdescendants() from context
Yuya Nishihara <yuya@tcha.org>
parents:
32903
diff
changeset
|
1008 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
|
1009 iterasc=False) |
5e3b49defbff
revset: add a 'descend' argument to followlines to return descendants
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
31810
diff
changeset
|
1010 return subset & rs |
30719
42c75b4fa46a
revset: add a followlines(file, fromline, toline[, rev]) revset
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
30702
diff
changeset
|
1011 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1012 @predicate('all()', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1013 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
|
1014 """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
|
1015 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1016 # i18n: "all" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1017 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
|
1018 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
|
1019 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1020 @predicate('grep(regex)', weight=10) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1021 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
|
1022 """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')`` |
14357 | 1023 to ensure special escape characters are handled correctly. Unlike |
1024 ``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
|
1025 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1026 try: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1027 # i18n: "grep" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1028 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
|
1029 except re.error as e: |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1030 raise error.ParseError(_('invalid match pattern: %s') % e) |
20453
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1031 |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1032 def matches(x): |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1033 c = repo[x] |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1034 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
|
1035 if gr.search(e): |
20453
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1036 return True |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1037 return False |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1038 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1039 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
|
1040 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1041 @predicate('_matchfiles', safe=True) |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1042 def _matchfiles(repo, subset, x): |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1043 # _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
|
1044 # |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1045 # [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
|
1046 # |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1047 # 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
|
1048 # 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
|
1049 # 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
|
1050 # 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
|
1051 # 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
|
1052 # 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
|
1053 # 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
|
1054 |
28271
5c454ab69558
revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents:
28217
diff
changeset
|
1055 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
|
1056 pats, inc, exc = [], [], [] |
16411
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1057 rev, default = None, None |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1058 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
|
1059 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
|
1060 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
|
1061 if prefix == 'p:': |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1062 pats.append(value) |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1063 elif prefix == 'i:': |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1064 inc.append(value) |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1065 elif prefix == 'x:': |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1066 exc.append(value) |
16181
1fd352aa08fc
graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents:
16174
diff
changeset
|
1067 elif prefix == 'r:': |
1fd352aa08fc
graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents:
16174
diff
changeset
|
1068 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
|
1069 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
|
1070 'revision') |
23950
caff3675cba5
log: evaluate filesets on working copy, not its parent
Martin von Zweigbergk <martinvonz@google.com>
parents:
23847
diff
changeset
|
1071 if value != '': # empty means working directory; leave rev as None |
caff3675cba5
log: evaluate filesets on working copy, not its parent
Martin von Zweigbergk <martinvonz@google.com>
parents:
23847
diff
changeset
|
1072 rev = value |
16411
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1073 elif prefix == 'd:': |
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1074 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
|
1075 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
|
1076 'default mode') |
16411
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1077 default = value |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1078 else: |
28271
5c454ab69558
revset: drop translation markers from error messages of internal _matchfiles
Yuya Nishihara <yuya@tcha.org>
parents:
28217
diff
changeset
|
1079 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
|
1080 if not default: |
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1081 default = 'glob' |
20458
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1082 |
23061
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1083 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc, |
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1084 exclude=exc, ctx=repo[rev], default=default) |
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1085 |
27028
f92053df8f0b
revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26778
diff
changeset
|
1086 # 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
|
1087 # revisions is quite expensive. |
27440
ff305ab2e0d7
log: speed up hg log <file|folder>
Laurent Charignon <lcharignon@fb.com>
parents:
27293
diff
changeset
|
1088 getfiles = repo.changelog.readfiles |
27028
f92053df8f0b
revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26778
diff
changeset
|
1089 wdirrev = node.wdirrev |
20458
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1090 def matches(x): |
27028
f92053df8f0b
revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26778
diff
changeset
|
1091 if x == wdirrev: |
f92053df8f0b
revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26778
diff
changeset
|
1092 files = repo[x].files() |
f92053df8f0b
revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26778
diff
changeset
|
1093 else: |
27440
ff305ab2e0d7
log: speed up hg log <file|folder>
Laurent Charignon <lcharignon@fb.com>
parents:
27293
diff
changeset
|
1094 files = getfiles(x) |
27028
f92053df8f0b
revset: speed up '_matchfiles'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26778
diff
changeset
|
1095 for f in files: |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1096 if m(f): |
20458
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1097 return True |
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1098 return False |
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1099 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1100 return subset.filter(matches, |
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1101 condrepr=('<matchfiles patterns=%r, include=%r ' |
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1102 'exclude=%r, default=%r, rev=%r>', |
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1103 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
|
1104 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1105 @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
|
1106 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
|
1107 """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
|
1108 |
17265
c30307eeec4b
revset: polish explanation of the difference between file() and filelog()
Greg Ward <greg@gerg.ca>
parents:
17259
diff
changeset
|
1109 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
|
1110 instead. |
20289
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1111 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1112 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
|
1113 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1114 # i18n: "file" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1115 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
|
1116 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
|
1117 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1118 @predicate('head()', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1119 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
|
1120 """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
|
1121 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1122 # i18n: "head" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1123 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
|
1124 hs = set() |
25620
5f87f2305ad0
revset: translate node directly with changelog in 'head'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25619
diff
changeset
|
1125 cl = repo.changelog |
29407
20fabe814f89
revsets: use itervalues() where only values are needed
Martin von Zweigbergk <martinvonz@google.com>
parents:
29406
diff
changeset
|
1126 for ls in repo.branchmap().itervalues(): |
25620
5f87f2305ad0
revset: translate node directly with changelog in 'head'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25619
diff
changeset
|
1127 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
|
1128 return subset & baseset(hs) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1129 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1130 @predicate('heads(set)', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1131 def heads(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
|
1132 """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
|
1133 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1134 s = getset(repo, subset, x) |
20366
5ec6321f49a9
revset: added substraction to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20365
diff
changeset
|
1135 ps = parents(repo, subset, x) |
5ec6321f49a9
revset: added substraction to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20365
diff
changeset
|
1136 return s - ps |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1137 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1138 @predicate('hidden()', safe=True) |
17390
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1139 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
|
1140 """Hidden changesets. |
17390
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1141 """ |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1142 # i18n: "hidden" is a keyword |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1143 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
|
1144 hiddenrevs = repoview.filterrevs(repo, 'visible') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
1145 return subset & hiddenrevs |
17390
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1146 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1147 @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
|
1148 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
|
1149 """Search commit message, user name, and names of changed files for |
14357 | 1150 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
|
1151 |
b1012cb1bec3
revset: point to 'grep' in the 'keyword' help for regex searches
Matt Harbison <matt_harbison@yahoo.com>
parents:
30754
diff
changeset
|
1152 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
|
1153 ``grep(regex)``. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1154 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1155 # 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
|
1156 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
|
1157 |
abb91b74f758
revset: added lazyset implementation to keyword revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20446
diff
changeset
|
1158 def matches(r): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1159 c = repo[r] |
25551
c1d163ce7394
revset: gratuitous formating fix in keyword
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25550
diff
changeset
|
1160 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
|
1161 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
|
1162 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1163 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
|
1164 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1165 @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
|
1166 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
|
1167 """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
|
1168 """ |
26638
7afaf2566e25
revset: add optional offset argument to limit() predicate
Yuya Nishihara <yuya@tcha.org>
parents:
26637
diff
changeset
|
1169 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
|
1170 if 'set' not in args: |
179764469754
revset: port limit() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
26636
diff
changeset
|
1171 # i18n: "limit" is a keyword |
26638
7afaf2566e25
revset: add optional offset argument to limit() predicate
Yuya Nishihara <yuya@tcha.org>
parents:
26637
diff
changeset
|
1172 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
|
1173 # i18n: "limit" is a keyword |
5eb3e4568c94
revset: add default value to getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30801
diff
changeset
|
1174 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
|
1175 if lim < 0: |
b36ec65ea583
revset: reject negative number to select first/last n members
Yuya Nishihara <yuya@tcha.org>
parents:
32798
diff
changeset
|
1176 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
|
1177 # i18n: "limit" is a keyword |
5eb3e4568c94
revset: add default value to getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30801
diff
changeset
|
1178 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
|
1179 if ofs < 0: |
67ee7874e53b
revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30800
diff
changeset
|
1180 raise error.ParseError(_("negative offset")) |
26637
179764469754
revset: port limit() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
26636
diff
changeset
|
1181 os = getset(repo, fullreposet(repo), args['set']) |
32819
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32801
diff
changeset
|
1182 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
|
1183 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
|
1184 return subset & ls |
32800
3e6f9bff7e3f
revset: filter first/last members by __and__ operation
Yuya Nishihara <yuya@tcha.org>
parents:
32799
diff
changeset
|
1185 return ls & subset |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1186 |
32801
348b491c0934
revset: fix order of first/last members in compound expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
32800
diff
changeset
|
1187 @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
|
1188 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
|
1189 """Last n members of set, defaulting to 1. |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1190 """ |
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1191 # 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
|
1192 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
|
1193 lim = 1 |
67ee7874e53b
revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30800
diff
changeset
|
1194 if len(l) == 2: |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1195 # i18n: "last" is a keyword |
30801
67ee7874e53b
revset: factor out getinteger() helper
Yuya Nishihara <yuya@tcha.org>
parents:
30800
diff
changeset
|
1196 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
|
1197 if lim < 0: |
b36ec65ea583
revset: reject negative number to select first/last n members
Yuya Nishihara <yuya@tcha.org>
parents:
32798
diff
changeset
|
1198 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
|
1199 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
|
1200 os.reverse() |
32819
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32801
diff
changeset
|
1201 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
|
1202 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
|
1203 return subset & ls |
32800
3e6f9bff7e3f
revset: filter first/last members by __and__ operation
Yuya Nishihara <yuya@tcha.org>
parents:
32799
diff
changeset
|
1204 ls.reverse() |
3e6f9bff7e3f
revset: filter first/last members by __and__ operation
Yuya Nishihara <yuya@tcha.org>
parents:
32799
diff
changeset
|
1205 return ls & subset |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1206 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1207 @predicate('max(set)', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1208 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
|
1209 """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
|
1210 """ |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1211 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
|
1212 try: |
20754
f15ff553b762
revset: changed minrev and maxrev implementations to use ordered sets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20753
diff
changeset
|
1213 m = os.max() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1214 if m in subset: |
28427
969a4615c4c4
revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents:
28426
diff
changeset
|
1215 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
|
1216 except ValueError: |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1217 # 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
|
1218 # Same as python's max(). |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1219 pass |
28427
969a4615c4c4
revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents:
28426
diff
changeset
|
1220 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
|
1221 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1222 @predicate('merge()', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1223 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
|
1224 """Changeset is a merge changeset. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1225 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1226 # i18n: "merge" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1227 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
|
1228 cl = repo.changelog |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1229 return subset.filter(lambda r: cl.parentrevs(r)[1] != -1, |
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1230 condrepr='<merge>') |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1231 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1232 @predicate('branchpoint()', safe=True) |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1233 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
|
1234 """Changesets with more than one child. |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1235 """ |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1236 # i18n: "branchpoint" is a keyword |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1237 getargs(x, 0, 0, _("branchpoint takes no arguments")) |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1238 cl = repo.changelog |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1239 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
|
1240 return baseset() |
25549
f93ff3ab8d14
revset: mark spots that should use 'smartset.min()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25548
diff
changeset
|
1241 # 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
|
1242 # (and if it is not, it should.) |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1243 baserev = min(subset) |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1244 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
|
1245 for r in cl.revs(start=baserev + 1): |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1246 for p in cl.parentrevs(r): |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1247 if p >= baserev: |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1248 parentscount[p - baserev] += 1 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1249 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
|
1250 condrepr='<branchpoint>') |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1251 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1252 @predicate('min(set)', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1253 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
|
1254 """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
|
1255 """ |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1256 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
|
1257 try: |
20754
f15ff553b762
revset: changed minrev and maxrev implementations to use ordered sets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20753
diff
changeset
|
1258 m = os.min() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1259 if m in subset: |
28427
969a4615c4c4
revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents:
28426
diff
changeset
|
1260 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
|
1261 except ValueError: |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1262 # 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
|
1263 # Same as python's min(). |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1264 pass |
28427
969a4615c4c4
revset: add inspection data to max() and min() functions
Yuya Nishihara <yuya@tcha.org>
parents:
28426
diff
changeset
|
1265 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
|
1266 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1267 @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
|
1268 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
|
1269 """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
|
1270 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1271 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
|
1272 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
|
1273 directory. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1274 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1275 # i18n: "modifies" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1276 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
|
1277 return checkstatus(repo, subset, pat, 0) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1278 |
27584
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
1279 @predicate('named(namespace)') |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1280 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
|
1281 """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
|
1282 |
30784
5dd67f0993ce
help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents:
30783
diff
changeset
|
1283 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
|
1284 :hg:`help revisions.patterns`. |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1285 """ |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1286 # i18n: "named" is a keyword |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1287 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
|
1288 |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1289 ns = getstring(args[0], |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1290 # i18n: "named" is a keyword |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1291 _('the argument to named must be a string')) |
26481
7d132557e44a
util: extract stringmatcher() from revset
Matt Harbison <matt_harbison@yahoo.com>
parents:
26307
diff
changeset
|
1292 kind, pattern, matcher = util.stringmatcher(ns) |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1293 namespaces = set() |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1294 if kind == 'literal': |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1295 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
|
1296 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
|
1297 % ns) |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1298 namespaces.add(repo.names[pattern]) |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1299 else: |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1300 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
|
1301 if matcher(name): |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1302 namespaces.add(ns) |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1303 if not namespaces: |
23978
eeb5d5ab14a6
revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23956
diff
changeset
|
1304 raise error.RepoLookupError(_("no namespace exists" |
eeb5d5ab14a6
revset: raise RepoLookupError to make present() predicate continue the query
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23956
diff
changeset
|
1305 " that match '%s'") % pattern) |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1306 |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1307 names = set() |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1308 for ns in namespaces: |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1309 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
|
1310 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
|
1311 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
|
1312 |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
1313 names -= {node.nullrev} |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1314 return subset & names |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1315 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1316 @predicate('id(string)', safe=True) |
16417
b4b0c6931e11
revset: avoid demandimport bug
Matt Mackall <mpm@selenic.com>
parents:
16415
diff
changeset
|
1317 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
|
1318 """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
|
1319 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
1320 # 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
|
1321 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
|
1322 # 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
|
1323 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
|
1324 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
|
1325 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
|
1326 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
|
1327 except error.WdirUnsupported: |
a3064fe3e495
revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents:
32442
diff
changeset
|
1328 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
|
1329 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
|
1330 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
|
1331 else: |
16735
47b8ec0eb7fb
revset: fix traceback for bogus revisions in id(rev)
Matt Harbison <matt_harbison@yahoo.com>
parents:
16640
diff
changeset
|
1332 rn = None |
32684
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32683
diff
changeset
|
1333 try: |
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32683
diff
changeset
|
1334 pm = repo.changelog._partialmatch(n) |
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32683
diff
changeset
|
1335 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
|
1336 rn = repo.changelog.rev(pm) |
32684
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32683
diff
changeset
|
1337 except error.WdirUnsupported: |
af854b1b36f8
revlog: add support for partial matching of wdir node id
Yuya Nishihara <yuya@tcha.org>
parents:
32683
diff
changeset
|
1338 rn = node.wdirrev |
16735
47b8ec0eb7fb
revset: fix traceback for bogus revisions in id(rev)
Matt Harbison <matt_harbison@yahoo.com>
parents:
16640
diff
changeset
|
1339 |
23005
9bfe68357c01
revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23004
diff
changeset
|
1340 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
|
1341 return baseset() |
9bfe68357c01
revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23004
diff
changeset
|
1342 result = baseset([rn]) |
9bfe68357c01
revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23004
diff
changeset
|
1343 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
|
1344 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1345 @predicate('obsolete()', safe=True) |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1346 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
|
1347 """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
|
1348 # i18n: "obsolete" is a keyword |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1349 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
|
1350 obsoletes = obsmod.getrevs(repo, 'obsolete') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
1351 return subset & obsoletes |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1352 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1353 @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
|
1354 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
|
1355 """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
|
1356 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
|
1357 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
|
1358 (i.e. ::<set1> - ::<set2>). |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1359 """ |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1360 cl = repo.changelog |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1361 # i18n: "only" is a keyword |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1362 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
|
1363 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
|
1364 if len(args) == 1: |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1365 if not include: |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1366 return baseset() |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1367 |
32903
27932a76a88d
dagop: split module hosting DAG-related algorithms from revset
Yuya Nishihara <yuya@tcha.org>
parents:
32885
diff
changeset
|
1368 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
|
1369 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
|
1370 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
|
1371 else: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1372 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
|
1373 |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1374 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
|
1375 # 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
|
1376 # 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
|
1377 return subset & results |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1378 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1379 @predicate('origin([set])', safe=True) |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1380 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
|
1381 """ |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1382 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
|
1383 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
|
1384 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
|
1385 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
|
1386 for the first operation is selected. |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1387 """ |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1388 if x is not None: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1389 dests = getset(repo, fullreposet(repo), x) |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1390 else: |
24201
77ef059b3317
revset: drop unnecessary calls of getall() with empty argument
Yuya Nishihara <yuya@tcha.org>
parents:
24163
diff
changeset
|
1391 dests = fullreposet(repo) |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1392 |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1393 def _firstsrc(rev): |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1394 src = _getrevsource(repo, rev) |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1395 if src is None: |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1396 return None |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1397 |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1398 while True: |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1399 prev = _getrevsource(repo, src) |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1400 |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1401 if prev is None: |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1402 return src |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1403 src = prev |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1404 |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
1405 o = {_firstsrc(r) for r in dests} |
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
1406 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
|
1407 # 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
|
1408 # 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
|
1409 return subset & o |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1410 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1411 @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
|
1412 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
|
1413 """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
|
1414 default push location. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1415 """ |
24722
02a5618e2fbf
revset: don't import discovery at module level
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24708
diff
changeset
|
1416 # Avoid cycles. |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1417 from . import ( |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1418 discovery, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1419 hg, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1420 ) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1421 # 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
|
1422 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
|
1423 # i18n: "outgoing" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1424 dest = l and getstring(l[0], _("outgoing requires a repository path")) or '' |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1425 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default') |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1426 dest, branches = hg.parseurl(dest) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1427 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
|
1428 if revs: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1429 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
|
1430 other = hg.peer(repo, {}, dest) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1431 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
|
1432 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
|
1433 repo.ui.popbuffer() |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1434 cl = repo.changelog |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
1435 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
|
1436 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
|
1437 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1438 @predicate('p1([set])', safe=True) |
11275 | 1439 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
|
1440 """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
|
1441 """ |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1442 if x is None: |
13878
a8d13ee0ce68
misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents:
13873
diff
changeset
|
1443 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
|
1444 if p >= 0: |
a428db9ab61d
revset: use `subset &` in bare `p1()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22537
diff
changeset
|
1445 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
|
1446 return baseset() |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1447 |
11275 | 1448 ps = set() |
1449 cl = repo.changelog | |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1450 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
|
1451 try: |
e8c043375b53
revset: make `hg log -r 'wdir()^'` work (issue4905)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32291
diff
changeset
|
1452 ps.add(cl.parentrevs(r)[0]) |
e8c043375b53
revset: make `hg log -r 'wdir()^'` work (issue4905)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32291
diff
changeset
|
1453 except error.WdirUnsupported: |
e8c043375b53
revset: make `hg log -r 'wdir()^'` work (issue4905)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32291
diff
changeset
|
1454 ps.add(repo[r].parents()[0].rev()) |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
1455 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
|
1456 # 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
|
1457 # 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
|
1458 return subset & ps |
11275 | 1459 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1460 @predicate('p2([set])', safe=True) |
11275 | 1461 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
|
1462 """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
|
1463 """ |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1464 if x is None: |
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1465 ps = repo[x].parents() |
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1466 try: |
12935
98b79c892768
revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e)
Patrick Mezard <pmezard@gmail.com>
parents:
12929
diff
changeset
|
1467 p = ps[1].rev() |
22539
6f434ef54222
revset: use `subset &` in bare `p2()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22538
diff
changeset
|
1468 if p >= 0: |
6f434ef54222
revset: use `subset &` in bare `p2()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22538
diff
changeset
|
1469 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
|
1470 return baseset() |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1471 except IndexError: |
22802
1fcd361efaf4
baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22801
diff
changeset
|
1472 return baseset() |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1473 |
11275 | 1474 ps = set() |
1475 cl = repo.changelog | |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1476 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
|
1477 try: |
c8fb2a82b5f9
revset: add support for p2(wdir()) to get second parent of working directory
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32439
diff
changeset
|
1478 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
|
1479 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
|
1480 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
|
1481 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
|
1482 ps.add(parents[1]) |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
1483 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
|
1484 # 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
|
1485 # 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
|
1486 return subset & ps |
11275 | 1487 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
1488 def parentpost(repo, subset, x, order): |
29931
d2d1be3009ca
revset: add stub to handle parentpost operation
Yuya Nishihara <yuya@tcha.org>
parents:
29930
diff
changeset
|
1489 return p1(repo, subset, x) |
d2d1be3009ca
revset: add stub to handle parentpost operation
Yuya Nishihara <yuya@tcha.org>
parents:
29930
diff
changeset
|
1490 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1491 @predicate('parents([set])', safe=True) |
11275 | 1492 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
|
1493 """ |
12929
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
1494 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
|
1495 """ |
12929
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
1496 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
|
1497 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
|
1498 else: |
35af9361a049
revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22495
diff
changeset
|
1499 ps = set() |
35af9361a049
revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22495
diff
changeset
|
1500 cl = repo.changelog |
25716
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1501 up = ps.update |
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1502 parentrevs = cl.parentrevs |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1503 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
|
1504 try: |
e72c5263ccaf
revset: use try-except instead of if-else because of perf
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32438
diff
changeset
|
1505 up(parentrevs(r)) |
e72c5263ccaf
revset: use try-except instead of if-else because of perf
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32438
diff
changeset
|
1506 except error.WdirUnsupported: |
25716
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1507 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
|
1508 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
|
1509 return subset & ps |
11275 | 1510 |
31017 | 1511 def _phase(repo, subset, *targets): |
1512 """helper to select all rev in <targets> phases""" | |
1513 s = repo._phasecache.getrevset(repo, targets) | |
1514 return subset & s | |
25621
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1515 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1516 @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
|
1517 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
|
1518 """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
|
1519 # 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
|
1520 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
|
1521 target = phases.draft |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1522 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
|
1523 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1524 @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
|
1525 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
|
1526 """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
|
1527 # 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
|
1528 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
|
1529 target = phases.secret |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1530 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
|
1531 |
29932
09a84e747c88
revset: pass around ordering flags to operations
Yuya Nishihara <yuya@tcha.org>
parents:
29931
diff
changeset
|
1532 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
|
1533 """``set^0`` |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1534 The set. |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1535 ``set^1`` (or ``set^``), ``set^2`` |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1536 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
|
1537 """ |
12320
40c40c6f20b8
revset: handle re.compile() errors in grep()
Brodie Rao <brodie@bitheap.org>
parents:
11882
diff
changeset
|
1538 try: |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1539 n = int(n[1]) |
14072
2e4d79dcc0a0
revset: add missing whitespace
Kevin Gessner <kevin@kevingessner.com>
parents:
14070
diff
changeset
|
1540 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
|
1541 raise ValueError |
14851
f96c354493d7
revsets: actually catch type error on tip^p1(tip) (issue2884)
Matt Mackall <mpm@selenic.com>
parents:
14842
diff
changeset
|
1542 except (TypeError, ValueError): |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1543 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
|
1544 ps = set() |
11275 | 1545 cl = repo.changelog |
23165
7e8737e6ab08
revset-parentspec: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23164
diff
changeset
|
1546 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
|
1547 if n == 0: |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1548 ps.add(r) |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1549 elif n == 1: |
32436
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1550 try: |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1551 ps.add(cl.parentrevs(r)[0]) |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1552 except error.WdirUnsupported: |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1553 ps.add(repo[r].parents()[0].rev()) |
32438
14482f8e6ce6
revset: remove redundant condition and change to else from elif
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32436
diff
changeset
|
1554 else: |
32436
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1555 try: |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1556 parents = cl.parentrevs(r) |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1557 if parents[1] != node.nullrev: |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1558 ps.add(parents[1]) |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1559 except error.WdirUnsupported: |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1560 parents = repo[r].parents() |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1561 if len(parents) == 2: |
f064e2f72c49
revset: add support for "wdir()^n"
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32435
diff
changeset
|
1562 ps.add(parents[1].rev()) |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
1563 return subset & ps |
11275 | 1564 |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
1565 @predicate('present(set)', safe=True, takeorder=True) |
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
1566 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
|
1567 """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
|
1568 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
|
1569 |
0a730d3c5aae
doc: add detail explanation for 'present()' predicate of revsets
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16735
diff
changeset
|
1570 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
|
1571 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
|
1572 to continue even in such cases. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1573 """ |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1574 try: |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
1575 return getset(repo, subset, x, order) |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1576 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
|
1577 return baseset() |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1578 |
25224
d032f57936f5
revset: drop docstring from internal _notpublic() function
Yuya Nishihara <yuya@tcha.org>
parents:
25191
diff
changeset
|
1579 # 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
|
1580 @predicate('_notpublic', safe=True) |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1581 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
|
1582 getargs(x, 0, 0, "_notpublic takes no arguments") |
31017 | 1583 return _phase(repo, subset, phases.draft, phases.secret) |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1584 |
34065
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1585 # for internal use |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1586 @predicate('_phaseandancestors(phasename, set)', safe=True) |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1587 def _phaseandancestors(repo, subset, x): |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1588 # equivalent to (phasename() & ancestors(set)) but more efficient |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1589 # phasename could be one of 'draft', 'secret', or '_notpublic' |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1590 args = getargs(x, 2, 2, "_phaseandancestors requires two arguments") |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1591 phasename = getsymbol(args[0]) |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1592 s = getset(repo, fullreposet(repo), args[1]) |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1593 |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1594 draft = phases.draft |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1595 secret = phases.secret |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1596 phasenamemap = { |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1597 '_notpublic': draft, |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1598 'draft': draft, # follow secret's ancestors |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1599 'secret': secret, |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1600 } |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1601 if phasename not in phasenamemap: |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1602 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
|
1603 |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1604 minimalphase = phasenamemap[phasename] |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1605 getphase = repo._phasecache.phase |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1606 |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1607 def cutfunc(rev): |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1608 return getphase(repo, rev) < minimalphase |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1609 |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1610 revs = dagop.revancestors(repo, s, cutfunc=cutfunc) |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1611 |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1612 if phasename == 'draft': # need to remove secret changesets |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1613 revs = revs.filter(lambda r: getphase(repo, r) == draft) |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1614 return subset & revs |
c6c8a52e28c9
revset: optimize "draft() & ::x" pattern
Jun Wu <quark@fb.com>
parents:
34020
diff
changeset
|
1615 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1616 @predicate('public()', safe=True) |
15819
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
1617 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
|
1618 """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
|
1619 # 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
|
1620 getargs(x, 0, 0, _("public takes no arguments")) |
23019
c8f32accd00a
revset-phases: prefetch attributes in phasesrelated revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23018
diff
changeset
|
1621 phase = repo._phasecache.phase |
c8f32accd00a
revset-phases: prefetch attributes in phasesrelated revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23018
diff
changeset
|
1622 target = phases.public |
c8f32accd00a
revset-phases: prefetch attributes in phasesrelated revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23018
diff
changeset
|
1623 condition = lambda r: phase(repo, r) == target |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1624 return subset.filter(condition, condrepr=('<phase %r>', target), |
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1625 cache=False) |
15819
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
1626 |
30850
41e31a6f5296
revset: prevent using outgoing() and remote() in hgweb session (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
30804
diff
changeset
|
1627 @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
|
1628 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
|
1629 """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
|
1630 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
|
1631 synonym for the current local branch. |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1632 """ |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1633 |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1634 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
|
1635 # i18n: "remote" is a keyword |
27293
9e06e7fb037d
grammar: favor zero, one, two over ... or no
timeless <timeless@mozdev.org>
parents:
27028
diff
changeset
|
1636 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
|
1637 |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1638 q = '.' |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1639 if len(l) > 0: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1640 # i18n: "remote" is a keyword |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1641 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
|
1642 if q == '.': |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1643 q = repo['.'].branch() |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1644 |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1645 dest = '' |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1646 if len(l) > 1: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1647 # i18n: "remote" is a keyword |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1648 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
|
1649 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
|
1650 dest, branches = hg.parseurl(dest) |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1651 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
|
1652 if revs: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1653 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
|
1654 other = hg.peer(repo, {}, dest) |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1655 n = other.lookup(q) |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1656 if n in repo: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1657 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
|
1658 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
|
1659 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
|
1660 return baseset() |
15936
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1661 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1662 @predicate('removes(pattern)', safe=True, weight=30) |
11275 | 1663 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
|
1664 """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
|
1665 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1666 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
|
1667 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
|
1668 directory. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1669 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
1670 # 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
|
1671 pat = getstring(x, _("removes requires a pattern")) |
11275 | 1672 return checkstatus(repo, subset, pat, 2) |
1673 | |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1674 @predicate('rev(number)', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1675 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
|
1676 """Revision with the given numeric identifier. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1677 """ |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1678 # i18n: "rev" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1679 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
|
1680 try: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1681 # i18n: "rev" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1682 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
|
1683 except (TypeError, ValueError): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1684 # i18n: "rev" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1685 raise error.ParseError(_("rev expects a number")) |
32661
a3064fe3e495
revset: add support for integer and hex wdir identifiers
Yuya Nishihara <yuya@tcha.org>
parents:
32442
diff
changeset
|
1686 if l not in repo.changelog and l not in (node.nullrev, node.wdirrev): |
23062
ba89f7b542c9
revset: have rev() drop out-of-range or filtered rev explicitly (issue4396)
Yuya Nishihara <yuya@tcha.org>
parents:
23061
diff
changeset
|
1687 return baseset() |
22537
bbf4f3dfd700
revset: use `subset &` in `rev`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22536
diff
changeset
|
1688 return subset & baseset([l]) |
11275 | 1689 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1690 @predicate('matching(revision [, field])', safe=True) |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1691 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
|
1692 """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
|
1693 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
|
1694 |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1695 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
|
1696 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
|
1697 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1698 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
|
1699 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1700 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
|
1701 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user`` |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1702 and ``diff``. |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1703 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
|
1704 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
|
1705 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
|
1706 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1707 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
|
1708 ``summary`` matches the first line of the description. |
16639
00290bd359fe
revset: documentation typo "metatadata"
Jesse Glick <jesse.glick@oracle.com>
parents:
16528
diff
changeset
|
1709 ``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
|
1710 (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
|
1711 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1712 ``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
|
1713 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
|
1714 """ |
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
|
1715 # i18n: "matching" is a keyword |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1716 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
|
1717 |
23166
30e0dcd7c5ff
revset-matching: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23165
diff
changeset
|
1718 revs = getset(repo, fullreposet(repo), l[0]) |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1719 |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1720 fieldlist = ['metadata'] |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1721 if len(l) > 1: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1722 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
|
1723 # i18n: "matching" is a keyword |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1724 _("matching requires a string " |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1725 "as its second argument")).split() |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1726 |
17102
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1727 # 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
|
1728 # expand the 'special' 'metadata' field type |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1729 # 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
|
1730 fields = [] |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1731 for field in fieldlist: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1732 if field == 'metadata': |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1733 fields += ['user', 'description', 'date'] |
17102
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1734 elif field == 'diff': |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1735 # 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
|
1736 # 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
|
1737 # also match the files first |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1738 fields += ['files', 'diff'] |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1739 else: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1740 if field == 'author': |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1741 field = 'user' |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1742 fields.append(field) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1743 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
|
1744 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
|
1745 # 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
|
1746 fields.discard('summary') |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1747 |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1748 # 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
|
1749 # 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
|
1750 # 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
|
1751 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
|
1752 '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
|
1753 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
|
1754 try: |
984e0412e82b
revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16445
diff
changeset
|
1755 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
|
1756 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
|
1757 # 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
|
1758 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
|
1759 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
|
1760 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
|
1761 |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1762 # 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
|
1763 # 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
|
1764 getfieldfuncs = [] |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1765 _funcs = { |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1766 'user': lambda r: repo[r].user(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1767 'branch': lambda r: repo[r].branch(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1768 'date': lambda r: repo[r].date(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1769 'description': lambda r: repo[r].description(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1770 'files': lambda r: repo[r].files(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1771 'parents': lambda r: repo[r].parents(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1772 'phase': lambda r: repo[r].phase(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1773 'substate': lambda r: repo[r].substate, |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1774 'summary': lambda r: repo[r].description().splitlines()[0], |
17102
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1775 'diff': lambda r: list(repo[r].diff(git=True),) |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1776 } |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1777 for info in fields: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1778 getfield = _funcs.get(info, None) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1779 if getfield is None: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1780 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
|
1781 # i18n: "matching" is a keyword |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1782 _("unexpected field name passed to matching: %s") % info) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1783 getfieldfuncs.append(getfield) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1784 # 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
|
1785 # 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
|
1786 # 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
|
1787 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
|
1788 |
20459
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1789 def matches(x): |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1790 for rev in revs: |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1791 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
|
1792 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
|
1793 for n, f in enumerate(getfieldfuncs): |
20459
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1794 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
|
1795 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
|
1796 if match: |
20459
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1797 return True |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1798 return False |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1799 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1800 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
|
1801 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1802 @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
|
1803 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
|
1804 """Reverse order of set. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1805 """ |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
1806 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
|
1807 if order == defineorder: |
89dbae952ec1
revset: make reverse() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29944
diff
changeset
|
1808 l.reverse() |
11275 | 1809 return l |
1810 | |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1811 @predicate('roots(set)', safe=True) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1812 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
|
1813 """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
|
1814 """ |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1815 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
|
1816 parents = repo.changelog.parentrevs |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1817 def filter(r): |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1818 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
|
1819 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
|
1820 return False |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1821 return True |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1822 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
|
1823 |
29265
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1824 _sortkeyfuncs = { |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1825 'rev': lambda c: c.rev(), |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1826 'branch': lambda c: c.branch(), |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1827 'desc': lambda c: c.description(), |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1828 'user': lambda c: c.user(), |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1829 'author': lambda c: c.user(), |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1830 'date': lambda c: c.date()[0], |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1831 } |
3f9e68864ccc
revset: define table of sort() key functions
Yuya Nishihara <yuya@tcha.org>
parents:
29264
diff
changeset
|
1832 |
29365
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1833 def _getsortargs(x): |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1834 """Parse sort options into (set, [(key, reverse)], opts)""" |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1835 args = getargsdict(x, 'sort', 'set keys topo.firstbranch') |
29238
e150c1d5f262
revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents:
29216
diff
changeset
|
1836 if 'set' not in args: |
e150c1d5f262
revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents:
29216
diff
changeset
|
1837 # i18n: "sort" is a keyword |
e150c1d5f262
revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents:
29216
diff
changeset
|
1838 raise error.ParseError(_('sort requires one or two arguments')) |
11275 | 1839 keys = "rev" |
29238
e150c1d5f262
revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents:
29216
diff
changeset
|
1840 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
|
1841 # i18n: "sort" is a keyword |
29238
e150c1d5f262
revset: use getargsdict for sort()
Martijn Pieters <mjpieters@fb.com>
parents:
29216
diff
changeset
|
1842 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
|
1843 |
29363
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1844 keyflags = [] |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1845 for k in keys.split(): |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1846 fk = k |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1847 reverse = (k[0] == '-') |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1848 if reverse: |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1849 k = k[1:] |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1850 if k not in _sortkeyfuncs and k != 'topo': |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1851 raise error.ParseError(_("unknown sort key %r") % fk) |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1852 keyflags.append((k, reverse)) |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1853 |
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1854 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
|
1855 # 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
|
1856 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
|
1857 'with other sort keys')) |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1858 |
29364
76a1a703e23d
revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents:
29363
diff
changeset
|
1859 opts = {} |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1860 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
|
1861 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
|
1862 opts['topo.firstbranch'] = args['topo.firstbranch'] |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1863 else: |
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1864 # 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
|
1865 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
|
1866 'when using the topo sort key')) |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1867 |
29365
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1868 return args['set'], keyflags, opts |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1869 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1870 @predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True, |
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
1871 weight=10) |
29946
285a8c3e53f2
revset: make sort() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29945
diff
changeset
|
1872 def sort(repo, subset, x, order): |
29365
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1873 """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
|
1874 as ``-key`` to sort in descending order. |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1875 |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1876 The keys can be: |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1877 |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1878 - ``rev`` for the revision number, |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1879 - ``branch`` for the branch name, |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1880 - ``desc`` for the commit message (description), |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1881 - ``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
|
1882 - ``date`` for the commit date |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1883 - ``topo`` for a reverse topographical sort |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1884 |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1885 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
|
1886 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
|
1887 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
|
1888 |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1889 """ |
f652e84f23f2
revset: extract function that validates sort() arguments
Yuya Nishihara <yuya@tcha.org>
parents:
29364
diff
changeset
|
1890 s, keyflags, opts = _getsortargs(x) |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
1891 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
|
1892 |
29946
285a8c3e53f2
revset: make sort() noop depending on ordering requirement (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29945
diff
changeset
|
1893 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
|
1894 return revs |
29363
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1895 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
|
1896 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
|
1897 return revs |
29363
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1898 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
|
1899 firstbranch = () |
76a1a703e23d
revset: build dict of extra sort options before evaluating set
Yuya Nishihara <yuya@tcha.org>
parents:
29363
diff
changeset
|
1900 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
|
1901 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
|
1902 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
|
1903 firstbranch), |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1904 istopo=True) |
29363
2d18c61173f1
revset: build list of (key, reverse) pairs before sorting
Yuya Nishihara <yuya@tcha.org>
parents:
29362
diff
changeset
|
1905 if keyflags[0][1]: |
29348
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1906 revs.reverse() |
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1907 return revs |
2188f170f5b6
revset: add new topographical sort
Martijn Pieters <mjpieters@fb.com>
parents:
29347
diff
changeset
|
1908 |
29001
923fa9e06ea0
revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218)
Yuya Nishihara <yuya@tcha.org>
parents:
28910
diff
changeset
|
1909 # 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
|
1910 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
|
1911 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
|
1912 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
|
1913 return baseset([c.rev() for c in ctxs]) |
11275 | 1914 |
27584
fc7c8cac6a4b
revset: use decorator to register a function as revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27517
diff
changeset
|
1915 @predicate('subrepo([pattern])') |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1916 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
|
1917 """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
|
1918 pattern is named, any subrepo changes are returned. |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1919 """ |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1920 # i18n: "subrepo" is a keyword |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1921 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
|
1922 pat = None |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1923 if len(args) != 0: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1924 pat = getstring(args[0], _("subrepo requires a pattern")) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1925 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1926 m = matchmod.exact(repo.root, repo.root, ['.hgsubstate']) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1927 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1928 def submatches(names): |
26481
7d132557e44a
util: extract stringmatcher() from revset
Matt Harbison <matt_harbison@yahoo.com>
parents:
26307
diff
changeset
|
1929 k, p, m = util.stringmatcher(pat) |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1930 for name in names: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1931 if m(name): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1932 yield name |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1933 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1934 def matches(x): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1935 c = repo[x] |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1936 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
|
1937 |
28272
760f9d04842a
revset: define "pat" variable unconditionally in subrepo()
Yuya Nishihara <yuya@tcha.org>
parents:
28271
diff
changeset
|
1938 if pat is None: |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1939 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
|
1940 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1941 if s.added: |
25149
3f0744eeaeaf
cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents:
25146
diff
changeset
|
1942 return any(submatches(c.substate.keys())) |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1943 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1944 if s.modified: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1945 subs = set(c.p1().substate.keys()) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1946 subs.update(c.substate.keys()) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1947 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1948 for path in submatches(subs): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1949 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
|
1950 return True |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1951 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1952 if s.removed: |
25149
3f0744eeaeaf
cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents:
25146
diff
changeset
|
1953 return any(submatches(c.p1().substate.keys())) |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1954 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1955 return False |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
1956 |
28424
534f968d33e5
revset: add inspection data to all filter() calls
Yuya Nishihara <yuya@tcha.org>
parents:
28423
diff
changeset
|
1957 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
|
1958 |
33377 | 1959 def _mapbynodefunc(repo, s, f): |
1960 """(repo, smartset, [node] -> [node]) -> smartset | |
1961 | |
1962 Helper method to map a smartset to another smartset given a function only | |
1963 talking about nodes. Handles converting between rev numbers and nodes, and | |
1964 filtering. | |
1965 """ | |
1966 cl = repo.unfiltered().changelog | |
1967 torev = cl.rev | |
1968 tonode = cl.node | |
1969 nodemap = cl.nodemap | |
1970 result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap) | |
1971 return smartset.baseset(result - repo.changelog.filteredrevs) | |
1972 | |
1973 @predicate('successors(set)', safe=True) | |
1974 def successors(repo, subset, x): | |
1975 """All successors for set, including the given set themselves""" | |
1976 s = getset(repo, fullreposet(repo), x) | |
1977 f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes) | |
1978 d = _mapbynodefunc(repo, s, f) | |
1979 return subset & d | |
1980 | |
30782
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1981 def _substringmatcher(pattern, casesensitive=True): |
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1982 kind, pattern, matcher = util.stringmatcher(pattern, |
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1983 casesensitive=casesensitive) |
16823
b23bacb230c9
revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents:
16822
diff
changeset
|
1984 if kind == 'literal': |
30782
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1985 if not casesensitive: |
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1986 pattern = encoding.lower(pattern) |
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1987 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
|
1988 else: |
db38cfc7c29d
revset: stop lowercasing the regex pattern for 'author'
Matt Harbison <matt_harbison@yahoo.com>
parents:
30772
diff
changeset
|
1989 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
|
1990 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
|
1991 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
1992 @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
|
1993 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
|
1994 """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
|
1995 |
30784
5dd67f0993ce
help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents:
30783
diff
changeset
|
1996 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
|
1997 :hg:`help revisions.patterns`. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1998 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
1999 # 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
|
2000 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
|
2001 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
|
2002 if args: |
16820
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2003 pattern = getstring(args[0], |
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2004 # i18n: "tag" is a keyword |
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2005 _('the argument to tag must be a string')) |
26481
7d132557e44a
util: extract stringmatcher() from revset
Matt Harbison <matt_harbison@yahoo.com>
parents:
26307
diff
changeset
|
2006 kind, pattern, matcher = util.stringmatcher(pattern) |
16820
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2007 if kind == 'literal': |
16825
b6ef1395d77f
revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents:
16824
diff
changeset
|
2008 # avoid resolving all tags |
b6ef1395d77f
revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents:
16824
diff
changeset
|
2009 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
|
2010 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
|
2011 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
|
2012 % pattern) |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
2013 s = {repo[tn].rev()} |
16820
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2014 else: |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
2015 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
|
2016 else: |
32291
bd872f64a8ba
cleanup: use set literals
Martin von Zweigbergk <martinvonz@google.com>
parents:
32085
diff
changeset
|
2017 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
|
2018 return subset & s |
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
2019 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
2020 @predicate('tagged', safe=True) |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2021 def tagged(repo, subset, x): |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2022 return tag(repo, subset, x) |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2023 |
27587
c8dc480142a8
revset: use decorator to mark a predicate as safe
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27586
diff
changeset
|
2024 @predicate('unstable()', safe=True) |
17171
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2025 def unstable(repo, subset, x): |
33774
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2026 msg = ("'unstable()' is deprecated, " |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2027 "use 'orphan()'") |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2028 repo.ui.deprecwarn(msg, '4.4') |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2029 |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2030 return orphan(repo, subset, x) |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2031 |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2032 @predicate('orphan()', safe=True) |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2033 def orphan(repo, subset, x): |
33855
457d1ebf151b
revset: mark evolution-related revsets as experimental
Boris Feld <boris.feld@octobus.net>
parents:
33779
diff
changeset
|
2034 """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
|
2035 """ |
33774
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2036 # i18n: "orphan" is a keyword |
9dcc3529e002
revset: rename unstable into orphan
Boris Feld <boris.feld@octobus.net>
parents:
33417
diff
changeset
|
2037 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
|
2038 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
|
2039 return subset & orphan |
17171
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2040 |
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2041 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
2042 @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
|
2043 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
|
2044 """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
|
2045 |
30784
5dd67f0993ce
help: eliminate duplicate text for revset string patterns
Matt Harbison <matt_harbison@yahoo.com>
parents:
30783
diff
changeset
|
2046 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
|
2047 :hg:`help revisions.patterns`. |
13359
87f248e78173
bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
2048 """ |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
2049 return author(repo, subset, x) |
13359
87f248e78173
bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
2050 |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
2051 @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
|
2052 def wdir(repo, subset, x): |
30701
8b1d87243710
revset: document wdir() as an experimental function
Yuya Nishihara <yuya@tcha.org>
parents:
30700
diff
changeset
|
2053 """Working directory. (EXPERIMENTAL)""" |
24419
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2054 # 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
|
2055 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
|
2056 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
|
2057 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
|
2058 return baseset() |
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2059 |
29935
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2060 def _orderedlist(repo, subset, x): |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2061 s = getstring(x, "internal error") |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2062 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
|
2063 return baseset() |
25341
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2064 # 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
|
2065 # 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
|
2066 cl = repo.changelog |
25341
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2067 ls = [] |
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2068 seen = set() |
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2069 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
|
2070 try: |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2071 # fast path for integer revision |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2072 r = int(t) |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2073 if str(r) != t or r not in cl: |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2074 raise ValueError |
26143
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2075 revs = [r] |
25344
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2076 except ValueError: |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
2077 revs = stringset(repo, subset, t, defineorder) |
26143
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2078 |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2079 for r in revs: |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2080 if r in seen: |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2081 continue |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2082 if (r in subset |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2083 or r == node.nullrev and isinstance(subset, fullreposet)): |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2084 ls.append(r) |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2085 seen.add(r) |
25341
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2086 return baseset(ls) |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2087 |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2088 # for internal use |
29935
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2089 @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
|
2090 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
|
2091 if order == followorder: |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2092 # 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
|
2093 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
|
2094 else: |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2095 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
|
2096 |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2097 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
|
2098 s = getstring(x, "internal error") |
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2099 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
|
2100 return baseset() |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2101 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
|
2102 s = subset |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2103 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
|
2104 |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2105 # for internal use |
34273
b0790bebfcf8
revset: move weight information to predicate
Jun Wu <quark@fb.com>
parents:
34065
diff
changeset
|
2106 @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
|
2107 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
|
2108 if order == followorder: |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2109 # 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
|
2110 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
|
2111 else: |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2112 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
|
2113 |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2114 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
|
2115 s = getstring(x, "internal error") |
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2116 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
|
2117 return baseset() |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2118 cl = repo.changelog |
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2119 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
|
2120 s = subset |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2121 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
|
2122 |
29935
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2123 # for internal use |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2124 @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
|
2125 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
|
2126 if order == followorder: |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2127 # 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
|
2128 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
|
2129 else: |
e34cd85dc5b1
revset: fix order of nested '_(|int|hex)list' expression (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29934
diff
changeset
|
2130 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
|
2131 |
11275 | 2132 methods = { |
2133 "range": rangeset, | |
30803
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
2134 "rangeall": rangeall, |
30044
69b61d0bb008
revset: do not rewrite ':y' to '0:y' (issue5385)
Yuya Nishihara <yuya@tcha.org>
parents:
30043
diff
changeset
|
2135 "rangepre": rangepre, |
30803
d389f19f14aa
revset: do not transform range* operators in parsed tree
Yuya Nishihara <yuya@tcha.org>
parents:
30802
diff
changeset
|
2136 "rangepost": rangepost, |
16860
e1aa1ed30030
revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents:
16859
diff
changeset
|
2137 "dagrange": dagrange, |
11275 | 2138 "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
|
2139 "symbol": stringset, |
11275 | 2140 "and": andset, |
34020
37b82485097f
revset: do not flip "and" arguments when optimizing
Jun Wu <quark@fb.com>
parents:
34019
diff
changeset
|
2141 "andsmally": andsmallyset, |
11275 | 2142 "or": orset, |
2143 "not": notset, | |
28217
d2ac8b57a75d
revset: use smartset minus operator
Durham Goode <durham@fb.com>
parents:
28139
diff
changeset
|
2144 "difference": differenceset, |
33416
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
2145 "relation": relationset, |
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
2146 "relsubscript": relsubscriptset, |
9467d5337292
revset: add experimental relation and subscript operators
Yuya Nishihara <yuya@tcha.org>
parents:
33377
diff
changeset
|
2147 "subscript": subscriptset, |
11275 | 2148 "list": listset, |
25704
70a2082f855a
revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents:
25689
diff
changeset
|
2149 "keyvalue": keyvaluepair, |
11275 | 2150 "func": func, |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2151 "ancestor": ancestorspec, |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2152 "parent": parentspec, |
29931
d2d1be3009ca
revset: add stub to handle parentpost operation
Yuya Nishihara <yuya@tcha.org>
parents:
29930
diff
changeset
|
2153 "parentpost": parentpost, |
11275 | 2154 } |
2155 | |
24518
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2156 def posttreebuilthook(tree, repo): |
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2157 # hook for extensions to execute code on the optimized tree |
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2158 pass |
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2159 |
34018
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
2160 def match(ui, spec, repo=None): |
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
2161 """Create a matcher for a single revision spec""" |
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
2162 return matchany(ui, [spec], repo=repo) |
29955
1b5931604a5a
revset: add option to make matcher takes the ordering of the input set
Yuya Nishihara <yuya@tcha.org>
parents:
29946
diff
changeset
|
2163 |
34018
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
2164 def matchany(ui, specs, repo=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
|
2165 """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
|
2166 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
|
2167 |
33336
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2168 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
|
2169 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
|
2170 """ |
25927
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2171 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
|
2172 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
|
2173 return baseset() |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2174 return mfunc |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2175 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
|
2176 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
|
2177 lookup = None |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2178 if repo: |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2179 lookup = repo.__contains__ |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2180 if len(specs) == 1: |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
2181 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
|
2182 else: |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
2183 tree = ('or', |
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
2184 ('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
|
2185 |
33336
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2186 aliases = [] |
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2187 warn = None |
14900
fc3d6f300d7d
revset: allow bypassing alias expansion
Matt Mackall <mpm@selenic.com>
parents:
14851
diff
changeset
|
2188 if ui: |
33336
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2189 aliases.extend(ui.configitems('revsetalias')) |
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2190 warn = ui.warn |
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2191 if localalias: |
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2192 aliases.extend(localalias.items()) |
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2193 if aliases: |
4672db164c98
revset: make repo.anyrevs accept customized alias override (API)
Jun Wu <quark@fb.com>
parents:
33080
diff
changeset
|
2194 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
|
2195 tree = revsetlang.foldconcat(tree) |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
2196 tree = revsetlang.analyze(tree) |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
31017
diff
changeset
|
2197 tree = revsetlang.optimize(tree) |
24518
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2198 posttreebuilthook(tree, repo) |
34018
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
2199 return makematcher(tree) |
29906
41491cf936f2
revset: add public function to create matcher from evaluatable tree
Yuya Nishihara <yuya@tcha.org>
parents:
29905
diff
changeset
|
2200 |
34018
de286200f722
revset: move order argument to run-time match function
Yuya Nishihara <yuya@tcha.org>
parents:
34017
diff
changeset
|
2201 def makematcher(tree): |
29906
41491cf936f2
revset: add public function to create matcher from evaluatable tree
Yuya Nishihara <yuya@tcha.org>
parents:
29905
diff
changeset
|
2202 """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
|
2203 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
|
2204 if order is None: |
205c47e30a93
revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents:
34018
diff
changeset
|
2205 if subset is None: |
205c47e30a93
revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents:
34018
diff
changeset
|
2206 order = defineorder # 'x' |
205c47e30a93
revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents:
34018
diff
changeset
|
2207 else: |
205c47e30a93
revset: make match function follow given subset if specified (API)
Yuya Nishihara <yuya@tcha.org>
parents:
34018
diff
changeset
|
2208 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
|
2209 if subset is None: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
2210 subset = fullreposet(repo) |
34011
1b28525e6698
revset: remove order information from tree (API)
Jun Wu <quark@fb.com>
parents:
33855
diff
changeset
|
2211 return getset(repo, subset, tree, order) |
11275 | 2212 return mfunc |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2213 |
28393
ac11ba7c2e56
registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28272
diff
changeset
|
2214 def loadpredicate(ui, extname, registrarobj): |
ac11ba7c2e56
registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28272
diff
changeset
|
2215 """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
|
2216 """ |
ac11ba7c2e56
registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28272
diff
changeset
|
2217 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
|
2218 symbols[name] = func |
ac11ba7c2e56
registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28272
diff
changeset
|
2219 if func._safe: |
ac11ba7c2e56
registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28272
diff
changeset
|
2220 safesymbols.add(name) |
ac11ba7c2e56
registrar: define revsetpredicate to decorate revset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28272
diff
changeset
|
2221 |
28395
0383f7a5e86c
revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28393
diff
changeset
|
2222 # 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
|
2223 loadpredicate(None, None, predicate) |
0383f7a5e86c
revset: replace predicate by revsetpredicate of registrar
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28393
diff
changeset
|
2224 |
12823
80deae3bc5ea
hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents:
12821
diff
changeset
|
2225 # 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
|
2226 i18nfunctions = symbols.values() |