Mercurial > hg
annotate mercurial/match.py @ 50757:19108906abaf stable
extensions: imp module is removed in Python 3.12 - use importlib to load files
imp has been deprecated for a long time, and has finally been removed in Python
3.12 .
imp was only used for loading extensions that has been specified with direct
.py path or path to a package directory. The same use cases can be achieved
quite simple with importlib, , possiby with small changes in corner cases with
undefined behaviour, such as extensions without .py source.
There might also be corner cases and undefined behaviour around use of
sys.modules and reloading.
author | Mads Kiilerich <mads@kiilerich.com> |
---|---|
date | Wed, 28 Jun 2023 14:23:13 +0200 |
parents | 1c31b343e514 |
children | b32c3146ec34 |
rev | line source |
---|---|
8761
0289f384e1e5
Generally replace "file name" with "filename" in help and comments.
timeless <timeless@gmail.com>
parents:
8682
diff
changeset
|
1 # match.py - filename matching |
8231
5d4d88a4f5e6
match: add copyright and license header
Martin Geisler <mg@lazybytes.net>
parents:
8152
diff
changeset
|
2 # |
46819
d4ba4d51f85f
contributor: change mentions of mpm to olivia
Raphaël Gomès <rgomes@octobus.net>
parents:
46064
diff
changeset
|
3 # Copyright 2008, 2009 Olivia Mackall <olivia@selenic.com> and others |
8231
5d4d88a4f5e6
match: add copyright and license header
Martin Geisler <mg@lazybytes.net>
parents:
8152
diff
changeset
|
4 # |
5d4d88a4f5e6
match: add copyright and license header
Martin Geisler <mg@lazybytes.net>
parents:
8152
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
8231
5d4d88a4f5e6
match: add copyright and license header
Martin Geisler <mg@lazybytes.net>
parents:
8152
diff
changeset
|
7 |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
8 |
46872
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
9 import bisect |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
10 import copy |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
11 import itertools |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
12 import os |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
13 import re |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
14 |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
15 from .i18n import _ |
43085
eef9a2d67051
py3: manually import pycompat.open into files that need it
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
16 from .pycompat import open |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
17 from . import ( |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
18 encoding, |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26014
diff
changeset
|
19 error, |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
20 pathutil, |
42452
a3a8887e4426
rust: using policy.importrust from Python callers
Georges Racinet <georges.racinet@octobus.net>
parents:
42367
diff
changeset
|
21 policy, |
36572
9adfa48792a7
match: some minimal pycompat fixes guided by test-hgignore.t
Augie Fackler <augie@google.com>
parents:
36050
diff
changeset
|
22 pycompat, |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
23 util, |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
24 ) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
25 from .utils import stringutil |
6576 | 26 |
44137
3bd77c64bc74
rust-filepatterns: remove bridge code for filepatterns-related functions
Raphaël Gomès <rgomes@octobus.net>
parents:
44009
diff
changeset
|
27 rustmod = policy.importrust('dirstate') |
42329
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42195
diff
changeset
|
28 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
29 allpatternkinds = ( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
30 b're', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
31 b'glob', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
32 b'path', |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
33 b'filepath', |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
34 b'relglob', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
35 b'relpath', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
36 b'relre', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
37 b'rootglob', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
38 b'listfile', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
39 b'listfile0', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
40 b'set', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
41 b'include', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
42 b'subinclude', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
43 b'rootfilesin', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
44 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
45 cwdrelativepatternkinds = (b'relpath', b'glob') |
33684
2be0bf186950
match: expose some data and functionality to other modules
Kostia Balytskyi <ikostia@fb.com>
parents:
33582
diff
changeset
|
46 |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
47 propertycache = util.propertycache |
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
48 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
49 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
50 def _rematcher(regex): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
51 """compile the regexp with the best available regexp engine and return a |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
52 matcher function""" |
21909
335bb8b80443
match: use util.re.compile instead of util.compilere
Siddharth Agarwal <sid0@fb.com>
parents:
21815
diff
changeset
|
53 m = util.re.compile(regex) |
16943
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
54 try: |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
55 # slightly faster, provided by facebook's re2 bindings |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
56 return m.test_match |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
57 except AttributeError: |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
58 return m.match |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
59 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
60 |
44009
e685fac56693
match: resolve filesets against the passed `cwd`, not the current one
Matt Harbison <matt_harbison@yahoo.com>
parents:
44002
diff
changeset
|
61 def _expandsets(cwd, kindpats, ctx=None, listsubrepos=False, badfn=None): |
38612
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38611
diff
changeset
|
62 '''Returns the kindpats list with the 'set' patterns expanded to matchers''' |
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38611
diff
changeset
|
63 matchers = [] |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
64 other = [] |
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
65 |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
66 for kind, pat, source in kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
67 if kind == b'set': |
41022
481249481392
match: fix assertion for fileset with no context (issue6046)
Yuya Nishihara <yuya@tcha.org>
parents:
40345
diff
changeset
|
68 if ctx is None: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
69 raise error.ProgrammingError( |
43117
8ff1ecfadcd1
cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents:
43106
diff
changeset
|
70 b"fileset expression with no context" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
71 ) |
44009
e685fac56693
match: resolve filesets against the passed `cwd`, not the current one
Matt Harbison <matt_harbison@yahoo.com>
parents:
44002
diff
changeset
|
72 matchers.append(ctx.matchfileset(cwd, pat, badfn=badfn)) |
25122
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
73 |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
74 if listsubrepos: |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
75 for subpath in ctx.substate: |
44009
e685fac56693
match: resolve filesets against the passed `cwd`, not the current one
Matt Harbison <matt_harbison@yahoo.com>
parents:
44002
diff
changeset
|
76 sm = ctx.sub(subpath).matchfileset(cwd, pat, badfn=badfn) |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
77 pm = prefixdirmatcher(subpath, sm, badfn=badfn) |
38612
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38611
diff
changeset
|
78 matchers.append(pm) |
25122
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
79 |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
80 continue |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
81 other.append((kind, pat, source)) |
38612
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38611
diff
changeset
|
82 return matchers, other |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
83 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
84 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
85 def _expandsubinclude(kindpats, root): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
86 """Returns the list of subinclude matcher args and the kindpats without the |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
87 subincludes in it.""" |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
88 relmatchers = [] |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
89 other = [] |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
90 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
91 for kind, pat, source in kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
92 if kind == b'subinclude': |
25301
caaf4045eca8
match: normpath the ignore source when expanding the 'subinclude' kind
Matt Harbison <matt_harbison@yahoo.com>
parents:
25283
diff
changeset
|
93 sourceroot = pathutil.dirname(util.normpath(source)) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
94 pat = util.pconvert(pat) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
95 path = pathutil.join(sourceroot, pat) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
96 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
97 newroot = pathutil.dirname(path) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
98 matcherargs = (newroot, b'', [], [b'include:%s' % path]) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
99 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
100 prefix = pathutil.canonpath(root, root, newroot) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
101 if prefix: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
102 prefix += b'/' |
32132
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
103 relmatchers.append((prefix, matcherargs)) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
104 else: |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
105 other.append((kind, pat, source)) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
106 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
107 return relmatchers, other |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
108 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
109 |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
110 def _kindpatsalwaysmatch(kindpats): |
45946
464539c305aa
formatting: drop a few extra double quotes in docstrings
Matt Harbison <matt_harbison@yahoo.com>
parents:
45942
diff
changeset
|
111 """Checks whether the kindspats match everything, as e.g. |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
112 'relpath:.' does. |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
113 """ |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
114 for kind, pat, source in kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
115 if pat != b'' or kind not in [b'relpath', b'glob']: |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
116 return False |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
117 return True |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
118 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
119 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
120 def _buildkindpatsmatcher( |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
121 matchercls, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
122 root, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
123 cwd, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
124 kindpats, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
125 ctx=None, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
126 listsubrepos=False, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
127 badfn=None, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
128 ): |
38580
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
129 matchers = [] |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
130 fms, kindpats = _expandsets( |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
131 cwd, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
132 kindpats, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
133 ctx=ctx, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
134 listsubrepos=listsubrepos, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
135 badfn=badfn, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
136 ) |
38580
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
137 if kindpats: |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
138 m = matchercls(root, kindpats, badfn=badfn) |
38580
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
139 matchers.append(m) |
38612
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38611
diff
changeset
|
140 if fms: |
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38611
diff
changeset
|
141 matchers.extend(fms) |
38580
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
142 if not matchers: |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
143 return nevermatcher(badfn=badfn) |
38580
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
144 if len(matchers) == 1: |
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
145 return matchers[0] |
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
146 return unionmatcher(matchers) |
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38579
diff
changeset
|
147 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
148 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
149 def match( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
150 root, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
151 cwd, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
152 patterns=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
153 include=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
154 exclude=None, |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
155 default=b'glob', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
156 auditor=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
157 ctx=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
158 listsubrepos=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
159 warn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
160 badfn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
161 icasefs=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
162 ): |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
163 r"""build an object to match a set of file patterns |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
164 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
165 arguments: |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
166 root - the canonical root of the tree you're matching against |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
167 cwd - the current working directory, if relevant |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
168 patterns - patterns to find |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
169 include - patterns to include (unless they are excluded) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
170 exclude - patterns to exclude (even if they are included) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
171 default - if a pattern in patterns has no explicit type, assume this one |
42083
bee1647578b7
match: complete documentation of match() parameters
Denis Laxalde <denis@laxalde.org>
parents:
42082
diff
changeset
|
172 auditor - optional path auditor |
bee1647578b7
match: complete documentation of match() parameters
Denis Laxalde <denis@laxalde.org>
parents:
42082
diff
changeset
|
173 ctx - optional changecontext |
bee1647578b7
match: complete documentation of match() parameters
Denis Laxalde <denis@laxalde.org>
parents:
42082
diff
changeset
|
174 listsubrepos - if True, recurse into subrepositories |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
175 warn - optional function used for printing warnings |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
176 badfn - optional bad() callback for this matcher instead of the default |
32401
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
177 icasefs - make a matcher for wdir on case insensitive filesystems, which |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
178 normalizes the given patterns to the case in the filesystem |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
179 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
180 a pattern is one of: |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
181 'glob:<glob>' - a glob relative to cwd |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
182 're:<regexp>' - a regular expression |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
183 'path:<path>' - a path relative to repository root, which is matched |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
184 recursively |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
185 'filepath:<path>' - an exact path to a single file, relative to the |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
186 repository root |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
187 'rootfilesin:<path>' - a path relative to repository root, which is |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
188 matched non-recursively (will not match subdirectories) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
189 'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
190 'relpath:<path>' - a path relative to cwd |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
191 'relre:<regexp>' - a regexp that needn't match the start of a name |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
192 'set:<fileset>' - a fileset expression |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
193 'include:<path>' - a file of patterns to read and include |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
194 'subinclude:<path>' - a file of patterns to match against files under |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
195 the same directory |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
196 '<something>' - a pattern of the specified default type |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
197 |
43964
8f67735344ae
tests: convert the `root` arg of matchmod.match() to local path separators
Matt Harbison <matt_harbison@yahoo.com>
parents:
43950
diff
changeset
|
198 >>> def _match(root, *args, **kwargs): |
8f67735344ae
tests: convert the `root` arg of matchmod.match() to local path separators
Matt Harbison <matt_harbison@yahoo.com>
parents:
43950
diff
changeset
|
199 ... return match(util.localpath(root), *args, **kwargs) |
8f67735344ae
tests: convert the `root` arg of matchmod.match() to local path separators
Matt Harbison <matt_harbison@yahoo.com>
parents:
43950
diff
changeset
|
200 |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
201 Usually a patternmatcher is returned: |
50304
805d4a462abb
py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences
Mads Kiilerich <mads@kiilerich.com>
parents:
49805
diff
changeset
|
202 >>> _match(b'/foo', b'.', [br're:.*\.c$', b'path:foo/a', b'*.py']) |
50337
47686726545d
match: sort patterns before compiling them into a regex
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50304
diff
changeset
|
203 <patternmatcher patterns='[^/]*\\.py$|foo/a(?:/|$)|.*\\.c$'> |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
204 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
205 Combining 'patterns' with 'include' (resp. 'exclude') gives an |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
206 intersectionmatcher (resp. a differencematcher): |
50304
805d4a462abb
py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences
Mads Kiilerich <mads@kiilerich.com>
parents:
49805
diff
changeset
|
207 >>> type(_match(b'/foo', b'.', [br're:.*\.c$'], include=[b'path:lib'])) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
208 <class 'mercurial.match.intersectionmatcher'> |
50304
805d4a462abb
py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences
Mads Kiilerich <mads@kiilerich.com>
parents:
49805
diff
changeset
|
209 >>> type(_match(b'/foo', b'.', [br're:.*\.c$'], exclude=[b'path:build'])) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
210 <class 'mercurial.match.differencematcher'> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
211 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
212 Notice that, if 'patterns' is empty, an alwaysmatcher is returned: |
43964
8f67735344ae
tests: convert the `root` arg of matchmod.match() to local path separators
Matt Harbison <matt_harbison@yahoo.com>
parents:
43950
diff
changeset
|
213 >>> _match(b'/foo', b'.', []) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
214 <alwaysmatcher> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
215 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
216 The 'default' argument determines which kind of pattern is assumed if a |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
217 pattern has no prefix: |
50304
805d4a462abb
py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences
Mads Kiilerich <mads@kiilerich.com>
parents:
49805
diff
changeset
|
218 >>> _match(b'/foo', b'.', [br'.*\.c$'], default=b're') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
219 <patternmatcher patterns='.*\\.c$'> |
43964
8f67735344ae
tests: convert the `root` arg of matchmod.match() to local path separators
Matt Harbison <matt_harbison@yahoo.com>
parents:
43950
diff
changeset
|
220 >>> _match(b'/foo', b'.', [b'main.py'], default=b'relpath') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
221 <patternmatcher patterns='main\\.py(?:/|$)'> |
43964
8f67735344ae
tests: convert the `root` arg of matchmod.match() to local path separators
Matt Harbison <matt_harbison@yahoo.com>
parents:
43950
diff
changeset
|
222 >>> _match(b'/foo', b'.', [b'main.py'], default=b're') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
223 <patternmatcher patterns='main.py'> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
224 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
225 The primary use of matchers is to check whether a value (usually a file |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
226 name) matches againset one of the patterns given at initialization. There |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
227 are two ways of doing this check. |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
228 |
50304
805d4a462abb
py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences
Mads Kiilerich <mads@kiilerich.com>
parents:
49805
diff
changeset
|
229 >>> m = _match(b'/foo', b'', [br're:.*\.c$', b'relpath:a']) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
230 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
231 1. Calling the matcher with a file name returns True if any pattern |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
232 matches that file name: |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
233 >>> m(b'a') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
234 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
235 >>> m(b'main.c') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
236 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
237 >>> m(b'test.py') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
238 False |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
239 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
240 2. Using the exact() method only returns True if the file name matches one |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
241 of the exact patterns (i.e. not re: or glob: patterns): |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
242 >>> m.exact(b'a') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
243 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
244 >>> m.exact(b'main.c') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
245 False |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
246 """ |
43949
8b1a9ba375e5
match: make sure `root` argument is always an absolute path (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43735
diff
changeset
|
247 assert os.path.isabs(root) |
43965
8a81fa44f7bb
match: don't util.normpath() cwd
Matt Harbison <matt_harbison@yahoo.com>
parents:
43964
diff
changeset
|
248 cwd = os.path.join(root, util.localpath(cwd)) |
32401
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
249 normalize = _donormalize |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
250 if icasefs: |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
251 dirstate = ctx.repo().dirstate |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
252 dsnormalize = dirstate.normalize |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
253 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
254 def normalize(patterns, default, root, cwd, auditor, warn): |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
255 kp = _donormalize(patterns, default, root, cwd, auditor, warn) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
256 kindpats = [] |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
257 for kind, pats, source in kp: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
258 if kind not in (b're', b'relre'): # regex can't be normalized |
32401
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
259 p = pats |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
260 pats = dsnormalize(pats) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
261 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
262 # Preserve the original to handle a case only rename. |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
263 if p != pats and p in dirstate: |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
264 kindpats.append((kind, p, source)) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
265 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
266 kindpats.append((kind, pats, source)) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
267 return kindpats |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32400
diff
changeset
|
268 |
41622
635a12c53ea6
match: remove unused "exact" argument (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41528
diff
changeset
|
269 if patterns: |
32556
5f08eca8f8d3
match: move normalize() call out of matcher constructors
Martin von Zweigbergk <martinvonz@google.com>
parents:
32555
diff
changeset
|
270 kindpats = normalize(patterns, default, root, cwd, auditor, warn) |
32557
3fdcc34c0aba
match: remove special-casing of always-matching patterns in patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32556
diff
changeset
|
271 if _kindpatsalwaysmatch(kindpats): |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
272 m = alwaysmatcher(badfn) |
32557
3fdcc34c0aba
match: remove special-casing of always-matching patterns in patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32556
diff
changeset
|
273 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
274 m = _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
275 patternmatcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
276 root, |
44009
e685fac56693
match: resolve filesets against the passed `cwd`, not the current one
Matt Harbison <matt_harbison@yahoo.com>
parents:
44002
diff
changeset
|
277 cwd, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
278 kindpats, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
279 ctx=ctx, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
280 listsubrepos=listsubrepos, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
281 badfn=badfn, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
282 ) |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
283 else: |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
284 # It's a little strange that no patterns means to match everything. |
32650
783394c0c978
match: simplify nevermatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32605
diff
changeset
|
285 # Consider changing this to match nothing (probably using nevermatcher). |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
286 m = alwaysmatcher(badfn) |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
287 |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
288 if include: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
289 kindpats = normalize(include, b'glob', root, cwd, auditor, warn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
290 im = _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
291 includematcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
292 root, |
44009
e685fac56693
match: resolve filesets against the passed `cwd`, not the current one
Matt Harbison <matt_harbison@yahoo.com>
parents:
44002
diff
changeset
|
293 cwd, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
294 kindpats, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
295 ctx=ctx, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
296 listsubrepos=listsubrepos, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
297 badfn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
298 ) |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
299 m = intersectmatchers(m, im) |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
300 if exclude: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
301 kindpats = normalize(exclude, b'glob', root, cwd, auditor, warn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
302 em = _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
303 includematcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
304 root, |
44009
e685fac56693
match: resolve filesets against the passed `cwd`, not the current one
Matt Harbison <matt_harbison@yahoo.com>
parents:
44002
diff
changeset
|
305 cwd, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
306 kindpats, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
307 ctx=ctx, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
308 listsubrepos=listsubrepos, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
309 badfn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
310 ) |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
311 m = differencematcher(m, em) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
312 return m |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
313 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
314 |
41676
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41675
diff
changeset
|
315 def exact(files, badfn=None): |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
316 return exactmatcher(files, badfn=badfn) |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
317 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
318 |
41676
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41675
diff
changeset
|
319 def always(badfn=None): |
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41675
diff
changeset
|
320 return alwaysmatcher(badfn) |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
321 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
322 |
41676
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41675
diff
changeset
|
323 def never(badfn=None): |
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41675
diff
changeset
|
324 return nevermatcher(badfn) |
32605
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
325 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
326 |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
327 def badmatch(match, badfn): |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
328 """Make a copy of the given matcher, replacing its bad method with the given |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
329 one. |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
330 """ |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
331 m = copy.copy(match) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
332 m.bad = badfn |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
333 return m |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
334 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
335 |
42085
54e6d7ef5ca5
match: make _donormalize's auditor and warn arguments optional
Denis Laxalde <denis@laxalde.org>
parents:
42084
diff
changeset
|
336 def _donormalize(patterns, default, root, cwd, auditor=None, warn=None): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
337 """Convert 'kind:pat' from the patterns list to tuples with kind and |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
338 normalized and rooted patterns and with listfiles expanded.""" |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
339 kindpats = [] |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
340 kinds_to_normalize = ( |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
341 b'relglob', |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
342 b'path', |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
343 b'filepath', |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
344 b'rootfilesin', |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
345 b'rootglob', |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
346 ) |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
347 |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
348 for kind, pat in [_patsplit(p, default) for p in patterns]: |
33684
2be0bf186950
match: expose some data and functionality to other modules
Kostia Balytskyi <ikostia@fb.com>
parents:
33582
diff
changeset
|
349 if kind in cwdrelativepatternkinds: |
42085
54e6d7ef5ca5
match: make _donormalize's auditor and warn arguments optional
Denis Laxalde <denis@laxalde.org>
parents:
42084
diff
changeset
|
350 pat = pathutil.canonpath(root, cwd, pat, auditor=auditor) |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
351 elif kind in kinds_to_normalize: |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
352 pat = util.normpath(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
353 elif kind in (b'listfile', b'listfile0'): |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
354 try: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
355 files = util.readfile(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
356 if kind == b'listfile0': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
357 files = files.split(b'\0') |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
358 else: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
359 files = files.splitlines() |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
360 files = [f for f in files if f] |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
361 except EnvironmentError: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
362 raise error.Abort(_(b"unable to read file list (%s)") % pat) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
363 for k, p, source in _donormalize( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
364 files, default, root, cwd, auditor, warn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
365 ): |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
366 kindpats.append((k, p, pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
367 continue |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
368 elif kind == b'include': |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
369 try: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
370 fullpath = os.path.join(root, util.localpath(pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
371 includepats = readpatternfile(fullpath, warn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
372 for k, p, source in _donormalize( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
373 includepats, default, root, cwd, auditor, warn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
374 ): |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
375 kindpats.append((k, p, source or pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
376 except error.Abort as inst: |
43485
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
377 raise error.Abort( |
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
378 b'%s: %s' |
45682
d2e1dcd4490d
errors: name arguments to Abort constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
44530
diff
changeset
|
379 % ( |
d2e1dcd4490d
errors: name arguments to Abort constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
44530
diff
changeset
|
380 pat, |
d2e1dcd4490d
errors: name arguments to Abort constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
44530
diff
changeset
|
381 inst.message, |
49805
a06a503e3cf8
typing: drop an unnecessary warning disabling comment in match.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
49645
diff
changeset
|
382 ) |
43485
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
383 ) |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
384 except IOError as inst: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
385 if warn: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
386 warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
387 _(b"skipping unreadable pattern file '%s': %s\n") |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
388 % (pat, stringutil.forcebytestr(inst.strerror)) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
389 ) |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
390 continue |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
391 # else: re or relre - which cannot be normalized |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
392 kindpats.append((kind, pat, b'')) |
32397
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
393 return kindpats |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32396
diff
changeset
|
394 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
395 |
48946
642e31cb55f0
py3: use class X: instead of class X(object):
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48941
diff
changeset
|
396 class basematcher: |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
397 def __init__(self, badfn=None): |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
398 if badfn is not None: |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
399 self.bad = badfn |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
400 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
401 def __call__(self, fn): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
402 return self.matchfn(fn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
403 |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
404 # Callbacks related to how the matcher is used by dirstate.walk. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
405 # Subscribers to these events must monkeypatch the matcher object. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
406 def bad(self, f, msg): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
407 """Callback from dirstate.walk for each explicit file that can't be |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
408 found/accessed, with an error message.""" |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
409 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
410 # If an traversedir is set, it will be called when a directory discovered |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
411 # by recursive traversal is visited. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
412 traversedir = None |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
413 |
32459
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32458
diff
changeset
|
414 @propertycache |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32458
diff
changeset
|
415 def _files(self): |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32458
diff
changeset
|
416 return [] |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32458
diff
changeset
|
417 |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
418 def files(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
419 """Explicitly listed files or patterns or roots: |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
420 if no patterns or .always(): empty list, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
421 if exact: list exact files, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
422 if not .anypats(): list all files and dirs, |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
423 else: optimal roots""" |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
424 return self._files |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
425 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
426 @propertycache |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
427 def _fileset(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
428 return set(self._files) |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
429 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
430 def exact(self, f): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
431 '''Returns True if f is in .files().''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
432 return f in self._fileset |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
433 |
32463
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32461
diff
changeset
|
434 def matchfn(self, f): |
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32461
diff
changeset
|
435 return False |
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32461
diff
changeset
|
436 |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
437 def visitdir(self, dir): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
438 """Decides whether a directory should be visited based on whether it |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
439 has potential matches in it or one of its subdirectories. This is |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
440 based on the match's primary, included, and excluded patterns. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
441 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
442 Returns the string 'all' if the given directory and all subdirectories |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
443 should be visited. Otherwise returns True or False indicating whether |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
444 the given directory should be visited. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
445 """ |
33478
cf15c3cc304c
match: make base matcher return True for visitdir
Durham Goode <durham@fb.com>
parents:
33448
diff
changeset
|
446 return True |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
447 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
448 def visitchildrenset(self, dir): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
449 """Decides whether a directory should be visited based on whether it |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
450 has potential matches in it or one of its subdirectories, and |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
451 potentially lists which subdirectories of that directory should be |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
452 visited. This is based on the match's primary, included, and excluded |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
453 patterns. |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
454 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
455 This function is very similar to 'visitdir', and the following mapping |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
456 can be applied: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
457 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
458 visitdir | visitchildrenlist |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
459 ----------+------------------- |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
460 False | set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
461 'all' | 'all' |
39260
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
462 True | 'this' OR non-empty set of subdirs -or files- to visit |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
463 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
464 Example: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
465 Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
466 the following values (assuming the implementation of visitchildrenset |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
467 is capable of recognizing this; some implementations are not). |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
468 |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42329
diff
changeset
|
469 '' -> {'foo', 'qux'} |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
470 'baz' -> set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
471 'foo' -> {'bar'} |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
472 # Ideally this would be 'all', but since the prefix nature of matchers |
39260
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
473 # is applied to the entire matcher, we have to downgrade this to |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
474 # 'this' due to the non-prefix 'rootfilesin'-kind matcher being mixed |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
475 # in. |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
476 'foo/bar' -> 'this' |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
477 'qux' -> 'this' |
39260
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
478 |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
479 Important: |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
480 Most matchers do not know if they're representing files or |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
481 directories. They see ['path:dir/f'] and don't know whether 'f' is a |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
482 file or a directory, so visitchildrenset('dir') for most matchers will |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
483 return {'f'}, but if the matcher knows it's a file (like exactmatcher |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
484 does), it may return 'this'. Do not rely on the return being a set |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
485 indicating that there are no files in this dir to investigate (or |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
486 equivalently that if there are files to investigate in 'dir' that it |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38958
diff
changeset
|
487 will always return 'this'). |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
488 """ |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
489 return b'this' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
490 |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
491 def always(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
492 """Matcher will match everything and .files() will be empty -- |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
493 optimization might be possible.""" |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
494 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
495 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
496 def isexact(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
497 """Matcher will match exactly the list of files in .files() -- |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
498 optimization might be possible.""" |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
499 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
500 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
501 def prefix(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
502 """Matcher will match the paths in .files() recursively -- |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
503 optimization might be possible.""" |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
504 return False |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
505 |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
506 def anypats(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
507 """None of .always(), .isexact(), and .prefix() is true -- |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
508 optimizations will be difficult.""" |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
509 return not self.always() and not self.isexact() and not self.prefix() |
32458
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
510 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
511 |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
512 class alwaysmatcher(basematcher): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
513 '''Matches everything.''' |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
514 |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
515 def __init__(self, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
516 super(alwaysmatcher, self).__init__(badfn) |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
517 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
518 def always(self): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
519 return True |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
520 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
521 def matchfn(self, f): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
522 return True |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
523 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
524 def visitdir(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
525 return b'all' |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
526 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
527 def visitchildrenset(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
528 return b'all' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
529 |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
530 def __repr__(self): |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
531 return r'<alwaysmatcher>' |
32553
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32552
diff
changeset
|
532 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
533 |
32605
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
534 class nevermatcher(basematcher): |
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
535 '''Matches nothing.''' |
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
536 |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
537 def __init__(self, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
538 super(nevermatcher, self).__init__(badfn) |
32605
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
539 |
33378
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
540 # It's a little weird to say that the nevermatcher is an exact matcher |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
541 # or a prefix matcher, but it seems to make sense to let callers take |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
542 # fast paths based on either. There will be no exact matches, nor any |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
543 # prefixes (files() returns []), so fast paths iterating over them should |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
544 # be efficient (and correct). |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
545 def isexact(self): |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
546 return True |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
547 |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
548 def prefix(self): |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
549 return True |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
550 |
33582
44bc181b9835
match: override visitdir() in nevermatcher to return False
Martin von Zweigbergk <martinvonz@google.com>
parents:
33497
diff
changeset
|
551 def visitdir(self, dir): |
44bc181b9835
match: override visitdir() in nevermatcher to return False
Martin von Zweigbergk <martinvonz@google.com>
parents:
33497
diff
changeset
|
552 return False |
44bc181b9835
match: override visitdir() in nevermatcher to return False
Martin von Zweigbergk <martinvonz@google.com>
parents:
33497
diff
changeset
|
553 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
554 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
555 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
556 |
32605
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
557 def __repr__(self): |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
558 return r'<nevermatcher>' |
32605
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32557
diff
changeset
|
559 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
560 |
38577
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
561 class predicatematcher(basematcher): |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
562 """A matcher adapter for a simple boolean function""" |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
563 |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
564 def __init__(self, predfn, predrepr=None, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
565 super(predicatematcher, self).__init__(badfn) |
38577
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
566 self.matchfn = predfn |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
567 self._predrepr = predrepr |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
568 |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
569 @encoding.strmethod |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
570 def __repr__(self): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
571 s = stringutil.buildrepr(self._predrepr) or pycompat.byterepr( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
572 self.matchfn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
573 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
574 return b'<predicatenmatcher pred=%s>' % s |
38577
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38475
diff
changeset
|
575 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
576 |
45999
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
577 def path_or_parents_in_set(path, prefix_set): |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
578 """Returns True if `path` (or any parent of `path`) is in `prefix_set`.""" |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
579 l = len(prefix_set) |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
580 if l == 0: |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
581 return False |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
582 if path in prefix_set: |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
583 return True |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
584 # If there's more than 5 paths in prefix_set, it's *probably* quicker to |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
585 # "walk up" the directory hierarchy instead, with the assumption that most |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
586 # directory hierarchies are relatively shallow and hash lookup is cheap. |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
587 if l > 5: |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
588 return any( |
46064
1f0ed7e63c2a
formatting: re-blacken match.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45999
diff
changeset
|
589 parentdir in prefix_set for parentdir in pathutil.finddirs(path) |
45999
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
590 ) |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
591 |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
592 # FIXME: Ideally we'd never get to this point if this is the case - we'd |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
593 # recognize ourselves as an 'always' matcher and skip this. |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
594 if b'' in prefix_set: |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
595 return True |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
596 |
48884
7f5e91cdebcd
match: delete Python 2 conditional code
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
597 sl = ord(b'/') |
45999
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
598 |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
599 # We already checked that path isn't in prefix_set exactly, so |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
600 # `path[len(pf)] should never raise IndexError. |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
601 return any(path.startswith(pf) and path[len(pf)] == sl for pf in prefix_set) |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
602 |
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
603 |
32501
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
604 class patternmatcher(basematcher): |
43721
bfbbf48d51e8
py3: make doc strings containing deprecated '\.' escape sequence raw strings
Daniel Ploch <dploch@google.com>
parents:
43117
diff
changeset
|
605 r"""Matches a set of (kind, pat, source) against a 'root' directory. |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
606 |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
607 >>> kindpats = [ |
42186
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
608 ... (b're', br'.*\.c$', b''), |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
609 ... (b'path', b'foo/a', b''), |
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
610 ... (b'relpath', b'b', b''), |
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
611 ... (b'glob', b'*.h', b''), |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
612 ... ] |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
613 >>> m = patternmatcher(b'foo', kindpats) |
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
614 >>> m(b'main.c') # matches re:.*\.c$ |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
615 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
616 >>> m(b'b.txt') |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
617 False |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
618 >>> m(b'foo/a') # matches path:foo/a |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
619 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
620 >>> m(b'a') # does not match path:b, since 'root' is 'foo' |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
621 False |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
622 >>> m(b'b') # matches relpath:b, since 'root' is 'foo' |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
623 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
624 >>> m(b'lib.h') # matches glob:*.h |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
625 True |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
626 |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
627 >>> m.files() |
50337
47686726545d
match: sort patterns before compiling them into a regex
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50304
diff
changeset
|
628 [b'', b'foo/a', b'', b'b'] |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
629 >>> m.exact(b'foo/a') |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
630 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
631 >>> m.exact(b'b') |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
632 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
633 >>> m.exact(b'lib.h') # exact matches are for (rel)path kinds |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
634 False |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
635 """ |
32395
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32325
diff
changeset
|
636 |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
637 def __init__(self, root, kindpats, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
638 super(patternmatcher, self).__init__(badfn) |
50337
47686726545d
match: sort patterns before compiling them into a regex
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50304
diff
changeset
|
639 kindpats.sort() |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
640 |
32557
3fdcc34c0aba
match: remove special-casing of always-matching patterns in patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32556
diff
changeset
|
641 self._files = _explicitfiles(kindpats) |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
642 self._prefix = _prefix(kindpats) |
50338
81c7d04f4722
match: match explicit file using a set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50337
diff
changeset
|
643 self._pats, self._matchfn = _buildmatch(kindpats, b'$', root) |
81c7d04f4722
match: match explicit file using a set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50337
diff
changeset
|
644 |
81c7d04f4722
match: match explicit file using a set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50337
diff
changeset
|
645 def matchfn(self, fn): |
81c7d04f4722
match: match explicit file using a set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50337
diff
changeset
|
646 if fn in self._fileset: |
81c7d04f4722
match: match explicit file using a set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50337
diff
changeset
|
647 return True |
81c7d04f4722
match: match explicit file using a set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50337
diff
changeset
|
648 return self._matchfn(fn) |
8587
8f15d54437b9
match: fold match into _match base class
Matt Mackall <mpm@selenic.com>
parents:
8586
diff
changeset
|
649 |
32322
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32312
diff
changeset
|
650 @propertycache |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
651 def _dirs(self): |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
652 return set(pathutil.dirs(self._fileset)) |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
653 |
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
654 def visitdir(self, dir): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
655 if self._prefix and dir in self._fileset: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
656 return b'all' |
46064
1f0ed7e63c2a
formatting: re-blacken match.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45999
diff
changeset
|
657 return dir in self._dirs or path_or_parents_in_set(dir, self._fileset) |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
658 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
659 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
660 ret = self.visitdir(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
661 if ret is True: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
662 return b'this' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
663 elif not ret: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
664 return set() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
665 assert ret == b'all' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
666 return b'all' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
667 |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
668 def prefix(self): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
669 return self._prefix |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
670 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
671 @encoding.strmethod |
32406
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32401
diff
changeset
|
672 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
673 return b'<patternmatcher patterns=%r>' % pycompat.bytestr(self._pats) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
674 |
32501
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
675 |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
676 # This is basically a reimplementation of pathutil.dirs that stores the |
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
677 # children instead of just a count of them, plus a small optional optimization |
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
678 # to avoid some directories we don't need. |
48946
642e31cb55f0
py3: use class X: instead of class X(object):
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48941
diff
changeset
|
679 class _dirchildren: |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
680 def __init__(self, paths, onlyinclude=None): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
681 self._dirs = {} |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
682 self._onlyinclude = onlyinclude or [] |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
683 addpath = self.addpath |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
684 for f in paths: |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
685 addpath(f) |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
686 |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
687 def addpath(self, path): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
688 if path == b'': |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
689 return |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
690 dirs = self._dirs |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
691 findsplitdirs = _dirchildren._findsplitdirs |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
692 for d, b in findsplitdirs(path): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
693 if d not in self._onlyinclude: |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
694 continue |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
695 dirs.setdefault(d, set()).add(b) |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
696 |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
697 @staticmethod |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
698 def _findsplitdirs(path): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
699 # yields (dirname, basename) tuples, walking back to the root. This is |
43633
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43595
diff
changeset
|
700 # very similar to pathutil.finddirs, except: |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
701 # - produces a (dirname, basename) tuple, not just 'dirname' |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
702 # Unlike manifest._splittopdir, this does not suffix `dirname` with a |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42329
diff
changeset
|
703 # slash. |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
704 oldpos = len(path) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
705 pos = path.rfind(b'/') |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
706 while pos != -1: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
707 yield path[:pos], path[pos + 1 : oldpos] |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
708 oldpos = pos |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
709 pos = path.rfind(b'/', 0, pos) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
710 yield b'', path[:oldpos] |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
711 |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
712 def get(self, path): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
713 return self._dirs.get(path, set()) |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
714 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
715 |
32501
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
716 class includematcher(basematcher): |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
717 def __init__(self, root, kindpats, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
718 super(includematcher, self).__init__(badfn) |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44452
diff
changeset
|
719 if rustmod is not None: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44452
diff
changeset
|
720 # We need to pass the patterns to Rust because they can contain |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44452
diff
changeset
|
721 # patterns from the user interface |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44452
diff
changeset
|
722 self._kindpats = kindpats |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
723 self._pats, self.matchfn = _buildmatch(kindpats, b'(?:/|$)', root) |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
724 self._prefix = _prefix(kindpats) |
38954
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
725 roots, dirs, parents = _rootsdirsandparents(kindpats) |
32502
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32501
diff
changeset
|
726 # roots are directories which are recursively included. |
32503
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32502
diff
changeset
|
727 self._roots = set(roots) |
32502
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32501
diff
changeset
|
728 # dirs are directories which are non-recursively included. |
32503
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32502
diff
changeset
|
729 self._dirs = set(dirs) |
38954
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
730 # parents are directories which are non-recursively included because |
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
731 # they are needed to get to items in _dirs or _roots. |
42361
c4b8f8637d7a
match: de-flake test-doctest.py by not depending on util.dirs() order
Martin von Zweigbergk <martinvonz@google.com>
parents:
42346
diff
changeset
|
732 self._parents = parents |
32501
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
733 |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
734 def visitdir(self, dir): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
735 if self._prefix and dir in self._roots: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
736 return b'all' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
737 return ( |
45999
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
738 dir in self._dirs |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
739 or dir in self._parents |
45999
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
740 or path_or_parents_in_set(dir, self._roots) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
741 ) |
32501
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
742 |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
743 @propertycache |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
744 def _allparentschildren(self): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
745 # It may seem odd that we add dirs, roots, and parents, and then |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
746 # restrict to only parents. This is to catch the case of: |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
747 # dirs = ['foo/bar'] |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
748 # parents = ['foo'] |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
749 # if we asked for the children of 'foo', but had only added |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
750 # self._parents, we wouldn't be able to respond ['bar']. |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
751 return _dirchildren( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
752 itertools.chain(self._dirs, self._roots, self._parents), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
753 onlyinclude=self._parents, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
754 ) |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
755 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
756 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
757 if self._prefix and dir in self._roots: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
758 return b'all' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
759 # Note: this does *not* include the 'dir in self._parents' case from |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
760 # visitdir, that's handled below. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
761 if ( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
762 b'' in self._roots |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
763 or dir in self._dirs |
45999
c4c7a6b61146
match: skip walking up the directory hierarchy if the number of pats are small
Kyle Lippincott <spectral@google.com>
parents:
45946
diff
changeset
|
764 or path_or_parents_in_set(dir, self._roots) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
765 ): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
766 return b'this' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
767 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
768 if dir in self._parents: |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
769 return self._allparentschildren.get(dir) or set() |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
770 return set() |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
771 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
772 @encoding.strmethod |
32501
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
773 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
774 return b'<includematcher includes=%r>' % pycompat.bytestr(self._pats) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
775 |
32406
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32401
diff
changeset
|
776 |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
777 class exactmatcher(basematcher): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
778 r"""Matches the input files exactly. They are interpreted as paths, not |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
779 patterns (so no kind-prefixes). |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
780 |
42186
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
781 >>> m = exactmatcher([b'a.txt', br're:.*\.c$']) |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
782 >>> m(b'a.txt') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
783 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
784 >>> m(b'b.txt') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
785 False |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
786 |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
787 Input files that would be matched are exactly those returned by .files() |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
788 >>> m.files() |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
789 ['a.txt', 're:.*\\.c$'] |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
790 |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
791 So pattern 're:.*\.c$' is not considered as a regex, but as a file name |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
792 >>> m(b'main.c') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
793 False |
42186
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
794 >>> m(br're:.*\.c$') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41676
diff
changeset
|
795 True |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
796 """ |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
797 |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
798 def __init__(self, files, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
799 super(exactmatcher, self).__init__(badfn) |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
800 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
801 if isinstance(files, list): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
802 self._files = files |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
803 else: |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
804 self._files = list(files) |
32543
cf7c88986e9f
match: define exactmatcher.matchfn statically
Yuya Nishihara <yuya@tcha.org>
parents:
32542
diff
changeset
|
805 |
cf7c88986e9f
match: define exactmatcher.matchfn statically
Yuya Nishihara <yuya@tcha.org>
parents:
32542
diff
changeset
|
806 matchfn = basematcher.exact |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
807 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
808 @propertycache |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
809 def _dirs(self): |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
810 return set(pathutil.dirs(self._fileset)) |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
811 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
812 def visitdir(self, dir): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
813 return dir in self._dirs |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
814 |
46872
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
815 @propertycache |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
816 def _visitchildrenset_candidates(self): |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
817 """A memoized set of candidates for visitchildrenset.""" |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
818 return self._fileset | self._dirs - {b''} |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
819 |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
820 @propertycache |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
821 def _sorted_visitchildrenset_candidates(self): |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
822 """A memoized sorted list of candidates for visitchildrenset.""" |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
823 return sorted(self._visitchildrenset_candidates) |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
824 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
825 def visitchildrenset(self, dir): |
39261
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
826 if not self._fileset or dir not in self._dirs: |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
827 return set() |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
828 |
46872
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
829 if dir == b'': |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
830 candidates = self._visitchildrenset_candidates |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
831 else: |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
832 candidates = self._sorted_visitchildrenset_candidates |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
833 d = dir + b'/' |
46872
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
834 # Use bisect to find the first element potentially starting with d |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
835 # (i.e. >= d). This should always find at least one element (we'll |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
836 # assert later if this is not the case). |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
837 first = bisect.bisect_left(candidates, d) |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
838 # We need a representation of the first element that is > d that |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
839 # does not start with d, so since we added a `/` on the end of dir, |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
840 # we'll add whatever comes after slash (we could probably assume |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
841 # that `0` is after `/`, but let's not) to the end of dir instead. |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
842 dnext = dir + encoding.strtolocal(chr(ord(b'/') + 1)) |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
843 # Use bisect to find the first element >= d_next |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
844 last = bisect.bisect_left(candidates, dnext, lo=first) |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
845 dlen = len(d) |
8bca353b1ebc
match: convert O(n) to O(log n) in exactmatcher.visitchildrenset
Kyle Lippincott <spectral@google.com>
parents:
46819
diff
changeset
|
846 candidates = {c[dlen:] for c in candidates[first:last]} |
39261
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
847 # self._dirs includes all of the directories, recursively, so if |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42329
diff
changeset
|
848 # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo', |
39261
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
849 # 'foo/bar' in it. Thus we can safely ignore a candidate that has a |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
850 # '/' in it, indicating a it's for a subdir-of-a-subdir; the |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
851 # immediate subdir will be in there without a slash. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
852 ret = {c for c in candidates if b'/' not in c} |
39261
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
853 # We really do not expect ret to be empty, since that would imply that |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
854 # there's something in _dirs that didn't have a file in _fileset. |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
855 assert ret |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39260
diff
changeset
|
856 return ret |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
857 |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
858 def isexact(self): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
859 return True |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
860 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
861 @encoding.strmethod |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
862 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
863 return b'<exactmatcher files=%r>' % self._files |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
864 |
32499
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
865 |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
866 class differencematcher(basematcher): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
867 """Composes two matchers by matching if the first matches and the second |
35659
821d8a5ab4ff
match: do not weirdly include explicit files excluded by -X option
Yuya Nishihara <yuya@tcha.org>
parents:
35164
diff
changeset
|
868 does not. |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
869 |
43715
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43633
diff
changeset
|
870 The second matcher's non-matching-attributes (bad, traversedir) are ignored. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
871 """ |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
872 |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
873 def __init__(self, m1, m2): |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
874 super(differencematcher, self).__init__() |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
875 self._m1 = m1 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
876 self._m2 = m2 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
877 self.bad = m1.bad |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
878 self.traversedir = m1.traversedir |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
879 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
880 def matchfn(self, f): |
35659
821d8a5ab4ff
match: do not weirdly include explicit files excluded by -X option
Yuya Nishihara <yuya@tcha.org>
parents:
35164
diff
changeset
|
881 return self._m1(f) and not self._m2(f) |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
882 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
883 @propertycache |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
884 def _files(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
885 if self.isexact(): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
886 return [f for f in self._m1.files() if self(f)] |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
887 # If m1 is not an exact matcher, we can't easily figure out the set of |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
888 # files, because its files() are not always files. For example, if |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
889 # m1 is "path:dir" and m2 is "rootfileins:.", we don't |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
890 # want to remove "dir" from the set even though it would match m2, |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
891 # because the "dir" in m1 may not be a file. |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
892 return self._m1.files() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
893 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
894 def visitdir(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
895 if self._m2.visitdir(dir) == b'all': |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
896 return False |
41528
b7a0efb3c370
match: teach diffmatcher.visitdir() to return 'all' if possible
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41282
diff
changeset
|
897 elif not self._m2.visitdir(dir): |
b7a0efb3c370
match: teach diffmatcher.visitdir() to return 'all' if possible
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41282
diff
changeset
|
898 # m2 does not match dir, we can return 'all' here if possible |
b7a0efb3c370
match: teach diffmatcher.visitdir() to return 'all' if possible
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41282
diff
changeset
|
899 return self._m1.visitdir(dir) |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
900 return bool(self._m1.visitdir(dir)) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
901 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
902 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
903 m2_set = self._m2.visitchildrenset(dir) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
904 if m2_set == b'all': |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
905 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
906 m1_set = self._m1.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
907 # Possible values for m1: 'all', 'this', set(...), set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
908 # Possible values for m2: 'this', set(...), set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
909 # If m2 has nothing under here that we care about, return m1, even if |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
910 # it's 'all'. This is a change in behavior from visitdir, which would |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
911 # return True, not 'all', for some reason. |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
912 if not m2_set: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
913 return m1_set |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
914 if m1_set in [b'all', b'this']: |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
915 # Never return 'all' here if m2_set is any kind of non-empty (either |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
916 # 'this' or set(foo)), since m2 might return set() for a |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
917 # subdirectory. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
918 return b'this' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
919 # Possible values for m1: set(...), set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
920 # Possible values for m2: 'this', set(...) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
921 # We ignore m2's set results. They're possibly incorrect: |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42329
diff
changeset
|
922 # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''): |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
923 # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
924 # return set(), which is *not* correct, we still need to visit 'dir'! |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
925 return m1_set |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
926 |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
927 def isexact(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
928 return self._m1.isexact() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
929 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
930 @encoding.strmethod |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
931 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
932 return b'<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
933 |
32465
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32464
diff
changeset
|
934 |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
935 def intersectmatchers(m1, m2): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
936 """Composes two matchers by matching if both of them match. |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
937 |
43715
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43633
diff
changeset
|
938 The second matcher's non-matching-attributes (bad, traversedir) are ignored. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
939 """ |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
940 if m1 is None or m2 is None: |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
941 return m1 or m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
942 if m1.always(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
943 m = copy.copy(m2) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
944 # TODO: Consider encapsulating these things in a class so there's only |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
945 # one thing to copy from m1. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
946 m.bad = m1.bad |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
947 m.traversedir = m1.traversedir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
948 return m |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
949 if m2.always(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
950 m = copy.copy(m1) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
951 return m |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
952 return intersectionmatcher(m1, m2) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
953 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
954 |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
955 class intersectionmatcher(basematcher): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
956 def __init__(self, m1, m2): |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
957 super(intersectionmatcher, self).__init__() |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
958 self._m1 = m1 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
959 self._m2 = m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
960 self.bad = m1.bad |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
961 self.traversedir = m1.traversedir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
962 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
963 @propertycache |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
964 def _files(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
965 if self.isexact(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
966 m1, m2 = self._m1, self._m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
967 if not m1.isexact(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
968 m1, m2 = m2, m1 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
969 return [f for f in m1.files() if m2(f)] |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
970 # It neither m1 nor m2 is an exact matcher, we can't easily intersect |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
971 # the set of files, because their files() are not always files. For |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
972 # example, if intersecting a matcher "-I glob:foo.txt" with matcher of |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
973 # "path:dir2", we don't want to remove "dir2" from the set. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
974 return self._m1.files() + self._m2.files() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
975 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
976 def matchfn(self, f): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
977 return self._m1(f) and self._m2(f) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
978 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
979 def visitdir(self, dir): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
980 visit1 = self._m1.visitdir(dir) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
981 if visit1 == b'all': |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
982 return self._m2.visitdir(dir) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
983 # bool() because visit1=True + visit2='all' should not be 'all' |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
984 return bool(visit1 and self._m2.visitdir(dir)) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
985 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
986 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
987 m1_set = self._m1.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
988 if not m1_set: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
989 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
990 m2_set = self._m2.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
991 if not m2_set: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
992 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
993 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
994 if m1_set == b'all': |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
995 return m2_set |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
996 elif m2_set == b'all': |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
997 return m1_set |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
998 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
999 if m1_set == b'this' or m2_set == b'this': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1000 return b'this' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1001 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1002 assert isinstance(m1_set, set) and isinstance(m2_set, set) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1003 return m1_set.intersection(m2_set) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1004 |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1005 def always(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1006 return self._m1.always() and self._m2.always() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1007 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1008 def isexact(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1009 return self._m1.isexact() or self._m2.isexact() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1010 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
1011 @encoding.strmethod |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1012 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1013 return b'<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1014 |
32497
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32496
diff
changeset
|
1015 |
32460
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32459
diff
changeset
|
1016 class subdirmatcher(basematcher): |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1017 """Adapt a matcher to work on a subdirectory only. |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1018 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1019 The paths are remapped to remove/insert the path as needed: |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1020 |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1021 >>> from . import pycompat |
44002
d9d78e70149a
tests: fix failing doctest in match.py by adding dummy auditor
Martin von Zweigbergk <martinvonz@google.com>
parents:
43965
diff
changeset
|
1022 >>> m1 = match(util.localpath(b'/root'), b'', [b'a.txt', b'sub/b.txt'], auditor=lambda name: None) |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1023 >>> m2 = subdirmatcher(b'sub', m1) |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1024 >>> m2(b'a.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1025 False |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1026 >>> m2(b'b.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1027 True |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1028 >>> m2.matchfn(b'a.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1029 False |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1030 >>> m2.matchfn(b'b.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1031 True |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1032 >>> m2.files() |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1033 ['b.txt'] |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1034 >>> m2.exact(b'b.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1035 True |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
1036 >>> def bad(f, msg): |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1037 ... print(pycompat.sysstr(b"%s: %s" % (f, msg))) |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
1038 >>> m1.bad = bad |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1039 >>> m2.bad(b'x.txt', b'No such file') |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
1040 sub/x.txt: No such file |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1041 """ |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1042 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1043 def __init__(self, path, matcher): |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
1044 super(subdirmatcher, self).__init__() |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1045 self._path = path |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1046 self._matcher = matcher |
32460
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32459
diff
changeset
|
1047 self._always = matcher.always() |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
1048 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1049 self._files = [ |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1050 f[len(path) + 1 :] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1051 for f in matcher._files |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1052 if f.startswith(path + b"/") |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1053 ] |
25194
ef4538ba67ef
match: explicitly naming a subrepo implies always() for the submatcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
24790
diff
changeset
|
1054 |
32325
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32324
diff
changeset
|
1055 # If the parent repo had a path to this subrepo and the matcher is |
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32324
diff
changeset
|
1056 # a prefix matcher, this submatcher always matches. |
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32324
diff
changeset
|
1057 if matcher.prefix(): |
25195 | 1058 self._always = any(f == path for f in matcher._files) |
25194
ef4538ba67ef
match: explicitly naming a subrepo implies always() for the submatcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
24790
diff
changeset
|
1059 |
32324
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32323
diff
changeset
|
1060 def bad(self, f, msg): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1061 self._matcher.bad(self._path + b"/" + f, msg) |
32324
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32323
diff
changeset
|
1062 |
32464
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32463
diff
changeset
|
1063 def matchfn(self, f): |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32463
diff
changeset
|
1064 # Some information is lost in the superclass's constructor, so we |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32463
diff
changeset
|
1065 # can not accurately create the matching function for the subdirectory |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32463
diff
changeset
|
1066 # from the inputs. Instead, we override matchfn() and visitdir() to |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32463
diff
changeset
|
1067 # call the original matcher with the subdirectory path prepended. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1068 return self._matcher.matchfn(self._path + b"/" + f) |
32464
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32463
diff
changeset
|
1069 |
32323
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32322
diff
changeset
|
1070 def visitdir(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1071 if dir == b'': |
32323
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32322
diff
changeset
|
1072 dir = self._path |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32322
diff
changeset
|
1073 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1074 dir = self._path + b"/" + dir |
32323
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32322
diff
changeset
|
1075 return self._matcher.visitdir(dir) |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32322
diff
changeset
|
1076 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1077 def visitchildrenset(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1078 if dir == b'': |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1079 dir = self._path |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1080 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1081 dir = self._path + b"/" + dir |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1082 return self._matcher.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1083 |
32460
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32459
diff
changeset
|
1084 def always(self): |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32459
diff
changeset
|
1085 return self._always |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32459
diff
changeset
|
1086 |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
1087 def prefix(self): |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
1088 return self._matcher.prefix() and not self._always |
32460
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32459
diff
changeset
|
1089 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
1090 @encoding.strmethod |
32552
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32543
diff
changeset
|
1091 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1092 return b'<subdirmatcher path=%r, matcher=%r>' % ( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1093 self._path, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1094 self._matcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1095 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1096 |
32552
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32543
diff
changeset
|
1097 |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1098 class prefixdirmatcher(basematcher): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1099 """Adapt a matcher to work on a parent directory. |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1100 |
43715
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43633
diff
changeset
|
1101 The matcher's non-matching-attributes (bad, traversedir) are ignored. |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1102 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1103 The prefix path should usually be the relative path from the root of |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1104 this matcher to the root of the wrapped matcher. |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1105 |
43949
8b1a9ba375e5
match: make sure `root` argument is always an absolute path (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43735
diff
changeset
|
1106 >>> m1 = match(util.localpath(b'/root/d/e'), b'f', [b'../a.txt', b'b.txt'], auditor=lambda name: None) |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
1107 >>> m2 = prefixdirmatcher(b'd/e', m1) |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1108 >>> m2(b'a.txt') |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1109 False |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1110 >>> m2(b'd/e/a.txt') |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1111 True |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1112 >>> m2(b'd/e/b.txt') |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1113 False |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1114 >>> m2.files() |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1115 ['d/e/a.txt', 'd/e/f/b.txt'] |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1116 >>> m2.exact(b'd/e/a.txt') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1117 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1118 >>> m2.visitdir(b'd') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1119 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1120 >>> m2.visitdir(b'd/e') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1121 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1122 >>> m2.visitdir(b'd/e/f') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1123 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1124 >>> m2.visitdir(b'd/e/g') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1125 False |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1126 >>> m2.visitdir(b'd/ef') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1127 False |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1128 """ |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1129 |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
1130 def __init__(self, path, matcher, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
1131 super(prefixdirmatcher, self).__init__(badfn) |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1132 if not path: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1133 raise error.ProgrammingError(b'prefix path must not be empty') |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1134 self._path = path |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1135 self._pathprefix = path + b'/' |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1136 self._matcher = matcher |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1137 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1138 @propertycache |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1139 def _files(self): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1140 return [self._pathprefix + f for f in self._matcher._files] |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1141 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1142 def matchfn(self, f): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1143 if not f.startswith(self._pathprefix): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1144 return False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1145 return self._matcher.matchfn(f[len(self._pathprefix) :]) |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1146 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1147 @propertycache |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1148 def _pathdirs(self): |
43633
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43595
diff
changeset
|
1149 return set(pathutil.finddirs(self._path)) |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1150 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1151 def visitdir(self, dir): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1152 if dir == self._path: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1153 return self._matcher.visitdir(b'') |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1154 if dir.startswith(self._pathprefix): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1155 return self._matcher.visitdir(dir[len(self._pathprefix) :]) |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1156 return dir in self._pathdirs |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1157 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1158 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1159 if dir == self._path: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1160 return self._matcher.visitchildrenset(b'') |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1161 if dir.startswith(self._pathprefix): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1162 return self._matcher.visitchildrenset(dir[len(self._pathprefix) :]) |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1163 if dir in self._pathdirs: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1164 return b'this' |
38958
b9f94d67ea73
match: add missing "return set()", add FIXME to test to doc a bug
Kyle Lippincott <spectral@google.com>
parents:
38957
diff
changeset
|
1165 return set() |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1166 |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1167 def isexact(self): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1168 return self._matcher.isexact() |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1169 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1170 def prefix(self): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1171 return self._matcher.prefix() |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1172 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1173 @encoding.strmethod |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1174 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1175 return b'<prefixdirmatcher path=%r, matcher=%r>' % ( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1176 pycompat.bytestr(self._path), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1177 self._matcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1178 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1179 |
38611
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38581
diff
changeset
|
1180 |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1181 class unionmatcher(basematcher): |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1182 """A matcher that is the union of several matchers. |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1183 |
43715
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43633
diff
changeset
|
1184 The non-matching-attributes (bad, traversedir) are taken from the first |
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43633
diff
changeset
|
1185 matcher. |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1186 """ |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1187 |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1188 def __init__(self, matchers): |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1189 m1 = matchers[0] |
41675
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41672
diff
changeset
|
1190 super(unionmatcher, self).__init__() |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1191 self.traversedir = m1.traversedir |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1192 self._matchers = matchers |
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1193 |
33380
892d255ec2a1
match: override matchfn instead of __call__ for consistency
Martin von Zweigbergk <martinvonz@google.com>
parents:
33379
diff
changeset
|
1194 def matchfn(self, f): |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1195 for match in self._matchers: |
33380
892d255ec2a1
match: override matchfn instead of __call__ for consistency
Martin von Zweigbergk <martinvonz@google.com>
parents:
33379
diff
changeset
|
1196 if match(f): |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1197 return True |
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1198 return False |
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1199 |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1200 def visitdir(self, dir): |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1201 r = False |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1202 for m in self._matchers: |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1203 v = m.visitdir(dir) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1204 if v == b'all': |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1205 return v |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1206 r |= v |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1207 return r |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1208 |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1209 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1210 r = set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1211 this = False |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1212 for m in self._matchers: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1213 v = m.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1214 if not v: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1215 continue |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1216 if v == b'all': |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1217 return v |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1218 if this or v == b'this': |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1219 this = True |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1220 # don't break, we might have an 'all' in here. |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1221 continue |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1222 assert isinstance(v, set) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1223 r = r.union(v) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1224 if this: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1225 return b'this' |
38955
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1226 return r |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38954
diff
changeset
|
1227 |
36050
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
1228 @encoding.strmethod |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1229 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1230 return b'<unionmatcher matchers=%r>' % self._matchers |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1231 |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1232 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1233 def patkind(pattern, default=None): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1234 r"""If pattern is 'kind:pat' with a known kind, return kind. |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1235 |
42186
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
1236 >>> patkind(br're:.*\.c$') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1237 're' |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1238 >>> patkind(b'glob:*.c') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1239 'glob' |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1240 >>> patkind(b'relpath:test.py') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1241 'relpath' |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1242 >>> patkind(b'main.py') |
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1243 >>> patkind(b'main.py', default=b're') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1244 're' |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1245 """ |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1246 return _patsplit(pattern, default)[0] |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1247 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1248 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1249 def _patsplit(pattern, default): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1250 """Split a string into the optional pattern kind prefix and the actual |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1251 pattern.""" |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1252 if b':' in pattern: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1253 kind, pat = pattern.split(b':', 1) |
33684
2be0bf186950
match: expose some data and functionality to other modules
Kostia Balytskyi <ikostia@fb.com>
parents:
33582
diff
changeset
|
1254 if kind in allpatternkinds: |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1255 return kind, pat |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1256 return default, pattern |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1257 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1258 |
8582
a4c199e12b5a
match: remove head and tail args from _globre
Matt Mackall <mpm@selenic.com>
parents:
8581
diff
changeset
|
1259 def _globre(pat): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1260 r"""Convert an extended glob string to a regexp string. |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1261 |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1262 >>> from . import pycompat |
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1263 >>> def bprint(s): |
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1264 ... print(pycompat.sysstr(s)) |
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1265 >>> bprint(_globre(br'?')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1266 . |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1267 >>> bprint(_globre(br'*')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1268 [^/]* |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1269 >>> bprint(_globre(br'**')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1270 .* |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1271 >>> bprint(_globre(br'**/a')) |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
1272 (?:.*/)?a |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1273 >>> bprint(_globre(br'a/**/b')) |
38475
67dc32d4e790
cleanup: migrate from re.escape to stringutil.reescape
Augie Fackler <augie@google.com>
parents:
38019
diff
changeset
|
1274 a/(?:.*/)?b |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1275 >>> bprint(_globre(br'[a*?!^][^b][!c]')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1276 [a*?!^][\^b][^c] |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1277 >>> bprint(_globre(br'{a,b}')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1278 (?:a|b) |
34137
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34131
diff
changeset
|
1279 >>> bprint(_globre(br'.\*\?')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1280 \.\*\? |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1281 """ |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1282 i, n = 0, len(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1283 res = b'' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1284 group = 0 |
40684
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1285 escape = util.stringutil.regexbytesescapemap.get |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1286 |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
1287 def peek(): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1288 return i < n and pat[i : i + 1] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1289 |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1290 while i < n: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1291 c = pat[i : i + 1] |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
1292 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1293 if c not in b'*?[{},\\': |
40684
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1294 res += escape(c, c) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1295 elif c == b'*': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1296 if peek() == b'*': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1297 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1298 if peek() == b'/': |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
1299 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1300 res += b'(?:.*/)?' |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
1301 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1302 res += b'.*' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1303 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1304 res += b'[^/]*' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1305 elif c == b'?': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1306 res += b'.' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1307 elif c == b'[': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1308 j = i |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1309 if j < n and pat[j : j + 1] in b'!]': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1310 j += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1311 while j < n and pat[j : j + 1] != b']': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1312 j += 1 |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1313 if j >= n: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1314 res += b'\\[' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1315 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1316 stuff = pat[i:j].replace(b'\\', b'\\\\') |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1317 i = j + 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1318 if stuff[0:1] == b'!': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1319 stuff = b'^' + stuff[1:] |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1320 elif stuff[0:1] == b'^': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1321 stuff = b'\\' + stuff |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1322 res = b'%s[%s]' % (res, stuff) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1323 elif c == b'{': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1324 group += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1325 res += b'(?:' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1326 elif c == b'}' and group: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1327 res += b')' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1328 group -= 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1329 elif c == b',' and group: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1330 res += b'|' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1331 elif c == b'\\': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1332 p = peek() |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1333 if p: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1334 i += 1 |
40684
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1335 res += escape(p, p) |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1336 else: |
40684
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1337 res += escape(c, c) |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1338 else: |
40684
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1339 res += escape(c, c) |
8582
a4c199e12b5a
match: remove head and tail args from _globre
Matt Mackall <mpm@selenic.com>
parents:
8581
diff
changeset
|
1340 return res |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1341 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1342 |
49645
c4874ebe8644
match: make the FLAG_RE pattern a raw string
Matt Harbison <matt_harbison@yahoo.com>
parents:
49605
diff
changeset
|
1343 FLAG_RE = util.re.compile(br'^\(\?([aiLmsux]+)\)(.*)') |
49603
3eda36e9b3d6
matcher: fix issues regex flag contained in pattern (issue6759)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48946
diff
changeset
|
1344 |
3eda36e9b3d6
matcher: fix issues regex flag contained in pattern (issue6759)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48946
diff
changeset
|
1345 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1346 def _regex(kind, pat, globsuffix): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1347 """Convert a (normalized) pattern of any kind into a |
42329
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42195
diff
changeset
|
1348 regular expression. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1349 globsuffix is appended to the regexp of globs.""" |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1350 if not pat and kind in (b'glob', b'relpath'): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1351 return b'' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1352 if kind == b're': |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1353 return pat |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1354 if kind == b'filepath': |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1355 raise error.ProgrammingError( |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1356 "'filepath:' patterns should not be converted to a regex" |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1357 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1358 if kind in (b'path', b'relpath'): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1359 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1360 return b'' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1361 return util.stringutil.reescape(pat) + b'(?:/|$)' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1362 if kind == b'rootfilesin': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1363 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1364 escaped = b'' |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1365 else: |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1366 # Pattern is a directory name. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1367 escaped = util.stringutil.reescape(pat) + b'/' |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1368 # Anything after the pattern must be a non-directory. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1369 return escaped + b'[^/]+$' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1370 if kind == b'relglob': |
42864
72890d8f9860
match: simplify the regexps created for glob patterns
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42766
diff
changeset
|
1371 globre = _globre(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1372 if globre.startswith(b'[^/]*'): |
42864
72890d8f9860
match: simplify the regexps created for glob patterns
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42766
diff
changeset
|
1373 # When pat has the form *XYZ (common), make the returned regex more |
72890d8f9860
match: simplify the regexps created for glob patterns
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42766
diff
changeset
|
1374 # legible by returning the regex for **XYZ instead of **/*XYZ. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1375 return b'.*' + globre[len(b'[^/]*') :] + globsuffix |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1376 return b'(?:|.*/)' + globre + globsuffix |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1377 if kind == b'relre': |
49605
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1378 flag = None |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1379 m = FLAG_RE.match(pat) |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1380 if m: |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1381 flag, pat = m.groups() |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1382 if not pat.startswith(b'^'): |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1383 pat = b'.*' + pat |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1384 if flag is not None: |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1385 pat = br'(?%s:%s)' % (flag, pat) |
b3480822a251
matcher: do not prepend '.*' to pattern using ^ after flags
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49603
diff
changeset
|
1386 return pat |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1387 if kind in (b'glob', b'rootglob'): |
38578
2d487b9cac07
match: explode if unsupported pattern passed down to _regex() builder
Yuya Nishihara <yuya@tcha.org>
parents:
38577
diff
changeset
|
1388 return _globre(pat) + globsuffix |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1389 raise error.ProgrammingError(b'not a regex pattern: %s:%s' % (kind, pat)) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1390 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1391 |
41669
a13268524c25
match: delete unused argument "listsubrepos" from _buildmatch()
Martin von Zweigbergk <martinvonz@google.com>
parents:
41668
diff
changeset
|
1392 def _buildmatch(kindpats, globsuffix, root): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1393 """Return regexp string and a matcher function for kindpats. |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1394 globsuffix is appended to the regexp of globs.""" |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1395 matchfuncs = [] |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1396 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1397 subincludes, kindpats = _expandsubinclude(kindpats, root) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1398 if subincludes: |
32132
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1399 submatchers = {} |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1400 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1401 def matchsubinclude(f): |
32132
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1402 for prefix, matcherargs in subincludes: |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1403 if f.startswith(prefix): |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1404 mf = submatchers.get(prefix) |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1405 if mf is None: |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1406 mf = match(*matcherargs) |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1407 submatchers[prefix] = mf |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1408 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1409 if mf(f[len(prefix) :]): |
32132
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31433
diff
changeset
|
1410 return True |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1411 return False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1412 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1413 matchfuncs.append(matchsubinclude) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
1414 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1415 regex = b'' |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1416 if kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1417 if all(k == b'rootfilesin' for k, p, s in kindpats): |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1418 dirs = {p for k, p, s in kindpats} |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1419 |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1420 def mf(f): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1421 i = f.rfind(b'/') |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1422 if i >= 0: |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1423 dir = f[:i] |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1424 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1425 dir = b'.' |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1426 return dir in dirs |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1427 |
40345
d30a19d10441
match: fix up a repr to not crash on Python 3
Augie Fackler <augie@google.com>
parents:
40242
diff
changeset
|
1428 regex = b'rootfilesin: %s' % stringutil.pprint(list(sorted(dirs))) |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1429 matchfuncs.append(mf) |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1430 else: |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1431 regex, mf = _buildregexmatch(kindpats, globsuffix) |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39460
diff
changeset
|
1432 matchfuncs.append(mf) |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1433 |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1434 if len(matchfuncs) == 1: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1435 return regex, matchfuncs[0] |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1436 else: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1437 return regex, lambda f: any(mf(f) for mf in matchfuncs) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
1438 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1439 |
40774
8306dac48061
match: extract a literal constant into a symbolic one
Boris Feld <boris.feld@octobus.net>
parents:
40757
diff
changeset
|
1440 MAX_RE_SIZE = 20000 |
8306dac48061
match: extract a literal constant into a symbolic one
Boris Feld <boris.feld@octobus.net>
parents:
40757
diff
changeset
|
1441 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1442 |
40776
ce401300f981
match: extract function that group regexps
Boris Feld <boris.feld@octobus.net>
parents:
40775
diff
changeset
|
1443 def _joinregexes(regexps): |
ce401300f981
match: extract function that group regexps
Boris Feld <boris.feld@octobus.net>
parents:
40775
diff
changeset
|
1444 """gather multiple regular expressions into a single one""" |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1445 return b'|'.join(regexps) |
40776
ce401300f981
match: extract function that group regexps
Boris Feld <boris.feld@octobus.net>
parents:
40775
diff
changeset
|
1446 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1447 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1448 def _buildregexmatch(kindpats, globsuffix): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1449 """Build a match function from a list of kinds and kindpats, |
40775
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1450 return regexp string and a matcher function. |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1451 |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1452 Test too large input |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1453 >>> _buildregexmatch([ |
40947
9e462fb88f79
match: fix doctest to use bytes instead of str
Augie Fackler <augie@google.com>
parents:
40782
diff
changeset
|
1454 ... (b'relglob', b'?' * MAX_RE_SIZE, b'') |
9e462fb88f79
match: fix doctest to use bytes instead of str
Augie Fackler <augie@google.com>
parents:
40782
diff
changeset
|
1455 ... ], b'$') |
40775
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1456 Traceback (most recent call last): |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1457 ... |
40778
69bd3176da7c
match: raise an Abort error instead of OverflowError
Boris Feld <boris.feld@octobus.net>
parents:
40777
diff
changeset
|
1458 Abort: matcher pattern is too long (20009 bytes) |
40775
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40774
diff
changeset
|
1459 """ |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1460 try: |
40777
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1461 allgroups = [] |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1462 regexps = [] |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1463 exact = set() |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1464 for (kind, pattern, _source) in kindpats: |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1465 if kind == b'filepath': |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1466 exact.add(pattern) |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1467 continue |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1468 regexps.append(_regex(kind, pattern, globsuffix)) |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1469 |
40777
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1470 fullregexp = _joinregexes(regexps) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1471 |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1472 startidx = 0 |
40782
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40781
diff
changeset
|
1473 groupsize = 0 |
40777
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1474 for idx, r in enumerate(regexps): |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1475 piecesize = len(r) |
40782
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40781
diff
changeset
|
1476 if piecesize > MAX_RE_SIZE: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1477 msg = _(b"matcher pattern is too long (%d bytes)") % piecesize |
40778
69bd3176da7c
match: raise an Abort error instead of OverflowError
Boris Feld <boris.feld@octobus.net>
parents:
40777
diff
changeset
|
1478 raise error.Abort(msg) |
40780
1e019f45fa88
match: make "groupsize" include the trailing "|"
Martin von Zweigbergk <martinvonz@google.com>
parents:
40779
diff
changeset
|
1479 elif (groupsize + piecesize) > MAX_RE_SIZE: |
40777
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1480 group = regexps[startidx:idx] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1481 allgroups.append(_joinregexes(group)) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1482 startidx = idx |
40782
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40781
diff
changeset
|
1483 groupsize = 0 |
40777
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1484 groupsize += piecesize + 1 |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1485 |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1486 if startidx == 0: |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1487 matcher = _rematcher(fullregexp) |
42099
bccb322f1496
match: fix re2 compability broken in 2e2699af5649
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42098
diff
changeset
|
1488 func = lambda s: bool(matcher(s)) |
40777
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1489 else: |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1490 group = regexps[startidx:] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1491 allgroups.append(_joinregexes(group)) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1492 allmatchers = [_rematcher(g) for g in allgroups] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40776
diff
changeset
|
1493 func = lambda s: any(m(s) for m in allmatchers) |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1494 |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1495 actualfunc = func |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1496 if exact: |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1497 # An empty regex will always match, so only call the regex if |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1498 # there were any actual patterns to match. |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1499 if not regexps: |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1500 actualfunc = lambda s: s in exact |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1501 else: |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1502 actualfunc = lambda s: s in exact or func(s) |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1503 return fullregexp, actualfunc |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1504 except re.error: |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1505 for k, p, s in kindpats: |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1506 if k == b'filepath': |
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1507 continue |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1508 try: |
40782
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40781
diff
changeset
|
1509 _rematcher(_regex(k, p, globsuffix)) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1510 except re.error: |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1511 if s: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1512 raise error.Abort( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1513 _(b"%s: invalid pattern (%s): %s") % (s, k, p) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1514 ) |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1515 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1516 raise error.Abort(_(b"invalid pattern (%s): %s") % (k, p)) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1517 raise error.Abort(_(b"invalid pattern")) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1518 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1519 |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1520 def _patternrootsanddirs(kindpats): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1521 """Returns roots and directories corresponding to each pattern. |
21079
b02ab6486a78
match: make it more clear what _roots do and that it ends up in match()._files
Mads Kiilerich <madski@unity3d.com>
parents:
20401
diff
changeset
|
1522 |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1523 This calculates the roots and directories exactly matching the patterns and |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1524 returns a tuple of (roots, dirs) for each. It does not return other |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1525 directories which may also need to be considered, like the parent |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1526 directories. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1527 """ |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
1528 r = [] |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1529 d = [] |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1530 for kind, pat, source in kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1531 if kind in (b'glob', b'rootglob'): # find the non-glob prefix |
8584
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
1532 root = [] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1533 for p in pat.split(b'/'): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1534 if b'[' in p or b'{' in p or b'*' in p or b'?' in p: |
8584
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
1535 break |
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
1536 root.append(p) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1537 r.append(b'/'.join(root)) |
50695
1c31b343e514
match: add `filepath:` pattern to match an exact filepath relative to the root
Raphaël Gomès <rgomes@octobus.net>
parents:
50338
diff
changeset
|
1538 elif kind in (b'relpath', b'path', b'filepath'): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1539 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1540 pat = b'' |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42329
diff
changeset
|
1541 r.append(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1542 elif kind in (b'rootfilesin',): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1543 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1544 pat = b'' |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42329
diff
changeset
|
1545 d.append(pat) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1546 else: # relglob, re, relre |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1547 r.append(b'') |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1548 return r, d |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1549 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1550 |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1551 def _roots(kindpats): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1552 '''Returns root directories to match recursively from the given patterns.''' |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1553 roots, dirs = _patternrootsanddirs(kindpats) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1554 return roots |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1555 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1556 |
38954
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
1557 def _rootsdirsandparents(kindpats): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1558 """Returns roots and exact directories from patterns. |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1559 |
38957
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38955
diff
changeset
|
1560 `roots` are directories to match recursively, `dirs` should |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38955
diff
changeset
|
1561 be matched non-recursively, and `parents` are the implicitly required |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38955
diff
changeset
|
1562 directories to walk to items in either roots or dirs. |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38955
diff
changeset
|
1563 |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38955
diff
changeset
|
1564 Returns a tuple of (roots, dirs, parents). |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1565 |
42367
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1566 >>> r = _rootsdirsandparents( |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1567 ... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1568 ... (b'glob', b'g*', b'')]) |
42367
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1569 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1570 (['g/h', 'g/h', ''], []) ['', 'g'] |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1571 >>> r = _rootsdirsandparents( |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1572 ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')]) |
42367
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1573 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1574 ([], ['g/h', '']) ['', 'g'] |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1575 >>> r = _rootsdirsandparents( |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1576 ... [(b'relpath', b'r', b''), (b'path', b'p/p', b''), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1577 ... (b'path', b'', b'')]) |
42367
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1578 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1579 (['r', 'p/p', ''], []) ['', 'p'] |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1580 >>> r = _rootsdirsandparents( |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1581 ... [(b'relglob', b'rg*', b''), (b're', b're/', b''), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1582 ... (b'relre', b'rr', b'')]) |
42367
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1583 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42362
diff
changeset
|
1584 (['', '', ''], []) [''] |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1585 """ |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1586 r, d = _patternrootsanddirs(kindpats) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1587 |
42361
c4b8f8637d7a
match: de-flake test-doctest.py by not depending on util.dirs() order
Martin von Zweigbergk <martinvonz@google.com>
parents:
42346
diff
changeset
|
1588 p = set() |
c4b8f8637d7a
match: de-flake test-doctest.py by not depending on util.dirs() order
Martin von Zweigbergk <martinvonz@google.com>
parents:
42346
diff
changeset
|
1589 # Add the parents as non-recursive/exact directories, since they must be |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1590 # scanned to get to either the roots or the other exact directories. |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
1591 p.update(pathutil.dirs(d)) |
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
1592 p.update(pathutil.dirs(r)) |
31013
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31012
diff
changeset
|
1593 |
39460
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
1594 # FIXME: all uses of this function convert these to sets, do so before |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
1595 # returning. |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
1596 # FIXME: all uses of this function do not need anything in 'roots' and |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39261
diff
changeset
|
1597 # 'dirs' to also be in 'parents', consider removing them before returning. |
38954
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
1598 return r, d, p |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
1599 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1600 |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1601 def _explicitfiles(kindpats): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1602 """Returns the potential explicit filenames from the patterns. |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1603 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1604 >>> _explicitfiles([(b'path', b'foo/bar', b'')]) |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1605 ['foo/bar'] |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33684
diff
changeset
|
1606 >>> _explicitfiles([(b'rootfilesin', b'foo/bar', b'')]) |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1607 [] |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1608 """ |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1609 # Keep only the pattern kinds where one can specify filenames (vs only |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1610 # directory names). |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1611 filable = [kp for kp in kindpats if kp[0] not in (b'rootfilesin',)] |
31012
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1612 return _roots(filable) |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30399
diff
changeset
|
1613 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1614 |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1615 def _prefix(kindpats): |
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1616 '''Whether all the patterns match a prefix (i.e. recursively)''' |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1617 for kind, pat, source in kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1618 if kind not in (b'path', b'relpath'): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1619 return False |
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1620 return True |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1621 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1622 |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1623 _commentre = None |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1624 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1625 |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1626 def readpatternfile(filepath, warn, sourceinfo=False): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1627 """parse a pattern file, returning a list of |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1628 patterns. These patterns should be given to compile() |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1629 to be validated and converted into a match function. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1630 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1631 trailing white space is dropped. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1632 the escape character is backslash. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1633 comments start with #. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1634 empty lines are skipped. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1635 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1636 lines can be of the following formats: |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1637 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1638 syntax: regexp # defaults following lines to non-rooted regexps |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1639 syntax: glob # defaults following lines to non-rooted globs |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1640 re:pattern # non-rooted regular expression |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1641 glob:pattern # non-rooted glob |
41282
4fab8a7d2d72
match: support rooted globs in hgignore
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents:
41129
diff
changeset
|
1642 rootglob:pat # rooted glob (same root as ^ in regexps) |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1643 pattern # pattern of the current default type |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1644 |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1645 if sourceinfo is set, returns a list of tuples: |
42329
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42195
diff
changeset
|
1646 (pattern, lineno, originalline). |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42195
diff
changeset
|
1647 This is useful to debug ignore patterns. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45682
diff
changeset
|
1648 """ |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1649 |
40685
e41f6c2e69c4
match: reformat `syntaxes` dictionary for better maintainability
Boris Feld <boris.feld@octobus.net>
parents:
40684
diff
changeset
|
1650 syntaxes = { |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1651 b're': b'relre:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1652 b'regexp': b'relre:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1653 b'glob': b'relglob:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1654 b'rootglob': b'rootglob:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1655 b'include': b'include', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1656 b'subinclude': b'subinclude', |
40685
e41f6c2e69c4
match: reformat `syntaxes` dictionary for better maintainability
Boris Feld <boris.feld@octobus.net>
parents:
40684
diff
changeset
|
1657 } |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1658 syntax = b'relre:' |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1659 patterns = [] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1660 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1661 fp = open(filepath, b'rb') |
48941
fd5b8e696b75
py3: stop using util.iterfile()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48913
diff
changeset
|
1662 for lineno, line in enumerate(fp, start=1): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1663 if b"#" in line: |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1664 global _commentre |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1665 if not _commentre: |
31420
40704098853f
match: make regular expression bytes to prevent TypeError
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31403
diff
changeset
|
1666 _commentre = util.re.compile(br'((?:^|[^\\])(?:\\\\)*)#.*') |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1667 # remove comments prefixed by an even number of escapes |
27327
d500341e4f55
match: use re2 in readpatternfile if possible
Bryan O'Sullivan <bos@serpentine.com>
parents:
26781
diff
changeset
|
1668 m = _commentre.search(line) |
d500341e4f55
match: use re2 in readpatternfile if possible
Bryan O'Sullivan <bos@serpentine.com>
parents:
26781
diff
changeset
|
1669 if m: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1670 line = line[: m.end(1)] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1671 # fixup properly escaped comments that survived the above |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1672 line = line.replace(b"\\#", b"#") |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1673 line = line.rstrip() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1674 if not line: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1675 continue |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1676 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1677 if line.startswith(b'syntax:'): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1678 s = line[7:].strip() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1679 try: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1680 syntax = syntaxes[s] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1681 except KeyError: |
25214
08703b10c3ae
match: add optional warn argument
Durham Goode <durham@fb.com>
parents:
25213
diff
changeset
|
1682 if warn: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1683 warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1684 _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1685 ) |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1686 continue |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1687 |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1688 linesyntax = syntax |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48884
diff
changeset
|
1689 for s, rels in syntaxes.items(): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1690 if line.startswith(rels): |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1691 linesyntax = rels |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1692 line = line[len(rels) :] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1693 break |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1694 elif line.startswith(s + b':'): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1695 linesyntax = rels |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42864
diff
changeset
|
1696 line = line[len(s) + 1 :] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1697 break |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1698 if sourceinfo: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1699 patterns.append((linesyntax + line, lineno, line)) |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1700 else: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1701 patterns.append(linesyntax + line) |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1702 fp.close() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1703 return patterns |