Mercurial > public > mercurial-scm > hg-stable
annotate mercurial/match.py @ 32587:f44ea253ffe2
match: optimize visitdir() for when no explicit files are listed
In patternmatcher, we used to say that all directories should be
visited if no explicit files were listed, because the case of empty
_files usually implied that no patterns were given (which in turns
meant that everything should match). However, this made e.g. "hg files
-r . rootfilesin:." slower than necessary, because that also ended
up with an empty list in _files. Now that patternmatcher does not
handle includes, the only remaining case where its _files/_fileset
fields will be empty is when it's matching everything. We can
therefore treat the always-case specially and stop treating the empty
_files case specially. This makes the case mentioned above faster on
treemanifest repos.
author | Martin von Zweigbergk <martinvonz@google.com> |
---|---|
date | Sat, 20 May 2017 23:49:14 -0700 |
parents | 20c9f3ecc192 |
children | b3083be7dcb9 |
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 |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
8 from __future__ import absolute_import |
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 |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
11 import os |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
12 import re |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
13 |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
14 from .i18n import _ |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
15 from . import ( |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26014
diff
changeset
|
16 error, |
25958
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
17 pathutil, |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
18 util, |
c4ccf2d394a7
match: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25875
diff
changeset
|
19 ) |
6576 | 20 |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
21 propertycache = util.propertycache |
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
22 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
23 def _rematcher(regex): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
24 '''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
|
25 matcher function''' |
21909
335bb8b80443
match: use util.re.compile instead of util.compilere
Siddharth Agarwal <sid0@fb.com>
parents:
21815
diff
changeset
|
26 m = util.re.compile(regex) |
16943
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
27 try: |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
28 # 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
|
29 return m.test_match |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
30 except AttributeError: |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
31 return m.match |
8d08a28aa63e
matcher: use re2 bindings if available
Bryan O'Sullivan <bryano@fb.com>
parents:
16791
diff
changeset
|
32 |
25122
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
33 def _expandsets(kindpats, ctx, listsubrepos): |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
34 '''Returns the kindpats list with the 'set' patterns expanded.''' |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
35 fset = set() |
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
36 other = [] |
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
37 |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
38 for kind, pat, source in kindpats: |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
39 if kind == 'set': |
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
40 if not ctx: |
32482
57d6c0c74b1b
match: use ProgrammingError where appropriate
Martin von Zweigbergk <martinvonz@google.com>
parents:
32453
diff
changeset
|
41 raise error.ProgrammingError("fileset expression with no " |
57d6c0c74b1b
match: use ProgrammingError where appropriate
Martin von Zweigbergk <martinvonz@google.com>
parents:
32453
diff
changeset
|
42 "context") |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
43 s = ctx.getfileset(pat) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
44 fset.update(s) |
25122
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
45 |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
46 if listsubrepos: |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
47 for subpath in ctx.substate: |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
48 s = ctx.sub(subpath).getfileset(pat) |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
49 fset.update(subpath + '/' + f for f in s) |
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
50 |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
51 continue |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
52 other.append((kind, pat, source)) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
53 return fset, other |
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
54 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
55 def _expandsubinclude(kindpats, root): |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
56 '''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
|
57 subincludes in it.''' |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
58 relmatchers = [] |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
59 other = [] |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
60 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
61 for kind, pat, source in kindpats: |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
62 if kind == 'subinclude': |
25301
caaf4045eca8
match: normpath the ignore source when expanding the 'subinclude' kind
Matt Harbison <matt_harbison@yahoo.com>
parents:
25283
diff
changeset
|
63 sourceroot = pathutil.dirname(util.normpath(source)) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
64 pat = util.pconvert(pat) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
65 path = pathutil.join(sourceroot, pat) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
66 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
67 newroot = pathutil.dirname(path) |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
68 matcherargs = (newroot, '', [], ['include:%s' % path]) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
69 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
70 prefix = pathutil.canonpath(root, root, newroot) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
71 if prefix: |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
72 prefix += '/' |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
73 relmatchers.append((prefix, matcherargs)) |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
74 else: |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
75 other.append((kind, pat, source)) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
76 |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
77 return relmatchers, other |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
78 |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
79 def _kindpatsalwaysmatch(kindpats): |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
80 """"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
|
81 'relpath:.' does. |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
82 """ |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
83 for kind, pat, source in kindpats: |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
84 if pat != '' or kind not in ['relpath', 'glob']: |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
85 return False |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
86 return True |
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
87 |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
88 def match(root, cwd, patterns, include=None, exclude=None, default='glob', |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
89 exact=False, auditor=None, ctx=None, listsubrepos=False, warn=None, |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
90 badfn=None, icasefs=False): |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
91 """build an object to match a set of file patterns |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
92 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
93 arguments: |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
94 root - the canonical root of the tree you're matching against |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
95 cwd - the current working directory, if relevant |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
96 patterns - patterns to find |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
97 include - patterns to include (unless they are excluded) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
98 exclude - patterns to exclude (even if they are included) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
99 default - if a pattern in patterns has no explicit type, assume this one |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
100 exact - patterns are actually filenames (include/exclude still apply) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
101 warn - optional function used for printing warnings |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
102 badfn - optional bad() callback for this matcher instead of the default |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
103 icasefs - make a matcher for wdir on case insensitive filesystems, which |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
104 normalizes the given patterns to the case in the filesystem |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
105 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
106 a pattern is one of: |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
107 'glob:<glob>' - a glob relative to cwd |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
108 're:<regexp>' - a regular expression |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
109 'path:<path>' - a path relative to repository root, which is matched |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
110 recursively |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
111 'rootfilesin:<path>' - a path relative to repository root, which is |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
112 matched non-recursively (will not match subdirectories) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
113 'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
114 'relpath:<path>' - a path relative to cwd |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
115 'relre:<regexp>' - a regexp that needn't match the start of a name |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
116 'set:<fileset>' - a fileset expression |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
117 'include:<path>' - a file of patterns to read and include |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
118 'subinclude:<path>' - a file of patterns to match against files under |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
119 the same directory |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
120 '<something>' - a pattern of the specified default type |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
121 """ |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
122 normalize = _donormalize |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
123 if icasefs: |
32453
9695aca1a3a0
match: catch attempts to create case-insenstive exact matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32444
diff
changeset
|
124 if exact: |
32482
57d6c0c74b1b
match: use ProgrammingError where appropriate
Martin von Zweigbergk <martinvonz@google.com>
parents:
32453
diff
changeset
|
125 raise error.ProgrammingError("a case-insensitive exact matcher " |
57d6c0c74b1b
match: use ProgrammingError where appropriate
Martin von Zweigbergk <martinvonz@google.com>
parents:
32453
diff
changeset
|
126 "doesn't make sense") |
32439
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
127 dirstate = ctx.repo().dirstate |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
128 dsnormalize = dirstate.normalize |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
129 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
130 def normalize(patterns, default, root, cwd, auditor, warn): |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
131 kp = _donormalize(patterns, default, root, cwd, auditor, warn) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
132 kindpats = [] |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
133 for kind, pats, source in kp: |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
134 if kind not in ('re', 'relre'): # regex can't be normalized |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
135 p = pats |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
136 pats = dsnormalize(pats) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
137 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
138 # Preserve the original to handle a case only rename. |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
139 if p != pats and p in dirstate: |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
140 kindpats.append((kind, p, source)) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
141 |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
142 kindpats.append((kind, pats, source)) |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
143 return kindpats |
284b18303f61
match: replace icasefsmatch() function by flag to regular match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
32438
diff
changeset
|
144 |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
145 if exact: |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
146 m = exactmatcher(root, cwd, patterns, badfn) |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
147 elif patterns: |
32537
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
148 m = patternmatcher(root, cwd, normalize, patterns, default=default, |
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
149 auditor=auditor, ctx=ctx, listsubrepos=listsubrepos, |
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
150 warn=warn, badfn=badfn) |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
151 else: |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
152 # It's a little strange that no patterns means to match everything. |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
153 # Consider changing this to match nothing (probably adding a |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
154 # "nevermatcher"). |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
155 m = alwaysmatcher(root, cwd, badfn) |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
156 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
157 if include: |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
158 im = includematcher(root, cwd, normalize, include, auditor=auditor, |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
159 ctx=ctx, listsubrepos=listsubrepos, warn=warn, |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
160 badfn=None) |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
161 m = intersectmatchers(m, im) |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
162 if exclude: |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
163 em = includematcher(root, cwd, normalize, exclude, auditor=auditor, |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
164 ctx=ctx, listsubrepos=listsubrepos, warn=warn, |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
165 badfn=None) |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
166 m = differencematcher(m, em) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
167 return m |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
168 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
169 def exact(root, cwd, files, badfn=None): |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
170 return exactmatcher(root, cwd, files, badfn=badfn) |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
171 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
172 def always(root, cwd): |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
173 return alwaysmatcher(root, cwd) |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
174 |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
175 def badmatch(match, badfn): |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
176 """Make a copy of the given matcher, replacing its bad method with the given |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
177 one. |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
178 """ |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
179 m = copy.copy(match) |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
180 m.bad = badfn |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
181 return m |
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
182 |
32435
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
183 def _donormalize(patterns, default, root, cwd, auditor, warn): |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
184 '''Convert 'kind:pat' from the patterns list to tuples with kind and |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
185 normalized and rooted patterns and with listfiles expanded.''' |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
186 kindpats = [] |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
187 for kind, pat in [_patsplit(p, default) for p in patterns]: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
188 if kind in ('glob', 'relpath'): |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
189 pat = pathutil.canonpath(root, cwd, pat, auditor) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
190 elif kind in ('relglob', 'path', 'rootfilesin'): |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
191 pat = util.normpath(pat) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
192 elif kind in ('listfile', 'listfile0'): |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
193 try: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
194 files = util.readfile(pat) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
195 if kind == 'listfile0': |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
196 files = files.split('\0') |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
197 else: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
198 files = files.splitlines() |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
199 files = [f for f in files if f] |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
200 except EnvironmentError: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
201 raise error.Abort(_("unable to read file list (%s)") % pat) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
202 for k, p, source in _donormalize(files, default, root, cwd, |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
203 auditor, warn): |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
204 kindpats.append((k, p, pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
205 continue |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
206 elif kind == 'include': |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
207 try: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
208 fullpath = os.path.join(root, util.localpath(pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
209 includepats = readpatternfile(fullpath, warn) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
210 for k, p, source in _donormalize(includepats, default, |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
211 root, cwd, auditor, warn): |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
212 kindpats.append((k, p, source or pat)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
213 except error.Abort as inst: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
214 raise error.Abort('%s: %s' % (pat, inst[0])) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
215 except IOError as inst: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
216 if warn: |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
217 warn(_("skipping unreadable pattern file '%s': %s\n") % |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
218 (pat, inst.strerror)) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
219 continue |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
220 # else: re or relre - which cannot be normalized |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
221 kindpats.append((kind, pat, '')) |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
222 return kindpats |
0ec4cd6fe051
match: move body of _normalize() to a static function
Martin von Zweigbergk <martinvonz@google.com>
parents:
32434
diff
changeset
|
223 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
224 class basematcher(object): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
225 |
32529
ca77a243ffa7
match: move entire uipath() implementation to basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
226 def __init__(self, root, cwd, badfn=None, relativeuipath=True): |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
227 self._root = root |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
228 self._cwd = cwd |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
229 if badfn is not None: |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
230 self.bad = badfn |
32529
ca77a243ffa7
match: move entire uipath() implementation to basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
231 self._relativeuipath = relativeuipath |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
232 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
233 def __call__(self, fn): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
234 return self.matchfn(fn) |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
235 def __iter__(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
236 for f in self._files: |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
237 yield f |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
238 # Callbacks related to how the matcher is used by dirstate.walk. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
239 # Subscribers to these events must monkeypatch the matcher object. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
240 def bad(self, f, msg): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
241 '''Callback from dirstate.walk for each explicit file that can't be |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
242 found/accessed, with an error message.''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
243 pass |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
244 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
245 # If an explicitdir is set, it will be called when an explicitly listed |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
246 # directory is visited. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
247 explicitdir = None |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
248 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
249 # If an traversedir is set, it will be called when a directory discovered |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
250 # by recursive traversal is visited. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
251 traversedir = None |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
252 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
253 def abs(self, f): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
254 '''Convert a repo path back to path that is relative to the root of the |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
255 matcher.''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
256 return f |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
257 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
258 def rel(self, f): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
259 '''Convert repo path back to path that is relative to cwd of matcher.''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
260 return util.pathto(self._root, self._cwd, f) |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
261 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
262 def uipath(self, f): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
263 '''Convert repo path to a display path. If patterns or -I/-X were used |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
264 to create this matcher, the display path will be relative to cwd. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
265 Otherwise it is relative to the root of the repo.''' |
32529
ca77a243ffa7
match: move entire uipath() implementation to basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32500
diff
changeset
|
266 return (self._relativeuipath and self.rel(f)) or self.abs(f) |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
267 |
32493
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
268 @propertycache |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
269 def _files(self): |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
270 return [] |
9f781f43f2ce
match: make basematcher._files a @propertycache
Martin von Zweigbergk <martinvonz@google.com>
parents:
32492
diff
changeset
|
271 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
272 def files(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
273 '''Explicitly listed files or patterns or roots: |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
274 if no patterns or .always(): empty list, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
275 if exact: list exact files, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
276 if not .anypats(): list all files and dirs, |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
277 else: optimal roots''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
278 return self._files |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
279 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
280 @propertycache |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
281 def _fileset(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
282 return set(self._files) |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
283 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
284 def exact(self, f): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
285 '''Returns True if f is in .files().''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
286 return f in self._fileset |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
287 |
32497
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32495
diff
changeset
|
288 def matchfn(self, f): |
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32495
diff
changeset
|
289 return False |
43e091847c4d
match: make matchfn a method on the class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32495
diff
changeset
|
290 |
32492
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
291 def visitdir(self, dir): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
292 '''Decides whether a directory should be visited based on whether it |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
293 has potential matches in it or one of its subdirectories. This is |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
294 based on the match's primary, included, and excluded patterns. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
295 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
296 Returns the string 'all' if the given directory and all subdirectories |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
297 should be visited. Otherwise returns True or False indicating whether |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
298 the given directory should be visited. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
299 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
300 This function's behavior is undefined if it has returned False for |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
301 one of the dir's parent directories. |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
302 ''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
303 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
304 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
305 def anypats(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
306 '''Matcher uses patterns or include/exclude.''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
307 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
308 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
309 def always(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
310 '''Matcher will match everything and .files() will be empty |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
311 - optimization might be possible and necessary.''' |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
312 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
313 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
314 def isexact(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
315 return False |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
316 |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
317 def prefix(self): |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
318 return not self.always() and not self.isexact() and not self.anypats() |
a04bc55201c3
match: extract base class for matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32482
diff
changeset
|
319 |
32586
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
320 class alwaysmatcher(basematcher): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
321 '''Matches everything.''' |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
322 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
323 def __init__(self, root, cwd, badfn=None): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
324 super(alwaysmatcher, self).__init__(root, cwd, badfn, |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
325 relativeuipath=False) |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
326 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
327 def always(self): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
328 return True |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
329 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
330 def matchfn(self, f): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
331 return True |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
332 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
333 def visitdir(self, dir): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
334 return 'all' |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
335 |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
336 def __repr__(self): |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
337 return '<alwaysmatcher>' |
20c9f3ecc192
match: handle everything-matching using new alwaysmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32585
diff
changeset
|
338 |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
339 class patternmatcher(basematcher): |
32433
24245b54aa8a
match: replace match class by match function (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32365
diff
changeset
|
340 |
32537
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
341 def __init__(self, root, cwd, normalize, patterns, default='glob', |
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
342 auditor=None, ctx=None, listsubrepos=False, warn=None, |
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
343 badfn=None): |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
344 super(patternmatcher, self).__init__(root, cwd, badfn, |
32537
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
345 relativeuipath=bool(patterns)) |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
346 |
32537
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
347 self._anypats = False |
18713
8728579f6bdc
match: more accurately report when we're always going to match
Bryan O'Sullivan <bryano@fb.com>
parents:
17425
diff
changeset
|
348 self._always = False |
32444
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32439
diff
changeset
|
349 self.patternspat = None |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
350 |
22513
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
351 matchfns = [] |
32533
369c2d5eeea3
match: remove support for exact matching from main matcher class
Martin von Zweigbergk <martinvonz@google.com>
parents:
32532
diff
changeset
|
352 if patterns: |
32437
1c1f7c946666
match: pass in normalize() function to matchers
Martin von Zweigbergk <martinvonz@google.com>
parents:
32436
diff
changeset
|
353 kindpats = normalize(patterns, default, root, cwd, auditor, warn) |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
354 if not _kindpatsalwaysmatch(kindpats): |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
355 self._files = _explicitfiles(kindpats) |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
356 self._anypats = self._anypats or _anypats(kindpats) |
25122
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
357 self.patternspat, pm = _buildmatch(ctx, kindpats, '$', |
25238
5a55ad6e8e24
match: add root to _buildmatch
Durham Goode <durham@fb.com>
parents:
25233
diff
changeset
|
358 listsubrepos, root) |
24447
d44d53bc9a1e
matcher: make e.g. 'relpath:.' lead to fast paths
Martin von Zweigbergk <martinvonz@google.com>
parents:
23686
diff
changeset
|
359 matchfns.append(pm) |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
360 |
22513
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
361 if not matchfns: |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
362 m = util.always |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
363 self._always = True |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
364 elif len(matchfns) == 1: |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
365 m = matchfns[0] |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
366 else: |
22513
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
367 def m(f): |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
368 for matchfn in matchfns: |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
369 if not matchfn(f): |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
370 return False |
ca709785caf2
match: simplify brittle predicate construction
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
21915
diff
changeset
|
371 return True |
8581
101d305c1d0b
match: fold _matcher into match.__init__
Matt Mackall <mpm@selenic.com>
parents:
8580
diff
changeset
|
372 |
8587
8f15d54437b9
match: fold match into _match base class
Matt Mackall <mpm@selenic.com>
parents:
8586
diff
changeset
|
373 self.matchfn = m |
8f15d54437b9
match: fold match into _match base class
Matt Mackall <mpm@selenic.com>
parents:
8586
diff
changeset
|
374 |
32362
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32352
diff
changeset
|
375 @propertycache |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
376 def _dirs(self): |
32362
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32352
diff
changeset
|
377 return set(util.dirs(self._fileset)) | {'.'} |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
378 |
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
379 def visitdir(self, dir): |
32587
f44ea253ffe2
match: optimize visitdir() for when no explicit files are listed
Martin von Zweigbergk <martinvonz@google.com>
parents:
32586
diff
changeset
|
380 if self.always(): |
f44ea253ffe2
match: optimize visitdir() for when no explicit files are listed
Martin von Zweigbergk <martinvonz@google.com>
parents:
32586
diff
changeset
|
381 return 'all' |
32362
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32352
diff
changeset
|
382 if self.prefix() and dir in self._fileset: |
27343
c59647c6694d
treemanifest: don't iterate entire matching submanifests on match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
27327
diff
changeset
|
383 return 'all' |
32587
f44ea253ffe2
match: optimize visitdir() for when no explicit files are listed
Martin von Zweigbergk <martinvonz@google.com>
parents:
32586
diff
changeset
|
384 return ('.' in self._fileset or |
32362
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32352
diff
changeset
|
385 dir in self._fileset or |
25576
d02f4b3e71f5
match: break boolean expressions into one operand per line
Martin von Zweigbergk <martinvonz@google.com>
parents:
25575
diff
changeset
|
386 dir in self._dirs or |
32362
23c9a2a71c6e
match: make _fileroots a @propertycache and rename it to _fileset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32352
diff
changeset
|
387 any(parentdir in self._fileset |
25577
a410479c7ee7
match: drop optimization (?) of 'parentdirs' calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
25576
diff
changeset
|
388 for parentdir in util.finddirs(dir))) |
24636
36872036169b
treemanifest: further optimize treemanifest.matches()
Drew Gottlieb <drgott@google.com>
parents:
24452
diff
changeset
|
389 |
8587
8f15d54437b9
match: fold match into _match base class
Matt Mackall <mpm@selenic.com>
parents:
8586
diff
changeset
|
390 def anypats(self): |
8f15d54437b9
match: fold match into _match base class
Matt Mackall <mpm@selenic.com>
parents:
8586
diff
changeset
|
391 return self._anypats |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
392 |
16645
9a21fc2c7d32
localrepo: optimize internode status calls using match.always
Jesse Glick <jesse.glick@oracle.com>
parents:
16182
diff
changeset
|
393 def always(self): |
18713
8728579f6bdc
match: more accurately report when we're always going to match
Bryan O'Sullivan <bryano@fb.com>
parents:
17425
diff
changeset
|
394 return self._always |
8568 | 395 |
32444
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32439
diff
changeset
|
396 def __repr__(self): |
32537
2ba4d3b74ba8
match: remove support for includes from patternmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32536
diff
changeset
|
397 return ('<patternmatcher patterns=%r>' % self.patternspat) |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
398 |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
399 class includematcher(basematcher): |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
400 |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
401 def __init__(self, root, cwd, normalize, include, auditor=None, ctx=None, |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
402 listsubrepos=False, warn=None, badfn=None): |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
403 super(includematcher, self).__init__(root, cwd, badfn) |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
404 |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
405 kindpats = normalize(include, 'glob', root, cwd, auditor, warn) |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
406 self.includepat, im = _buildmatch(ctx, kindpats, '(?:/|$)', |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
407 listsubrepos, root) |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
408 self._anypats = _anypats(kindpats) |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
409 roots, dirs = _rootsanddirs(kindpats) |
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
410 # roots are directories which are recursively included. |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
411 self._roots = set(roots) |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
412 # dirs are directories which are non-recursively included. |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
413 self._dirs = set(dirs) |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
414 self.matchfn = im |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
415 |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
416 def visitdir(self, dir): |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
417 if not self._anypats and dir in self._roots: |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
418 # The condition above is essentially self.prefix() for includes |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
419 return 'all' |
32536
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
420 return ('.' in self._roots or |
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
421 dir in self._roots or |
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
422 dir in self._dirs or |
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
423 any(parentdir in self._roots |
361808a2b0b8
match: simplify includematcher a bit
Martin von Zweigbergk <martinvonz@google.com>
parents:
32535
diff
changeset
|
424 for parentdir in util.finddirs(dir))) |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
425 |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
426 def anypats(self): |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
427 return True |
32534
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
428 |
7095dbc266e3
match: split up main matcher into patternmatcher and includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32533
diff
changeset
|
429 def __repr__(self): |
32535
3026f19b4b01
match: remove support for non-include patterns from includematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32534
diff
changeset
|
430 return ('<includematcher includes=%r>' % self.includepat) |
32444
952017471f93
match: implement __repr__() and update users (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
32439
diff
changeset
|
431 |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
432 class exactmatcher(basematcher): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
433 '''Matches the input files exactly. They are interpreted as paths, not |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
434 patterns (so no kind-prefixes). |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
435 ''' |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
436 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
437 def __init__(self, root, cwd, files, badfn=None): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
438 super(exactmatcher, self).__init__(root, cwd, badfn) |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
439 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
440 if isinstance(files, list): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
441 self._files = files |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
442 else: |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
443 self._files = list(files) |
32576
cf7c88986e9f
match: define exactmatcher.matchfn statically
Yuya Nishihara <yuya@tcha.org>
parents:
32575
diff
changeset
|
444 |
cf7c88986e9f
match: define exactmatcher.matchfn statically
Yuya Nishihara <yuya@tcha.org>
parents:
32575
diff
changeset
|
445 matchfn = basematcher.exact |
32532
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
446 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
447 @propertycache |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
448 def _dirs(self): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
449 return set(util.dirs(self._fileset)) | {'.'} |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
450 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
451 def visitdir(self, dir): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
452 return dir in self._dirs |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
453 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
454 def isexact(self): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
455 return True |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
456 |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
457 def __repr__(self): |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
458 return ('<exactmatcher files=%r>' % self._files) |
a3583852861a
match: handle exact matching using new exactmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32530
diff
changeset
|
459 |
32499
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
460 class differencematcher(basematcher): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
461 '''Composes two matchers by matching if the first matches and the second |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
462 does not. Well, almost... If the user provides a pattern like "-X foo foo", |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
463 Mercurial actually does match "foo" against that. That's because exact |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
464 matches are treated specially. So, since this differencematcher is used for |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
465 excludes, it needs to special-case exact matching. |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
466 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
467 The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
468 traversedir) are ignored. |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
469 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
470 TODO: If we want to keep the behavior described above for exact matches, we |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
471 should consider instead treating the above case something like this: |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
472 union(exact(foo), difference(pattern(foo), include(foo))) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
473 ''' |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
474 def __init__(self, m1, m2): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
475 super(differencematcher, self).__init__(m1._root, m1._cwd) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
476 self._m1 = m1 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
477 self._m2 = m2 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
478 self.bad = m1.bad |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
479 self.explicitdir = m1.explicitdir |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
480 self.traversedir = m1.traversedir |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
481 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
482 def matchfn(self, f): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
483 return self._m1(f) and (not self._m2(f) or self._m1.exact(f)) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
484 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
485 @propertycache |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
486 def _files(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
487 if self.isexact(): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
488 return [f for f in self._m1.files() if self(f)] |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
489 # If m1 is not an exact matcher, we can't easily figure out the set of |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
490 # files, because its files() are not always files. For example, if |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
491 # m1 is "path:dir" and m2 is "rootfileins:.", we don't |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
492 # want to remove "dir" from the set even though it would match m2, |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
493 # because the "dir" in m1 may not be a file. |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
494 return self._m1.files() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
495 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
496 def visitdir(self, dir): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
497 if self._m2.visitdir(dir) == 'all': |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
498 # There's a bug here: If m1 matches file 'dir/file' and m2 excludes |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
499 # 'dir' (recursively), we should still visit 'dir' due to the |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
500 # exception we have for exact matches. |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
501 return False |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
502 return bool(self._m1.visitdir(dir)) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
503 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
504 def isexact(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
505 return self._m1.isexact() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
506 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
507 def anypats(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
508 return self._m1.anypats() or self._m2.anypats() |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
509 |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
510 def __repr__(self): |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
511 return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)) |
a83a7d27911e
match: handle excludes using new differencematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32498
diff
changeset
|
512 |
32530
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
513 def intersectmatchers(m1, m2): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
514 '''Composes two matchers by matching if both of them match. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
515 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
516 The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
517 traversedir) are ignored. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
518 ''' |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
519 if m1 is None or m2 is None: |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
520 return m1 or m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
521 if m1.always(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
522 m = copy.copy(m2) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
523 # TODO: Consider encapsulating these things in a class so there's only |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
524 # one thing to copy from m1. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
525 m.bad = m1.bad |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
526 m.explicitdir = m1.explicitdir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
527 m.traversedir = m1.traversedir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
528 m.abs = m1.abs |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
529 m.rel = m1.rel |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
530 m._relativeuipath |= m1._relativeuipath |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
531 return m |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
532 if m2.always(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
533 m = copy.copy(m1) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
534 m._relativeuipath |= m2._relativeuipath |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
535 return m |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
536 return intersectionmatcher(m1, m2) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
537 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
538 class intersectionmatcher(basematcher): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
539 def __init__(self, m1, m2): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
540 super(intersectionmatcher, self).__init__(m1._root, m1._cwd) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
541 self._m1 = m1 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
542 self._m2 = m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
543 self.bad = m1.bad |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
544 self.explicitdir = m1.explicitdir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
545 self.traversedir = m1.traversedir |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
546 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
547 @propertycache |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
548 def _files(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
549 if self.isexact(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
550 m1, m2 = self._m1, self._m2 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
551 if not m1.isexact(): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
552 m1, m2 = m2, m1 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
553 return [f for f in m1.files() if m2(f)] |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
554 # It neither m1 nor m2 is an exact matcher, we can't easily intersect |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
555 # the set of files, because their files() are not always files. For |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
556 # example, if intersecting a matcher "-I glob:foo.txt" with matcher of |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
557 # "path:dir2", we don't want to remove "dir2" from the set. |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
558 return self._m1.files() + self._m2.files() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
559 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
560 def matchfn(self, f): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
561 return self._m1(f) and self._m2(f) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
562 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
563 def visitdir(self, dir): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
564 visit1 = self._m1.visitdir(dir) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
565 if visit1 == 'all': |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
566 return self._m2.visitdir(dir) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
567 # bool() because visit1=True + visit2='all' should not be 'all' |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
568 return bool(visit1 and self._m2.visitdir(dir)) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
569 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
570 def always(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
571 return self._m1.always() and self._m2.always() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
572 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
573 def isexact(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
574 return self._m1.isexact() or self._m2.isexact() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
575 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
576 def anypats(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
577 return self._m1.anypats() or self._m2.anypats() |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
578 |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
579 def __repr__(self): |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
580 return ('<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2)) |
9eccd559c592
match: handle includes using new intersectionmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32529
diff
changeset
|
581 |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
582 class subdirmatcher(basematcher): |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
583 """Adapt a matcher to work on a subdirectory only. |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
584 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
585 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
|
586 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
587 >>> m1 = match('root', '', ['a.txt', 'sub/b.txt']) |
28017
d3f1b7ee5e70
match: rename "narrowmatcher" to "subdirmatcher" (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
27595
diff
changeset
|
588 >>> m2 = subdirmatcher('sub', m1) |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
589 >>> bool(m2('a.txt')) |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
590 False |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
591 >>> bool(m2('b.txt')) |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
592 True |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
593 >>> bool(m2.matchfn('a.txt')) |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
594 False |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
595 >>> bool(m2.matchfn('b.txt')) |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
596 True |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
597 >>> m2.files() |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
598 ['b.txt'] |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
599 >>> m2.exact('b.txt') |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
600 True |
23686
164915e8ef7b
narrowmatcher: propagate the rel() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23685
diff
changeset
|
601 >>> util.pconvert(m2.rel('b.txt')) |
164915e8ef7b
narrowmatcher: propagate the rel() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23685
diff
changeset
|
602 'sub/b.txt' |
12268
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
603 >>> def bad(f, msg): |
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
604 ... print "%s: %s" % (f, msg) |
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
605 >>> m1.bad = bad |
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
606 >>> m2.bad('x.txt', 'No such file') |
83aaeba32b88
narrowmatcher: propagate bad method
Martin Geisler <mg@lazybytes.net>
parents:
12267
diff
changeset
|
607 sub/x.txt: No such file |
23685
5b1eac343ccd
match: add the abs() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23549
diff
changeset
|
608 >>> m2.abs('c.txt') |
5b1eac343ccd
match: add the abs() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23549
diff
changeset
|
609 'sub/c.txt' |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
610 """ |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
611 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
612 def __init__(self, path, matcher): |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
613 super(subdirmatcher, self).__init__(matcher._root, matcher._cwd) |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
614 self._path = path |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
615 self._matcher = matcher |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
616 self._always = matcher.always() |
12165
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
617 |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
618 self._files = [f[len(path) + 1:] for f in matcher._files |
b7fbf24c8a93
match: add narrowmatcher class
Martin Geisler <mg@lazybytes.net>
parents:
12163
diff
changeset
|
619 if f.startswith(path + "/")] |
25194
ef4538ba67ef
match: explicitly naming a subrepo implies always() for the submatcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
24790
diff
changeset
|
620 |
32365
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32364
diff
changeset
|
621 # If the parent repo had a path to this subrepo and the matcher is |
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32364
diff
changeset
|
622 # a prefix matcher, this submatcher always matches. |
763d72925691
match: use match.prefix() in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32364
diff
changeset
|
623 if matcher.prefix(): |
25195 | 624 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
|
625 |
32364
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
626 def bad(self, f, msg): |
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
627 self._matcher.bad(self._path + "/" + f, msg) |
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
628 |
23685
5b1eac343ccd
match: add the abs() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23549
diff
changeset
|
629 def abs(self, f): |
5b1eac343ccd
match: add the abs() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23549
diff
changeset
|
630 return self._matcher.abs(self._path + "/" + f) |
5b1eac343ccd
match: add the abs() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23549
diff
changeset
|
631 |
23686
164915e8ef7b
narrowmatcher: propagate the rel() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23685
diff
changeset
|
632 def rel(self, f): |
164915e8ef7b
narrowmatcher: propagate the rel() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23685
diff
changeset
|
633 return self._matcher.rel(self._path + "/" + f) |
164915e8ef7b
narrowmatcher: propagate the rel() method
Matt Harbison <matt_harbison@yahoo.com>
parents:
23685
diff
changeset
|
634 |
32364
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
635 def uipath(self, f): |
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
636 return self._matcher.uipath(self._path + "/" + f) |
77dac8fd30ee
match: avoid accessing match._pathrestricted from subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32363
diff
changeset
|
637 |
32498
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
638 def matchfn(self, f): |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
639 # Some information is lost in the superclass's constructor, so we |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
640 # can not accurately create the matching function for the subdirectory |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
641 # from the inputs. Instead, we override matchfn() and visitdir() to |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
642 # call the original matcher with the subdirectory path prepended. |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
643 return self._matcher.matchfn(self._path + "/" + f) |
2e80a691e575
match: override matchfn() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32497
diff
changeset
|
644 |
32363
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
645 def visitdir(self, dir): |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
646 if dir == '.': |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
647 dir = self._path |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
648 else: |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
649 dir = self._path + "/" + dir |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
650 return self._matcher.visitdir(dir) |
0aa4032a97e1
match: override visitdir() the usual way in subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32362
diff
changeset
|
651 |
32494
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
652 def always(self): |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
653 return self._always |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
654 |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
655 def anypats(self): |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
656 return self._matcher.anypats() |
f9445b528687
match: make subdirmatcher extend basematcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32493
diff
changeset
|
657 |
32585
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32576
diff
changeset
|
658 def __repr__(self): |
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32576
diff
changeset
|
659 return ('<subdirmatcher path=%r, matcher=%r>' % |
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32576
diff
changeset
|
660 (self._path, self._matcher)) |
e7aa11f3abcd
match: add __repr__ for subdirmatcher
Martin von Zweigbergk <martinvonz@google.com>
parents:
32576
diff
changeset
|
661 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
662 def patkind(pattern, default=None): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
663 '''If pattern is 'kind:pat' with a known kind, return kind.''' |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
664 return _patsplit(pattern, default)[0] |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
665 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
666 def _patsplit(pattern, default): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
667 """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
|
668 pattern.""" |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
669 if ':' in pattern: |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
670 kind, pat = pattern.split(':', 1) |
13218
1f4721de2ca9
match: support reading pattern lists from files
Steve Borho <steve@borho.org>
parents:
12268
diff
changeset
|
671 if kind in ('re', 'glob', 'path', 'relglob', 'relpath', 'relre', |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
672 'listfile', 'listfile0', 'set', 'include', 'subinclude', |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
673 'rootfilesin'): |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
674 return kind, pat |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
675 return default, pattern |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
676 |
8582
a4c199e12b5a
match: remove head and tail args from _globre
Matt Mackall <mpm@selenic.com>
parents:
8581
diff
changeset
|
677 def _globre(pat): |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
678 r'''Convert an extended glob string to a regexp string. |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
679 |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
680 >>> print _globre(r'?') |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
681 . |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
682 >>> print _globre(r'*') |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
683 [^/]* |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
684 >>> print _globre(r'**') |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
685 .* |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
686 >>> print _globre(r'**/a') |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
687 (?:.*/)?a |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
688 >>> print _globre(r'a/**/b') |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
689 a\/(?:.*/)?b |
21112
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
690 >>> print _globre(r'[a*?!^][^b][!c]') |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
691 [a*?!^][\^b][^c] |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
692 >>> print _globre(r'{a,b}') |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
693 (?:a|b) |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
694 >>> print _globre(r'.\*\?') |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
695 \.\*\? |
03782d2fc776
match: _globre doctests
Mads Kiilerich <madski@unity3d.com>
parents:
21111
diff
changeset
|
696 ''' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
697 i, n = 0, len(pat) |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
698 res = '' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
699 group = 0 |
21915
d516b6de3821
match: use util.re.escape instead of re.escape
Siddharth Agarwal <sid0@fb.com>
parents:
21909
diff
changeset
|
700 escape = util.re.escape |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
701 def peek(): |
31430
5c9cda37d7f6
match: slice over bytes to get the byteschr instead of ascii value
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31429
diff
changeset
|
702 return i < n and pat[i:i + 1] |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
703 while i < n: |
31430
5c9cda37d7f6
match: slice over bytes to get the byteschr instead of ascii value
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31429
diff
changeset
|
704 c = pat[i:i + 1] |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
705 i += 1 |
8583
19d1b2aec562
match: optimize escaping in _globre
Matt Mackall <mpm@selenic.com>
parents:
8582
diff
changeset
|
706 if c not in '*?[{},\\': |
19d1b2aec562
match: optimize escaping in _globre
Matt Mackall <mpm@selenic.com>
parents:
8582
diff
changeset
|
707 res += escape(c) |
19d1b2aec562
match: optimize escaping in _globre
Matt Mackall <mpm@selenic.com>
parents:
8582
diff
changeset
|
708 elif c == '*': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
709 if peek() == '*': |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
710 i += 1 |
21815
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
711 if peek() == '/': |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
712 i += 1 |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
713 res += '(?:.*/)?' |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
714 else: |
a4b67bf1f0a5
match: make glob '**/' match the empty string
Siddharth Agarwal <sid0@fb.com>
parents:
21191
diff
changeset
|
715 res += '.*' |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
716 else: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
717 res += '[^/]*' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
718 elif c == '?': |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
719 res += '.' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
720 elif c == '[': |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
721 j = i |
31430
5c9cda37d7f6
match: slice over bytes to get the byteschr instead of ascii value
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31429
diff
changeset
|
722 if j < n and pat[j:j + 1] in '!]': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
723 j += 1 |
31430
5c9cda37d7f6
match: slice over bytes to get the byteschr instead of ascii value
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31429
diff
changeset
|
724 while j < n and pat[j:j + 1] != ']': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
725 j += 1 |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
726 if j >= n: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
727 res += '\\[' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
728 else: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
729 stuff = pat[i:j].replace('\\','\\\\') |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
730 i = j + 1 |
31430
5c9cda37d7f6
match: slice over bytes to get the byteschr instead of ascii value
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31429
diff
changeset
|
731 if stuff[0:1] == '!': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
732 stuff = '^' + stuff[1:] |
31430
5c9cda37d7f6
match: slice over bytes to get the byteschr instead of ascii value
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31429
diff
changeset
|
733 elif stuff[0:1] == '^': |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
734 stuff = '\\' + stuff |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
735 res = '%s[%s]' % (res, stuff) |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
736 elif c == '{': |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
737 group += 1 |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
738 res += '(?:' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
739 elif c == '}' and group: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
740 res += ')' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
741 group -= 1 |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
742 elif c == ',' and group: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
743 res += '|' |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
744 elif c == '\\': |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
745 p = peek() |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
746 if p: |
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
747 i += 1 |
8583
19d1b2aec562
match: optimize escaping in _globre
Matt Mackall <mpm@selenic.com>
parents:
8582
diff
changeset
|
748 res += escape(p) |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
749 else: |
8583
19d1b2aec562
match: optimize escaping in _globre
Matt Mackall <mpm@selenic.com>
parents:
8582
diff
changeset
|
750 res += escape(c) |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
751 else: |
8583
19d1b2aec562
match: optimize escaping in _globre
Matt Mackall <mpm@selenic.com>
parents:
8582
diff
changeset
|
752 res += escape(c) |
8582
a4c199e12b5a
match: remove head and tail args from _globre
Matt Mackall <mpm@selenic.com>
parents:
8581
diff
changeset
|
753 return res |
8570
7fe2012b3bd0
match: move util match functions over
Matt Mackall <mpm@selenic.com>
parents:
8568
diff
changeset
|
754 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
755 def _regex(kind, pat, globsuffix): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
756 '''Convert a (normalized) pattern of any kind into a regular expression. |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
757 globsuffix is appended to the regexp of globs.''' |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
758 if not pat: |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
759 return '' |
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
760 if kind == 're': |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
761 return pat |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
762 if kind == 'path': |
25636
bfe9ed85f27c
match: let 'path:.' and 'path:' match everything (issue4687)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25194
diff
changeset
|
763 if pat == '.': |
bfe9ed85f27c
match: let 'path:.' and 'path:' match everything (issue4687)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25194
diff
changeset
|
764 return '' |
21915
d516b6de3821
match: use util.re.escape instead of re.escape
Siddharth Agarwal <sid0@fb.com>
parents:
21909
diff
changeset
|
765 return '^' + util.re.escape(pat) + '(?:/|$)' |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
766 if kind == 'rootfilesin': |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
767 if pat == '.': |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
768 escaped = '' |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
769 else: |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
770 # Pattern is a directory name. |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
771 escaped = util.re.escape(pat) + '/' |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
772 # Anything after the pattern must be a non-directory. |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
773 return '^' + escaped + '[^/]+$' |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
774 if kind == 'relglob': |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
775 return '(?:|.*/)' + _globre(pat) + globsuffix |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
776 if kind == 'relpath': |
21915
d516b6de3821
match: use util.re.escape instead of re.escape
Siddharth Agarwal <sid0@fb.com>
parents:
21909
diff
changeset
|
777 return util.re.escape(pat) + '(?:/|$)' |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
778 if kind == 'relre': |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
779 if pat.startswith('^'): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
780 return pat |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
781 return '.*' + pat |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
782 return _globre(pat) + globsuffix |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
783 |
25238
5a55ad6e8e24
match: add root to _buildmatch
Durham Goode <durham@fb.com>
parents:
25233
diff
changeset
|
784 def _buildmatch(ctx, kindpats, globsuffix, listsubrepos, root): |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
785 '''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
|
786 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
|
787 matchfuncs = [] |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
788 |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
789 subincludes, kindpats = _expandsubinclude(kindpats, root) |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
790 if subincludes: |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
791 submatchers = {} |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
792 def matchsubinclude(f): |
32185
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
793 for prefix, matcherargs in subincludes: |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
794 if f.startswith(prefix): |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
795 mf = submatchers.get(prefix) |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
796 if mf is None: |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
797 mf = match(*matcherargs) |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
798 submatchers[prefix] = mf |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
799 |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
800 if mf(f[len(prefix):]): |
6dea1701f170
match: make subinclude construction lazy
Durham Goode <durham@fb.com>
parents:
31442
diff
changeset
|
801 return True |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
802 return False |
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
803 matchfuncs.append(matchsubinclude) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
804 |
25122
755d23a49170
match: resolve filesets in subrepos for commands given the '-S' argument
Matt Harbison <matt_harbison@yahoo.com>
parents:
25114
diff
changeset
|
805 fset, kindpats = _expandsets(kindpats, ctx, listsubrepos) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
806 if fset: |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
807 matchfuncs.append(fset.__contains__) |
14675
cfc89398f710
match: introduce basic fileset support
Matt Mackall <mpm@selenic.com>
parents:
14674
diff
changeset
|
808 |
25239
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
809 regex = '' |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
810 if kindpats: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
811 regex, mf = _buildregexmatch(kindpats, globsuffix) |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
812 matchfuncs.append(mf) |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
813 |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
814 if len(matchfuncs) == 1: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
815 return regex, matchfuncs[0] |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
816 else: |
714f612f2afc
match: allow unioning arbitrary match functions
Durham Goode <durham@fb.com>
parents:
25238
diff
changeset
|
817 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
|
818 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
819 def _buildregexmatch(kindpats, globsuffix): |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
820 """Build a match function from a list of kinds and kindpats, |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
821 return regexp string and a matcher function.""" |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
822 try: |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
823 regex = '(?:%s)' % '|'.join([_regex(k, p, globsuffix) |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
824 for (k, p, s) in kindpats]) |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
825 if len(regex) > 20000: |
16687
e34106fa0dc3
cleanup: "raise SomeException()" -> "raise SomeException"
Brodie Rao <brodie@sf.io>
parents:
16645
diff
changeset
|
826 raise OverflowError |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
827 return regex, _rematcher(regex) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
828 except OverflowError: |
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
829 # We're using a Python with a tiny regex engine and we |
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
830 # made it explode, so we'll divide the pattern list in two |
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
831 # until it works |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
832 l = len(kindpats) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
833 if l < 2: |
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
834 raise |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
835 regexa, a = _buildregexmatch(kindpats[:l//2], globsuffix) |
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
836 regexb, b = _buildregexmatch(kindpats[l//2:], globsuffix) |
21191
a2f4ea82d6d3
match: fix NameError 'pat' on overflow of regex pattern length
Yuya Nishihara <yuya@tcha.org>
parents:
21113
diff
changeset
|
837 return regex, lambda s: a(s) or b(s) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
838 except re.error: |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
839 for k, p, s in kindpats: |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
840 try: |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
841 _rematcher('(?:%s)' % _regex(k, p, globsuffix)) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
842 except re.error: |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
843 if s: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26014
diff
changeset
|
844 raise error.Abort(_("%s: invalid pattern (%s): %s") % |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
845 (s, k, p)) |
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
846 else: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26014
diff
changeset
|
847 raise error.Abort(_("invalid pattern (%s): %s") % (k, p)) |
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26014
diff
changeset
|
848 raise error.Abort(_("invalid pattern")) |
8574
63a7ed2128d5
match: unnest functions in _matcher
Matt Mackall <mpm@selenic.com>
parents:
8573
diff
changeset
|
849 |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
850 def _patternrootsanddirs(kindpats): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
851 '''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
|
852 |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
853 This calculates the roots and directories exactly matching the patterns and |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
854 returns a tuple of (roots, dirs) for each. It does not return other |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
855 directories which may also need to be considered, like the parent |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
856 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
|
857 ''' |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
858 r = [] |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
859 d = [] |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
860 for kind, pat, source in kindpats: |
8584
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
861 if kind == 'glob': # find the non-glob prefix |
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
862 root = [] |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
863 for p in pat.split('/'): |
8584
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
864 if '[' in p or '{' in p or '*' in p or '?' in p: |
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
865 break |
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
866 root.append(p) |
0f06e72abfdc
match: fold _globprefix into _roots
Matt Mackall <mpm@selenic.com>
parents:
8583
diff
changeset
|
867 r.append('/'.join(root) or '.') |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
868 elif kind in ('relpath', 'path'): |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
869 r.append(pat or '.') |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
870 elif kind in ('rootfilesin',): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
871 d.append(pat or '.') |
19107
fcf08023c011
match: fix root calculation for combining regexps with simple paths
Mads Kiilerich <madski@unity3d.com>
parents:
18713
diff
changeset
|
872 else: # relglob, re, relre |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
873 r.append('.') |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
874 return r, d |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
875 |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
876 def _roots(kindpats): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
877 '''Returns root directories to match recursively from the given patterns.''' |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
878 roots, dirs = _patternrootsanddirs(kindpats) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
879 return roots |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
880 |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
881 def _rootsanddirs(kindpats): |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
882 '''Returns roots and exact directories from patterns. |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
883 |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
884 roots are directories to match recursively, whereas exact directories should |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
885 be matched non-recursively. The returned (roots, dirs) tuple will also |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
886 include directories that need to be implicitly considered as either, such as |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
887 parent directories. |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
888 |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
889 >>> _rootsanddirs(\ |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
890 [('glob', 'g/h/*', ''), ('glob', 'g/h', ''), ('glob', 'g*', '')]) |
32225
cf042543afa2
match: optimize visitdir() for patterns matching only root directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
32185
diff
changeset
|
891 (['g/h', 'g/h', '.'], ['g', '.']) |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
892 >>> _rootsanddirs(\ |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
893 [('rootfilesin', 'g/h', ''), ('rootfilesin', '', '')]) |
32225
cf042543afa2
match: optimize visitdir() for patterns matching only root directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
32185
diff
changeset
|
894 ([], ['g/h', '.', 'g', '.']) |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
895 >>> _rootsanddirs(\ |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
896 [('relpath', 'r', ''), ('path', 'p/p', ''), ('path', '', '')]) |
32225
cf042543afa2
match: optimize visitdir() for patterns matching only root directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
32185
diff
changeset
|
897 (['r', 'p/p', '.'], ['p', '.']) |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
898 >>> _rootsanddirs(\ |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
899 [('relglob', 'rg*', ''), ('re', 're/', ''), ('relre', 'rr', '')]) |
32225
cf042543afa2
match: optimize visitdir() for patterns matching only root directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
32185
diff
changeset
|
900 (['.', '.', '.'], ['.']) |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
901 ''' |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
902 r, d = _patternrootsanddirs(kindpats) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
903 |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
904 # Append the parents as non-recursive/exact directories, since they must be |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
905 # scanned to get to either the roots or the other exact directories. |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
906 d.extend(util.dirs(d)) |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
907 d.extend(util.dirs(r)) |
32225
cf042543afa2
match: optimize visitdir() for patterns matching only root directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
32185
diff
changeset
|
908 # util.dirs() does not include the root directory, so add it manually |
cf042543afa2
match: optimize visitdir() for patterns matching only root directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
32185
diff
changeset
|
909 d.append('.') |
31033
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
910 |
693a5bb47854
match: making visitdir() deal with non-recursive entries
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
31032
diff
changeset
|
911 return r, d |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
912 |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
913 def _explicitfiles(kindpats): |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
914 '''Returns the potential explicit filenames from the patterns. |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
915 |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
916 >>> _explicitfiles([('path', 'foo/bar', '')]) |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
917 ['foo/bar'] |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
918 >>> _explicitfiles([('rootfilesin', 'foo/bar', '')]) |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
919 [] |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
920 ''' |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
921 # Keep only the pattern kinds where one can specify filenames (vs only |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
922 # directory names). |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
923 filable = [kp for kp in kindpats if kp[0] not in ('rootfilesin',)] |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
924 return _roots(filable) |
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
925 |
21111
9d28fd795215
match: improve documentation - docstrings and more descriptive variable naming
Mads Kiilerich <madski@unity3d.com>
parents:
21079
diff
changeset
|
926 def _anypats(kindpats): |
25213
08a8e9da0ae7
match: add source to kindpats list
Durham Goode <durham@fb.com>
parents:
25195
diff
changeset
|
927 for kind, pat, source in kindpats: |
31032
88358446da16
match: adding support for matching files inside a directory
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
30409
diff
changeset
|
928 if kind in ('glob', 're', 'relglob', 'relre', 'set', 'rootfilesin'): |
8576
ec4ed21db4b2
match: split up _normalizepats
Matt Mackall <mpm@selenic.com>
parents:
8575
diff
changeset
|
929 return True |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
930 |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
931 _commentre = None |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
932 |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
933 def readpatternfile(filepath, warn, sourceinfo=False): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
934 '''parse a pattern file, returning a list of |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
935 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
|
936 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
|
937 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
938 trailing white space is dropped. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
939 the escape character is backslash. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
940 comments start with #. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
941 empty lines are skipped. |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
942 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
943 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
|
944 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
945 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
|
946 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
|
947 re:pattern # non-rooted regular expression |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
948 glob:pattern # non-rooted glob |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
949 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
|
950 |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
951 if sourceinfo is set, returns a list of tuples: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
952 (pattern, lineno, originalline). This is useful to debug ignore patterns. |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
953 ''' |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25215
diff
changeset
|
954 |
25215
4040e06e9b99
match: add 'include:' syntax
Durham Goode <durham@fb.com>
parents:
25214
diff
changeset
|
955 syntaxes = {'re': 'relre:', 'regexp': 'relre:', 'glob': 'relglob:', |
25283
19d0e5efa6ca
match: enable 'subinclude:' syntax
Durham Goode <durham@fb.com>
parents:
25250
diff
changeset
|
956 'include': 'include', 'subinclude': 'subinclude'} |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
957 syntax = 'relre:' |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
958 patterns = [] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
959 |
31412
10c17f8bfcf3
py3: open file in rb mode
Rishabh Madan <rishabhmadan96@gmail.com>
parents:
31401
diff
changeset
|
960 fp = open(filepath, 'rb') |
30409 | 961 for lineno, line in enumerate(util.iterfile(fp), start=1): |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
962 if "#" in line: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
963 global _commentre |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
964 if not _commentre: |
31429
40704098853f
match: make regular expression bytes to prevent TypeError
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31412
diff
changeset
|
965 _commentre = util.re.compile(br'((?:^|[^\\])(?:\\\\)*)#.*') |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
966 # 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
|
967 m = _commentre.search(line) |
d500341e4f55
match: use re2 in readpatternfile if possible
Bryan O'Sullivan <bos@serpentine.com>
parents:
26781
diff
changeset
|
968 if m: |
d500341e4f55
match: use re2 in readpatternfile if possible
Bryan O'Sullivan <bos@serpentine.com>
parents:
26781
diff
changeset
|
969 line = line[:m.end(1)] |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
970 # fixup properly escaped comments that survived the above |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
971 line = line.replace("\\#", "#") |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
972 line = line.rstrip() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
973 if not line: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
974 continue |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
975 |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
976 if line.startswith('syntax:'): |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
977 s = line[7:].strip() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
978 try: |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
979 syntax = syntaxes[s] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
980 except KeyError: |
25214
08703b10c3ae
match: add optional warn argument
Durham Goode <durham@fb.com>
parents:
25213
diff
changeset
|
981 if warn: |
08703b10c3ae
match: add optional warn argument
Durham Goode <durham@fb.com>
parents:
25213
diff
changeset
|
982 warn(_("%s: ignoring invalid syntax '%s'\n") % |
08703b10c3ae
match: add optional warn argument
Durham Goode <durham@fb.com>
parents:
25213
diff
changeset
|
983 (filepath, s)) |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
984 continue |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
985 |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
986 linesyntax = syntax |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
987 for s, rels in syntaxes.iteritems(): |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
988 if line.startswith(rels): |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
989 linesyntax = rels |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
990 line = line[len(rels):] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
991 break |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
992 elif line.startswith(s+':'): |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
993 linesyntax = rels |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
994 line = line[len(s) + 1:] |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
995 break |
27595
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
996 if sourceinfo: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
997 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
|
998 else: |
9e2d01707e71
match: add option to return line and lineno from readpattern
Laurent Charignon <lcharignon@fb.com>
parents:
27343
diff
changeset
|
999 patterns.append(linesyntax + line) |
25167
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1000 fp.close() |
6f7048cc2419
ignore: move readpatternfile to match.py
Durham Goode <durham@fb.com>
parents:
25122
diff
changeset
|
1001 return patterns |