This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6401

match: use '' instead of '.' for root directory (API)
ClosedPublic

Authored by martinvonz on May 17 2019, 1:57 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG27d6956d386b: match: use '' instead of '.' for root directory (API)
Summary

I think '' is generally a better value for the root directory than '.'
is. For example, os.path.join('', 'foo') => 'foo', while
os.path.join('.', 'foo') => './foo'.

This patch mostly makes it so we use '' internally in
match.py. However, it also affects the API in visitdir(),
visitchildrenset() and files(). The two former now also accept '' as
input. I've updated the callers of these methods. I've also added a
deprecation warning for passing '.' (for external callers). The only
caller I could find that was affected by files() returning '' instead
of '.' was in dirstate.walk(). I've updated that.

The next few patches show some workarounds we can remove by using ''
instead of '.'.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

Diff 15179

hgext/narrow/narrowcommands.py

todelete = [] todelete = []
for f, f2, size in repo.store.datafiles(): for f, f2, size in repo.store.datafiles():
if f.startswith('data/'): if f.startswith('data/'):
file = f[5:-2] file = f[5:-2]
if not newmatch(file): if not newmatch(file):
todelete.append(f) todelete.append(f)
elif f.startswith('meta/'): elif f.startswith('meta/'):
dir = f[5:-13] dir = f[5:-13]
dirs = ['.'] + sorted(util.dirs({dir})) + [dir] dirs = [''] + sorted(util.dirs({dir})) + [dir]
include = True include = True
for d in dirs: for d in dirs:
visit = newmatch.visitdir(d) visit = newmatch.visitdir(d)
if not visit: if not visit:
include = False include = False
break break
if visit == 'all': if visit == 'all':
break break

mercurial/changegroup.py

if clrevorder[clnode] < clrevorder[fclnode]: if clrevorder[clnode] < clrevorder[fclnode]:
fclnodes[n] = clnode fclnodes[n] = clnode
return clnode return clnode
return lookupmflinknode return lookupmflinknode
while tmfnodes: while tmfnodes:
tree, nodes = tmfnodes.popitem() tree, nodes = tmfnodes.popitem()
should_visit = self._matcher.visitdir(tree[:-1] or '.') should_visit = self._matcher.visitdir(tree[:-1])
if tree and not should_visit: if tree and not should_visit:
continue continue
store = mfl.getstorage(tree) store = mfl.getstorage(tree)
if not should_visit: if not should_visit:
# No nodes to send because this directory is out of # No nodes to send because this directory is out of
# the client's view of the repository (probably # the client's view of the repository (probably
self._repo, store, prunednodes, False, lookupfn, self._repo, store, prunednodes, False, lookupfn,
self._forcedeltaparentprev, self._forcedeltaparentprev,
ellipses=self._ellipses, ellipses=self._ellipses,
topic=_('manifests'), topic=_('manifests'),
clrevtolocalrev=clrevtolocalrev, clrevtolocalrev=clrevtolocalrev,
fullclnodes=self._fullclnodes, fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis) precomputedellipsis=self._precomputedellipsis)
if not self._oldmatcher.visitdir(store.tree[:-1] or '.'): if not self._oldmatcher.visitdir(store.tree[:-1]):
yield tree, deltas yield tree, deltas
else: else:
# 'deltas' is a generator and we need to consume it even if # 'deltas' is a generator and we need to consume it even if
# we are not going to send it because a side-effect is that # we are not going to send it because a side-effect is that
# it updates tmdnodes (via lookupfn) # it updates tmdnodes (via lookupfn)
for d in deltas: for d in deltas:
pass pass
if not tree: if not tree:

mercurial/dirstate.py

subpath = subrepos[j] + "/" subpath = subrepos[j] + "/"
if files[i] < subpath: if files[i] < subpath:
i += 1 i += 1
continue continue
while i < len(files) and files[i].startswith(subpath): while i < len(files) and files[i].startswith(subpath):
del files[i] del files[i]
j += 1 j += 1
if not files or '.' in files: if not files or '' in files:
files = ['.'] files = ['']
# constructing the foldmap is expensive, so don't do it for the # constructing the foldmap is expensive, so don't do it for the
# common case where files is ['.'] # common case where files is ['']
normalize = None normalize = None
results = dict.fromkeys(subrepos) results = dict.fromkeys(subrepos)
results['.hg'] = None results['.hg'] = None
for ff in files: for ff in files:
if normalize: if normalize:
nf = normalize(ff, False, True) nf = normalize(ff, False, True)
else: else:
while work: while work:
nd = work.pop() nd = work.pop()
visitentries = match.visitchildrenset(nd) visitentries = match.visitchildrenset(nd)
if not visitentries: if not visitentries:
continue continue
if visitentries == 'this' or visitentries == 'all': if visitentries == 'this' or visitentries == 'all':
visitentries = None visitentries = None
skip = None skip = None
if nd == '.': if nd != '':
nd = ''
else:
skip = '.hg' skip = '.hg'
try: try:
entries = listdir(join(nd), stat=True, skip=skip) entries = listdir(join(nd), stat=True, skip=skip)
except OSError as inst: except OSError as inst:
if inst.errno in (errno.EACCES, errno.ENOENT): if inst.errno in (errno.EACCES, errno.ENOENT):
match.bad(self.pathto(nd), match.bad(self.pathto(nd),
encoding.strtolocal(inst.strerror)) encoding.strtolocal(inst.strerror))
continue continue

mercurial/manifest.py

for fn in self: for fn in self:
if fn in fset: if fn in fset:
# specified pattern is the exact name # specified pattern is the exact name
fset.remove(fn) fset.remove(fn)
if match(fn): if match(fn):
yield fn yield fn
# for dirstate.walk, files=['.'] means "walk the whole tree". # for dirstate.walk, files=[''] means "walk the whole tree".
# follow that here, too # follow that here, too
fset.discard('.') fset.discard('')
for fn in sorted(fset): for fn in sorted(fset):
if not self.hasdir(fn): if not self.hasdir(fn):
match.bad(fn, None) match.bad(fn, None)
def matches(self, match): def matches(self, match):
'''generate a new manifest filtered by the match argument''' '''generate a new manifest filtered by the match argument'''
if match.always(): if match.always():
fset = set(match.files()) fset = set(match.files())
for fn in self._walk(match): for fn in self._walk(match):
if fn in fset: if fn in fset:
# specified pattern is the exact name # specified pattern is the exact name
fset.remove(fn) fset.remove(fn)
yield fn yield fn
# for dirstate.walk, files=['.'] means "walk the whole tree". # for dirstate.walk, files=[''] means "walk the whole tree".
# follow that here, too # follow that here, too
fset.discard('.') fset.discard('')
for fn in sorted(fset): for fn in sorted(fset):
if not self.hasdir(fn): if not self.hasdir(fn):
match.bad(fn, None) match.bad(fn, None)
def _walk(self, match): def _walk(self, match):
'''Recursively generates matching file names for walk().''' '''Recursively generates matching file names for walk().'''
visit = match.visitchildrenset(self._dir[:-1] or '.') visit = match.visitchildrenset(self._dir[:-1])
if not visit: if not visit:
return return
# yield this dir's files and walk its submanifests # yield this dir's files and walk its submanifests
self._load() self._load()
visit = self._loadchildrensetlazy(visit) visit = self._loadchildrensetlazy(visit)
for p in sorted(list(self._dirs) + list(self._files)): for p in sorted(list(self._dirs) + list(self._files)):
if p in self._files: if p in self._files:
return self.copy() return self.copy()
return self._matches(match) return self._matches(match)
def _matches(self, match): def _matches(self, match):
'''recursively generate a new manifest filtered by the match argument. '''recursively generate a new manifest filtered by the match argument.
''' '''
visit = match.visitchildrenset(self._dir[:-1] or '.') visit = match.visitchildrenset(self._dir[:-1])
if visit == 'all': if visit == 'all':
return self.copy() return self.copy()
ret = treemanifest(self._dir) ret = treemanifest(self._dir)
if not visit: if not visit:
return ret return ret
self._load() self._load()
for fn in self._files: for fn in self._files:
emptytree = treemanifest() emptytree = treemanifest()
def getnode(m, d): def getnode(m, d):
ld = m._lazydirs.get(d) ld = m._lazydirs.get(d)
if ld: if ld:
return ld[1] return ld[1]
return m._dirs.get(d, emptytree)._node return m._dirs.get(d, emptytree)._node
# let's skip investigating things that `match` says we do not need. # let's skip investigating things that `match` says we do not need.
visit = match.visitchildrenset(self._dir[:-1] or '.') visit = match.visitchildrenset(self._dir[:-1])
visit = self._loadchildrensetlazy(visit) visit = self._loadchildrensetlazy(visit)
if visit == 'this' or visit == 'all': if visit == 'this' or visit == 'all':
visit = None visit = None
for d, subm in self._dirs.iteritems(): for d, subm in self._dirs.iteritems():
if visit and d[:-1] not in visit: if visit and d[:-1] not in visit:
continue continue
subp1 = getnode(m1, d) subp1 = getnode(m1, d)
subp2 = getnode(m2, d) subp2 = getnode(m2, d)
if subp1 == nullid: if subp1 == nullid:
subp1, subp2 = subp2, subp1 subp1, subp2 = subp2, subp1
writesubtree(subm, subp1, subp2, match) writesubtree(subm, subp1, subp2, match)
def walksubtrees(self, matcher=None): def walksubtrees(self, matcher=None):
"""Returns an iterator of the subtrees of this manifest, including this """Returns an iterator of the subtrees of this manifest, including this
manifest itself. manifest itself.
If `matcher` is provided, it only returns subtrees that match. If `matcher` is provided, it only returns subtrees that match.
""" """
if matcher and not matcher.visitdir(self._dir[:-1] or '.'): if matcher and not matcher.visitdir(self._dir[:-1]):
return return
if not matcher or matcher(self._dir[:-1]): if not matcher or matcher(self._dir[:-1]):
yield self yield self
self._load() self._load()
# OPT: use visitchildrenset to avoid loading everything. # OPT: use visitchildrenset to avoid loading everything.
self._loadalllazy() self._loadalllazy()
for d, subm in self._dirs.iteritems(): for d, subm in self._dirs.iteritems():
`verify` - if True an exception will be thrown if the node is not in `verify` - if True an exception will be thrown if the node is not in
the revlog the revlog
""" """
if node in self._dirmancache.get(tree, ()): if node in self._dirmancache.get(tree, ()):
return self._dirmancache[tree][node] return self._dirmancache[tree][node]
if not self._narrowmatch.always(): if not self._narrowmatch.always():
if not self._narrowmatch.visitdir(tree[:-1] or '.'): if not self._narrowmatch.visitdir(tree[:-1]):
return excludeddirmanifestctx(tree, node) return excludeddirmanifestctx(tree, node)
if tree: if tree:
if self._rootstore._treeondisk: if self._rootstore._treeondisk:
if verify: if verify:
# Side-effect is LookupError is raised if node doesn't # Side-effect is LookupError is raised if node doesn't
# exist. # exist.
self.getstorage(tree).rev(node) self.getstorage(tree).rev(node)
# have on disk. # have on disk.
#self.p1, self.p2 = store.parents(node) #self.p1, self.p2 = store.parents(node)
#rev = store.rev(node) #rev = store.rev(node)
#self.linkrev = store.linkrev(rev) #self.linkrev = store.linkrev(rev)
def _storage(self): def _storage(self):
narrowmatch = self._manifestlog._narrowmatch narrowmatch = self._manifestlog._narrowmatch
if not narrowmatch.always(): if not narrowmatch.always():
if not narrowmatch.visitdir(self._dir[:-1] or '.'): if not narrowmatch.visitdir(self._dir[:-1]):
return excludedmanifestrevlog(self._dir) return excludedmanifestrevlog(self._dir)
return self._manifestlog.getstorage(self._dir) return self._manifestlog.getstorage(self._dir)
def read(self): def read(self):
if self._data is None: if self._data is None:
store = self._storage() store = self._storage()
if self._node == nullid: if self._node == nullid:
self._data = treemanifest() self._data = treemanifest()

mercurial/match.py

'all' | 'all' 'all' | 'all'
True | 'this' OR non-empty set of subdirs -or files- to visit True | 'this' OR non-empty set of subdirs -or files- to visit
Example: Example:
Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return
the following values (assuming the implementation of visitchildrenset the following values (assuming the implementation of visitchildrenset
is capable of recognizing this; some implementations are not). is capable of recognizing this; some implementations are not).
'.' -> {'foo', 'qux'} '' -> {'foo', 'qux'}
'baz' -> set() 'baz' -> set()
'foo' -> {'bar'} 'foo' -> {'bar'}
# Ideally this would be 'all', but since the prefix nature of matchers # Ideally this would be 'all', but since the prefix nature of matchers
# is applied to the entire matcher, we have to downgrade this to # is applied to the entire matcher, we have to downgrade this to
# 'this' due to the non-prefix 'rootfilesin'-kind matcher being mixed # 'this' due to the non-prefix 'rootfilesin'-kind matcher being mixed
# in. # in.
'foo/bar' -> 'this' 'foo/bar' -> 'this'
'qux' -> 'this' 'qux' -> 'this'
self._predrepr = predrepr self._predrepr = predrepr
@encoding.strmethod @encoding.strmethod
def __repr__(self): def __repr__(self):
s = (stringutil.buildrepr(self._predrepr) s = (stringutil.buildrepr(self._predrepr)
or pycompat.byterepr(self.matchfn)) or pycompat.byterepr(self.matchfn))
return '<predicatenmatcher pred=%s>' % s return '<predicatenmatcher pred=%s>' % s
def normalizerootdir(dir, funcname):
if dir == '.':
util.nouideprecwarn("match.%s() no longer accepts "
"'.', use '' instead." % funcname, '5.1')
return ''
return dir
class patternmatcher(basematcher): class patternmatcher(basematcher):
"""Matches a set of (kind, pat, source) against a 'root' directory. """Matches a set of (kind, pat, source) against a 'root' directory.
>>> kindpats = [ >>> kindpats = [
... (b're', br'.*\.c$', b''), ... (b're', br'.*\.c$', b''),
... (b'path', b'foo/a', b''), ... (b'path', b'foo/a', b''),
... (b'relpath', b'b', b''), ... (b'relpath', b'b', b''),
... (b'glob', b'*.h', b''), ... (b'glob', b'*.h', b''),
... ] ... ]
>>> m = patternmatcher(b'foo', kindpats) >>> m = patternmatcher(b'foo', kindpats)
>>> m(b'main.c') # matches re:.*\.c$ >>> m(b'main.c') # matches re:.*\.c$
True True
>>> m(b'b.txt') >>> m(b'b.txt')
False False
>>> m(b'foo/a') # matches path:foo/a >>> m(b'foo/a') # matches path:foo/a
True True
>>> m(b'a') # does not match path:b, since 'root' is 'foo' >>> m(b'a') # does not match path:b, since 'root' is 'foo'
False False
>>> m(b'b') # matches relpath:b, since 'root' is 'foo' >>> m(b'b') # matches relpath:b, since 'root' is 'foo'
True True
>>> m(b'lib.h') # matches glob:*.h >>> m(b'lib.h') # matches glob:*.h
True True
>>> m.files() >>> m.files()
['.', 'foo/a', 'b', '.'] ['', 'foo/a', 'b', '']
>>> m.exact(b'foo/a') >>> m.exact(b'foo/a')
True True
>>> m.exact(b'b') >>> m.exact(b'b')
True True
>>> m.exact(b'lib.h') # exact matches are for (rel)path kinds >>> m.exact(b'lib.h') # exact matches are for (rel)path kinds
False False
""" """
def __init__(self, root, kindpats, badfn=None): def __init__(self, root, kindpats, badfn=None):
super(patternmatcher, self).__init__(badfn) super(patternmatcher, self).__init__(badfn)
self._files = _explicitfiles(kindpats) self._files = _explicitfiles(kindpats)
self._prefix = _prefix(kindpats) self._prefix = _prefix(kindpats)
self._pats, self.matchfn = _buildmatch(kindpats, '$', root) self._pats, self.matchfn = _buildmatch(kindpats, '$', root)
@propertycache @propertycache
def _dirs(self): def _dirs(self):
return set(util.dirs(self._fileset)) | {'.'} return set(util.dirs(self._fileset)) | {''}
def visitdir(self, dir): def visitdir(self, dir):
dir = normalizerootdir(dir, 'visitdir')
if self._prefix and dir in self._fileset: if self._prefix and dir in self._fileset:
return 'all' return 'all'
return ('.' in self._fileset or return ('' in self._fileset or
dir in self._fileset or dir in self._fileset or
dir in self._dirs or dir in self._dirs or
any(parentdir in self._fileset any(parentdir in self._fileset
for parentdir in util.finddirs(dir))) for parentdir in util.finddirs(dir)))
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
ret = self.visitdir(dir) ret = self.visitdir(dir)
if ret is True: if ret is True:
def __init__(self, paths, onlyinclude=None): def __init__(self, paths, onlyinclude=None):
self._dirs = {} self._dirs = {}
self._onlyinclude = onlyinclude or [] self._onlyinclude = onlyinclude or []
addpath = self.addpath addpath = self.addpath
for f in paths: for f in paths:
addpath(f) addpath(f)
def addpath(self, path): def addpath(self, path):
if path == '.': if path == '':
return return
dirs = self._dirs dirs = self._dirs
findsplitdirs = _dirchildren._findsplitdirs findsplitdirs = _dirchildren._findsplitdirs
for d, b in findsplitdirs(path): for d, b in findsplitdirs(path):
if d not in self._onlyinclude: if d not in self._onlyinclude:
continue continue
dirs.setdefault(d, set()).add(b) dirs.setdefault(d, set()).add(b)
@staticmethod @staticmethod
def _findsplitdirs(path): def _findsplitdirs(path):
# yields (dirname, basename) tuples, walking back to the root. This is # yields (dirname, basename) tuples, walking back to the root. This is
# very similar to util.finddirs, except: # very similar to util.finddirs, except:
# - produces a (dirname, basename) tuple, not just 'dirname' # - produces a (dirname, basename) tuple, not just 'dirname'
# - includes root dir # - includes root dir
# Unlike manifest._splittopdir, this does not suffix `dirname` with a # Unlike manifest._splittopdir, this does not suffix `dirname` with a
# slash, and produces '.' for the root instead of ''. # slash.
oldpos = len(path) oldpos = len(path)
pos = path.rfind('/') pos = path.rfind('/')
while pos != -1: while pos != -1:
yield path[:pos], path[pos + 1:oldpos] yield path[:pos], path[pos + 1:oldpos]
oldpos = pos oldpos = pos
pos = path.rfind('/', 0, pos) pos = path.rfind('/', 0, pos)
yield '.', path[:oldpos] yield '', path[:oldpos]
def get(self, path): def get(self, path):
return self._dirs.get(path, set()) return self._dirs.get(path, set())
class includematcher(basematcher): class includematcher(basematcher):
def __init__(self, root, kindpats, badfn=None): def __init__(self, root, kindpats, badfn=None):
super(includematcher, self).__init__(badfn) super(includematcher, self).__init__(badfn)
self._pats, self.matchfn = _buildmatch(kindpats, '(?:/|$)', root) self._pats, self.matchfn = _buildmatch(kindpats, '(?:/|$)', root)
self._prefix = _prefix(kindpats) self._prefix = _prefix(kindpats)
roots, dirs, parents = _rootsdirsandparents(kindpats) roots, dirs, parents = _rootsdirsandparents(kindpats)
# roots are directories which are recursively included. # roots are directories which are recursively included.
self._roots = set(roots) self._roots = set(roots)
# dirs are directories which are non-recursively included. # dirs are directories which are non-recursively included.
self._dirs = set(dirs) self._dirs = set(dirs)
# parents are directories which are non-recursively included because # parents are directories which are non-recursively included because
# they are needed to get to items in _dirs or _roots. # they are needed to get to items in _dirs or _roots.
self._parents = set(parents) self._parents = set(parents)
def visitdir(self, dir): def visitdir(self, dir):
dir = normalizerootdir(dir, 'visitdir')
if self._prefix and dir in self._roots: if self._prefix and dir in self._roots:
return 'all' return 'all'
return ('.' in self._roots or return ('' in self._roots or
dir in self._roots or dir in self._roots or
dir in self._dirs or dir in self._dirs or
dir in self._parents or dir in self._parents or
any(parentdir in self._roots any(parentdir in self._roots
for parentdir in util.finddirs(dir))) for parentdir in util.finddirs(dir)))
@propertycache @propertycache
def _allparentschildren(self): def _allparentschildren(self):
# It may seem odd that we add dirs, roots, and parents, and then # It may seem odd that we add dirs, roots, and parents, and then
# restrict to only parents. This is to catch the case of: # restrict to only parents. This is to catch the case of:
# dirs = ['foo/bar'] # dirs = ['foo/bar']
# parents = ['foo'] # parents = ['foo']
# if we asked for the children of 'foo', but had only added # if we asked for the children of 'foo', but had only added
# self._parents, we wouldn't be able to respond ['bar']. # self._parents, we wouldn't be able to respond ['bar'].
return _dirchildren( return _dirchildren(
itertools.chain(self._dirs, self._roots, self._parents), itertools.chain(self._dirs, self._roots, self._parents),
onlyinclude=self._parents) onlyinclude=self._parents)
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
if self._prefix and dir in self._roots: if self._prefix and dir in self._roots:
return 'all' return 'all'
# Note: this does *not* include the 'dir in self._parents' case from # Note: this does *not* include the 'dir in self._parents' case from
# visitdir, that's handled below. # visitdir, that's handled below.
if ('.' in self._roots or if ('' in self._roots or
dir in self._roots or dir in self._roots or
dir in self._dirs or dir in self._dirs or
any(parentdir in self._roots any(parentdir in self._roots
for parentdir in util.finddirs(dir))): for parentdir in util.finddirs(dir))):
return 'this' return 'this'
if dir in self._parents: if dir in self._parents:
return self._allparentschildren.get(dir) or set() return self._allparentschildren.get(dir) or set()
self._files = files self._files = files
else: else:
self._files = list(files) self._files = list(files)
matchfn = basematcher.exact matchfn = basematcher.exact
@propertycache @propertycache
def _dirs(self): def _dirs(self):
return set(util.dirs(self._fileset)) | {'.'} return set(util.dirs(self._fileset)) | {''}
def visitdir(self, dir): def visitdir(self, dir):
dir = normalizerootdir(dir, 'visitdir')
return dir in self._dirs return dir in self._dirs
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
dir = normalizerootdir(dir, 'visitchildrenset')
if not self._fileset or dir not in self._dirs: if not self._fileset or dir not in self._dirs:
return set() return set()
candidates = self._fileset | self._dirs - {'.'} candidates = self._fileset | self._dirs - {''}
if dir != '.': if dir != '':
d = dir + '/' d = dir + '/'
candidates = set(c[len(d):] for c in candidates if candidates = set(c[len(d):] for c in candidates if
c.startswith(d)) c.startswith(d))
# self._dirs includes all of the directories, recursively, so if # self._dirs includes all of the directories, recursively, so if
# we're attempting to match foo/bar/baz.txt, it'll have '.', 'foo', # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo',
# 'foo/bar' in it. Thus we can safely ignore a candidate that has a # '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 # '/' in it, indicating a it's for a subdir-of-a-subdir; the
# immediate subdir will be in there without a slash. # immediate subdir will be in there without a slash.
ret = {c for c in candidates if '/' not in c} ret = {c for c in candidates if '/' not in c}
# We really do not expect ret to be empty, since that would imply that # 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. # there's something in _dirs that didn't have a file in _fileset.
assert ret assert ret
return ret return ret
if m1_set in ['all', 'this']: if m1_set in ['all', 'this']:
# Never return 'all' here if m2_set is any kind of non-empty (either # 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 # 'this' or set(foo)), since m2 might return set() for a
# subdirectory. # subdirectory.
return 'this' return 'this'
# Possible values for m1: set(...), set() # Possible values for m1: set(...), set()
# Possible values for m2: 'this', set(...) # Possible values for m2: 'this', set(...)
# We ignore m2's set results. They're possibly incorrect: # We ignore m2's set results. They're possibly incorrect:
# m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset('.'): # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''):
# m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd
# return set(), which is *not* correct, we still need to visit 'dir'! # return set(), which is *not* correct, we still need to visit 'dir'!
return m1_set return m1_set
def isexact(self): def isexact(self):
return self._m1.isexact() return self._m1.isexact()
@encoding.strmethod @encoding.strmethod
def matchfn(self, f): def matchfn(self, f):
# Some information is lost in the superclass's constructor, so we # Some information is lost in the superclass's constructor, so we
# can not accurately create the matching function for the subdirectory # can not accurately create the matching function for the subdirectory
# from the inputs. Instead, we override matchfn() and visitdir() to # from the inputs. Instead, we override matchfn() and visitdir() to
# call the original matcher with the subdirectory path prepended. # call the original matcher with the subdirectory path prepended.
return self._matcher.matchfn(self._path + "/" + f) return self._matcher.matchfn(self._path + "/" + f)
def visitdir(self, dir): def visitdir(self, dir):
if dir == '.': dir = normalizerootdir(dir, 'visitdir')
if dir == '':
dir = self._path dir = self._path
else: else:
dir = self._path + "/" + dir dir = self._path + "/" + dir
return self._matcher.visitdir(dir) return self._matcher.visitdir(dir)
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
if dir == '.': dir = normalizerootdir(dir, 'visitchildrenset')
if dir == '':
dir = self._path dir = self._path
else: else:
dir = self._path + "/" + dir dir = self._path + "/" + dir
return self._matcher.visitchildrenset(dir) return self._matcher.visitchildrenset(dir)
def always(self): def always(self):
return self._always return self._always
def matchfn(self, f): def matchfn(self, f):
if not f.startswith(self._pathprefix): if not f.startswith(self._pathprefix):
return False return False
return self._matcher.matchfn(f[len(self._pathprefix):]) return self._matcher.matchfn(f[len(self._pathprefix):])
@propertycache @propertycache
def _pathdirs(self): def _pathdirs(self):
return set(util.finddirs(self._path)) | {'.'} return set(util.finddirs(self._path)) | {''}
def visitdir(self, dir): def visitdir(self, dir):
if dir == self._path: if dir == self._path:
return self._matcher.visitdir('.') return self._matcher.visitdir('')
if dir.startswith(self._pathprefix): if dir.startswith(self._pathprefix):
return self._matcher.visitdir(dir[len(self._pathprefix):]) return self._matcher.visitdir(dir[len(self._pathprefix):])
return dir in self._pathdirs return dir in self._pathdirs
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
if dir == self._path: if dir == self._path:
return self._matcher.visitchildrenset('.') return self._matcher.visitchildrenset('')
if dir.startswith(self._pathprefix): if dir.startswith(self._pathprefix):
return self._matcher.visitchildrenset(dir[len(self._pathprefix):]) return self._matcher.visitchildrenset(dir[len(self._pathprefix):])
if dir in self._pathdirs: if dir in self._pathdirs:
return 'this' return 'this'
return set() return set()
def isexact(self): def isexact(self):
return self._matcher.isexact() return self._matcher.isexact()
pat, pat,
globsuffix globsuffix
) )
except rustext.filepatterns.PatternError: except rustext.filepatterns.PatternError:
raise error.ProgrammingError( raise error.ProgrammingError(
'not a regex pattern: %s:%s' % (kind, pat) 'not a regex pattern: %s:%s' % (kind, pat)
) )
if not pat: if not pat and kind in ('glob', 'relpath'):
return '' return ''
if kind == 're': if kind == 're':
return pat return pat
if kind in ('path', 'relpath'): if kind in ('path', 'relpath'):
if pat == '.': if pat == '.':
return '' return ''
return util.stringutil.reescape(pat) + '(?:/|$)' return util.stringutil.reescape(pat) + '(?:/|$)'
if kind == 'rootfilesin': if kind == 'rootfilesin':
d = [] d = []
for kind, pat, source in kindpats: for kind, pat, source in kindpats:
if kind in ('glob', 'rootglob'): # find the non-glob prefix if kind in ('glob', 'rootglob'): # find the non-glob prefix
root = [] root = []
for p in pat.split('/'): for p in pat.split('/'):
if '[' in p or '{' in p or '*' in p or '?' in p: if '[' in p or '{' in p or '*' in p or '?' in p:
break break
root.append(p) root.append(p)
r.append('/'.join(root) or '.') r.append('/'.join(root))
elif kind in ('relpath', 'path'): elif kind in ('relpath', 'path'):
r.append(pat or '.') if pat == '.':
pat = ''
r.append(pat)
elif kind in ('rootfilesin',): elif kind in ('rootfilesin',):
d.append(pat or '.') if pat == '.':
pat = ''
d.append(pat)
else: # relglob, re, relre else: # relglob, re, relre
r.append('.') r.append('')
return r, d return r, d
def _roots(kindpats): def _roots(kindpats):
'''Returns root directories to match recursively from the given patterns.''' '''Returns root directories to match recursively from the given patterns.'''
roots, dirs = _patternrootsanddirs(kindpats) roots, dirs = _patternrootsanddirs(kindpats)
return roots return roots
def _rootsdirsandparents(kindpats): def _rootsdirsandparents(kindpats):
'''Returns roots and exact directories from patterns. '''Returns roots and exact directories from patterns.
`roots` are directories to match recursively, `dirs` should `roots` are directories to match recursively, `dirs` should
be matched non-recursively, and `parents` are the implicitly required be matched non-recursively, and `parents` are the implicitly required
directories to walk to items in either roots or dirs. directories to walk to items in either roots or dirs.
Returns a tuple of (roots, dirs, parents). Returns a tuple of (roots, dirs, parents).
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''), ... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''),
... (b'glob', b'g*', b'')]) ... (b'glob', b'g*', b'')])
(['g/h', 'g/h', '.'], [], ['g', '.']) (['g/h', 'g/h', ''], [], ['g', ''])
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')]) ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')])
([], ['g/h', '.'], ['g', '.']) ([], ['g/h', ''], ['g', ''])
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'relpath', b'r', b''), (b'path', b'p/p', b''), ... [(b'relpath', b'r', b''), (b'path', b'p/p', b''),
... (b'path', b'', b'')]) ... (b'path', b'', b'')])
(['r', 'p/p', '.'], [], ['p', '.']) (['r', 'p/p', ''], [], ['p', ''])
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'relglob', b'rg*', b''), (b're', b're/', b''), ... [(b'relglob', b'rg*', b''), (b're', b're/', b''),
... (b'relre', b'rr', b'')]) ... (b'relre', b'rr', b'')])
(['.', '.', '.'], [], ['.']) (['', '', ''], [], [''])
''' '''
r, d = _patternrootsanddirs(kindpats) r, d = _patternrootsanddirs(kindpats)
p = [] p = []
# Append the parents as non-recursive/exact directories, since they must be # Append the parents as non-recursive/exact directories, since they must be
# scanned to get to either the roots or the other exact directories. # scanned to get to either the roots or the other exact directories.
p.extend(util.dirs(d)) p.extend(util.dirs(d))
p.extend(util.dirs(r)) p.extend(util.dirs(r))
# util.dirs() does not include the root directory, so add it manually # util.dirs() does not include the root directory, so add it manually
p.append('.') p.append('')
# FIXME: all uses of this function convert these to sets, do so before # FIXME: all uses of this function convert these to sets, do so before
# returning. # returning.
# FIXME: all uses of this function do not need anything in 'roots' and # FIXME: all uses of this function do not need anything in 'roots' and
# 'dirs' to also be in 'parents', consider removing them before returning. # 'dirs' to also be in 'parents', consider removing them before returning.
return r, d, p return r, d, p
def _explicitfiles(kindpats): def _explicitfiles(kindpats):

mercurial/store.py

If matcher is None, returns True""" If matcher is None, returns True"""
if matcher is None: if matcher is None:
return True return True
path = decodedir(path) path = decodedir(path)
if path.startswith('data/'): if path.startswith('data/'):
return matcher(path[len('data/'):-len('.i')]) return matcher(path[len('data/'):-len('.i')])
elif path.startswith('meta/'): elif path.startswith('meta/'):
return matcher.visitdir(path[len('meta/'):-len('/00manifest.i')] or '.') return matcher.visitdir(path[len('meta/'):-len('/00manifest.i')])
raise error.ProgrammingError("cannot decode path %s" % path) raise error.ProgrammingError("cannot decode path %s" % path)
# This avoids a collision between a file named foo and a dir named # This avoids a collision between a file named foo and a dir named
# foo.i or foo.d # foo.i or foo.d
def _encodedir(path): def _encodedir(path):
''' '''
>>> _encodedir(b'data/foo.i') >>> _encodedir(b'data/foo.i')

relnotes/next

== Backwards Compatibility Changes == == Backwards Compatibility Changes ==
== Internal API Changes == == Internal API Changes ==
* Matchers are no longer iterable. Use `match.files()` instead. * Matchers are no longer iterable. Use `match.files()` instead.
* `match.visitdir()` and `match.visitchildrenset()` now expect the
empty string instead of '.' to indicate the root directory.

tests/test-match.py

from __future__ import absolute_import from __future__ import absolute_import
import unittest import unittest
import silenttestrunner import silenttestrunner
from mercurial import ( from mercurial import (
match as matchmod, match as matchmod,
util, util,
) )
class BaseMatcherTests(unittest.TestCase): class BaseMatcherTests(unittest.TestCase):
def testVisitdir(self): def testVisitdir(self):
m = matchmod.basematcher() m = matchmod.basematcher()
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.basematcher() m = matchmod.basematcher()
self.assertEqual(m.visitchildrenset(b'.'), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
class AlwaysMatcherTests(unittest.TestCase): class AlwaysMatcherTests(unittest.TestCase):
def testVisitdir(self): def testVisitdir(self):
m = matchmod.alwaysmatcher() m = matchmod.alwaysmatcher()
self.assertEqual(m.visitdir(b'.'), b'all') self.assertEqual(m.visitdir(b''), b'all')
self.assertEqual(m.visitdir(b'dir'), b'all') self.assertEqual(m.visitdir(b'dir'), b'all')
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.alwaysmatcher() m = matchmod.alwaysmatcher()
self.assertEqual(m.visitchildrenset(b'.'), b'all') self.assertEqual(m.visitchildrenset(b''), b'all')
self.assertEqual(m.visitchildrenset(b'dir'), b'all') self.assertEqual(m.visitchildrenset(b'dir'), b'all')
class NeverMatcherTests(unittest.TestCase): class NeverMatcherTests(unittest.TestCase):
def testVisitdir(self): def testVisitdir(self):
m = matchmod.nevermatcher() m = matchmod.nevermatcher()
self.assertFalse(m.visitdir(b'.')) self.assertFalse(m.visitdir(b''))
self.assertFalse(m.visitdir(b'dir')) self.assertFalse(m.visitdir(b'dir'))
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.nevermatcher() m = matchmod.nevermatcher()
self.assertEqual(m.visitchildrenset(b'.'), set()) self.assertEqual(m.visitchildrenset(b''), set())
self.assertEqual(m.visitchildrenset(b'dir'), set()) self.assertEqual(m.visitchildrenset(b'dir'), set())
class PredicateMatcherTests(unittest.TestCase): class PredicateMatcherTests(unittest.TestCase):
# predicatematcher does not currently define either of these methods, so # predicatematcher does not currently define either of these methods, so
# this is equivalent to BaseMatcherTests. # this is equivalent to BaseMatcherTests.
def testVisitdir(self): def testVisitdir(self):
m = matchmod.predicatematcher(lambda *a: False) m = matchmod.predicatematcher(lambda *a: False)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.predicatematcher(lambda *a: False) m = matchmod.predicatematcher(lambda *a: False)
self.assertEqual(m.visitchildrenset(b'.'), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
class PatternMatcherTests(unittest.TestCase): class PatternMatcherTests(unittest.TestCase):
def testVisitdirPrefix(self): def testVisitdirPrefix(self):
m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir']) m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertEqual(m.visitdir(b'dir/subdir'), b'all') self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrensetPrefix(self): def testVisitchildrensetPrefix(self):
m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir']) m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertEqual(m.visitchildrenset(b'.'), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitdirRootfilesin(self): def testVisitdirRootfilesin(self):
m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir']) m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertFalse(m.visitdir(b'dir/subdir/x')) self.assertFalse(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
# FIXME: These should probably be True. # FIXME: These should probably be True.
self.assertFalse(m.visitdir(b'dir')) self.assertFalse(m.visitdir(b'dir'))
self.assertFalse(m.visitdir(b'dir/subdir')) self.assertFalse(m.visitdir(b'dir/subdir'))
def testVisitchildrensetRootfilesin(self): def testVisitchildrensetRootfilesin(self):
m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir']) m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertEqual(m.visitchildrenset(b'.'), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
# FIXME: These should probably be {'subdir'} and 'this', respectively, # FIXME: These should probably be {'subdir'} and 'this', respectively,
# or at least 'this' and 'this'. # or at least 'this' and 'this'.
self.assertEqual(m.visitchildrenset(b'dir'), set()) self.assertEqual(m.visitchildrenset(b'dir'), set())
self.assertEqual(m.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())
def testVisitdirGlob(self): def testVisitdirGlob(self):
m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*']) m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
# OPT: these should probably be False. # OPT: these should probably be False.
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
def testVisitchildrensetGlob(self): def testVisitchildrensetGlob(self):
m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*']) m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertEqual(m.visitchildrenset(b'.'), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
# OPT: these should probably be set(). # OPT: these should probably be set().
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
class IncludeMatcherTests(unittest.TestCase): class IncludeMatcherTests(unittest.TestCase):
def testVisitdirPrefix(self): def testVisitdirPrefix(self):
m = matchmod.match(b'x', b'', include=[b'path:dir/subdir']) m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertEqual(m.visitdir(b'dir/subdir'), b'all') self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrensetPrefix(self): def testVisitchildrensetPrefix(self):
m = matchmod.match(b'x', b'', include=[b'path:dir/subdir']) m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertEqual(m.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitdirRootfilesin(self): def testVisitdirRootfilesin(self):
m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir']) m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertFalse(m.visitdir(b'dir/subdir/x')) self.assertFalse(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrensetRootfilesin(self): def testVisitchildrensetRootfilesin(self):
m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir']) m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertEqual(m.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitdirGlob(self): def testVisitdirGlob(self):
m = matchmod.match(b'x', b'', include=[b'glob:dir/z*']) m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
# OPT: these should probably be False. # OPT: these should probably be False.
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
def testVisitchildrensetGlob(self): def testVisitchildrensetGlob(self):
m = matchmod.match(b'x', b'', include=[b'glob:dir/z*']) m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertEqual(m.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
# OPT: these should probably be set(). # OPT: these should probably be set().
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
class ExactMatcherTests(unittest.TestCase): class ExactMatcherTests(unittest.TestCase):
def testVisitdir(self): def testVisitdir(self):
m = matchmod.exact(files=[b'dir/subdir/foo.txt']) m = matchmod.exact(files=[b'dir/subdir/foo.txt'])
assert isinstance(m, matchmod.exactmatcher) assert isinstance(m, matchmod.exactmatcher)
self.assertTrue(m.visitdir(b'.')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertFalse(m.visitdir(b'dir/subdir/foo.txt')) self.assertFalse(m.visitdir(b'dir/subdir/foo.txt'))
self.assertFalse(m.visitdir(b'dir/foo')) self.assertFalse(m.visitdir(b'dir/foo'))
self.assertFalse(m.visitdir(b'dir/subdir/x')) self.assertFalse(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.exact(files=[b'dir/subdir/foo.txt']) m = matchmod.exact(files=[b'dir/subdir/foo.txt'])
assert isinstance(m, matchmod.exactmatcher) assert isinstance(m, matchmod.exactmatcher)
self.assertEqual(m.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'}) self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'})
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(m.visitchildrenset(b'dir/subdir/foo.txt'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir/foo.txt'), set())
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitchildrensetFilesAndDirs(self): def testVisitchildrensetFilesAndDirs(self):
m = matchmod.exact(files=[b'rootfile.txt', m = matchmod.exact(files=[b'rootfile.txt',
b'a/file1.txt', b'a/file1.txt',
b'a/b/file2.txt', b'a/b/file2.txt',
# no file in a/b/c # no file in a/b/c
b'a/b/c/d/file4.txt']) b'a/b/c/d/file4.txt'])
assert isinstance(m, matchmod.exactmatcher) assert isinstance(m, matchmod.exactmatcher)
self.assertEqual(m.visitchildrenset(b'.'), {b'a', b'rootfile.txt'}) self.assertEqual(m.visitchildrenset(b''), {b'a', b'rootfile.txt'})
self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'}) self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'})
self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'}) self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'})
self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'}) self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'})
self.assertEqual(m.visitchildrenset(b'a/b/c/d'), {b'file4.txt'}) self.assertEqual(m.visitchildrenset(b'a/b/c/d'), {b'file4.txt'})
self.assertEqual(m.visitchildrenset(b'a/b/c/d/e'), set()) self.assertEqual(m.visitchildrenset(b'a/b/c/d/e'), set())
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
class DifferenceMatcherTests(unittest.TestCase): class DifferenceMatcherTests(unittest.TestCase):
def testVisitdirM2always(self): def testVisitdirM2always(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
# dm should be equivalent to a nevermatcher. # dm should be equivalent to a nevermatcher.
self.assertFalse(dm.visitdir(b'.')) self.assertFalse(dm.visitdir(b''))
self.assertFalse(dm.visitdir(b'dir')) self.assertFalse(dm.visitdir(b'dir'))
self.assertFalse(dm.visitdir(b'dir/subdir')) self.assertFalse(dm.visitdir(b'dir/subdir'))
self.assertFalse(dm.visitdir(b'dir/subdir/z')) self.assertFalse(dm.visitdir(b'dir/subdir/z'))
self.assertFalse(dm.visitdir(b'dir/foo')) self.assertFalse(dm.visitdir(b'dir/foo'))
self.assertFalse(dm.visitdir(b'dir/subdir/x')) self.assertFalse(dm.visitdir(b'dir/subdir/x'))
self.assertFalse(dm.visitdir(b'folder')) self.assertFalse(dm.visitdir(b'folder'))
def testVisitchildrensetM2always(self): def testVisitchildrensetM2always(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
# dm should be equivalent to a nevermatcher. # dm should be equivalent to a nevermatcher.
self.assertEqual(dm.visitchildrenset(b'.'), set()) self.assertEqual(dm.visitchildrenset(b''), set())
self.assertEqual(dm.visitchildrenset(b'dir'), set()) self.assertEqual(dm.visitchildrenset(b'dir'), set())
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(dm.visitchildrenset(b'dir/foo'), set()) self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(dm.visitchildrenset(b'folder'), set()) self.assertEqual(dm.visitchildrenset(b'folder'), set())
def testVisitdirM2never(self): def testVisitdirM2never(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.nevermatcher() m2 = matchmod.nevermatcher()
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
# dm should be equivalent to a alwaysmatcher. # dm should be equivalent to a alwaysmatcher.
# #
# We're testing Equal-to-True instead of just 'assertTrue' since # We're testing Equal-to-True instead of just 'assertTrue' since
# assertTrue does NOT verify that it's a bool, just that it's truthy. # assertTrue does NOT verify that it's a bool, just that it's truthy.
# While we may want to eventually make these return 'all', they should # While we may want to eventually make these return 'all', they should
# not currently do so. # not currently do so.
self.assertEqual(dm.visitdir(b'.'), b'all') self.assertEqual(dm.visitdir(b''), b'all')
self.assertEqual(dm.visitdir(b'dir'), b'all') self.assertEqual(dm.visitdir(b'dir'), b'all')
self.assertEqual(dm.visitdir(b'dir/subdir'), b'all') self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')
self.assertEqual(dm.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(dm.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(dm.visitdir(b'dir/foo'), b'all') self.assertEqual(dm.visitdir(b'dir/foo'), b'all')
self.assertEqual(dm.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(dm.visitdir(b'dir/subdir/x'), b'all')
self.assertEqual(dm.visitdir(b'folder'), b'all') self.assertEqual(dm.visitdir(b'folder'), b'all')
def testVisitchildrensetM2never(self): def testVisitchildrensetM2never(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.nevermatcher() m2 = matchmod.nevermatcher()
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
# dm should be equivalent to a alwaysmatcher. # dm should be equivalent to a alwaysmatcher.
self.assertEqual(dm.visitchildrenset(b'.'), b'all') self.assertEqual(dm.visitchildrenset(b''), b'all')
self.assertEqual(dm.visitchildrenset(b'dir'), b'all') self.assertEqual(dm.visitchildrenset(b'dir'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(dm.visitchildrenset(b'folder'), b'all') self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
def testVisitdirM2SubdirPrefix(self): def testVisitdirM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitdir(b'.'), True) self.assertEqual(dm.visitdir(b''), True)
self.assertEqual(dm.visitdir(b'dir'), True) self.assertEqual(dm.visitdir(b'dir'), True)
self.assertFalse(dm.visitdir(b'dir/subdir')) self.assertFalse(dm.visitdir(b'dir/subdir'))
# OPT: We should probably return False for these; we don't because # OPT: We should probably return False for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just True. # an 'all' pattern, just True.
self.assertEqual(dm.visitdir(b'dir/subdir/z'), True) self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
self.assertEqual(dm.visitdir(b'dir/subdir/x'), True) self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
self.assertEqual(dm.visitdir(b'dir/foo'), b'all') self.assertEqual(dm.visitdir(b'dir/foo'), b'all')
self.assertEqual(dm.visitdir(b'folder'), b'all') self.assertEqual(dm.visitdir(b'folder'), b'all')
def testVisitchildrensetM2SubdirPrefix(self): def testVisitchildrensetM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitchildrenset(b'.'), b'this') self.assertEqual(dm.visitchildrenset(b''), b'this')
self.assertEqual(dm.visitchildrenset(b'dir'), b'this') self.assertEqual(dm.visitchildrenset(b'dir'), b'this')
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(dm.visitchildrenset(b'folder'), b'all') self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
# OPT: We should probably return set() for these; we don't because # OPT: We should probably return set() for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just 'this'. # an 'all' pattern, just 'this'.
self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeIncludfe(self): def testVisitdirIncludeIncludfe(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitdir(b'.'), True) self.assertEqual(dm.visitdir(b''), True)
self.assertEqual(dm.visitdir(b'dir'), True) self.assertEqual(dm.visitdir(b'dir'), True)
self.assertEqual(dm.visitdir(b'dir/subdir'), b'all') self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')
self.assertFalse(dm.visitdir(b'dir/foo')) self.assertFalse(dm.visitdir(b'dir/foo'))
self.assertFalse(dm.visitdir(b'folder')) self.assertFalse(dm.visitdir(b'folder'))
# OPT: We should probably return False for these; we don't because # OPT: We should probably return False for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just True. # an 'all' pattern, just True.
self.assertEqual(dm.visitdir(b'dir/subdir/z'), True) self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
self.assertEqual(dm.visitdir(b'dir/subdir/x'), True) self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude(self): def testVisitchildrensetIncludeInclude(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(dm.visitchildrenset(b''), {b'dir'})
self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/foo'), set()) self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
self.assertEqual(dm.visitchildrenset(b'folder'), set()) self.assertEqual(dm.visitchildrenset(b'folder'), set())
# OPT: We should probably return set() for these; we don't because # OPT: We should probably return set() for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just 'this'. # an 'all' pattern, just 'this'.
self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
class IntersectionMatcherTests(unittest.TestCase): class IntersectionMatcherTests(unittest.TestCase):
def testVisitdirM2always(self): def testVisitdirM2always(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# im should be equivalent to a alwaysmatcher. # im should be equivalent to a alwaysmatcher.
self.assertEqual(im.visitdir(b'.'), b'all') self.assertEqual(im.visitdir(b''), b'all')
self.assertEqual(im.visitdir(b'dir'), b'all') self.assertEqual(im.visitdir(b'dir'), b'all')
self.assertEqual(im.visitdir(b'dir/subdir'), b'all') self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
self.assertEqual(im.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(im.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(im.visitdir(b'dir/foo'), b'all') self.assertEqual(im.visitdir(b'dir/foo'), b'all')
self.assertEqual(im.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(im.visitdir(b'dir/subdir/x'), b'all')
self.assertEqual(im.visitdir(b'folder'), b'all') self.assertEqual(im.visitdir(b'folder'), b'all')
def testVisitchildrensetM2always(self): def testVisitchildrensetM2always(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# im should be equivalent to a alwaysmatcher. # im should be equivalent to a alwaysmatcher.
self.assertEqual(im.visitchildrenset(b'.'), b'all') self.assertEqual(im.visitchildrenset(b''), b'all')
self.assertEqual(im.visitchildrenset(b'dir'), b'all') self.assertEqual(im.visitchildrenset(b'dir'), b'all')
self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(im.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(im.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(im.visitchildrenset(b'folder'), b'all') self.assertEqual(im.visitchildrenset(b'folder'), b'all')
def testVisitdirM2never(self): def testVisitdirM2never(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.nevermatcher() m2 = matchmod.nevermatcher()
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# im should be equivalent to a nevermatcher. # im should be equivalent to a nevermatcher.
self.assertFalse(im.visitdir(b'.')) self.assertFalse(im.visitdir(b''))
self.assertFalse(im.visitdir(b'dir')) self.assertFalse(im.visitdir(b'dir'))
self.assertFalse(im.visitdir(b'dir/subdir')) self.assertFalse(im.visitdir(b'dir/subdir'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
def testVisitchildrensetM2never(self): def testVisitchildrensetM2never(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.nevermatcher() m2 = matchmod.nevermatcher()
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# im should be equivalent to a nevermqtcher. # im should be equivalent to a nevermqtcher.
self.assertEqual(im.visitchildrenset(b'.'), set()) self.assertEqual(im.visitchildrenset(b''), set())
self.assertEqual(im.visitchildrenset(b'dir'), set()) self.assertEqual(im.visitchildrenset(b'dir'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
def testVisitdirM2SubdirPrefix(self): def testVisitdirM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitdir(b'.'), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertEqual(im.visitdir(b'dir/subdir'), b'all') self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
# OPT: We should probably return 'all' for these; we don't because # OPT: We should probably return 'all' for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just True. # an 'all' pattern, just True.
self.assertEqual(im.visitdir(b'dir/subdir/z'), True) self.assertEqual(im.visitdir(b'dir/subdir/z'), True)
self.assertEqual(im.visitdir(b'dir/subdir/x'), True) self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetM2SubdirPrefix(self): def testVisitchildrensetM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
# OPT: We should probably return 'all' for these # OPT: We should probably return 'all' for these
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeIncludfe(self): def testVisitdirIncludeIncludfe(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitdir(b'.'), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertFalse(im.visitdir(b'dir/subdir')) self.assertFalse(im.visitdir(b'dir/subdir'))
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
def testVisitchildrensetIncludeInclude(self): def testVisitchildrensetIncludeInclude(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), b'this') self.assertEqual(im.visitchildrenset(b'dir'), b'this')
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude2(self): def testVisitdirIncludeInclude2(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'path:folder']) m2 = matchmod.match(b'', b'', include=[b'path:folder'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# FIXME: is True correct here? # FIXME: is True correct here?
self.assertEqual(im.visitdir(b'.'), True) self.assertEqual(im.visitdir(b''), True)
self.assertFalse(im.visitdir(b'dir')) self.assertFalse(im.visitdir(b'dir'))
self.assertFalse(im.visitdir(b'dir/subdir')) self.assertFalse(im.visitdir(b'dir/subdir'))
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
def testVisitchildrensetIncludeInclude2(self): def testVisitchildrensetIncludeInclude2(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'path:folder']) m2 = matchmod.match(b'', b'', include=[b'path:folder'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# FIXME: is set() correct here? # FIXME: is set() correct here?
self.assertEqual(im.visitchildrenset(b'.'), set()) self.assertEqual(im.visitchildrenset(b''), set())
self.assertEqual(im.visitchildrenset(b'dir'), set()) self.assertEqual(im.visitchildrenset(b'dir'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude3(self): def testVisitdirIncludeInclude3(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitdir(b'.'), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertEqual(im.visitdir(b'dir/subdir'), True) self.assertEqual(im.visitdir(b'dir/subdir'), True)
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
# OPT: this should probably be 'all' not True. # OPT: this should probably be 'all' not True.
self.assertEqual(im.visitdir(b'dir/subdir/x'), True) self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude3(self): def testVisitchildrensetIncludeInclude3(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'}) self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
# OPT: this should probably be 'all' not 'this'. # OPT: this should probably be 'all' not 'this'.
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude4(self): def testVisitdirIncludeInclude4(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# OPT: these next three could probably be False as well. # OPT: these next three could probably be False as well.
self.assertEqual(im.visitdir(b'.'), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertEqual(im.visitdir(b'dir/subdir'), True) self.assertEqual(im.visitdir(b'dir/subdir'), True)
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
def testVisitchildrensetIncludeInclude4(self): def testVisitchildrensetIncludeInclude4(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# OPT: these next two could probably be set() as well. # OPT: these next two could probably be set() as well.
self.assertEqual(im.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
class UnionMatcherTests(unittest.TestCase): class UnionMatcherTests(unittest.TestCase):
def testVisitdirM2always(self): def testVisitdirM2always(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# um should be equivalent to a alwaysmatcher. # um should be equivalent to a alwaysmatcher.
self.assertEqual(um.visitdir(b'.'), b'all') self.assertEqual(um.visitdir(b''), b'all')
self.assertEqual(um.visitdir(b'dir'), b'all') self.assertEqual(um.visitdir(b'dir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/foo'), b'all') self.assertEqual(um.visitdir(b'dir/foo'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
def testVisitchildrensetM2always(self): def testVisitchildrensetM2always(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# um should be equivalent to a alwaysmatcher. # um should be equivalent to a alwaysmatcher.
self.assertEqual(um.visitchildrenset(b'.'), b'all') self.assertEqual(um.visitchildrenset(b''), b'all')
self.assertEqual(um.visitchildrenset(b'dir'), b'all') self.assertEqual(um.visitchildrenset(b'dir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
def testVisitdirM1never(self): def testVisitdirM1never(self):
m1 = matchmod.nevermatcher() m1 = matchmod.nevermatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# um should be equivalent to a alwaysmatcher. # um should be equivalent to a alwaysmatcher.
self.assertEqual(um.visitdir(b'.'), b'all') self.assertEqual(um.visitdir(b''), b'all')
self.assertEqual(um.visitdir(b'dir'), b'all') self.assertEqual(um.visitdir(b'dir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/foo'), b'all') self.assertEqual(um.visitdir(b'dir/foo'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
def testVisitchildrensetM1never(self): def testVisitchildrensetM1never(self):
m1 = matchmod.nevermatcher() m1 = matchmod.nevermatcher()
m2 = matchmod.alwaysmatcher() m2 = matchmod.alwaysmatcher()
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# um should be equivalent to a alwaysmatcher. # um should be equivalent to a alwaysmatcher.
self.assertEqual(um.visitchildrenset(b'.'), b'all') self.assertEqual(um.visitchildrenset(b''), b'all')
self.assertEqual(um.visitchildrenset(b'dir'), b'all') self.assertEqual(um.visitchildrenset(b'dir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
def testVisitdirM2never(self): def testVisitdirM2never(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.nevermatcher() m2 = matchmod.nevermatcher()
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# um should be equivalent to a alwaysmatcher. # um should be equivalent to a alwaysmatcher.
self.assertEqual(um.visitdir(b'.'), b'all') self.assertEqual(um.visitdir(b''), b'all')
self.assertEqual(um.visitdir(b'dir'), b'all') self.assertEqual(um.visitdir(b'dir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/foo'), b'all') self.assertEqual(um.visitdir(b'dir/foo'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
def testVisitchildrensetM2never(self): def testVisitchildrensetM2never(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.nevermatcher() m2 = matchmod.nevermatcher()
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# um should be equivalent to a alwaysmatcher. # um should be equivalent to a alwaysmatcher.
self.assertEqual(um.visitchildrenset(b'.'), b'all') self.assertEqual(um.visitchildrenset(b''), b'all')
self.assertEqual(um.visitchildrenset(b'dir'), b'all') self.assertEqual(um.visitchildrenset(b'dir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
def testVisitdirM2SubdirPrefix(self): def testVisitdirM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b'.'), b'all') self.assertEqual(um.visitdir(b''), b'all')
self.assertEqual(um.visitdir(b'dir'), b'all') self.assertEqual(um.visitdir(b'dir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertEqual(um.visitdir(b'dir/foo'), b'all') self.assertEqual(um.visitdir(b'dir/foo'), b'all')
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
def testVisitchildrensetM2SubdirPrefix(self): def testVisitchildrensetM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b'.'), b'all') self.assertEqual(um.visitchildrenset(b''), b'all')
self.assertEqual(um.visitchildrenset(b'dir'), b'all') self.assertEqual(um.visitchildrenset(b'dir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeIncludfe(self): def testVisitdirIncludeIncludfe(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b'.'), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertFalse(um.visitdir(b'folder')) self.assertFalse(um.visitdir(b'folder'))
# OPT: These two should probably be 'all' not True. # OPT: These two should probably be 'all' not True.
self.assertEqual(um.visitdir(b'dir/subdir/z'), True) self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
self.assertEqual(um.visitdir(b'dir/subdir/x'), True) self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude(self): def testVisitchildrensetIncludeInclude(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), b'this') self.assertEqual(um.visitchildrenset(b'dir'), b'this')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), set()) self.assertEqual(um.visitchildrenset(b'folder'), set())
# OPT: These next two could be 'all' instead of 'this'. # OPT: These next two could be 'all' instead of 'this'.
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude2(self): def testVisitdirIncludeInclude2(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'path:folder']) m2 = matchmod.match(b'', b'', include=[b'path:folder'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b'.'), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
# OPT: These should probably be 'all' not True. # OPT: These should probably be 'all' not True.
self.assertEqual(um.visitdir(b'dir/subdir/z'), True) self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
self.assertEqual(um.visitdir(b'dir/subdir/x'), True) self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude2(self): def testVisitchildrensetIncludeInclude2(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
m2 = matchmod.match(b'', b'', include=[b'path:folder']) m2 = matchmod.match(b'', b'', include=[b'path:folder'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b'.'), {b'folder', b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'folder', b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
# OPT: These next two could be 'all' instead of 'this'. # OPT: These next two could be 'all' instead of 'this'.
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude3(self): def testVisitdirIncludeInclude3(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b'.'), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertFalse(um.visitdir(b'folder')) self.assertFalse(um.visitdir(b'folder'))
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
# OPT: this should probably be 'all' not True. # OPT: this should probably be 'all' not True.
self.assertEqual(um.visitdir(b'dir/subdir/z'), True) self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
def testVisitchildrensetIncludeInclude3(self): def testVisitchildrensetIncludeInclude3(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), set()) self.assertEqual(um.visitchildrenset(b'folder'), set())
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
# OPT: this should probably be 'all' not 'this'. # OPT: this should probably be 'all' not 'this'.
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude4(self): def testVisitdirIncludeInclude4(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# OPT: these next three could probably be False as well. # OPT: these next three could probably be False as well.
self.assertEqual(um.visitdir(b'.'), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), True) self.assertEqual(um.visitdir(b'dir/subdir'), True)
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertFalse(um.visitdir(b'folder')) self.assertFalse(um.visitdir(b'folder'))
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
def testVisitchildrensetIncludeInclude4(self): def testVisitchildrensetIncludeInclude4(self):
m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b'.'), {b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'}) self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'})
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), set()) self.assertEqual(um.visitchildrenset(b'folder'), set())
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
class SubdirMatcherTests(unittest.TestCase): class SubdirMatcherTests(unittest.TestCase):
def testVisitdir(self): def testVisitdir(self):
m = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
sm = matchmod.subdirmatcher(b'dir', m) sm = matchmod.subdirmatcher(b'dir', m)
self.assertEqual(sm.visitdir(b'.'), True) self.assertEqual(sm.visitdir(b''), True)
self.assertEqual(sm.visitdir(b'subdir'), b'all') self.assertEqual(sm.visitdir(b'subdir'), b'all')
# OPT: These next two should probably be 'all' not True. # OPT: These next two should probably be 'all' not True.
self.assertEqual(sm.visitdir(b'subdir/x'), True) self.assertEqual(sm.visitdir(b'subdir/x'), True)
self.assertEqual(sm.visitdir(b'subdir/z'), True) self.assertEqual(sm.visitdir(b'subdir/z'), True)
self.assertFalse(sm.visitdir(b'foo')) self.assertFalse(sm.visitdir(b'foo'))
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.match(b'', b'', include=[b'path:dir/subdir']) m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
sm = matchmod.subdirmatcher(b'dir', m) sm = matchmod.subdirmatcher(b'dir', m)
self.assertEqual(sm.visitchildrenset(b'.'), {b'subdir'}) self.assertEqual(sm.visitchildrenset(b''), {b'subdir'})
self.assertEqual(sm.visitchildrenset(b'subdir'), b'all') self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')
# OPT: These next two should probably be 'all' not 'this'. # OPT: These next two should probably be 'all' not 'this'.
self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this') self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this')
self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this') self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this')
self.assertEqual(sm.visitchildrenset(b'foo'), set()) self.assertEqual(sm.visitchildrenset(b'foo'), set())
class PrefixdirMatcherTests(unittest.TestCase): class PrefixdirMatcherTests(unittest.TestCase):
# The prefix matcher re-adds 'd' to the paths, so they need to be # The prefix matcher re-adds 'd' to the paths, so they need to be
# specified when using the prefixdirmatcher. # specified when using the prefixdirmatcher.
self.assertEqual(bool(pm(b'a.txt')), False) self.assertEqual(bool(pm(b'a.txt')), False)
self.assertEqual(bool(pm(b'b.txt')), False) self.assertEqual(bool(pm(b'b.txt')), False)
self.assertEqual(bool(pm(b'd/e/a.txt')), True) self.assertEqual(bool(pm(b'd/e/a.txt')), True)
self.assertEqual(bool(pm(b'd/e/b.txt')), False) self.assertEqual(bool(pm(b'd/e/b.txt')), False)
self.assertEqual(bool(pm(b'd/e/f/b.txt')), True) self.assertEqual(bool(pm(b'd/e/f/b.txt')), True)
self.assertEqual(m.visitdir(b'.'), True) self.assertEqual(m.visitdir(b''), True)
self.assertEqual(m.visitdir(b'e'), True) self.assertEqual(m.visitdir(b'e'), True)
self.assertEqual(m.visitdir(b'e/f'), True) self.assertEqual(m.visitdir(b'e/f'), True)
self.assertEqual(m.visitdir(b'e/f/g'), False) self.assertEqual(m.visitdir(b'e/f/g'), False)
self.assertEqual(pm.visitdir(b'.'), True) self.assertEqual(pm.visitdir(b''), True)
self.assertEqual(pm.visitdir(b'd'), True) self.assertEqual(pm.visitdir(b'd'), True)
self.assertEqual(pm.visitdir(b'd/e'), True) self.assertEqual(pm.visitdir(b'd/e'), True)
self.assertEqual(pm.visitdir(b'd/e/f'), True) self.assertEqual(pm.visitdir(b'd/e/f'), True)
self.assertEqual(pm.visitdir(b'd/e/f/g'), False) self.assertEqual(pm.visitdir(b'd/e/f/g'), False)
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.match(util.localpath(b'root/d'), b'e/f', m = matchmod.match(util.localpath(b'root/d'), b'e/f',
[b'../a.txt', b'b.txt']) [b'../a.txt', b'b.txt'])
pm = matchmod.prefixdirmatcher(b'd', m) pm = matchmod.prefixdirmatcher(b'd', m)
# OPT: visitchildrenset could possibly return {'e'} and {'f'} for these # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these
# next two, respectively; patternmatcher does not have this # next two, respectively; patternmatcher does not have this
# optimization. # optimization.
self.assertEqual(m.visitchildrenset(b'.'), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'e'), b'this') self.assertEqual(m.visitchildrenset(b'e'), b'this')
self.assertEqual(m.visitchildrenset(b'e/f'), b'this') self.assertEqual(m.visitchildrenset(b'e/f'), b'this')
self.assertEqual(m.visitchildrenset(b'e/f/g'), set()) self.assertEqual(m.visitchildrenset(b'e/f/g'), set())
# OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'} # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'}
# for these next three, respectively; patternmatcher does not have this # for these next three, respectively; patternmatcher does not have this
# optimization. # optimization.
self.assertEqual(pm.visitchildrenset(b'.'), b'this') self.assertEqual(pm.visitchildrenset(b''), b'this')
self.assertEqual(pm.visitchildrenset(b'd'), b'this') self.assertEqual(pm.visitchildrenset(b'd'), b'this')
self.assertEqual(pm.visitchildrenset(b'd/e'), b'this') self.assertEqual(pm.visitchildrenset(b'd/e'), b'this')
self.assertEqual(pm.visitchildrenset(b'd/e/f'), b'this') self.assertEqual(pm.visitchildrenset(b'd/e/f'), b'this')
self.assertEqual(pm.visitchildrenset(b'd/e/f/g'), set()) self.assertEqual(pm.visitchildrenset(b'd/e/f/g'), set())
if __name__ == '__main__': if __name__ == '__main__':
silenttestrunner.main(__name__) silenttestrunner.main(__name__)