Mercurial > hg-stable
annotate mercurial/match.py @ 43833:19da643dc10c
tests: finally fix up test-fuzz-targets.t
It's been failing on my workstation for a while, since I have a new enough
LLVM that I had the fuzzer goo, but not so new that I actually had
FuzzedDataProvider. This is a better solution all around in my opinion.
I _believe_ this should let us run these tests on most systems, even
those using GCC instead of clang. That said, my one attempt to test
this on my macOS laptop failed miserably, and I don't feel like doing
more work on this right now.
Differential Revision: https://phab.mercurial-scm.org/D7566
author | Augie Fackler <augie@google.com> |
---|---|
date | Fri, 06 Dec 2019 15:08:37 -0500 |
parents | 7eb701e355bd |
children | 8b1a9ba375e5 |
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 # |
5d4d88a4f5e6
match: add copyright and license header
Martin Geisler <mg@lazybytes.net>
parents:
8152
diff
changeset
|
3 # Copyright 2008, 2009 Matt Mackall <mpm@selenic.com> and others |
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 |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
8 from __future__ import absolute_import, print_function |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
9 |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
10 import copy |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
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 ( |
36088
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, |
42468
a3a8887e4426
rust: using policy.importrust from Python callers
Georges Racinet <georges.racinet@octobus.net>
parents:
42389
diff
changeset
|
21 policy, |
36601
9adfa48792a7
match: some minimal pycompat fixes guided by test-hgignore.t
Augie Fackler <augie@google.com>
parents:
36088
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:
42870
diff
changeset
|
25 from .utils import stringutil |
6576 | 26 |
43554
9f70512ae2cf
cleanup: remove pointless r-prefixes on single-quoted strings
Augie Fackler <augie@google.com>
parents:
43533
diff
changeset
|
27 rustmod = policy.importrust('filepatterns') |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
28 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
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', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
33 b'relglob', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
34 b'relpath', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
35 b'relre', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
36 b'rootglob', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
37 b'listfile', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
38 b'listfile0', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
39 b'set', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
40 b'include', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
41 b'subinclude', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
42 b'rootfilesin', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
43 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
44 cwdrelativepatternkinds = (b'relpath', b'glob') |
33710
2be0bf186950
match: expose some data and functionality to other modules
Kostia Balytskyi <ikostia@fb.com>
parents:
33582
diff
changeset
|
45 |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
46 propertycache = util.propertycache |
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
47 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
48 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
49 def _rematcher(regex): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
50 '''compile the regexp with the best available regexp engine and return a |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
51 matcher function''' |
21909
335bb8b80443
match: use util.re.compile instead of util.compilere
Siddharth Agarwal <sid0@fb.com>
parents:
21815
diff
changeset
|
52 m = util.re.compile(regex) |
16943
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
53 try: |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
54 # 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
|
55 return m.test_match |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
56 except AttributeError: |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
57 return m.match |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
58 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
59 |
42086
1721b92f2b5e
match: make arguments of _expandsets() optional
Denis Laxalde <denis@laxalde.org>
parents:
42085
diff
changeset
|
60 def _expandsets(kindpats, ctx=None, listsubrepos=False, badfn=None): |
38613
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
61 '''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:
38612
diff
changeset
|
62 matchers = [] |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
63 other = [] |
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
64 |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
65 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
|
66 if kind == b'set': |
40478
481249481392
match: fix assertion for fileset with no context (issue6046)
Yuya Nishihara <yuya@tcha.org>
parents:
40345
diff
changeset
|
67 if ctx is None: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
68 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
|
69 b"fileset expression with no context" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
70 ) |
38613
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
71 matchers.append(ctx.matchfileset(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
|
72 |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
73 if listsubrepos: |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
74 for subpath in ctx.substate: |
38613
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
75 sm = ctx.sub(subpath).matchfileset(pat, badfn=badfn) |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
76 pm = prefixdirmatcher(subpath, sm, badfn=badfn) |
38613
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
77 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
|
78 |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
79 continue |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
80 other.append((kind, pat, source)) |
38613
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
81 return matchers, other |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
82 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
83 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
84 def _expandsubinclude(kindpats, root): |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
85 '''Returns the list of subinclude matcher args and the kindpats without the |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
86 subincludes in it.''' |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
87 relmatchers = [] |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
88 other = [] |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
89 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
90 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
|
91 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
|
92 sourceroot = pathutil.dirname(util.normpath(source)) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
93 pat = util.pconvert(pat) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
94 path = pathutil.join(sourceroot, pat) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
95 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
96 newroot = pathutil.dirname(path) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
97 matcherargs = (newroot, b'', [], [b'include:%s' % path]) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
98 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
99 prefix = pathutil.canonpath(root, root, newroot) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
100 if prefix: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
101 prefix += b'/' |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
102 relmatchers.append((prefix, matcherargs)) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
103 else: |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
104 other.append((kind, pat, source)) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
105 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
106 return relmatchers, other |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
107 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
108 |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
109 def _kindpatsalwaysmatch(kindpats): |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
110 """"Checks whether the kindspats match everything, as e.g. |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
111 'relpath:.' does. |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
112 """ |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
113 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
|
114 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
|
115 return False |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
116 return True |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
117 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
118 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
119 def _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
120 matchercls, root, kindpats, ctx=None, listsubrepos=False, badfn=None |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
121 ): |
38581
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
122 matchers = [] |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
123 fms, kindpats = _expandsets( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
124 kindpats, ctx=ctx, listsubrepos=listsubrepos, badfn=badfn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
125 ) |
38581
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
126 if kindpats: |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
127 m = matchercls(root, kindpats, badfn=badfn) |
38581
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
128 matchers.append(m) |
38613
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
129 if fms: |
760cc5dc01e8
fileset: restrict getfileset() to not return a computed set (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38612
diff
changeset
|
130 matchers.extend(fms) |
38581
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
131 if not matchers: |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
132 return nevermatcher(badfn=badfn) |
38581
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
133 if len(matchers) == 1: |
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
134 return matchers[0] |
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
135 return unionmatcher(matchers) |
9f9ffe5f687c
match: compose 'set:' pattern as matcher
Yuya Nishihara <yuya@tcha.org>
parents:
38580
diff
changeset
|
136 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
137 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
138 def match( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
139 root, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
140 cwd, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
141 patterns=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
142 include=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
143 exclude=None, |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
144 default=b'glob', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
145 auditor=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
146 ctx=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
147 listsubrepos=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
148 warn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
149 badfn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
150 icasefs=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
151 ): |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
152 r"""build an object to match a set of file patterns |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
153 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
154 arguments: |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
155 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:
32365
diff
changeset
|
156 cwd - the current working directory, if relevant |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
157 patterns - patterns to find |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
158 include - patterns to include (unless they are excluded) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
159 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:
32365
diff
changeset
|
160 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
|
161 auditor - optional path auditor |
bee1647578b7
match: complete documentation of match() parameters
Denis Laxalde <denis@laxalde.org>
parents:
42082
diff
changeset
|
162 ctx - optional changecontext |
bee1647578b7
match: complete documentation of match() parameters
Denis Laxalde <denis@laxalde.org>
parents:
42082
diff
changeset
|
163 listsubrepos - if True, recurse into subrepositories |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
164 warn - optional function used for printing warnings |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
165 badfn - optional bad() callback for this matcher instead of the default |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
166 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:
32438
diff
changeset
|
167 normalizes the given patterns to the case in the filesystem |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
168 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
169 a pattern is one of: |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
170 'glob:<glob>' - a glob relative to cwd |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
171 're:<regexp>' - a regular expression |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
172 '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:
32365
diff
changeset
|
173 recursively |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
174 '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:
32365
diff
changeset
|
175 matched non-recursively (will not match subdirectories) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
176 '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:
32365
diff
changeset
|
177 'relpath:<path>' - a path relative to cwd |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
178 '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:
32365
diff
changeset
|
179 'set:<fileset>' - a fileset expression |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
180 '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:
32365
diff
changeset
|
181 '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:
32365
diff
changeset
|
182 the same directory |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
183 '<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
|
184 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
185 Usually a patternmatcher is returned: |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
186 >>> match(b'foo', b'.', [b're:.*\.c$', b'path:foo/a', b'*.py']) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
187 <patternmatcher patterns='.*\\.c$|foo/a(?:/|$)|[^/]*\\.py$'> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
188 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
189 Combining 'patterns' with 'include' (resp. 'exclude') gives an |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
190 intersectionmatcher (resp. a differencematcher): |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
191 >>> type(match(b'foo', b'.', [b're:.*\.c$'], include=[b'path:lib'])) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
192 <class 'mercurial.match.intersectionmatcher'> |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
193 >>> type(match(b'foo', b'.', [b're:.*\.c$'], exclude=[b'path:build'])) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
194 <class 'mercurial.match.differencematcher'> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
195 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
196 Notice that, if 'patterns' is empty, an alwaysmatcher is returned: |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
197 >>> match(b'foo', b'.', []) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
198 <alwaysmatcher> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
199 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
200 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
|
201 pattern has no prefix: |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
202 >>> match(b'foo', b'.', [b'.*\.c$'], default=b're') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
203 <patternmatcher patterns='.*\\.c$'> |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
204 >>> 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
|
205 <patternmatcher patterns='main\\.py(?:/|$)'> |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
206 >>> 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
|
207 <patternmatcher patterns='main.py'> |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
208 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
209 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
|
210 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
|
211 are two ways of doing this check. |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
212 |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
213 >>> m = match(b'foo', b'', [b're:.*\.c$', b'relpath:a']) |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
214 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
215 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
|
216 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
|
217 >>> m(b'a') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
218 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
219 >>> m(b'main.c') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
220 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
221 >>> m(b'test.py') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
222 False |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
223 |
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
224 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
|
225 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
|
226 >>> m.exact(b'a') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
227 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
228 >>> m.exact(b'main.c') |
42084
42537dfc7a7c
match: add doctest examples in match()
Denis Laxalde <denis@laxalde.org>
parents:
42083
diff
changeset
|
229 False |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
230 """ |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
231 normalize = _donormalize |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
232 if icasefs: |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
233 dirstate = ctx.repo().dirstate |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
234 dsnormalize = dirstate.normalize |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
235 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
236 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:
32438
diff
changeset
|
237 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:
32438
diff
changeset
|
238 kindpats = [] |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
239 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
|
240 if kind not in (b're', b'relre'): # regex can't be normalized |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
241 p = pats |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
242 pats = dsnormalize(pats) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
243 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
244 # 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:
32438
diff
changeset
|
245 if p != pats and p in dirstate: |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
246 kindpats.append((kind, p, source)) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
247 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
248 kindpats.append((kind, pats, source)) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
249 return kindpats |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
250 |
41633
635a12c53ea6
match: remove unused "exact" argument (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41542
diff
changeset
|
251 if patterns: |
32589
5f08eca8f8d3
match: move normalize() call out of matcher constructors
Martin von Zweigbergk <martinvonz@google.com>
parents:
32588
diff
changeset
|
252 kindpats = normalize(patterns, default, root, cwd, auditor, warn) |
32590
3fdcc34c0aba
match: remove special-casing of always-matching patterns in patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32589
diff
changeset
|
253 if _kindpatsalwaysmatch(kindpats): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
254 m = alwaysmatcher(badfn) |
32590
3fdcc34c0aba
match: remove special-casing of always-matching patterns in patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32589
diff
changeset
|
255 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
256 m = _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
257 patternmatcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
258 root, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
259 kindpats, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
260 ctx=ctx, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
261 listsubrepos=listsubrepos, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
262 badfn=badfn, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
263 ) |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
264 else: |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
265 # It's a little strange that no patterns means to match everything. |
32673
783394c0c978
match: simplify nevermatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32631
diff
changeset
|
266 # Consider changing this to match nothing (probably using nevermatcher). |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
267 m = alwaysmatcher(badfn) |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
268 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
269 if include: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
270 kindpats = normalize(include, b'glob', root, cwd, auditor, warn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
271 im = _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
272 includematcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
273 root, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
274 kindpats, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
275 ctx=ctx, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
276 listsubrepos=listsubrepos, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
277 badfn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
278 ) |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
279 m = intersectmatchers(m, im) |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
280 if exclude: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
281 kindpats = normalize(exclude, b'glob', root, cwd, auditor, warn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
282 em = _buildkindpatsmatcher( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
283 includematcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
284 root, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
285 kindpats, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
286 ctx=ctx, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
287 listsubrepos=listsubrepos, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
288 badfn=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
289 ) |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
290 m = differencematcher(m, em) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
291 return m |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
292 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
293 |
41687
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41686
diff
changeset
|
294 def exact(files, badfn=None): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
295 return exactmatcher(files, badfn=badfn) |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
296 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
297 |
41687
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41686
diff
changeset
|
298 def always(badfn=None): |
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41686
diff
changeset
|
299 return alwaysmatcher(badfn) |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
300 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
301 |
41687
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41686
diff
changeset
|
302 def never(badfn=None): |
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41686
diff
changeset
|
303 return nevermatcher(badfn) |
32631
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
304 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
305 |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
306 def badmatch(match, badfn): |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
307 """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:
32365
diff
changeset
|
308 one. |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
309 """ |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
310 m = copy.copy(match) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
311 m.bad = badfn |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
312 return m |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
313 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
314 |
42085
54e6d7ef5ca5
match: make _donormalize's auditor and warn arguments optional
Denis Laxalde <denis@laxalde.org>
parents:
42084
diff
changeset
|
315 def _donormalize(patterns, default, root, cwd, auditor=None, warn=None): |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
316 '''Convert 'kind:pat' from the patterns list to tuples with kind and |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
317 normalized and rooted patterns and with listfiles expanded.''' |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
318 kindpats = [] |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
319 for kind, pat in [_patsplit(p, default) for p in patterns]: |
33710
2be0bf186950
match: expose some data and functionality to other modules
Kostia Balytskyi <ikostia@fb.com>
parents:
33582
diff
changeset
|
320 if kind in cwdrelativepatternkinds: |
42085
54e6d7ef5ca5
match: make _donormalize's auditor and warn arguments optional
Denis Laxalde <denis@laxalde.org>
parents:
42084
diff
changeset
|
321 pat = pathutil.canonpath(root, cwd, pat, auditor=auditor) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
322 elif kind in (b'relglob', b'path', b'rootfilesin', b'rootglob'): |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
323 pat = util.normpath(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
324 elif kind in (b'listfile', b'listfile0'): |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
325 try: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
326 files = util.readfile(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
327 if kind == b'listfile0': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
328 files = files.split(b'\0') |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
329 else: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
330 files = files.splitlines() |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
331 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:
32434
diff
changeset
|
332 except EnvironmentError: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
333 raise error.Abort(_(b"unable to read file list (%s)") % pat) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
334 for k, p, source in _donormalize( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
335 files, default, root, cwd, auditor, warn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
336 ): |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
337 kindpats.append((k, p, pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
338 continue |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
339 elif kind == b'include': |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
340 try: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
341 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:
32434
diff
changeset
|
342 includepats = readpatternfile(fullpath, warn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
343 for k, p, source in _donormalize( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
344 includepats, default, root, cwd, auditor, warn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
345 ): |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
346 kindpats.append((k, p, source or pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
347 except error.Abort as inst: |
43533
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
348 raise error.Abort( |
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
349 b'%s: %s' |
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
350 % (pat, inst[0]) # pytype: disable=unsupported-operands |
6ff196d2553b
match: suppress error about subscripting an exception
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
351 ) |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
352 except IOError as inst: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
353 if warn: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
354 warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
355 _(b"skipping unreadable pattern file '%s': %s\n") |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
356 % (pat, stringutil.forcebytestr(inst.strerror)) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
357 ) |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
358 continue |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
359 # 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
|
360 kindpats.append((kind, pat, b'')) |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
361 return kindpats |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
362 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
363 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
364 class basematcher(object): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
365 def __init__(self, badfn=None): |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
366 if badfn is not None: |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
367 self.bad = badfn |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
368 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
369 def __call__(self, fn): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
370 return self.matchfn(fn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
371 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
372 # 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:
32482
diff
changeset
|
373 # Subscribers to these events must monkeypatch the matcher object. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
374 def bad(self, f, msg): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
375 '''Callback from dirstate.walk for each explicit file that can't be |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
376 found/accessed, with an error message.''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
377 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
378 # 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:
32482
diff
changeset
|
379 # by recursive traversal is visited. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
380 traversedir = None |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
381 |
32493
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
382 @propertycache |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
383 def _files(self): |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
384 return [] |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
385 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
386 def files(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
387 '''Explicitly listed files or patterns or roots: |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
388 if no patterns or .always(): empty list, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
389 if exact: list exact files, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
390 if not .anypats(): list all files and dirs, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
391 else: optimal roots''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
392 return self._files |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
393 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
394 @propertycache |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
395 def _fileset(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
396 return set(self._files) |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
397 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
398 def exact(self, f): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
399 '''Returns True if f is in .files().''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
400 return f in self._fileset |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
401 |
32497
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32495
diff
changeset
|
402 def matchfn(self, f): |
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32495
diff
changeset
|
403 return False |
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32495
diff
changeset
|
404 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
405 def visitdir(self, dir): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
406 '''Decides whether a directory should be visited based on whether it |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
407 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:
32482
diff
changeset
|
408 based on the match's primary, included, and excluded patterns. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
409 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
410 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:
32482
diff
changeset
|
411 should be visited. Otherwise returns True or False indicating whether |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
412 the given directory should be visited. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
413 ''' |
33478
cf15c3cc304c
match: make base matcher return True for visitdir
Durham Goode <durham@fb.com>
parents:
33448
diff
changeset
|
414 return True |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
415 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
416 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
417 '''Decides whether a directory should be visited based on whether it |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
418 has potential matches in it or one of its subdirectories, and |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
419 potentially lists which subdirectories of that directory should be |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
420 visited. This is based on the match's primary, included, and excluded |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
421 patterns. |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
422 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
423 This function is very similar to 'visitdir', and the following mapping |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
424 can be applied: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
425 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
426 visitdir | visitchildrenlist |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
427 ----------+------------------- |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
428 False | set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
429 'all' | 'all' |
39288
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38996
diff
changeset
|
430 True | 'this' OR non-empty set of subdirs -or files- to visit |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
431 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
432 Example: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
433 Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
434 the following values (assuming the implementation of visitchildrenset |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
435 is capable of recognizing this; some implementations are not). |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
436 |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
437 '' -> {'foo', 'qux'} |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
438 'baz' -> set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
439 'foo' -> {'bar'} |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
440 # Ideally this would be 'all', but since the prefix nature of matchers |
39288
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38996
diff
changeset
|
441 # 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:
38996
diff
changeset
|
442 # '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:
38996
diff
changeset
|
443 # in. |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
444 'foo/bar' -> 'this' |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
445 'qux' -> 'this' |
39288
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38996
diff
changeset
|
446 |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38996
diff
changeset
|
447 Important: |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38996
diff
changeset
|
448 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:
38996
diff
changeset
|
449 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:
38996
diff
changeset
|
450 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:
38996
diff
changeset
|
451 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:
38996
diff
changeset
|
452 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:
38996
diff
changeset
|
453 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:
38996
diff
changeset
|
454 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:
38996
diff
changeset
|
455 will always return 'this'). |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
456 ''' |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
457 return b'this' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
458 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
459 def always(self): |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
460 '''Matcher will match everything and .files() will be empty -- |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
461 optimization might be possible.''' |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
462 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
463 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
464 def isexact(self): |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
465 '''Matcher will match exactly the list of files in .files() -- |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
466 optimization might be possible.''' |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
467 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
468 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
469 def prefix(self): |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
470 '''Matcher will match the paths in .files() recursively -- |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
471 optimization might be possible.''' |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
472 return False |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
473 |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
474 def anypats(self): |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
475 '''None of .always(), .isexact(), and .prefix() is true -- |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
476 optimizations will be difficult.''' |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
477 return not self.always() and not self.isexact() and not self.prefix() |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
478 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
479 |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
480 class alwaysmatcher(basematcher): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
481 '''Matches everything.''' |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
482 |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
483 def __init__(self, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
484 super(alwaysmatcher, self).__init__(badfn) |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
485 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
486 def always(self): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
487 return True |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
488 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
489 def matchfn(self, f): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
490 return True |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
491 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
492 def visitdir(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
493 return b'all' |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
494 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
495 def visitchildrenset(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
496 return b'all' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
497 |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
498 def __repr__(self): |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
499 return r'<alwaysmatcher>' |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
500 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
501 |
32631
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
502 class nevermatcher(basematcher): |
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
503 '''Matches nothing.''' |
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
504 |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
505 def __init__(self, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
506 super(nevermatcher, self).__init__(badfn) |
32631
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
507 |
33378
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
508 # 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
|
509 # 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
|
510 # 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
|
511 # 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
|
512 # 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
|
513 def isexact(self): |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
514 return True |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
515 |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
516 def prefix(self): |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
517 return True |
adf95bfb423a
match: make nevermatcher an exact matcher and a prefix matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33358
diff
changeset
|
518 |
33582
44bc181b9835
match: override visitdir() in nevermatcher to return False
Martin von Zweigbergk <martinvonz@google.com>
parents:
33497
diff
changeset
|
519 def visitdir(self, dir): |
44bc181b9835
match: override visitdir() in nevermatcher to return False
Martin von Zweigbergk <martinvonz@google.com>
parents:
33497
diff
changeset
|
520 return False |
44bc181b9835
match: override visitdir() in nevermatcher to return False
Martin von Zweigbergk <martinvonz@google.com>
parents:
33497
diff
changeset
|
521 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
522 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
523 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
524 |
32631
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
525 def __repr__(self): |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
526 return r'<nevermatcher>' |
32631
e6ff007e107e
match: introduce nevermatcher for when no ignore files are present
Siddharth Agarwal <sid0@fb.com>
parents:
32590
diff
changeset
|
527 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
528 |
38578
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
529 class predicatematcher(basematcher): |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
530 """A matcher adapter for a simple boolean function""" |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
531 |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
532 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:
41683
diff
changeset
|
533 super(predicatematcher, self).__init__(badfn) |
38578
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
534 self.matchfn = predfn |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
535 self._predrepr = predrepr |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
536 |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
537 @encoding.strmethod |
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
538 def __repr__(self): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
539 s = stringutil.buildrepr(self._predrepr) or pycompat.byterepr( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
540 self.matchfn |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
541 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
542 return b'<predicatenmatcher pred=%s>' % s |
38578
76838305b9dd
match: add basic wrapper for boolean function
Yuya Nishihara <yuya@tcha.org>
parents:
38479
diff
changeset
|
543 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
544 |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
545 class patternmatcher(basematcher): |
43437
bfbbf48d51e8
py3: make doc strings containing deprecated '\.' escape sequence raw strings
Daniel Ploch <dploch@google.com>
parents:
43117
diff
changeset
|
546 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
|
547 |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
548 >>> kindpats = [ |
42224
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
549 ... (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
|
550 ... (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
|
551 ... (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
|
552 ... (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
|
553 ... ] |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
554 >>> 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
|
555 >>> 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
|
556 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
557 >>> m(b'b.txt') |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
558 False |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
559 >>> 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
|
560 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
561 >>> 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
|
562 False |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
563 >>> 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
|
564 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
565 >>> 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
|
566 True |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
567 |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
568 >>> m.files() |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
569 ['', 'foo/a', 'b', ''] |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
570 >>> 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
|
571 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
572 >>> m.exact(b'b') |
42081
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
573 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
574 >>> 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
|
575 False |
bf777c1e78dd
match: add a docstring with doctest examples to patternmatcher
Denis Laxalde <denis@laxalde.org>
parents:
42080
diff
changeset
|
576 """ |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
577 |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
578 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:
41683
diff
changeset
|
579 super(patternmatcher, self).__init__(badfn) |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
580 |
32590
3fdcc34c0aba
match: remove special-casing of always-matching patterns in patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32589
diff
changeset
|
581 self._files = _explicitfiles(kindpats) |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
582 self._prefix = _prefix(kindpats) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
583 self._pats, self.matchfn = _buildmatch(kindpats, b'$', root) |
8587
8f15d54437b9
match: fold match into _match base class
Matt Mackall <mpm@selenic.com>
parents:
8586
diff
changeset
|
584 |
32362
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32352
diff
changeset
|
585 @propertycache |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
586 def _dirs(self): |
43571
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43554
diff
changeset
|
587 return set(pathutil.dirs(self._fileset)) |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
588 |
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
589 def visitdir(self, dir): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
590 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
|
591 return b'all' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
592 return ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
593 dir in self._fileset |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
594 or dir in self._dirs |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
595 or any( |
43677
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
596 parentdir in self._fileset |
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
597 for parentdir in pathutil.finddirs(dir) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
598 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
599 ) |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
600 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
601 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
602 ret = self.visitdir(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
603 if ret is True: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
604 return b'this' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
605 elif not ret: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
606 return set() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
607 assert ret == b'all' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
608 return b'all' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
609 |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
610 def prefix(self): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
611 return self._prefix |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
612 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
613 @encoding.strmethod |
32444
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32439
diff
changeset
|
614 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
615 return b'<patternmatcher patterns=%r>' % pycompat.bytestr(self._pats) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
616 |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
617 |
43571
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43554
diff
changeset
|
618 # 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:
43554
diff
changeset
|
619 # 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:
43554
diff
changeset
|
620 # to avoid some directories we don't need. |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
621 class _dirchildren(object): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
622 def __init__(self, paths, onlyinclude=None): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
623 self._dirs = {} |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
624 self._onlyinclude = onlyinclude or [] |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
625 addpath = self.addpath |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
626 for f in paths: |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
627 addpath(f) |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
628 |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
629 def addpath(self, path): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
630 if path == b'': |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
631 return |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
632 dirs = self._dirs |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
633 findsplitdirs = _dirchildren._findsplitdirs |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
634 for d, b in findsplitdirs(path): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
635 if d not in self._onlyinclude: |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
636 continue |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
637 dirs.setdefault(d, set()).add(b) |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
638 |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
639 @staticmethod |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
640 def _findsplitdirs(path): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
641 # yields (dirname, basename) tuples, walking back to the root. This is |
43677
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
642 # very similar to pathutil.finddirs, except: |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
643 # - 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:
39289
diff
changeset
|
644 # Unlike manifest._splittopdir, this does not suffix `dirname` with a |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
645 # slash. |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
646 oldpos = len(path) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
647 pos = path.rfind(b'/') |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
648 while pos != -1: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
649 yield path[:pos], path[pos + 1 : oldpos] |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
650 oldpos = pos |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
651 pos = path.rfind(b'/', 0, pos) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
652 yield b'', path[:oldpos] |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
653 |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
654 def get(self, path): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
655 return self._dirs.get(path, set()) |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
656 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
657 |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
658 class includematcher(basematcher): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
659 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:
41683
diff
changeset
|
660 super(includematcher, self).__init__(badfn) |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
661 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
662 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
|
663 self._prefix = _prefix(kindpats) |
38992
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
664 roots, dirs, parents = _rootsdirsandparents(kindpats) |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
665 # roots are directories which are recursively included. |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
666 self._roots = set(roots) |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
667 # dirs are directories which are non-recursively included. |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
668 self._dirs = set(dirs) |
38992
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
669 # parents are directories which are non-recursively included because |
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
670 # they are needed to get to items in _dirs or _roots. |
42383
c4b8f8637d7a
match: de-flake test-doctest.py by not depending on util.dirs() order
Martin von Zweigbergk <martinvonz@google.com>
parents:
42368
diff
changeset
|
671 self._parents = parents |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
672 |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
673 def visitdir(self, dir): |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
674 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
|
675 return b'all' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
676 return ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
677 dir in self._roots |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
678 or dir in self._dirs |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
679 or dir in self._parents |
43677
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
680 or any( |
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
681 parentdir in self._roots for parentdir in pathutil.finddirs(dir) |
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
682 ) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
683 ) |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
684 |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
685 @propertycache |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
686 def _allparentschildren(self): |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
687 # 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:
39289
diff
changeset
|
688 # 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:
39289
diff
changeset
|
689 # dirs = ['foo/bar'] |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
690 # parents = ['foo'] |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
691 # 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:
39289
diff
changeset
|
692 # 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:
39289
diff
changeset
|
693 return _dirchildren( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
694 itertools.chain(self._dirs, self._roots, self._parents), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
695 onlyinclude=self._parents, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
696 ) |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
697 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
698 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
699 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
|
700 return b'all' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
701 # Note: this does *not* include the 'dir in self._parents' case from |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
702 # visitdir, that's handled below. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
703 if ( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
704 b'' in self._roots |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
705 or dir in self._roots |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
706 or dir in self._dirs |
43677
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
707 or any( |
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
708 parentdir in self._roots for parentdir in pathutil.finddirs(dir) |
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
709 ) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
710 ): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
711 return b'this' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
712 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
713 if dir in self._parents: |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
714 return self._allparentschildren.get(dir) or set() |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
715 return set() |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
716 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
717 @encoding.strmethod |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
718 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
719 return b'<includematcher includes=%r>' % pycompat.bytestr(self._pats) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
720 |
32444
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32439
diff
changeset
|
721 |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
722 class exactmatcher(basematcher): |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
723 r'''Matches the input files exactly. They are interpreted as paths, not |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
724 patterns (so no kind-prefixes). |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
725 |
42224
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
726 >>> 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
|
727 >>> m(b'a.txt') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
728 True |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
729 >>> m(b'b.txt') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
730 False |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
731 |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
732 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:
41687
diff
changeset
|
733 >>> m.files() |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
734 ['a.txt', 're:.*\\.c$'] |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
735 |
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
736 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
|
737 >>> m(b'main.c') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
738 False |
42224
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
739 >>> m(br're:.*\.c$') |
42080
f3db5c805a67
match: add doctest examples for exactmatcher
Denis Laxalde <denis@laxalde.org>
parents:
41687
diff
changeset
|
740 True |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
741 ''' |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
742 |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
743 def __init__(self, files, badfn=None): |
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
744 super(exactmatcher, self).__init__(badfn) |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
745 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
746 if isinstance(files, list): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
747 self._files = files |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
748 else: |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
749 self._files = list(files) |
32576
cf7c88986e9f
match: define exactmatcher.matchfn statically
Yuya Nishihara <yuya@tcha.org>
parents:
32575
diff
changeset
|
750 |
cf7c88986e9f
match: define exactmatcher.matchfn statically
Yuya Nishihara <yuya@tcha.org>
parents:
32575
diff
changeset
|
751 matchfn = basematcher.exact |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
752 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
753 @propertycache |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
754 def _dirs(self): |
43571
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43554
diff
changeset
|
755 return set(pathutil.dirs(self._fileset)) |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
756 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
757 def visitdir(self, dir): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
758 return dir in self._dirs |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
759 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
760 def visitchildrenset(self, dir): |
39289
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39288
diff
changeset
|
761 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:
39288
diff
changeset
|
762 return set() |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39288
diff
changeset
|
763 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
764 candidates = self._fileset | self._dirs - {b''} |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
765 if dir != b'': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
766 d = dir + b'/' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
767 candidates = set(c[len(d) :] for c in candidates if c.startswith(d)) |
39289
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39288
diff
changeset
|
768 # self._dirs includes all of the directories, recursively, so if |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
769 # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo', |
39289
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39288
diff
changeset
|
770 # '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:
39288
diff
changeset
|
771 # '/' 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:
39288
diff
changeset
|
772 # 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
|
773 ret = {c for c in candidates if b'/' not in c} |
39289
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39288
diff
changeset
|
774 # 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:
39288
diff
changeset
|
775 # 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:
39288
diff
changeset
|
776 assert ret |
c9a3f7f5c023
match: make exactmatcher.visitchildrenset return file children as well
Kyle Lippincott <spectral@google.com>
parents:
39288
diff
changeset
|
777 return ret |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
778 |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
779 def isexact(self): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
780 return True |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
781 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
782 @encoding.strmethod |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
783 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
784 return b'<exactmatcher files=%r>' % self._files |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
785 |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
786 |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
787 class differencematcher(basematcher): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
788 '''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:
35185
diff
changeset
|
789 does not. |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
790 |
43754
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43677
diff
changeset
|
791 The second matcher's non-matching-attributes (bad, traversedir) are ignored. |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
792 ''' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
793 |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
794 def __init__(self, m1, m2): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
795 super(differencematcher, self).__init__() |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
796 self._m1 = m1 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
797 self._m2 = m2 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
798 self.bad = m1.bad |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
799 self.traversedir = m1.traversedir |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
800 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
801 def matchfn(self, f): |
35659
821d8a5ab4ff
match: do not weirdly include explicit files excluded by -X option
Yuya Nishihara <yuya@tcha.org>
parents:
35185
diff
changeset
|
802 return self._m1(f) and not self._m2(f) |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
803 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
804 @propertycache |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
805 def _files(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
806 if self.isexact(): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
807 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:
32498
diff
changeset
|
808 # 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:
32498
diff
changeset
|
809 # 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:
32498
diff
changeset
|
810 # 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:
32498
diff
changeset
|
811 # 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:
32498
diff
changeset
|
812 # because the "dir" in m1 may not be a file. |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
813 return self._m1.files() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
814 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
815 def visitdir(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
816 if self._m2.visitdir(dir) == b'all': |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
817 return False |
41542
b7a0efb3c370
match: teach diffmatcher.visitdir() to return 'all' if possible
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41282
diff
changeset
|
818 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
|
819 # 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
|
820 return self._m1.visitdir(dir) |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
821 return bool(self._m1.visitdir(dir)) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
822 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
823 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
824 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
|
825 if m2_set == b'all': |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
826 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
827 m1_set = self._m1.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
828 # Possible values for m1: 'all', 'this', set(...), set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
829 # Possible values for m2: 'this', set(...), set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
830 # 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:
38992
diff
changeset
|
831 # 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:
38992
diff
changeset
|
832 # return True, not 'all', for some reason. |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
833 if not m2_set: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
834 return m1_set |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
835 if m1_set in [b'all', b'this']: |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
836 # 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:
38992
diff
changeset
|
837 # 'this' or set(foo)), since m2 might return set() for a |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
838 # subdirectory. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
839 return b'this' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
840 # Possible values for m1: set(...), set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
841 # Possible values for m2: 'this', set(...) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
842 # We ignore m2's set results. They're possibly incorrect: |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
843 # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''): |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
844 # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
845 # return set(), which is *not* correct, we still need to visit 'dir'! |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
846 return m1_set |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
847 |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
848 def isexact(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
849 return self._m1.isexact() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
850 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
851 @encoding.strmethod |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
852 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
853 return b'<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
854 |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
855 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
856 def intersectmatchers(m1, m2): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
857 '''Composes two matchers by matching if both of them match. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
858 |
43754
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43677
diff
changeset
|
859 The second matcher's non-matching-attributes (bad, traversedir) are ignored. |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
860 ''' |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
861 if m1 is None or m2 is None: |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
862 return m1 or m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
863 if m1.always(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
864 m = copy.copy(m2) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
865 # 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:
32529
diff
changeset
|
866 # one thing to copy from m1. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
867 m.bad = m1.bad |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
868 m.traversedir = m1.traversedir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
869 return m |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
870 if m2.always(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
871 m = copy.copy(m1) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
872 return m |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
873 return intersectionmatcher(m1, m2) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
874 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
875 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
876 class intersectionmatcher(basematcher): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
877 def __init__(self, m1, m2): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
878 super(intersectionmatcher, self).__init__() |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
879 self._m1 = m1 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
880 self._m2 = m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
881 self.bad = m1.bad |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
882 self.traversedir = m1.traversedir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
883 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
884 @propertycache |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
885 def _files(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
886 if self.isexact(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
887 m1, m2 = self._m1, self._m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
888 if not m1.isexact(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
889 m1, m2 = m2, m1 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
890 return [f for f in m1.files() if m2(f)] |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
891 # 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:
32529
diff
changeset
|
892 # 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:
32529
diff
changeset
|
893 # 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:
32529
diff
changeset
|
894 # "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:
32529
diff
changeset
|
895 return self._m1.files() + self._m2.files() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
896 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
897 def matchfn(self, f): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
898 return self._m1(f) and self._m2(f) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
899 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
900 def visitdir(self, dir): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
901 visit1 = self._m1.visitdir(dir) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
902 if visit1 == b'all': |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
903 return self._m2.visitdir(dir) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
904 # bool() because visit1=True + visit2='all' should not be 'all' |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
905 return bool(visit1 and self._m2.visitdir(dir)) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
906 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
907 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
908 m1_set = self._m1.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
909 if not m1_set: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
910 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
911 m2_set = self._m2.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
912 if not m2_set: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
913 return set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
914 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
915 if m1_set == b'all': |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
916 return m2_set |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
917 elif m2_set == b'all': |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
918 return m1_set |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
919 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
920 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
|
921 return b'this' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
922 |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
923 assert isinstance(m1_set, set) and isinstance(m2_set, set) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
924 return m1_set.intersection(m2_set) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
925 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
926 def always(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
927 return self._m1.always() and self._m2.always() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
928 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
929 def isexact(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
930 return self._m1.isexact() or self._m2.isexact() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
931 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
932 @encoding.strmethod |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
933 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
934 return b'<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
935 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
936 |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
937 class subdirmatcher(basematcher): |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
938 """Adapt a matcher to work on a subdirectory only. |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
939 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
940 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
|
941 |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
942 >>> from . import pycompat |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
943 >>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt']) |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
944 >>> m2 = subdirmatcher(b'sub', m1) |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
945 >>> m2(b'a.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
946 False |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
947 >>> m2(b'b.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
948 True |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
949 >>> m2.matchfn(b'a.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
950 False |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
951 >>> m2.matchfn(b'b.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
952 True |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
953 >>> m2.files() |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
954 ['b.txt'] |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
955 >>> m2.exact(b'b.txt') |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
956 True |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
957 >>> def bad(f, msg): |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
958 ... print(pycompat.sysstr(b"%s: %s" % (f, msg))) |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
959 >>> m1.bad = bad |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
960 >>> m2.bad(b'x.txt', b'No such file') |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
961 sub/x.txt: No such file |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
962 """ |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
963 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
964 def __init__(self, path, matcher): |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
965 super(subdirmatcher, self).__init__() |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
966 self._path = path |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
967 self._matcher = matcher |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
968 self._always = matcher.always() |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
969 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
970 self._files = [ |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
971 f[len(path) + 1 :] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
972 for f in matcher._files |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
973 if f.startswith(path + b"/") |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
974 ] |
25194
ef4538ba67ef
match: explicitly naming a subrepo implies always() for the submatcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
24790
diff
changeset
|
975 |
32365
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32364
diff
changeset
|
976 # 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:
32364
diff
changeset
|
977 # a prefix matcher, this submatcher always matches. |
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32364
diff
changeset
|
978 if matcher.prefix(): |
25195 | 979 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
|
980 |
32364
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
981 def bad(self, f, msg): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
982 self._matcher.bad(self._path + b"/" + f, msg) |
32364
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
983 |
32498
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
984 def matchfn(self, f): |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
985 # 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:
32497
diff
changeset
|
986 # 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:
32497
diff
changeset
|
987 # 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:
32497
diff
changeset
|
988 # 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
|
989 return self._matcher.matchfn(self._path + b"/" + f) |
32498
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
990 |
32363
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
991 def visitdir(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
992 if dir == b'': |
32363
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
993 dir = self._path |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
994 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
995 dir = self._path + b"/" + dir |
32363
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
996 return self._matcher.visitdir(dir) |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
997 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
998 def visitchildrenset(self, dir): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
999 if dir == b'': |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1000 dir = self._path |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1001 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1002 dir = self._path + b"/" + dir |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1003 return self._matcher.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1004 |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
1005 def always(self): |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
1006 return self._always |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
1007 |
33379
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
1008 def prefix(self): |
7ddb2aa2b7af
match: express anypats(), not prefix(), in terms of the others
Martin von Zweigbergk <martinvonz@google.com>
parents:
33378
diff
changeset
|
1009 return self._matcher.prefix() and not self._always |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
1010 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
1011 @encoding.strmethod |
32585
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32576
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'<subdirmatcher path=%r, matcher=%r>' % ( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1014 self._path, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1015 self._matcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1016 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1017 |
32585
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32576
diff
changeset
|
1018 |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1019 class prefixdirmatcher(basematcher): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1020 """Adapt a matcher to work on a parent directory. |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1021 |
43754
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43677
diff
changeset
|
1022 The matcher's non-matching-attributes (bad, traversedir) are ignored. |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1023 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1024 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:
38582
diff
changeset
|
1025 this matcher to the root of the wrapped matcher. |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1026 |
38750
a8bfaf592033
doctest: convert matcher root to native path
Yuya Nishihara <yuya@tcha.org>
parents:
38613
diff
changeset
|
1027 >>> m1 = match(util.localpath(b'root/d/e'), b'f', [b'../a.txt', b'b.txt']) |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
1028 >>> 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
|
1029 >>> m2(b'a.txt') |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1030 False |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1031 >>> m2(b'd/e/a.txt') |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1032 True |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1033 >>> m2(b'd/e/b.txt') |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1034 False |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1035 >>> m2.files() |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1036 ['d/e/a.txt', 'd/e/f/b.txt'] |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1037 >>> m2.exact(b'd/e/a.txt') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1038 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1039 >>> m2.visitdir(b'd') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1040 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1041 >>> m2.visitdir(b'd/e') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1042 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1043 >>> m2.visitdir(b'd/e/f') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1044 True |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1045 >>> m2.visitdir(b'd/e/g') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1046 False |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1047 >>> m2.visitdir(b'd/ef') |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1048 False |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1049 """ |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1050 |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
1051 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:
41683
diff
changeset
|
1052 super(prefixdirmatcher, self).__init__(badfn) |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1053 if not path: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1054 raise error.ProgrammingError(b'prefix path must not be empty') |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1055 self._path = path |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1056 self._pathprefix = path + b'/' |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1057 self._matcher = matcher |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1058 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1059 @propertycache |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1060 def _files(self): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1061 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:
38582
diff
changeset
|
1062 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1063 def matchfn(self, f): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1064 if not f.startswith(self._pathprefix): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1065 return False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1066 return self._matcher.matchfn(f[len(self._pathprefix) :]) |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1067 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1068 @propertycache |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1069 def _pathdirs(self): |
43677
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43640
diff
changeset
|
1070 return set(pathutil.finddirs(self._path)) |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1071 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1072 def visitdir(self, dir): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1073 if dir == self._path: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1074 return self._matcher.visitdir(b'') |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1075 if dir.startswith(self._pathprefix): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1076 return self._matcher.visitdir(dir[len(self._pathprefix) :]) |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1077 return dir in self._pathdirs |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1078 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1079 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1080 if dir == self._path: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1081 return self._matcher.visitchildrenset(b'') |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1082 if dir.startswith(self._pathprefix): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1083 return self._matcher.visitchildrenset(dir[len(self._pathprefix) :]) |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1084 if dir in self._pathdirs: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1085 return b'this' |
38996
b9f94d67ea73
match: add missing "return set()", add FIXME to test to doc a bug
Kyle Lippincott <spectral@google.com>
parents:
38995
diff
changeset
|
1086 return set() |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1087 |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1088 def isexact(self): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1089 return self._matcher.isexact() |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1090 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1091 def prefix(self): |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1092 return self._matcher.prefix() |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1093 |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1094 @encoding.strmethod |
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1095 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1096 return b'<prefixdirmatcher path=%r, matcher=%r>' % ( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1097 pycompat.bytestr(self._path), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1098 self._matcher, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1099 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1100 |
38612
0ba4cf3f088f
match: add prefixdirmatcher to adapt subrepo matcher back
Yuya Nishihara <yuya@tcha.org>
parents:
38582
diff
changeset
|
1101 |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1102 class unionmatcher(basematcher): |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1103 """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
|
1104 |
43754
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43677
diff
changeset
|
1105 The non-matching-attributes (bad, traversedir) are taken from the first |
5e1b0470cee7
match: remove explicitdir attribute
Martin von Zweigbergk <martinvonz@google.com>
parents:
43677
diff
changeset
|
1106 matcher. |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1107 """ |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1108 |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1109 def __init__(self, matchers): |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1110 m1 = matchers[0] |
41686
ddbebce94665
match: delete unused root and cwd arguments to constructors (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41683
diff
changeset
|
1111 super(unionmatcher, self).__init__() |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1112 self.traversedir = m1.traversedir |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1113 self._matchers = matchers |
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1114 |
33380
892d255ec2a1
match: override matchfn instead of __call__ for consistency
Martin von Zweigbergk <martinvonz@google.com>
parents:
33379
diff
changeset
|
1115 def matchfn(self, f): |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1116 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
|
1117 if match(f): |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1118 return True |
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1119 return False |
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1120 |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1121 def visitdir(self, dir): |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1122 r = False |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1123 for m in self._matchers: |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1124 v = m.visitdir(dir) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1125 if v == b'all': |
33448
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1126 return v |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1127 r |= v |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1128 return r |
04be8aec44a8
match: make unionmatcher a proper matcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
33447
diff
changeset
|
1129 |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1130 def visitchildrenset(self, dir): |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1131 r = set() |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1132 this = False |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1133 for m in self._matchers: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1134 v = m.visitchildrenset(dir) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1135 if not v: |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1136 continue |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1137 if v == b'all': |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1138 return v |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1139 if this or v == b'this': |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1140 this = True |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1141 # don't break, we might have an 'all' in here. |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1142 continue |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1143 assert isinstance(v, set) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1144 r = r.union(v) |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1145 if this: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1146 return b'this' |
38993
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1147 return r |
081cc9a95b65
match: add visitchildrenset complement to visitdir
spectral <spectral@google.com>
parents:
38992
diff
changeset
|
1148 |
36088
c4fa47f880d3
py3: make sure we return str from __repr__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35659
diff
changeset
|
1149 @encoding.strmethod |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1150 def __repr__(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1151 return b'<unionmatcher matchers=%r>' % self._matchers |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1152 |
33319
3c84591e7321
match: move matchers from sparse into core
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33306
diff
changeset
|
1153 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1154 def patkind(pattern, default=None): |
43437
bfbbf48d51e8
py3: make doc strings containing deprecated '\.' escape sequence raw strings
Daniel Ploch <dploch@google.com>
parents:
43117
diff
changeset
|
1155 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
|
1156 |
42224
fd384911f51b
match: use raw strings to avoid illegal baskslash escape
Gregory Szorc <gregory.szorc@gmail.com>
parents:
42099
diff
changeset
|
1157 >>> patkind(br're:.*\.c$') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1158 're' |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1159 >>> patkind(b'glob:*.c') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1160 'glob' |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1161 >>> patkind(b'relpath:test.py') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1162 'relpath' |
42098
5753e5949b51
py3: add b'' prefixes to new doctests in match.py
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42087
diff
changeset
|
1163 >>> 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
|
1164 >>> patkind(b'main.py', default=b're') |
42082
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1165 're' |
413a75da98ce
match: add doctest examples for patkind()
Denis Laxalde <denis@laxalde.org>
parents:
42081
diff
changeset
|
1166 ''' |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1167 return _patsplit(pattern, default)[0] |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1168 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1169 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1170 def _patsplit(pattern, default): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1171 """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
|
1172 pattern.""" |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1173 if b':' in pattern: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1174 kind, pat = pattern.split(b':', 1) |
33710
2be0bf186950
match: expose some data and functionality to other modules
Kostia Balytskyi <ikostia@fb.com>
parents:
33582
diff
changeset
|
1175 if kind in allpatternkinds: |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1176 return kind, pat |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1177 return default, pattern |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1178 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1179 |
8582
a4c199e12b5a
match: remove head and tail args from _globre
Matt Mackall <mpm@selenic.com>
parents:
8581
diff
changeset
|
1180 def _globre(pat): |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1181 r'''Convert an extended glob string to a regexp string. |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1182 |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1183 >>> from . import pycompat |
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1184 >>> def bprint(s): |
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1185 ... print(pycompat.sysstr(s)) |
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1186 >>> bprint(_globre(br'?')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1187 . |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1188 >>> bprint(_globre(br'*')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1189 [^/]* |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1190 >>> bprint(_globre(br'**')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1191 .* |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1192 >>> bprint(_globre(br'**/a')) |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
1193 (?:.*/)?a |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1194 >>> bprint(_globre(br'a/**/b')) |
38479
67dc32d4e790
cleanup: migrate from re.escape to stringutil.reescape
Augie Fackler <augie@google.com>
parents:
38061
diff
changeset
|
1195 a/(?:.*/)?b |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1196 >>> bprint(_globre(br'[a*?!^][^b][!c]')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1197 [a*?!^][\^b][^c] |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1198 >>> bprint(_globre(br'{a,b}')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1199 (?:a|b) |
34152
a8994d08e4a2
doctest: use print_function and convert bytes to unicode where needed
Yuya Nishihara <yuya@tcha.org>
parents:
34146
diff
changeset
|
1200 >>> bprint(_globre(br'.\*\?')) |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1201 \.\*\? |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
1202 ''' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1203 i, n = 0, len(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1204 res = b'' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1205 group = 0 |
40723
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1206 escape = util.stringutil.regexbytesescapemap.get |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1207 |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
1208 def peek(): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1209 return i < n and pat[i : i + 1] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1210 |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1211 while i < n: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1212 c = pat[i : i + 1] |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
1213 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1214 if c not in b'*?[{},\\': |
40723
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1215 res += escape(c, c) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1216 elif c == b'*': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1217 if peek() == b'*': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1218 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1219 if peek() == b'/': |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
1220 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1221 res += b'(?:.*/)?' |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
1222 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1223 res += b'.*' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1224 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1225 res += b'[^/]*' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1226 elif c == b'?': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1227 res += b'.' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1228 elif c == b'[': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1229 j = i |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1230 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
|
1231 j += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1232 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
|
1233 j += 1 |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1234 if j >= n: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1235 res += b'\\[' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1236 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1237 stuff = pat[i:j].replace(b'\\', b'\\\\') |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1238 i = j + 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1239 if stuff[0:1] == b'!': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1240 stuff = b'^' + stuff[1:] |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1241 elif stuff[0:1] == b'^': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1242 stuff = b'\\' + stuff |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1243 res = b'%s[%s]' % (res, stuff) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1244 elif c == b'{': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1245 group += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1246 res += b'(?:' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1247 elif c == b'}' and group: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1248 res += b')' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1249 group -= 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1250 elif c == b',' and group: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1251 res += b'|' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1252 elif c == b'\\': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1253 p = peek() |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1254 if p: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1255 i += 1 |
40723
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1256 res += escape(p, p) |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1257 else: |
40723
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1258 res += escape(c, c) |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1259 else: |
40723
e6c9ef5e11a0
match: provide and use a quick way to escape a single byte
Boris Feld <boris.feld@octobus.net>
parents:
40345
diff
changeset
|
1260 res += escape(c, c) |
8582
a4c199e12b5a
match: remove head and tail args from _globre
Matt Mackall <mpm@selenic.com>
parents:
8581
diff
changeset
|
1261 return res |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
1262 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1263 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1264 def _regex(kind, pat, globsuffix): |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1265 '''Convert a (normalized) pattern of any kind into a |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1266 regular expression. |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1267 globsuffix is appended to the regexp of globs.''' |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1268 |
42468
a3a8887e4426
rust: using policy.importrust from Python callers
Georges Racinet <georges.racinet@octobus.net>
parents:
42389
diff
changeset
|
1269 if rustmod is not None: |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1270 try: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1271 return rustmod.build_single_regex(kind, pat, globsuffix) |
42468
a3a8887e4426
rust: using policy.importrust from Python callers
Georges Racinet <georges.racinet@octobus.net>
parents:
42389
diff
changeset
|
1272 except rustmod.PatternError: |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1273 raise error.ProgrammingError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1274 b'not a regex pattern: %s:%s' % (kind, pat) |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1275 ) |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1276 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1277 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
|
1278 return b'' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1279 if kind == b're': |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1280 return pat |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1281 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
|
1282 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1283 return b'' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1284 return util.stringutil.reescape(pat) + b'(?:/|$)' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1285 if kind == b'rootfilesin': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1286 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1287 escaped = b'' |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1288 else: |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1289 # Pattern is a directory name. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1290 escaped = util.stringutil.reescape(pat) + b'/' |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1291 # 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
|
1292 return escaped + b'[^/]+$' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1293 if kind == b'relglob': |
42870
72890d8f9860
match: simplify the regexps created for glob patterns
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42782
diff
changeset
|
1294 globre = _globre(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1295 if globre.startswith(b'[^/]*'): |
42870
72890d8f9860
match: simplify the regexps created for glob patterns
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42782
diff
changeset
|
1296 # 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:
42782
diff
changeset
|
1297 # 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
|
1298 return b'.*' + globre[len(b'[^/]*') :] + globsuffix |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1299 return b'(?:|.*/)' + globre + globsuffix |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1300 if kind == b'relre': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1301 if pat.startswith(b'^'): |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1302 return pat |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1303 return b'.*' + pat |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1304 if kind in (b'glob', b'rootglob'): |
38579
2d487b9cac07
match: explode if unsupported pattern passed down to _regex() builder
Yuya Nishihara <yuya@tcha.org>
parents:
38578
diff
changeset
|
1305 return _globre(pat) + globsuffix |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1306 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
|
1307 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1308 |
41680
a13268524c25
match: delete unused argument "listsubrepos" from _buildmatch()
Martin von Zweigbergk <martinvonz@google.com>
parents:
41679
diff
changeset
|
1309 def _buildmatch(kindpats, globsuffix, root): |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1310 '''Return regexp string and a matcher function for kindpats. |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1311 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
|
1312 matchfuncs = [] |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1313 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1314 subincludes, kindpats = _expandsubinclude(kindpats, root) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1315 if subincludes: |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1316 submatchers = {} |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1317 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1318 def matchsubinclude(f): |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1319 for prefix, matcherargs in subincludes: |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1320 if f.startswith(prefix): |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1321 mf = submatchers.get(prefix) |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1322 if mf is None: |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1323 mf = match(*matcherargs) |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1324 submatchers[prefix] = mf |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1325 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1326 if mf(f[len(prefix) :]): |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
1327 return True |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1328 return False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1329 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
1330 matchfuncs.append(matchsubinclude) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
1331 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1332 regex = b'' |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1333 if kindpats: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1334 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:
39477
diff
changeset
|
1335 dirs = {p for k, p, s in kindpats} |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1336 |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1337 def mf(f): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1338 i = f.rfind(b'/') |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1339 if i >= 0: |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1340 dir = f[:i] |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1341 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1342 dir = b'.' |
40242
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1343 return dir in dirs |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1344 |
40345
d30a19d10441
match: fix up a repr to not crash on Python 3
Augie Fackler <augie@google.com>
parents:
40242
diff
changeset
|
1345 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:
39477
diff
changeset
|
1346 matchfuncs.append(mf) |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1347 else: |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1348 regex, mf = _buildregexmatch(kindpats, globsuffix) |
19ed212de2d1
match: optimize matcher when all patterns are of rootfilesin kind
Martin von Zweigbergk <martinvonz@google.com>
parents:
39477
diff
changeset
|
1349 matchfuncs.append(mf) |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1350 |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1351 if len(matchfuncs) == 1: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1352 return regex, matchfuncs[0] |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1353 else: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
1354 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
|
1355 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1356 |
40808
8306dac48061
match: extract a literal constant into a symbolic one
Boris Feld <boris.feld@octobus.net>
parents:
40791
diff
changeset
|
1357 MAX_RE_SIZE = 20000 |
8306dac48061
match: extract a literal constant into a symbolic one
Boris Feld <boris.feld@octobus.net>
parents:
40791
diff
changeset
|
1358 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1359 |
40810
ce401300f981
match: extract function that group regexps
Boris Feld <boris.feld@octobus.net>
parents:
40809
diff
changeset
|
1360 def _joinregexes(regexps): |
ce401300f981
match: extract function that group regexps
Boris Feld <boris.feld@octobus.net>
parents:
40809
diff
changeset
|
1361 """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
|
1362 return b'|'.join(regexps) |
40810
ce401300f981
match: extract function that group regexps
Boris Feld <boris.feld@octobus.net>
parents:
40809
diff
changeset
|
1363 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1364 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1365 def _buildregexmatch(kindpats, globsuffix): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
1366 """Build a match function from a list of kinds and kindpats, |
40809
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1367 return regexp string and a matcher function. |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1368 |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1369 Test too large input |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1370 >>> _buildregexmatch([ |
40960
9e462fb88f79
match: fix doctest to use bytes instead of str
Augie Fackler <augie@google.com>
parents:
40816
diff
changeset
|
1371 ... (b'relglob', b'?' * MAX_RE_SIZE, b'') |
9e462fb88f79
match: fix doctest to use bytes instead of str
Augie Fackler <augie@google.com>
parents:
40816
diff
changeset
|
1372 ... ], b'$') |
40809
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1373 Traceback (most recent call last): |
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1374 ... |
40812
69bd3176da7c
match: raise an Abort error instead of OverflowError
Boris Feld <boris.feld@octobus.net>
parents:
40811
diff
changeset
|
1375 Abort: matcher pattern is too long (20009 bytes) |
40809
4e02f25f31c6
match: test for overflow error in pattern
Boris Feld <boris.feld@octobus.net>
parents:
40808
diff
changeset
|
1376 """ |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1377 try: |
40811
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1378 allgroups = [] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1379 regexps = [_regex(k, p, globsuffix) for (k, p, s) in kindpats] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1380 fullregexp = _joinregexes(regexps) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1381 |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1382 startidx = 0 |
40816
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40815
diff
changeset
|
1383 groupsize = 0 |
40811
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1384 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:
40810
diff
changeset
|
1385 piecesize = len(r) |
40816
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40815
diff
changeset
|
1386 if piecesize > MAX_RE_SIZE: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1387 msg = _(b"matcher pattern is too long (%d bytes)") % piecesize |
40812
69bd3176da7c
match: raise an Abort error instead of OverflowError
Boris Feld <boris.feld@octobus.net>
parents:
40811
diff
changeset
|
1388 raise error.Abort(msg) |
40814
1e019f45fa88
match: make "groupsize" include the trailing "|"
Martin von Zweigbergk <martinvonz@google.com>
parents:
40813
diff
changeset
|
1389 elif (groupsize + piecesize) > MAX_RE_SIZE: |
40811
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1390 group = regexps[startidx:idx] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1391 allgroups.append(_joinregexes(group)) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1392 startidx = idx |
40816
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40815
diff
changeset
|
1393 groupsize = 0 |
40811
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1394 groupsize += piecesize + 1 |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1395 |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1396 if startidx == 0: |
42087
2e2699af5649
match: let regex match function return a boolean
Denis Laxalde <denis@laxalde.org>
parents:
42086
diff
changeset
|
1397 matcher = _rematcher(fullregexp) |
42099
bccb322f1496
match: fix re2 compability broken in 2e2699af5649
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42098
diff
changeset
|
1398 func = lambda s: bool(matcher(s)) |
40811
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1399 else: |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1400 group = regexps[startidx:] |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1401 allgroups.append(_joinregexes(group)) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1402 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:
40810
diff
changeset
|
1403 func = lambda s: any(m(s) for m in allmatchers) |
3c842749debc
match: avoid translating glob to matcher multiple times for large sets
Boris Feld <boris.feld@octobus.net>
parents:
40810
diff
changeset
|
1404 return fullregexp, func |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1405 except re.error: |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1406 for k, p, s in kindpats: |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1407 try: |
40816
3984409e144b
match: drop unnecessary wrapping of regex in group
Martin von Zweigbergk <martinvonz@google.com>
parents:
40815
diff
changeset
|
1408 _rematcher(_regex(k, p, globsuffix)) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1409 except re.error: |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1410 if s: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1411 raise error.Abort( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1412 _(b"%s: invalid pattern (%s): %s") % (s, k, p) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1413 ) |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1414 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1415 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
|
1416 raise error.Abort(_(b"invalid pattern")) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
1417 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1418 |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1419 def _patternrootsanddirs(kindpats): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1420 '''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
|
1421 |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1422 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:
31032
diff
changeset
|
1423 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:
31032
diff
changeset
|
1424 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:
31032
diff
changeset
|
1425 directories. |
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
|
1426 ''' |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
1427 r = [] |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1428 d = [] |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
1429 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
|
1430 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
|
1431 root = [] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1432 for p in pat.split(b'/'): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1433 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
|
1434 break |
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
1435 root.append(p) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1436 r.append(b'/'.join(root)) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1437 elif kind in (b'relpath', b'path'): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1438 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1439 pat = b'' |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
1440 r.append(pat) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1441 elif kind in (b'rootfilesin',): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1442 if pat == b'.': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1443 pat = b'' |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42351
diff
changeset
|
1444 d.append(pat) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1445 else: # relglob, re, relre |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1446 r.append(b'') |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1447 return r, d |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1448 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1449 |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1450 def _roots(kindpats): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1451 '''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:
31032
diff
changeset
|
1452 roots, dirs = _patternrootsanddirs(kindpats) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1453 return roots |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1454 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1455 |
38992
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
1456 def _rootsdirsandparents(kindpats): |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1457 '''Returns roots and exact directories from patterns. |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1458 |
38995
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38993
diff
changeset
|
1459 `roots` are directories to match recursively, `dirs` should |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38993
diff
changeset
|
1460 be matched non-recursively, and `parents` are the implicitly required |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38993
diff
changeset
|
1461 directories to walk to items in either roots or dirs. |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38993
diff
changeset
|
1462 |
f356be1a7ba3
match: correct doc for _rootsdirsandparents after 5a7df82de142
Kyle Lippincott <spectral@google.com>
parents:
38993
diff
changeset
|
1463 Returns a tuple of (roots, dirs, parents). |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1464 |
42389
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1465 >>> r = _rootsdirsandparents( |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
1466 ... [(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:
33710
diff
changeset
|
1467 ... (b'glob', b'g*', b'')]) |
42389
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1468 >>> 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:
42384
diff
changeset
|
1469 (['g/h', 'g/h', ''], []) ['', 'g'] |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1470 >>> r = _rootsdirsandparents( |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
1471 ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')]) |
42389
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1472 >>> 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:
42384
diff
changeset
|
1473 ([], ['g/h', '']) ['', 'g'] |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1474 >>> r = _rootsdirsandparents( |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
1475 ... [(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:
33710
diff
changeset
|
1476 ... (b'path', b'', b'')]) |
42389
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1477 >>> 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:
42384
diff
changeset
|
1478 (['r', 'p/p', ''], []) ['', 'p'] |
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1479 >>> r = _rootsdirsandparents( |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
1480 ... [(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:
33710
diff
changeset
|
1481 ... (b'relre', b'rr', b'')]) |
42389
96fc696a9cb2
match: stabilize _rootsdirsandparents doctest
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42384
diff
changeset
|
1482 >>> 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:
42384
diff
changeset
|
1483 (['', '', ''], []) [''] |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1484 ''' |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1485 r, d = _patternrootsanddirs(kindpats) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1486 |
42383
c4b8f8637d7a
match: de-flake test-doctest.py by not depending on util.dirs() order
Martin von Zweigbergk <martinvonz@google.com>
parents:
42368
diff
changeset
|
1487 p = set() |
c4b8f8637d7a
match: de-flake test-doctest.py by not depending on util.dirs() order
Martin von Zweigbergk <martinvonz@google.com>
parents:
42368
diff
changeset
|
1488 # Add the parents as non-recursive/exact directories, since they must be |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1489 # scanned to get to either the roots or the other exact directories. |
43571
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43554
diff
changeset
|
1490 p.update(pathutil.dirs(d)) |
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43554
diff
changeset
|
1491 p.update(pathutil.dirs(r)) |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
1492 |
39477
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
1493 # 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:
39289
diff
changeset
|
1494 # returning. |
35ecaa999a12
match: improve includematcher.visitchildrenset to be much faster and cached
Kyle Lippincott <spectral@google.com>
parents:
39289
diff
changeset
|
1495 # 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:
39289
diff
changeset
|
1496 # 'dirs' to also be in 'parents', consider removing them before returning. |
38992
5a7df82de142
includematcher: separate "parents" from "dirs"
spectral <spectral@google.com>
parents:
38750
diff
changeset
|
1497 return r, d, p |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
1498 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1499 |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1500 def _explicitfiles(kindpats): |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1501 '''Returns the potential explicit filenames from the patterns. |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1502 |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
1503 >>> _explicitfiles([(b'path', b'foo/bar', b'')]) |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1504 ['foo/bar'] |
34146
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33710
diff
changeset
|
1505 >>> _explicitfiles([(b'rootfilesin', b'foo/bar', b'')]) |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1506 [] |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1507 ''' |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1508 # 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:
30409
diff
changeset
|
1509 # directory names). |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1510 filable = [kp for kp in kindpats if kp[0] not in (b'rootfilesin',)] |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1511 return _roots(filable) |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
1512 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1513 |
33405
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1514 def _prefix(kindpats): |
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1515 '''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
|
1516 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
|
1517 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
|
1518 return False |
6aa643762641
match: inverse _anypats(), making it _prefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
33380
diff
changeset
|
1519 return True |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1520 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1521 |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1522 _commentre = None |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1523 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1524 |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1525 def readpatternfile(filepath, warn, sourceinfo=False): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1526 '''parse a pattern file, returning a list of |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1527 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
|
1528 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
|
1529 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1530 trailing white space is dropped. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1531 the escape character is backslash. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1532 comments start with #. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1533 empty lines are skipped. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1534 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1535 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
|
1536 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1537 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
|
1538 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
|
1539 re:pattern # non-rooted regular expression |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1540 glob:pattern # non-rooted glob |
41282
4fab8a7d2d72
match: support rooted globs in hgignore
Valentin Gatien-Baron <vgatien-baron@janestreet.com>
parents:
41130
diff
changeset
|
1541 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
|
1542 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
|
1543 |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1544 if sourceinfo is set, returns a list of tuples: |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1545 (pattern, lineno, originalline). |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1546 This is useful to debug ignore patterns. |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1547 ''' |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
1548 |
42468
a3a8887e4426
rust: using policy.importrust from Python callers
Georges Racinet <georges.racinet@octobus.net>
parents:
42389
diff
changeset
|
1549 if rustmod is not None: |
a3a8887e4426
rust: using policy.importrust from Python callers
Georges Racinet <georges.racinet@octobus.net>
parents:
42389
diff
changeset
|
1550 result, warnings = rustmod.read_pattern_file( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1551 filepath, bool(warn), sourceinfo, |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1552 ) |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1553 |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1554 for warning_params in warnings: |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1555 # Can't be easily emitted from Rust, because it would require |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1556 # a mechanism for both gettext and calling the `warn` function. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1557 warn(_(b"%s: ignoring invalid syntax '%s'\n") % warning_params) |
42351
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1558 |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1559 return result |
c7652f7440d9
rust-filepatterns: call new Rust implementations from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42230
diff
changeset
|
1560 |
40724
e41f6c2e69c4
match: reformat `syntaxes` dictionary for better maintainability
Boris Feld <boris.feld@octobus.net>
parents:
40723
diff
changeset
|
1561 syntaxes = { |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1562 b're': b'relre:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1563 b'regexp': b'relre:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1564 b'glob': b'relglob:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1565 b'rootglob': b'rootglob:', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1566 b'include': b'include', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1567 b'subinclude': b'subinclude', |
40724
e41f6c2e69c4
match: reformat `syntaxes` dictionary for better maintainability
Boris Feld <boris.feld@octobus.net>
parents:
40723
diff
changeset
|
1568 } |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1569 syntax = b'relre:' |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1570 patterns = [] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1571 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1572 fp = open(filepath, b'rb') |
30409 | 1573 for lineno, line in enumerate(util.iterfile(fp), start=1): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1574 if b"#" in line: |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1575 global _commentre |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1576 if not _commentre: |
31429
40704098853f
match: make regular expression bytes to prevent TypeError
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31412
diff
changeset
|
1577 _commentre = util.re.compile(br'((?:^|[^\\])(?:\\\\)*)#.*') |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1578 # 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
|
1579 m = _commentre.search(line) |
d500341e4f55
match: use re2 in readpatternfile if possible
Bryan O'Sullivan <bos@serpentine.com>
parents:
26781
diff
changeset
|
1580 if m: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1581 line = line[: m.end(1)] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1582 # 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
|
1583 line = line.replace(b"\\#", b"#") |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1584 line = line.rstrip() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1585 if not line: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1586 continue |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1587 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1588 if line.startswith(b'syntax:'): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1589 s = line[7:].strip() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1590 try: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1591 syntax = syntaxes[s] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1592 except KeyError: |
25214
08703b10c3ae
match: add optional warn argument
Durham Goode <durham@fb.com>
parents:
25213
diff
changeset
|
1593 if warn: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1594 warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1595 _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1596 ) |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1597 continue |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1598 |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1599 linesyntax = syntax |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43085
diff
changeset
|
1600 for s, rels in pycompat.iteritems(syntaxes): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1601 if line.startswith(rels): |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1602 linesyntax = rels |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1603 line = line[len(rels) :] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1604 break |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1605 elif line.startswith(s + b':'): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1606 linesyntax = rels |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42870
diff
changeset
|
1607 line = line[len(s) + 1 :] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1608 break |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1609 if sourceinfo: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1610 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
|
1611 else: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
1612 patterns.append(linesyntax + line) |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1613 fp.close() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1614 return patterns |