annotate mercurial/match.py @ 46362:24a32dea6955

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