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