match.py
1604 lines
| 50.0 KiB
| text/x-python
|
PythonLexer
/ mercurial / match.py
|
r8761 | # match.py - filename matching | ||
|
r8231 | # | ||
# Copyright 2008, 2009 Matt Mackall <mpm@selenic.com> and others | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r8231 | |||
|
r34139 | from __future__ import absolute_import, print_function | ||
|
r25958 | |||
import copy | ||||
|
r38990 | import itertools | ||
|
r25958 | import os | ||
import re | ||||
from .i18n import _ | ||||
|
r43355 | from .pycompat import open | ||
|
r25958 | from . import ( | ||
|
r36067 | encoding, | ||
|
r26587 | error, | ||
|
r25958 | pathutil, | ||
|
r42652 | policy, | ||
|
r36590 | pycompat, | ||
|
r25958 | util, | ||
) | ||||
|
r43346 | from .utils import stringutil | ||
|
r6576 | |||
|
r44589 | rustmod = policy.importrust('dirstate') | ||
|
r42516 | |||
|
r43346 | allpatternkinds = ( | ||
|
r43347 | b're', | ||
b'glob', | ||||
b'path', | ||||
b'relglob', | ||||
b'relpath', | ||||
b'relre', | ||||
b'rootglob', | ||||
b'listfile', | ||||
b'listfile0', | ||||
b'set', | ||||
b'include', | ||||
b'subinclude', | ||||
b'rootfilesin', | ||||
|
r43346 | ) | ||
|
r43347 | cwdrelativepatternkinds = (b'relpath', b'glob') | ||
|
r33647 | |||
|
r24636 | propertycache = util.propertycache | ||
|
r43346 | |||
|
r21111 | def _rematcher(regex): | ||
'''compile the regexp with the best available regexp engine and return a | ||||
matcher function''' | ||||
|
r21909 | m = util.re.compile(regex) | ||
|
r16943 | try: | ||
# slightly faster, provided by facebook's re2 bindings | ||||
return m.test_match | ||||
except AttributeError: | ||||
return m.match | ||||
|
r43346 | |||
|
r44461 | def _expandsets(cwd, kindpats, ctx=None, listsubrepos=False, badfn=None): | ||
|
r38631 | '''Returns the kindpats list with the 'set' patterns expanded to matchers''' | ||
matchers = [] | ||||
|
r14675 | other = [] | ||
|
r25213 | for kind, pat, source in kindpats: | ||
|
r43347 | if kind == b'set': | ||
|
r41144 | if ctx is None: | ||
|
r43346 | raise error.ProgrammingError( | ||
|
r43387 | b"fileset expression with no context" | ||
|
r43346 | ) | ||
|
r44461 | matchers.append(ctx.matchfileset(cwd, pat, badfn=badfn)) | ||
|
r25122 | |||
if listsubrepos: | ||||
for subpath in ctx.substate: | ||||
|
r44461 | sm = ctx.sub(subpath).matchfileset(cwd, pat, badfn=badfn) | ||
|
r41824 | pm = prefixdirmatcher(subpath, sm, badfn=badfn) | ||
|
r38631 | matchers.append(pm) | ||
|
r25122 | |||
|
r14675 | continue | ||
|
r25213 | other.append((kind, pat, source)) | ||
|
r38631 | return matchers, other | ||
|
r14675 | |||
|
r43346 | |||
|
r25283 | def _expandsubinclude(kindpats, root): | ||
|
r32132 | '''Returns the list of subinclude matcher args and the kindpats without the | ||
|
r25283 | subincludes in it.''' | ||
relmatchers = [] | ||||
other = [] | ||||
for kind, pat, source in kindpats: | ||||
|
r43347 | if kind == b'subinclude': | ||
|
r25301 | sourceroot = pathutil.dirname(util.normpath(source)) | ||
|
r25283 | pat = util.pconvert(pat) | ||
path = pathutil.join(sourceroot, pat) | ||||
newroot = pathutil.dirname(path) | ||||
|
r43347 | matcherargs = (newroot, b'', [], [b'include:%s' % path]) | ||
|
r25283 | |||
prefix = pathutil.canonpath(root, root, newroot) | ||||
if prefix: | ||||
|
r43347 | prefix += b'/' | ||
|
r32132 | relmatchers.append((prefix, matcherargs)) | ||
|
r25283 | else: | ||
other.append((kind, pat, source)) | ||||
return relmatchers, other | ||||
|
r43346 | |||
|
r24447 | def _kindpatsalwaysmatch(kindpats): | ||
""""Checks whether the kindspats match everything, as e.g. | ||||
'relpath:.' does. | ||||
""" | ||||
|
r25213 | for kind, pat, source in kindpats: | ||
|
r43347 | if pat != b'' or kind not in [b'relpath', b'glob']: | ||
|
r24447 | return False | ||
return True | ||||
|
r43346 | |||
def _buildkindpatsmatcher( | ||||
|
r44461 | matchercls, root, cwd, kindpats, ctx=None, listsubrepos=False, badfn=None, | ||
|
r43346 | ): | ||
|
r38599 | matchers = [] | ||
|
r43346 | fms, kindpats = _expandsets( | ||
|
r44461 | cwd, kindpats, ctx=ctx, listsubrepos=listsubrepos, badfn=badfn, | ||
|
r43346 | ) | ||
|
r38599 | if kindpats: | ||
|
r41824 | m = matchercls(root, kindpats, badfn=badfn) | ||
|
r38599 | matchers.append(m) | ||
|
r38631 | if fms: | ||
matchers.extend(fms) | ||||
|
r38599 | if not matchers: | ||
|
r41824 | return nevermatcher(badfn=badfn) | ||
|
r38599 | if len(matchers) == 1: | ||
return matchers[0] | ||||
return unionmatcher(matchers) | ||||
|
r43346 | |||
def match( | ||||
root, | ||||
cwd, | ||||
patterns=None, | ||||
include=None, | ||||
exclude=None, | ||||
|
r43347 | default=b'glob', | ||
|
r43346 | auditor=None, | ||
ctx=None, | ||||
listsubrepos=False, | ||||
warn=None, | ||||
badfn=None, | ||||
icasefs=False, | ||||
): | ||||
|
r42253 | r"""build an object to match a set of file patterns | ||
|
r32394 | |||
arguments: | ||||
root - the canonical root of the tree you're matching against | ||||
cwd - the current working directory, if relevant | ||||
patterns - patterns to find | ||||
include - patterns to include (unless they are excluded) | ||||
exclude - patterns to exclude (even if they are included) | ||||
default - if a pattern in patterns has no explicit type, assume this one | ||||
|
r42252 | auditor - optional path auditor | ||
ctx - optional changecontext | ||||
listsubrepos - if True, recurse into subrepositories | ||||
|
r32394 | warn - optional function used for printing warnings | ||
badfn - optional bad() callback for this matcher instead of the default | ||||
|
r32400 | icasefs - make a matcher for wdir on case insensitive filesystems, which | ||
normalizes the given patterns to the case in the filesystem | ||||
|
r32394 | |||
a pattern is one of: | ||||
'glob:<glob>' - a glob relative to cwd | ||||
're:<regexp>' - a regular expression | ||||
'path:<path>' - a path relative to repository root, which is matched | ||||
recursively | ||||
'rootfilesin:<path>' - a path relative to repository root, which is | ||||
matched non-recursively (will not match subdirectories) | ||||
'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs) | ||||
'relpath:<path>' - a path relative to cwd | ||||
'relre:<regexp>' - a regexp that needn't match the start of a name | ||||
'set:<fileset>' - a fileset expression | ||||
'include:<path>' - a file of patterns to read and include | ||||
'subinclude:<path>' - a file of patterns to match against files under | ||||
the same directory | ||||
'<something>' - a pattern of the specified default type | ||||
|
r42253 | |||
|
r44416 | >>> def _match(root, *args, **kwargs): | ||
... return match(util.localpath(root), *args, **kwargs) | ||||
|
r42253 | Usually a patternmatcher is returned: | ||
|
r44416 | >>> _match(b'/foo', b'.', [b're:.*\.c$', b'path:foo/a', b'*.py']) | ||
|
r42253 | <patternmatcher patterns='.*\\.c$|foo/a(?:/|$)|[^/]*\\.py$'> | ||
Combining 'patterns' with 'include' (resp. 'exclude') gives an | ||||
intersectionmatcher (resp. a differencematcher): | ||||
|
r44416 | >>> type(_match(b'/foo', b'.', [b're:.*\.c$'], include=[b'path:lib'])) | ||
|
r42253 | <class 'mercurial.match.intersectionmatcher'> | ||
|
r44416 | >>> type(_match(b'/foo', b'.', [b're:.*\.c$'], exclude=[b'path:build'])) | ||
|
r42253 | <class 'mercurial.match.differencematcher'> | ||
Notice that, if 'patterns' is empty, an alwaysmatcher is returned: | ||||
|
r44416 | >>> _match(b'/foo', b'.', []) | ||
|
r42253 | <alwaysmatcher> | ||
The 'default' argument determines which kind of pattern is assumed if a | ||||
pattern has no prefix: | ||||
|
r44416 | >>> _match(b'/foo', b'.', [b'.*\.c$'], default=b're') | ||
|
r42253 | <patternmatcher patterns='.*\\.c$'> | ||
|
r44416 | >>> _match(b'/foo', b'.', [b'main.py'], default=b'relpath') | ||
|
r42253 | <patternmatcher patterns='main\\.py(?:/|$)'> | ||
|
r44416 | >>> _match(b'/foo', b'.', [b'main.py'], default=b're') | ||
|
r42253 | <patternmatcher patterns='main.py'> | ||
The primary use of matchers is to check whether a value (usually a file | ||||
name) matches againset one of the patterns given at initialization. There | ||||
are two ways of doing this check. | ||||
|
r44416 | >>> m = _match(b'/foo', b'', [b're:.*\.c$', b'relpath:a']) | ||
|
r42253 | |||
1. Calling the matcher with a file name returns True if any pattern | ||||
matches that file name: | ||||
|
r42267 | >>> m(b'a') | ||
|
r42253 | True | ||
|
r42267 | >>> m(b'main.c') | ||
|
r42253 | True | ||
|
r42267 | >>> m(b'test.py') | ||
|
r42253 | False | ||
2. Using the exact() method only returns True if the file name matches one | ||||
of the exact patterns (i.e. not re: or glob: patterns): | ||||
|
r42267 | >>> m.exact(b'a') | ||
|
r42253 | True | ||
|
r42267 | >>> m.exact(b'main.c') | ||
|
r42253 | False | ||
|
r32394 | """ | ||
|
r44401 | assert os.path.isabs(root) | ||
|
r44417 | cwd = os.path.join(root, util.localpath(cwd)) | ||
|
r32400 | normalize = _donormalize | ||
if icasefs: | ||||
dirstate = ctx.repo().dirstate | ||||
dsnormalize = dirstate.normalize | ||||
def normalize(patterns, default, root, cwd, auditor, warn): | ||||
kp = _donormalize(patterns, default, root, cwd, auditor, warn) | ||||
kindpats = [] | ||||
for kind, pats, source in kp: | ||||
|
r43347 | if kind not in (b're', b'relre'): # regex can't be normalized | ||
|
r32400 | p = pats | ||
pats = dsnormalize(pats) | ||||
# Preserve the original to handle a case only rename. | ||||
if p != pats and p in dirstate: | ||||
kindpats.append((kind, p, source)) | ||||
kindpats.append((kind, pats, source)) | ||||
return kindpats | ||||
|
r41771 | if patterns: | ||
|
r32556 | kindpats = normalize(patterns, default, root, cwd, auditor, warn) | ||
|
r32557 | if _kindpatsalwaysmatch(kindpats): | ||
|
r41824 | m = alwaysmatcher(badfn) | ||
|
r32557 | else: | ||
|
r43346 | m = _buildkindpatsmatcher( | ||
patternmatcher, | ||||
root, | ||||
|
r44461 | cwd, | ||
|
r43346 | kindpats, | ||
ctx=ctx, | ||||
listsubrepos=listsubrepos, | ||||
badfn=badfn, | ||||
) | ||||
|
r32553 | else: | ||
# It's a little strange that no patterns means to match everything. | ||||
|
r32650 | # Consider changing this to match nothing (probably using nevermatcher). | ||
|
r41824 | m = alwaysmatcher(badfn) | ||
|
r32553 | |||
|
r32497 | if include: | ||
|
r43347 | kindpats = normalize(include, b'glob', root, cwd, auditor, warn) | ||
|
r43346 | im = _buildkindpatsmatcher( | ||
includematcher, | ||||
root, | ||||
|
r44461 | cwd, | ||
|
r43346 | kindpats, | ||
ctx=ctx, | ||||
listsubrepos=listsubrepos, | ||||
badfn=None, | ||||
) | ||||
|
r32497 | m = intersectmatchers(m, im) | ||
|
r32465 | if exclude: | ||
|
r43347 | kindpats = normalize(exclude, b'glob', root, cwd, auditor, warn) | ||
|
r43346 | em = _buildkindpatsmatcher( | ||
includematcher, | ||||
root, | ||||
|
r44461 | cwd, | ||
|
r43346 | kindpats, | ||
ctx=ctx, | ||||
listsubrepos=listsubrepos, | ||||
badfn=None, | ||||
) | ||||
|
r32465 | m = differencematcher(m, em) | ||
return m | ||||
|
r32394 | |||
|
r43346 | |||
|
r41825 | def exact(files, badfn=None): | ||
|
r41824 | return exactmatcher(files, badfn=badfn) | ||
|
r32394 | |||
|
r43346 | |||
|
r41825 | def always(badfn=None): | ||
return alwaysmatcher(badfn) | ||||
|
r32394 | |||
|
r43346 | |||
|
r41825 | def never(badfn=None): | ||
return nevermatcher(badfn) | ||||
|
r32600 | |||
|
r43346 | |||
|
r32394 | def badmatch(match, badfn): | ||
"""Make a copy of the given matcher, replacing its bad method with the given | ||||
one. | ||||
""" | ||||
m = copy.copy(match) | ||||
m.bad = badfn | ||||
return m | ||||
|
r43346 | |||
|
r42254 | def _donormalize(patterns, default, root, cwd, auditor=None, warn=None): | ||
|
r32396 | '''Convert 'kind:pat' from the patterns list to tuples with kind and | ||
normalized and rooted patterns and with listfiles expanded.''' | ||||
kindpats = [] | ||||
for kind, pat in [_patsplit(p, default) for p in patterns]: | ||||
|
r33647 | if kind in cwdrelativepatternkinds: | ||
|
r42254 | pat = pathutil.canonpath(root, cwd, pat, auditor=auditor) | ||
|
r43347 | elif kind in (b'relglob', b'path', b'rootfilesin', b'rootglob'): | ||
|
r32396 | pat = util.normpath(pat) | ||
|
r43347 | elif kind in (b'listfile', b'listfile0'): | ||
|
r32396 | try: | ||
files = util.readfile(pat) | ||||
|
r43347 | if kind == b'listfile0': | ||
files = files.split(b'\0') | ||||
|
r32396 | else: | ||
files = files.splitlines() | ||||
files = [f for f in files if f] | ||||
except EnvironmentError: | ||||
|
r43347 | raise error.Abort(_(b"unable to read file list (%s)") % pat) | ||
|
r43346 | for k, p, source in _donormalize( | ||
files, default, root, cwd, auditor, warn | ||||
): | ||||
|
r32396 | kindpats.append((k, p, pat)) | ||
continue | ||||
|
r43347 | elif kind == b'include': | ||
|
r32396 | try: | ||
fullpath = os.path.join(root, util.localpath(pat)) | ||||
includepats = readpatternfile(fullpath, warn) | ||||
|
r43346 | for k, p, source in _donormalize( | ||
includepats, default, root, cwd, auditor, warn | ||||
): | ||||
|
r32396 | kindpats.append((k, p, source or pat)) | ||
except error.Abort as inst: | ||||
|
r43786 | raise error.Abort( | ||
b'%s: %s' | ||||
% (pat, inst[0]) # pytype: disable=unsupported-operands | ||||
) | ||||
|
r32396 | except IOError as inst: | ||
if warn: | ||||
|
r43346 | warn( | ||
|
r43347 | _(b"skipping unreadable pattern file '%s': %s\n") | ||
|
r43346 | % (pat, stringutil.forcebytestr(inst.strerror)) | ||
) | ||||
|
r32396 | continue | ||
# else: re or relre - which cannot be normalized | ||||
|
r43347 | kindpats.append((kind, pat, b'')) | ||
|
r32396 | return kindpats | ||
|
r43346 | |||
|
r32454 | class basematcher(object): | ||
|
r41824 | def __init__(self, badfn=None): | ||
|
r32454 | if badfn is not None: | ||
self.bad = badfn | ||||
def __call__(self, fn): | ||||
return self.matchfn(fn) | ||||
|
r43346 | |||
|
r32454 | # Callbacks related to how the matcher is used by dirstate.walk. | ||
# Subscribers to these events must monkeypatch the matcher object. | ||||
def bad(self, f, msg): | ||||
'''Callback from dirstate.walk for each explicit file that can't be | ||||
found/accessed, with an error message.''' | ||||
# If an traversedir is set, it will be called when a directory discovered | ||||
# by recursive traversal is visited. | ||||
traversedir = None | ||||
|
r32455 | @propertycache | ||
def _files(self): | ||||
return [] | ||||
|
r32454 | def files(self): | ||
'''Explicitly listed files or patterns or roots: | ||||
if no patterns or .always(): empty list, | ||||
if exact: list exact files, | ||||
if not .anypats(): list all files and dirs, | ||||
else: optimal roots''' | ||||
return self._files | ||||
@propertycache | ||||
def _fileset(self): | ||||
return set(self._files) | ||||
def exact(self, f): | ||||
'''Returns True if f is in .files().''' | ||||
return f in self._fileset | ||||
|
r32463 | def matchfn(self, f): | ||
return False | ||||
|
r32454 | def visitdir(self, dir): | ||
'''Decides whether a directory should be visited based on whether it | ||||
has potential matches in it or one of its subdirectories. This is | ||||
based on the match's primary, included, and excluded patterns. | ||||
Returns the string 'all' if the given directory and all subdirectories | ||||
should be visited. Otherwise returns True or False indicating whether | ||||
the given directory should be visited. | ||||
''' | ||||
|
r33478 | return True | ||
|
r32454 | |||
|
r38990 | def visitchildrenset(self, dir): | ||
'''Decides whether a directory should be visited based on whether it | ||||
has potential matches in it or one of its subdirectories, and | ||||
potentially lists which subdirectories of that directory should be | ||||
visited. This is based on the match's primary, included, and excluded | ||||
patterns. | ||||
This function is very similar to 'visitdir', and the following mapping | ||||
can be applied: | ||||
visitdir | visitchildrenlist | ||||
----------+------------------- | ||||
False | set() | ||||
'all' | 'all' | ||||
|
r39296 | True | 'this' OR non-empty set of subdirs -or files- to visit | ||
|
r38990 | |||
Example: | ||||
Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return | ||||
the following values (assuming the implementation of visitchildrenset | ||||
is capable of recognizing this; some implementations are not). | ||||
|
r42528 | '' -> {'foo', 'qux'} | ||
|
r38990 | 'baz' -> set() | ||
'foo' -> {'bar'} | ||||
# Ideally this would be 'all', but since the prefix nature of matchers | ||||
|
r39296 | # is applied to the entire matcher, we have to downgrade this to | ||
# 'this' due to the non-prefix 'rootfilesin'-kind matcher being mixed | ||||
# in. | ||||
|
r38990 | 'foo/bar' -> 'this' | ||
'qux' -> 'this' | ||||
|
r39296 | |||
Important: | ||||
Most matchers do not know if they're representing files or | ||||
directories. They see ['path:dir/f'] and don't know whether 'f' is a | ||||
file or a directory, so visitchildrenset('dir') for most matchers will | ||||
return {'f'}, but if the matcher knows it's a file (like exactmatcher | ||||
does), it may return 'this'. Do not rely on the return being a set | ||||
indicating that there are no files in this dir to investigate (or | ||||
equivalently that if there are files to investigate in 'dir' that it | ||||
will always return 'this'). | ||||
|
r38990 | ''' | ||
|
r43347 | return b'this' | ||
|
r38990 | |||
|
r32454 | def always(self): | ||
|
r33379 | '''Matcher will match everything and .files() will be empty -- | ||
optimization might be possible.''' | ||||
|
r32454 | return False | ||
def isexact(self): | ||||
|
r33379 | '''Matcher will match exactly the list of files in .files() -- | ||
optimization might be possible.''' | ||||
|
r32454 | return False | ||
def prefix(self): | ||||
|
r33379 | '''Matcher will match the paths in .files() recursively -- | ||
optimization might be possible.''' | ||||
return False | ||||
def anypats(self): | ||||
'''None of .always(), .isexact(), and .prefix() is true -- | ||||
optimizations will be difficult.''' | ||||
return not self.always() and not self.isexact() and not self.prefix() | ||||
|
r32454 | |||
|
r43346 | |||
|
r32553 | class alwaysmatcher(basematcher): | ||
'''Matches everything.''' | ||||
|
r41824 | def __init__(self, badfn=None): | ||
super(alwaysmatcher, self).__init__(badfn) | ||||
|
r32553 | |||
def always(self): | ||||
return True | ||||
def matchfn(self, f): | ||||
return True | ||||
def visitdir(self, dir): | ||||
|
r43347 | return b'all' | ||
|
r32553 | |||
|
r38990 | def visitchildrenset(self, dir): | ||
|
r43347 | return b'all' | ||
|
r38990 | |||
|
r32553 | def __repr__(self): | ||
|
r36067 | return r'<alwaysmatcher>' | ||
|
r32553 | |||
|
r43346 | |||
|
r32600 | class nevermatcher(basematcher): | ||
'''Matches nothing.''' | ||||
|
r41824 | def __init__(self, badfn=None): | ||
super(nevermatcher, self).__init__(badfn) | ||||
|
r32600 | |||
|
r33378 | # It's a little weird to say that the nevermatcher is an exact matcher | ||
# or a prefix matcher, but it seems to make sense to let callers take | ||||
# fast paths based on either. There will be no exact matches, nor any | ||||
# prefixes (files() returns []), so fast paths iterating over them should | ||||
# be efficient (and correct). | ||||
def isexact(self): | ||||
return True | ||||
def prefix(self): | ||||
return True | ||||
|
r33583 | def visitdir(self, dir): | ||
return False | ||||
|
r38990 | def visitchildrenset(self, dir): | ||
return set() | ||||
|
r32600 | def __repr__(self): | ||
|
r36067 | return r'<nevermatcher>' | ||
|
r32600 | |||
|
r43346 | |||
|
r38596 | class predicatematcher(basematcher): | ||
"""A matcher adapter for a simple boolean function""" | ||||
|
r41824 | def __init__(self, predfn, predrepr=None, badfn=None): | ||
super(predicatematcher, self).__init__(badfn) | ||||
|
r38596 | self.matchfn = predfn | ||
self._predrepr = predrepr | ||||
@encoding.strmethod | ||||
def __repr__(self): | ||||
|
r43346 | s = stringutil.buildrepr(self._predrepr) or pycompat.byterepr( | ||
self.matchfn | ||||
) | ||||
|
r43347 | return b'<predicatenmatcher pred=%s>' % s | ||
|
r38596 | |||
|
r43346 | |||
|
r32501 | class patternmatcher(basematcher): | ||
|
r44125 | r"""Matches a set of (kind, pat, source) against a 'root' directory. | ||
|
r42250 | |||
>>> kindpats = [ | ||||
|
r42367 | ... (b're', br'.*\.c$', b''), | ||
|
r42267 | ... (b'path', b'foo/a', b''), | ||
... (b'relpath', b'b', b''), | ||||
... (b'glob', b'*.h', b''), | ||||
|
r42250 | ... ] | ||
|
r42267 | >>> m = patternmatcher(b'foo', kindpats) | ||
>>> m(b'main.c') # matches re:.*\.c$ | ||||
|
r42250 | True | ||
|
r42267 | >>> m(b'b.txt') | ||
|
r42250 | False | ||
|
r42267 | >>> m(b'foo/a') # matches path:foo/a | ||
|
r42250 | True | ||
|
r42267 | >>> m(b'a') # does not match path:b, since 'root' is 'foo' | ||
|
r42250 | False | ||
|
r42267 | >>> m(b'b') # matches relpath:b, since 'root' is 'foo' | ||
|
r42250 | True | ||
|
r42267 | >>> m(b'lib.h') # matches glob:*.h | ||
|
r42250 | True | ||
>>> m.files() | ||||
|
r42528 | ['', 'foo/a', 'b', ''] | ||
|
r42267 | >>> m.exact(b'foo/a') | ||
|
r42250 | True | ||
|
r42267 | >>> m.exact(b'b') | ||
|
r42250 | True | ||
|
r42267 | >>> m.exact(b'lib.h') # exact matches are for (rel)path kinds | ||
|
r42250 | False | ||
""" | ||||
|
r32394 | |||
|
r41824 | def __init__(self, root, kindpats, badfn=None): | ||
super(patternmatcher, self).__init__(badfn) | ||||
|
r8581 | |||
|
r32557 | self._files = _explicitfiles(kindpats) | ||
|
r33405 | self._prefix = _prefix(kindpats) | ||
|
r43347 | self._pats, self.matchfn = _buildmatch(kindpats, b'$', root) | ||
|
r8587 | |||
|
r32323 | @propertycache | ||
|
r24636 | def _dirs(self): | ||
r43923 | return set(pathutil.dirs(self._fileset)) | |||
|
r24636 | |||
def visitdir(self, dir): | ||||
|
r33405 | if self._prefix and dir in self._fileset: | ||
|
r43347 | return b'all' | ||
|
r43346 | return ( | ||
dir in self._fileset | ||||
or dir in self._dirs | ||||
or any( | ||||
|
r44032 | parentdir in self._fileset | ||
for parentdir in pathutil.finddirs(dir) | ||||
|
r43346 | ) | ||
) | ||||
|
r24636 | |||
|
r38990 | def visitchildrenset(self, dir): | ||
ret = self.visitdir(dir) | ||||
if ret is True: | ||||
|
r43347 | return b'this' | ||
|
r38990 | elif not ret: | ||
return set() | ||||
|
r43347 | assert ret == b'all' | ||
return b'all' | ||||
|
r38990 | |||
|
r33379 | def prefix(self): | ||
|
r33405 | return self._prefix | ||
|
r21111 | |||
|
r36067 | @encoding.strmethod | ||
|
r32406 | def __repr__(self): | ||
|
r43347 | return b'<patternmatcher patterns=%r>' % pycompat.bytestr(self._pats) | ||
|
r43346 | |||
|
r32501 | |||
r43923 | # This is basically a reimplementation of pathutil.dirs that stores the | |||
# children instead of just a count of them, plus a small optional optimization | ||||
# to avoid some directories we don't need. | ||||
|
r39494 | class _dirchildren(object): | ||
def __init__(self, paths, onlyinclude=None): | ||||
self._dirs = {} | ||||
self._onlyinclude = onlyinclude or [] | ||||
addpath = self.addpath | ||||
for f in paths: | ||||
addpath(f) | ||||
def addpath(self, path): | ||||
|
r43347 | if path == b'': | ||
|
r39494 | return | ||
dirs = self._dirs | ||||
findsplitdirs = _dirchildren._findsplitdirs | ||||
for d, b in findsplitdirs(path): | ||||
if d not in self._onlyinclude: | ||||
continue | ||||
dirs.setdefault(d, set()).add(b) | ||||
@staticmethod | ||||
def _findsplitdirs(path): | ||||
# yields (dirname, basename) tuples, walking back to the root. This is | ||||
|
r44032 | # very similar to pathutil.finddirs, except: | ||
|
r39494 | # - produces a (dirname, basename) tuple, not just 'dirname' | ||
# Unlike manifest._splittopdir, this does not suffix `dirname` with a | ||||
|
r42528 | # slash. | ||
|
r39494 | oldpos = len(path) | ||
|
r43347 | pos = path.rfind(b'/') | ||
|
r39494 | while pos != -1: | ||
|
r43346 | yield path[:pos], path[pos + 1 : oldpos] | ||
|
r39494 | oldpos = pos | ||
|
r43347 | pos = path.rfind(b'/', 0, pos) | ||
yield b'', path[:oldpos] | ||||
|
r39494 | |||
def get(self, path): | ||||
return self._dirs.get(path, set()) | ||||
|
r43346 | |||
|
r32501 | class includematcher(basematcher): | ||
|
r41824 | def __init__(self, root, kindpats, badfn=None): | ||
super(includematcher, self).__init__(badfn) | ||||
|
r45017 | if rustmod is not None: | ||
# We need to pass the patterns to Rust because they can contain | ||||
# patterns from the user interface | ||||
self._kindpats = kindpats | ||||
|
r43347 | self._pats, self.matchfn = _buildmatch(kindpats, b'(?:/|$)', root) | ||
|
r33405 | self._prefix = _prefix(kindpats) | ||
|
r38989 | roots, dirs, parents = _rootsdirsandparents(kindpats) | ||
|
r32502 | # roots are directories which are recursively included. | ||
|
r32503 | self._roots = set(roots) | ||
|
r32502 | # dirs are directories which are non-recursively included. | ||
|
r32503 | self._dirs = set(dirs) | ||
|
r38989 | # parents are directories which are non-recursively included because | ||
# they are needed to get to items in _dirs or _roots. | ||||
|
r42553 | self._parents = parents | ||
|
r32501 | |||
def visitdir(self, dir): | ||||
|
r33405 | if self._prefix and dir in self._roots: | ||
|
r43347 | return b'all' | ||
|
r43346 | return ( | ||
dir in self._roots | ||||
or dir in self._dirs | ||||
or dir in self._parents | ||||
|
r44032 | or any( | ||
parentdir in self._roots for parentdir in pathutil.finddirs(dir) | ||||
) | ||||
|
r43346 | ) | ||
|
r32501 | |||
|
r39494 | @propertycache | ||
def _allparentschildren(self): | ||||
# It may seem odd that we add dirs, roots, and parents, and then | ||||
# restrict to only parents. This is to catch the case of: | ||||
# dirs = ['foo/bar'] | ||||
# parents = ['foo'] | ||||
# if we asked for the children of 'foo', but had only added | ||||
# self._parents, we wouldn't be able to respond ['bar']. | ||||
return _dirchildren( | ||||
|
r43346 | itertools.chain(self._dirs, self._roots, self._parents), | ||
onlyinclude=self._parents, | ||||
) | ||||
|
r39494 | |||
|
r38990 | def visitchildrenset(self, dir): | ||
if self._prefix and dir in self._roots: | ||||
|
r43347 | return b'all' | ||
|
r38990 | # Note: this does *not* include the 'dir in self._parents' case from | ||
# visitdir, that's handled below. | ||||
|
r43346 | if ( | ||
|
r43347 | b'' in self._roots | ||
|
r43346 | or dir in self._roots | ||
or dir in self._dirs | ||||
|
r44032 | or any( | ||
parentdir in self._roots for parentdir in pathutil.finddirs(dir) | ||||
) | ||||
|
r43346 | ): | ||
|
r43347 | return b'this' | ||
|
r38990 | |||
if dir in self._parents: | ||||
|
r39494 | return self._allparentschildren.get(dir) or set() | ||
return set() | ||||
|
r38990 | |||
|
r36067 | @encoding.strmethod | ||
|
r32501 | def __repr__(self): | ||
|
r43347 | return b'<includematcher includes=%r>' % pycompat.bytestr(self._pats) | ||
|
r43346 | |||
|
r32406 | |||
|
r32499 | class exactmatcher(basematcher): | ||
|
r42249 | r'''Matches the input files exactly. They are interpreted as paths, not | ||
|
r32499 | patterns (so no kind-prefixes). | ||
|
r42249 | |||
|
r42367 | >>> m = exactmatcher([b'a.txt', br're:.*\.c$']) | ||
|
r42267 | >>> m(b'a.txt') | ||
|
r42249 | True | ||
|
r42267 | >>> m(b'b.txt') | ||
|
r42249 | False | ||
Input files that would be matched are exactly those returned by .files() | ||||
>>> m.files() | ||||
['a.txt', 're:.*\\.c$'] | ||||
So pattern 're:.*\.c$' is not considered as a regex, but as a file name | ||||
|
r42267 | >>> m(b'main.c') | ||
|
r42249 | False | ||
|
r42367 | >>> m(br're:.*\.c$') | ||
|
r42249 | True | ||
|
r32499 | ''' | ||
|
r41824 | def __init__(self, files, badfn=None): | ||
super(exactmatcher, self).__init__(badfn) | ||||
|
r32499 | |||
if isinstance(files, list): | ||||
self._files = files | ||||
else: | ||||
self._files = list(files) | ||||
|
r32543 | |||
matchfn = basematcher.exact | ||||
|
r32499 | |||
@propertycache | ||||
def _dirs(self): | ||||
r43923 | return set(pathutil.dirs(self._fileset)) | |||
|
r32499 | |||
def visitdir(self, dir): | ||||
return dir in self._dirs | ||||
|
r38990 | def visitchildrenset(self, dir): | ||
|
r39297 | if not self._fileset or dir not in self._dirs: | ||
return set() | ||||
|
r43347 | candidates = self._fileset | self._dirs - {b''} | ||
if dir != b'': | ||||
d = dir + b'/' | ||||
|
r44937 | candidates = {c[len(d) :] for c in candidates if c.startswith(d)} | ||
|
r39297 | # self._dirs includes all of the directories, recursively, so if | ||
|
r42528 | # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo', | ||
|
r39297 | # 'foo/bar' in it. Thus we can safely ignore a candidate that has a | ||
# '/' in it, indicating a it's for a subdir-of-a-subdir; the | ||||
# immediate subdir will be in there without a slash. | ||||
|
r43347 | ret = {c for c in candidates if b'/' not in c} | ||
|
r39297 | # We really do not expect ret to be empty, since that would imply that | ||
# there's something in _dirs that didn't have a file in _fileset. | ||||
assert ret | ||||
return ret | ||||
|
r38990 | |||
|
r32499 | def isexact(self): | ||
return True | ||||
|
r36067 | @encoding.strmethod | ||
|
r32499 | def __repr__(self): | ||
|
r43347 | return b'<exactmatcher files=%r>' % self._files | ||
|
r43346 | |||
|
r32499 | |||
|
r32465 | class differencematcher(basematcher): | ||
'''Composes two matchers by matching if the first matches and the second | ||||
|
r35677 | does not. | ||
|
r32465 | |||
|
r44114 | The second matcher's non-matching-attributes (bad, traversedir) are ignored. | ||
|
r32465 | ''' | ||
|
r43346 | |||
|
r32465 | def __init__(self, m1, m2): | ||
|
r41824 | super(differencematcher, self).__init__() | ||
|
r32465 | self._m1 = m1 | ||
self._m2 = m2 | ||||
self.bad = m1.bad | ||||
self.traversedir = m1.traversedir | ||||
def matchfn(self, f): | ||||
|
r35677 | return self._m1(f) and not self._m2(f) | ||
|
r32465 | |||
@propertycache | ||||
def _files(self): | ||||
if self.isexact(): | ||||
return [f for f in self._m1.files() if self(f)] | ||||
# If m1 is not an exact matcher, we can't easily figure out the set of | ||||
# files, because its files() are not always files. For example, if | ||||
# m1 is "path:dir" and m2 is "rootfileins:.", we don't | ||||
# want to remove "dir" from the set even though it would match m2, | ||||
# because the "dir" in m1 may not be a file. | ||||
return self._m1.files() | ||||
def visitdir(self, dir): | ||||
|
r43347 | if self._m2.visitdir(dir) == b'all': | ||
|
r32465 | return False | ||
|
r41669 | elif not self._m2.visitdir(dir): | ||
# m2 does not match dir, we can return 'all' here if possible | ||||
return self._m1.visitdir(dir) | ||||
|
r32465 | return bool(self._m1.visitdir(dir)) | ||
|
r38990 | def visitchildrenset(self, dir): | ||
m2_set = self._m2.visitchildrenset(dir) | ||||
|
r43347 | if m2_set == b'all': | ||
|
r38990 | return set() | ||
m1_set = self._m1.visitchildrenset(dir) | ||||
# Possible values for m1: 'all', 'this', set(...), set() | ||||
# Possible values for m2: 'this', set(...), set() | ||||
# If m2 has nothing under here that we care about, return m1, even if | ||||
# it's 'all'. This is a change in behavior from visitdir, which would | ||||
# return True, not 'all', for some reason. | ||||
if not m2_set: | ||||
return m1_set | ||||
|
r43347 | if m1_set in [b'all', b'this']: | ||
|
r38990 | # Never return 'all' here if m2_set is any kind of non-empty (either | ||
# 'this' or set(foo)), since m2 might return set() for a | ||||
# subdirectory. | ||||
|
r43347 | return b'this' | ||
|
r38990 | # Possible values for m1: set(...), set() | ||
# Possible values for m2: 'this', set(...) | ||||
# We ignore m2's set results. They're possibly incorrect: | ||||
|
r42528 | # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''): | ||
|
r38990 | # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd | ||
# return set(), which is *not* correct, we still need to visit 'dir'! | ||||
return m1_set | ||||
|
r32465 | def isexact(self): | ||
return self._m1.isexact() | ||||
|
r36067 | @encoding.strmethod | ||
|
r32465 | def __repr__(self): | ||
|
r43347 | return b'<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2) | ||
|
r43346 | |||
|
r32465 | |||
|
r32497 | def intersectmatchers(m1, m2): | ||
'''Composes two matchers by matching if both of them match. | ||||
|
r44114 | The second matcher's non-matching-attributes (bad, traversedir) are ignored. | ||
|
r32497 | ''' | ||
if m1 is None or m2 is None: | ||||
return m1 or m2 | ||||
if m1.always(): | ||||
m = copy.copy(m2) | ||||
# TODO: Consider encapsulating these things in a class so there's only | ||||
# one thing to copy from m1. | ||||
m.bad = m1.bad | ||||
m.traversedir = m1.traversedir | ||||
return m | ||||
if m2.always(): | ||||
m = copy.copy(m1) | ||||
return m | ||||
return intersectionmatcher(m1, m2) | ||||
|
r43346 | |||
|
r32497 | class intersectionmatcher(basematcher): | ||
def __init__(self, m1, m2): | ||||
|
r41824 | super(intersectionmatcher, self).__init__() | ||
|
r32497 | self._m1 = m1 | ||
self._m2 = m2 | ||||
self.bad = m1.bad | ||||
self.traversedir = m1.traversedir | ||||
@propertycache | ||||
def _files(self): | ||||
if self.isexact(): | ||||
m1, m2 = self._m1, self._m2 | ||||
if not m1.isexact(): | ||||
m1, m2 = m2, m1 | ||||
return [f for f in m1.files() if m2(f)] | ||||
# It neither m1 nor m2 is an exact matcher, we can't easily intersect | ||||
# the set of files, because their files() are not always files. For | ||||
# example, if intersecting a matcher "-I glob:foo.txt" with matcher of | ||||
# "path:dir2", we don't want to remove "dir2" from the set. | ||||
return self._m1.files() + self._m2.files() | ||||
def matchfn(self, f): | ||||
return self._m1(f) and self._m2(f) | ||||
def visitdir(self, dir): | ||||
visit1 = self._m1.visitdir(dir) | ||||
|
r43347 | if visit1 == b'all': | ||
|
r32497 | return self._m2.visitdir(dir) | ||
# bool() because visit1=True + visit2='all' should not be 'all' | ||||
return bool(visit1 and self._m2.visitdir(dir)) | ||||
|
r38990 | def visitchildrenset(self, dir): | ||
m1_set = self._m1.visitchildrenset(dir) | ||||
if not m1_set: | ||||
return set() | ||||
m2_set = self._m2.visitchildrenset(dir) | ||||
if not m2_set: | ||||
return set() | ||||
|
r43347 | if m1_set == b'all': | ||
|
r38990 | return m2_set | ||
|
r43347 | elif m2_set == b'all': | ||
|
r38990 | return m1_set | ||
|
r43347 | if m1_set == b'this' or m2_set == b'this': | ||
return b'this' | ||||
|
r38990 | |||
assert isinstance(m1_set, set) and isinstance(m2_set, set) | ||||
return m1_set.intersection(m2_set) | ||||
|
r32497 | def always(self): | ||
return self._m1.always() and self._m2.always() | ||||
def isexact(self): | ||||
return self._m1.isexact() or self._m2.isexact() | ||||
|
r36067 | @encoding.strmethod | ||
|
r32497 | def __repr__(self): | ||
|
r43347 | return b'<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2) | ||
|
r43346 | |||
|
r32497 | |||
|
r32456 | class subdirmatcher(basematcher): | ||
|
r12165 | """Adapt a matcher to work on a subdirectory only. | ||
The paths are remapped to remove/insert the path as needed: | ||||
|
r34139 | >>> from . import pycompat | ||
|
r44454 | >>> m1 = match(util.localpath(b'/root'), b'', [b'a.txt', b'sub/b.txt'], auditor=lambda name: None) | ||
|
r34133 | >>> m2 = subdirmatcher(b'sub', m1) | ||
|
r42256 | >>> m2(b'a.txt') | ||
|
r12165 | False | ||
|
r42256 | >>> m2(b'b.txt') | ||
|
r12165 | True | ||
|
r42256 | >>> m2.matchfn(b'a.txt') | ||
|
r12165 | False | ||
|
r42256 | >>> m2.matchfn(b'b.txt') | ||
|
r12165 | True | ||
>>> m2.files() | ||||
['b.txt'] | ||||
|
r34133 | >>> m2.exact(b'b.txt') | ||
|
r12165 | True | ||
|
r12268 | >>> def bad(f, msg): | ||
|
r34139 | ... print(pycompat.sysstr(b"%s: %s" % (f, msg))) | ||
|
r12268 | >>> m1.bad = bad | ||
|
r34133 | >>> m2.bad(b'x.txt', b'No such file') | ||
|
r12268 | sub/x.txt: No such file | ||
|
r12165 | """ | ||
def __init__(self, path, matcher): | ||||
|
r41824 | super(subdirmatcher, self).__init__() | ||
|
r12165 | self._path = path | ||
self._matcher = matcher | ||||
|
r32456 | self._always = matcher.always() | ||
|
r12165 | |||
|
r43346 | self._files = [ | ||
f[len(path) + 1 :] | ||||
for f in matcher._files | ||||
|
r43347 | if f.startswith(path + b"/") | ||
|
r43346 | ] | ||
|
r25194 | |||
|
r32326 | # If the parent repo had a path to this subrepo and the matcher is | ||
# a prefix matcher, this submatcher always matches. | ||||
if matcher.prefix(): | ||||
|
r25195 | self._always = any(f == path for f in matcher._files) | ||
|
r25194 | |||
|
r32325 | def bad(self, f, msg): | ||
|
r43347 | self._matcher.bad(self._path + b"/" + f, msg) | ||
|
r32325 | |||
|
r32464 | def matchfn(self, f): | ||
# Some information is lost in the superclass's constructor, so we | ||||
# can not accurately create the matching function for the subdirectory | ||||
# from the inputs. Instead, we override matchfn() and visitdir() to | ||||
# call the original matcher with the subdirectory path prepended. | ||||
|
r43347 | return self._matcher.matchfn(self._path + b"/" + f) | ||
|
r32464 | |||
|
r32324 | def visitdir(self, dir): | ||
|
r43347 | if dir == b'': | ||
|
r32324 | dir = self._path | ||
else: | ||||
|
r43347 | dir = self._path + b"/" + dir | ||
|
r32324 | return self._matcher.visitdir(dir) | ||
|
r38990 | def visitchildrenset(self, dir): | ||
|
r43347 | if dir == b'': | ||
|
r38990 | dir = self._path | ||
else: | ||||
|
r43347 | dir = self._path + b"/" + dir | ||
|
r38990 | return self._matcher.visitchildrenset(dir) | ||
|
r32456 | def always(self): | ||
return self._always | ||||
|
r33379 | def prefix(self): | ||
return self._matcher.prefix() and not self._always | ||||
|
r32456 | |||
|
r36067 | @encoding.strmethod | ||
|
r32552 | def __repr__(self): | ||
|
r43347 | return b'<subdirmatcher path=%r, matcher=%r>' % ( | ||
|
r43346 | self._path, | ||
self._matcher, | ||||
) | ||||
|
r32552 | |||
|
r38630 | class prefixdirmatcher(basematcher): | ||
"""Adapt a matcher to work on a parent directory. | ||||
|
r44114 | The matcher's non-matching-attributes (bad, traversedir) are ignored. | ||
|
r38630 | |||
The prefix path should usually be the relative path from the root of | ||||
this matcher to the root of the wrapped matcher. | ||||
|
r44401 | >>> m1 = match(util.localpath(b'/root/d/e'), b'f', [b'../a.txt', b'b.txt'], auditor=lambda name: None) | ||
|
r41824 | >>> m2 = prefixdirmatcher(b'd/e', m1) | ||
|
r42256 | >>> m2(b'a.txt') | ||
|
r38630 | False | ||
|
r42256 | >>> m2(b'd/e/a.txt') | ||
|
r38630 | True | ||
|
r42256 | >>> m2(b'd/e/b.txt') | ||
|
r38630 | False | ||
>>> m2.files() | ||||
['d/e/a.txt', 'd/e/f/b.txt'] | ||||
>>> m2.exact(b'd/e/a.txt') | ||||
True | ||||
>>> m2.visitdir(b'd') | ||||
True | ||||
>>> m2.visitdir(b'd/e') | ||||
True | ||||
>>> m2.visitdir(b'd/e/f') | ||||
True | ||||
>>> m2.visitdir(b'd/e/g') | ||||
False | ||||
>>> m2.visitdir(b'd/ef') | ||||
False | ||||
""" | ||||
|
r41824 | def __init__(self, path, matcher, badfn=None): | ||
super(prefixdirmatcher, self).__init__(badfn) | ||||
|
r38630 | if not path: | ||
|
r43347 | raise error.ProgrammingError(b'prefix path must not be empty') | ||
|
r38630 | self._path = path | ||
|
r43347 | self._pathprefix = path + b'/' | ||
|
r38630 | self._matcher = matcher | ||
@propertycache | ||||
def _files(self): | ||||
return [self._pathprefix + f for f in self._matcher._files] | ||||
def matchfn(self, f): | ||||
if not f.startswith(self._pathprefix): | ||||
return False | ||||
|
r43346 | return self._matcher.matchfn(f[len(self._pathprefix) :]) | ||
|
r38630 | |||
@propertycache | ||||
def _pathdirs(self): | ||||
|
r44032 | return set(pathutil.finddirs(self._path)) | ||
|
r38630 | |||
def visitdir(self, dir): | ||||
if dir == self._path: | ||||
|
r43347 | return self._matcher.visitdir(b'') | ||
|
r38630 | if dir.startswith(self._pathprefix): | ||
|
r43346 | return self._matcher.visitdir(dir[len(self._pathprefix) :]) | ||
|
r38630 | return dir in self._pathdirs | ||
|
r38990 | def visitchildrenset(self, dir): | ||
if dir == self._path: | ||||
|
r43347 | return self._matcher.visitchildrenset(b'') | ||
|
r38990 | if dir.startswith(self._pathprefix): | ||
|
r43346 | return self._matcher.visitchildrenset(dir[len(self._pathprefix) :]) | ||
|
r38990 | if dir in self._pathdirs: | ||
|
r43347 | return b'this' | ||
|
r38993 | return set() | ||
|
r38990 | |||
|
r38630 | def isexact(self): | ||
return self._matcher.isexact() | ||||
def prefix(self): | ||||
return self._matcher.prefix() | ||||
@encoding.strmethod | ||||
def __repr__(self): | ||||
|
r43347 | return b'<prefixdirmatcher path=%r, matcher=%r>' % ( | ||
|
r43346 | pycompat.bytestr(self._path), | ||
self._matcher, | ||||
) | ||||
|
r38630 | |||
|
r33319 | class unionmatcher(basematcher): | ||
|
r33448 | """A matcher that is the union of several matchers. | ||
|
r44114 | The non-matching-attributes (bad, traversedir) are taken from the first | ||
matcher. | ||||
|
r33448 | """ | ||
|
r33319 | def __init__(self, matchers): | ||
|
r33448 | m1 = matchers[0] | ||
|
r41824 | super(unionmatcher, self).__init__() | ||
|
r33448 | self.traversedir = m1.traversedir | ||
|
r33319 | self._matchers = matchers | ||
|
r33380 | def matchfn(self, f): | ||
|
r33319 | for match in self._matchers: | ||
|
r33380 | if match(f): | ||
|
r33319 | return True | ||
return False | ||||
|
r33448 | def visitdir(self, dir): | ||
r = False | ||||
for m in self._matchers: | ||||
v = m.visitdir(dir) | ||||
|
r43347 | if v == b'all': | ||
|
r33448 | return v | ||
r |= v | ||||
return r | ||||
|
r38990 | def visitchildrenset(self, dir): | ||
r = set() | ||||
this = False | ||||
for m in self._matchers: | ||||
v = m.visitchildrenset(dir) | ||||
if not v: | ||||
continue | ||||
|
r43347 | if v == b'all': | ||
|
r38990 | return v | ||
|
r43347 | if this or v == b'this': | ||
|
r38990 | this = True | ||
# don't break, we might have an 'all' in here. | ||||
continue | ||||
assert isinstance(v, set) | ||||
r = r.union(v) | ||||
if this: | ||||
|
r43347 | return b'this' | ||
|
r38990 | return r | ||
|
r36067 | @encoding.strmethod | ||
|
r33319 | def __repr__(self): | ||
|
r43347 | return b'<unionmatcher matchers=%r>' % self._matchers | ||
|
r43346 | |||
|
r33319 | |||
|
r21111 | def patkind(pattern, default=None): | ||
|
r44125 | r'''If pattern is 'kind:pat' with a known kind, return kind. | ||
|
r42251 | |||
|
r42367 | >>> patkind(br're:.*\.c$') | ||
|
r42251 | 're' | ||
|
r42267 | >>> patkind(b'glob:*.c') | ||
|
r42251 | 'glob' | ||
|
r42267 | >>> patkind(b'relpath:test.py') | ||
|
r42251 | 'relpath' | ||
|
r42267 | >>> patkind(b'main.py') | ||
>>> patkind(b'main.py', default=b're') | ||||
|
r42251 | 're' | ||
''' | ||||
|
r21111 | return _patsplit(pattern, default)[0] | ||
|
r8570 | |||
|
r43346 | |||
|
r21111 | def _patsplit(pattern, default): | ||
"""Split a string into the optional pattern kind prefix and the actual | ||||
pattern.""" | ||||
|
r43347 | if b':' in pattern: | ||
kind, pat = pattern.split(b':', 1) | ||||
|
r33647 | if kind in allpatternkinds: | ||
|
r21111 | return kind, pat | ||
return default, pattern | ||||
|
r8570 | |||
|
r43346 | |||
|
r8582 | def _globre(pat): | ||
|
r21112 | r'''Convert an extended glob string to a regexp string. | ||
|
r34139 | >>> from . import pycompat | ||
>>> def bprint(s): | ||||
... print(pycompat.sysstr(s)) | ||||
>>> bprint(_globre(br'?')) | ||||
|
r21112 | . | ||
|
r34139 | >>> bprint(_globre(br'*')) | ||
|
r21112 | [^/]* | ||
|
r34139 | >>> bprint(_globre(br'**')) | ||
|
r21112 | .* | ||
|
r34139 | >>> bprint(_globre(br'**/a')) | ||
|
r21815 | (?:.*/)?a | ||
|
r34139 | >>> bprint(_globre(br'a/**/b')) | ||
|
r38494 | a/(?:.*/)?b | ||
|
r34139 | >>> bprint(_globre(br'[a*?!^][^b][!c]')) | ||
|
r21112 | [a*?!^][\^b][^c] | ||
|
r34139 | >>> bprint(_globre(br'{a,b}')) | ||
|
r21112 | (?:a|b) | ||
|
r34139 | >>> bprint(_globre(br'.\*\?')) | ||
|
r21112 | \.\*\? | ||
''' | ||||
|
r8570 | i, n = 0, len(pat) | ||
|
r43347 | res = b'' | ||
|
r8570 | group = 0 | ||
|
r40720 | escape = util.stringutil.regexbytesescapemap.get | ||
|
r43346 | |||
|
r10282 | def peek(): | ||
|
r43346 | return i < n and pat[i : i + 1] | ||
|
r8570 | while i < n: | ||
|
r43346 | c = pat[i : i + 1] | ||
|
r10282 | i += 1 | ||
|
r43347 | if c not in b'*?[{},\\': | ||
|
r40720 | res += escape(c, c) | ||
|
r43347 | elif c == b'*': | ||
if peek() == b'*': | ||||
|
r8570 | i += 1 | ||
|
r43347 | if peek() == b'/': | ||
|
r21815 | i += 1 | ||
|
r43347 | res += b'(?:.*/)?' | ||
|
r21815 | else: | ||
|
r43347 | res += b'.*' | ||
|
r8570 | else: | ||
|
r43347 | res += b'[^/]*' | ||
elif c == b'?': | ||||
res += b'.' | ||||
elif c == b'[': | ||||
|
r8570 | j = i | ||
|
r43347 | if j < n and pat[j : j + 1] in b'!]': | ||
|
r8570 | j += 1 | ||
|
r43347 | while j < n and pat[j : j + 1] != b']': | ||
|
r8570 | j += 1 | ||
if j >= n: | ||||
|
r43347 | res += b'\\[' | ||
|
r8570 | else: | ||
|
r43347 | stuff = pat[i:j].replace(b'\\', b'\\\\') | ||
|
r8570 | i = j + 1 | ||
|
r43347 | if stuff[0:1] == b'!': | ||
stuff = b'^' + stuff[1:] | ||||
elif stuff[0:1] == b'^': | ||||
stuff = b'\\' + stuff | ||||
res = b'%s[%s]' % (res, stuff) | ||||
elif c == b'{': | ||||
|
r8570 | group += 1 | ||
|
r43347 | res += b'(?:' | ||
elif c == b'}' and group: | ||||
res += b')' | ||||
|
r8570 | group -= 1 | ||
|
r43347 | elif c == b',' and group: | ||
res += b'|' | ||||
elif c == b'\\': | ||||
|
r8570 | p = peek() | ||
if p: | ||||
i += 1 | ||||
|
r40720 | res += escape(p, p) | ||
|
r8570 | else: | ||
|
r40720 | res += escape(c, c) | ||
|
r8570 | else: | ||
|
r40720 | res += escape(c, c) | ||
|
r8582 | return res | ||
|
r8570 | |||
|
r43346 | |||
|
r21111 | def _regex(kind, pat, globsuffix): | ||
|
r42516 | '''Convert a (normalized) pattern of any kind into a | ||
regular expression. | ||||
|
r21111 | globsuffix is appended to the regexp of globs.''' | ||
|
r43347 | if not pat and kind in (b'glob', b'relpath'): | ||
return b'' | ||||
if kind == b're': | ||||
|
r21111 | return pat | ||
|
r43347 | if kind in (b'path', b'relpath'): | ||
if pat == b'.': | ||||
return b'' | ||||
return util.stringutil.reescape(pat) + b'(?:/|$)' | ||||
if kind == b'rootfilesin': | ||||
if pat == b'.': | ||||
escaped = b'' | ||||
|
r31012 | else: | ||
# Pattern is a directory name. | ||||
|
r43347 | escaped = util.stringutil.reescape(pat) + b'/' | ||
|
r31012 | # Anything after the pattern must be a non-directory. | ||
|
r43347 | return escaped + b'[^/]+$' | ||
if kind == b'relglob': | ||||
|
r43132 | globre = _globre(pat) | ||
|
r43347 | if globre.startswith(b'[^/]*'): | ||
|
r43132 | # When pat has the form *XYZ (common), make the returned regex more | ||
# legible by returning the regex for **XYZ instead of **/*XYZ. | ||||
|
r43347 | return b'.*' + globre[len(b'[^/]*') :] + globsuffix | ||
return b'(?:|.*/)' + globre + globsuffix | ||||
if kind == b'relre': | ||||
if pat.startswith(b'^'): | ||||
|
r21111 | return pat | ||
|
r43347 | return b'.*' + pat | ||
if kind in (b'glob', b'rootglob'): | ||||
|
r38597 | return _globre(pat) + globsuffix | ||
|
r43347 | raise error.ProgrammingError(b'not a regex pattern: %s:%s' % (kind, pat)) | ||
|
r8574 | |||
|
r43346 | |||
|
r41818 | def _buildmatch(kindpats, globsuffix, root): | ||
|
r21111 | '''Return regexp string and a matcher function for kindpats. | ||
globsuffix is appended to the regexp of globs.''' | ||||
|
r25239 | matchfuncs = [] | ||
|
r25283 | subincludes, kindpats = _expandsubinclude(kindpats, root) | ||
if subincludes: | ||||
|
r32132 | submatchers = {} | ||
|
r43346 | |||
|
r25283 | def matchsubinclude(f): | ||
|
r32132 | for prefix, matcherargs in subincludes: | ||
if f.startswith(prefix): | ||||
mf = submatchers.get(prefix) | ||||
if mf is None: | ||||
mf = match(*matcherargs) | ||||
submatchers[prefix] = mf | ||||
|
r43346 | if mf(f[len(prefix) :]): | ||
|
r32132 | return True | ||
|
r25283 | return False | ||
|
r43346 | |||
|
r25283 | matchfuncs.append(matchsubinclude) | ||
|
r14675 | |||
|
r43347 | regex = b'' | ||
|
r25239 | if kindpats: | ||
|
r43347 | if all(k == b'rootfilesin' for k, p, s in kindpats): | ||
|
r40278 | dirs = {p for k, p, s in kindpats} | ||
|
r43346 | |||
|
r40278 | def mf(f): | ||
|
r43347 | i = f.rfind(b'/') | ||
|
r40278 | if i >= 0: | ||
dir = f[:i] | ||||
else: | ||||
|
r43347 | dir = b'.' | ||
|
r40278 | return dir in dirs | ||
|
r43346 | |||
|
r40381 | regex = b'rootfilesin: %s' % stringutil.pprint(list(sorted(dirs))) | ||
|
r40278 | matchfuncs.append(mf) | ||
else: | ||||
regex, mf = _buildregexmatch(kindpats, globsuffix) | ||||
matchfuncs.append(mf) | ||||
|
r25239 | |||
if len(matchfuncs) == 1: | ||||
return regex, matchfuncs[0] | ||||
else: | ||||
return regex, lambda f: any(mf(f) for mf in matchfuncs) | ||||
|
r14675 | |||
|
r43346 | |||
|
r40810 | MAX_RE_SIZE = 20000 | ||
|
r43346 | |||
|
r40812 | def _joinregexes(regexps): | ||
"""gather multiple regular expressions into a single one""" | ||||
|
r43347 | return b'|'.join(regexps) | ||
|
r40812 | |||
|
r43346 | |||
|
r21111 | def _buildregexmatch(kindpats, globsuffix): | ||
"""Build a match function from a list of kinds and kindpats, | ||||
|
r40811 | return regexp string and a matcher function. | ||
Test too large input | ||||
>>> _buildregexmatch([ | ||||
|
r40983 | ... (b'relglob', b'?' * MAX_RE_SIZE, b'') | ||
... ], b'$') | ||||
|
r40811 | Traceback (most recent call last): | ||
... | ||||
|
r40814 | Abort: matcher pattern is too long (20009 bytes) | ||
|
r40811 | """ | ||
|
r8574 | try: | ||
|
r40813 | allgroups = [] | ||
regexps = [_regex(k, p, globsuffix) for (k, p, s) in kindpats] | ||||
fullregexp = _joinregexes(regexps) | ||||
startidx = 0 | ||||
|
r40818 | groupsize = 0 | ||
|
r40813 | for idx, r in enumerate(regexps): | ||
piecesize = len(r) | ||||
|
r40818 | if piecesize > MAX_RE_SIZE: | ||
|
r43347 | msg = _(b"matcher pattern is too long (%d bytes)") % piecesize | ||
|
r40814 | raise error.Abort(msg) | ||
|
r40816 | elif (groupsize + piecesize) > MAX_RE_SIZE: | ||
|
r40813 | group = regexps[startidx:idx] | ||
allgroups.append(_joinregexes(group)) | ||||
startidx = idx | ||||
|
r40818 | groupsize = 0 | ||
|
r40813 | groupsize += piecesize + 1 | ||
if startidx == 0: | ||||
|
r42256 | matcher = _rematcher(fullregexp) | ||
r42268 | func = lambda s: bool(matcher(s)) | |||
|
r40813 | else: | ||
group = regexps[startidx:] | ||||
allgroups.append(_joinregexes(group)) | ||||
allmatchers = [_rematcher(g) for g in allgroups] | ||||
func = lambda s: any(m(s) for m in allmatchers) | ||||
return fullregexp, func | ||||
|
r8574 | except re.error: | ||
|
r25213 | for k, p, s in kindpats: | ||
|
r8574 | try: | ||
|
r40818 | _rematcher(_regex(k, p, globsuffix)) | ||
|
r8574 | except re.error: | ||
|
r25213 | if s: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"%s: invalid pattern (%s): %s") % (s, k, p) | ||
|
r43346 | ) | ||
|
r25213 | else: | ||
|
r43347 | raise error.Abort(_(b"invalid pattern (%s): %s") % (k, p)) | ||
raise error.Abort(_(b"invalid pattern")) | ||||
|
r8574 | |||
|
r43346 | |||
|
r31013 | def _patternrootsanddirs(kindpats): | ||
'''Returns roots and directories corresponding to each pattern. | ||||
|
r21079 | |||
|
r31013 | This calculates the roots and directories exactly matching the patterns and | ||
returns a tuple of (roots, dirs) for each. It does not return other | ||||
directories which may also need to be considered, like the parent | ||||
directories. | ||||
|
r21079 | ''' | ||
|
r8576 | r = [] | ||
|
r31013 | d = [] | ||
|
r25213 | for kind, pat, source in kindpats: | ||
|
r43347 | if kind in (b'glob', b'rootglob'): # find the non-glob prefix | ||
|
r8584 | root = [] | ||
|
r43347 | for p in pat.split(b'/'): | ||
if b'[' in p or b'{' in p or b'*' in p or b'?' in p: | ||||
|
r8584 | break | ||
root.append(p) | ||||
|
r43347 | r.append(b'/'.join(root)) | ||
elif kind in (b'relpath', b'path'): | ||||
if pat == b'.': | ||||
pat = b'' | ||||
|
r42528 | r.append(pat) | ||
|
r43347 | elif kind in (b'rootfilesin',): | ||
if pat == b'.': | ||||
pat = b'' | ||||
|
r42528 | d.append(pat) | ||
|
r43346 | else: # relglob, re, relre | ||
|
r43347 | r.append(b'') | ||
|
r31013 | return r, d | ||
|
r43346 | |||
|
r31013 | def _roots(kindpats): | ||
'''Returns root directories to match recursively from the given patterns.''' | ||||
roots, dirs = _patternrootsanddirs(kindpats) | ||||
return roots | ||||
|
r43346 | |||
|
r38989 | def _rootsdirsandparents(kindpats): | ||
|
r31013 | '''Returns roots and exact directories from patterns. | ||
|
r38992 | `roots` are directories to match recursively, `dirs` should | ||
be matched non-recursively, and `parents` are the implicitly required | ||||
directories to walk to items in either roots or dirs. | ||||
Returns a tuple of (roots, dirs, parents). | ||||
|
r31013 | |||
r42559 | >>> r = _rootsdirsandparents( | |||
|
r34133 | ... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''), | ||
... (b'glob', b'g*', b'')]) | ||||
r42559 | >>> print(r[0:2], sorted(r[2])) # the set has an unstable output | |||
(['g/h', 'g/h', ''], []) ['', 'g'] | ||||
>>> r = _rootsdirsandparents( | ||||
|
r34133 | ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')]) | ||
r42559 | >>> print(r[0:2], sorted(r[2])) # the set has an unstable output | |||
([], ['g/h', '']) ['', 'g'] | ||||
>>> r = _rootsdirsandparents( | ||||
|
r34133 | ... [(b'relpath', b'r', b''), (b'path', b'p/p', b''), | ||
... (b'path', b'', b'')]) | ||||
r42559 | >>> print(r[0:2], sorted(r[2])) # the set has an unstable output | |||
(['r', 'p/p', ''], []) ['', 'p'] | ||||
>>> r = _rootsdirsandparents( | ||||
|
r34133 | ... [(b'relglob', b'rg*', b''), (b're', b're/', b''), | ||
... (b'relre', b'rr', b'')]) | ||||
r42559 | >>> print(r[0:2], sorted(r[2])) # the set has an unstable output | |||
(['', '', ''], []) [''] | ||||
|
r31013 | ''' | ||
r, d = _patternrootsanddirs(kindpats) | ||||
|
r42553 | p = set() | ||
# Add the parents as non-recursive/exact directories, since they must be | ||||
|
r31013 | # scanned to get to either the roots or the other exact directories. | ||
r43923 | p.update(pathutil.dirs(d)) | |||
p.update(pathutil.dirs(r)) | ||||
|
r31013 | |||
|
r39494 | # FIXME: all uses of this function convert these to sets, do so before | ||
# returning. | ||||
# FIXME: all uses of this function do not need anything in 'roots' and | ||||
# 'dirs' to also be in 'parents', consider removing them before returning. | ||||
|
r38989 | return r, d, p | ||
|
r8576 | |||
|
r43346 | |||
|
r31012 | def _explicitfiles(kindpats): | ||
'''Returns the potential explicit filenames from the patterns. | ||||
|
r34133 | >>> _explicitfiles([(b'path', b'foo/bar', b'')]) | ||
|
r31012 | ['foo/bar'] | ||
|
r34133 | >>> _explicitfiles([(b'rootfilesin', b'foo/bar', b'')]) | ||
|
r31012 | [] | ||
''' | ||||
# Keep only the pattern kinds where one can specify filenames (vs only | ||||
# directory names). | ||||
|
r43347 | filable = [kp for kp in kindpats if kp[0] not in (b'rootfilesin',)] | ||
|
r31012 | return _roots(filable) | ||
|
r43346 | |||
|
r33405 | def _prefix(kindpats): | ||
'''Whether all the patterns match a prefix (i.e. recursively)''' | ||||
|
r25213 | for kind, pat, source in kindpats: | ||
|
r43347 | if kind not in (b'path', b'relpath'): | ||
|
r33405 | return False | ||
return True | ||||
|
r25167 | |||
|
r43346 | |||
|
r25167 | _commentre = None | ||
|
r43346 | |||
|
r27595 | def readpatternfile(filepath, warn, sourceinfo=False): | ||
|
r25167 | '''parse a pattern file, returning a list of | ||
patterns. These patterns should be given to compile() | ||||
|
r25216 | to be validated and converted into a match function. | ||
trailing white space is dropped. | ||||
the escape character is backslash. | ||||
comments start with #. | ||||
empty lines are skipped. | ||||
lines can be of the following formats: | ||||
syntax: regexp # defaults following lines to non-rooted regexps | ||||
syntax: glob # defaults following lines to non-rooted globs | ||||
re:pattern # non-rooted regular expression | ||||
glob:pattern # non-rooted glob | ||||
|
r41318 | rootglob:pat # rooted glob (same root as ^ in regexps) | ||
|
r27595 | pattern # pattern of the current default type | ||
if sourceinfo is set, returns a list of tuples: | ||||
|
r42516 | (pattern, lineno, originalline). | ||
This is useful to debug ignore patterns. | ||||
|
r27595 | ''' | ||
|
r25216 | |||
|
r40721 | syntaxes = { | ||
|
r43347 | b're': b'relre:', | ||
b'regexp': b'relre:', | ||||
b'glob': b'relglob:', | ||||
b'rootglob': b'rootglob:', | ||||
b'include': b'include', | ||||
b'subinclude': b'subinclude', | ||||
|
r40721 | } | ||
|
r43347 | syntax = b'relre:' | ||
|
r25167 | patterns = [] | ||
|
r43347 | fp = open(filepath, b'rb') | ||
|
r30399 | for lineno, line in enumerate(util.iterfile(fp), start=1): | ||
|
r43347 | if b"#" in line: | ||
|
r25167 | global _commentre | ||
if not _commentre: | ||||
|
r31420 | _commentre = util.re.compile(br'((?:^|[^\\])(?:\\\\)*)#.*') | ||
|
r25167 | # remove comments prefixed by an even number of escapes | ||
|
r27327 | m = _commentre.search(line) | ||
if m: | ||||
|
r43346 | line = line[: m.end(1)] | ||
|
r25167 | # fixup properly escaped comments that survived the above | ||
|
r43347 | line = line.replace(b"\\#", b"#") | ||
|
r25167 | line = line.rstrip() | ||
if not line: | ||||
continue | ||||
|
r43347 | if line.startswith(b'syntax:'): | ||
|
r25167 | s = line[7:].strip() | ||
try: | ||||
syntax = syntaxes[s] | ||||
except KeyError: | ||||
|
r25214 | if warn: | ||
|
r43346 | warn( | ||
|
r43347 | _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s) | ||
|
r43346 | ) | ||
|
r25167 | continue | ||
linesyntax = syntax | ||||
|
r43376 | for s, rels in pycompat.iteritems(syntaxes): | ||
|
r25167 | if line.startswith(rels): | ||
linesyntax = rels | ||||
|
r43346 | line = line[len(rels) :] | ||
|
r25167 | break | ||
|
r43347 | elif line.startswith(s + b':'): | ||
|
r25167 | linesyntax = rels | ||
|
r43346 | line = line[len(s) + 1 :] | ||
|
r25167 | break | ||
|
r27595 | if sourceinfo: | ||
patterns.append((linesyntax + line, lineno, line)) | ||||
else: | ||||
patterns.append(linesyntax + line) | ||||
|
r25167 | fp.close() | ||
return patterns | ||||