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