| hg-reviewers |
Most matchers no longer need the root and cwd
arguments. patternmatcher and includematcher still need the root
argument for subincludes.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext/sparse.py (2 lines) | |||
| M | mercurial/fileset.py (5 lines) | |||
| M | mercurial/localrepo.py (2 lines) | |||
| M | mercurial/match.py (85 lines) | |||
| M | mercurial/sparse.py (2 lines) | |||
| M | mercurial/subrepo.py (3 lines) | |||
| M | tests/test-match.py (88 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz |
| def _setupdirstate(ui): | def _setupdirstate(ui): | ||||
| """Modify the dirstate to prevent stat'ing excluded files, | """Modify the dirstate to prevent stat'ing excluded files, | ||||
| and to prevent modifications to files outside the checkout. | and to prevent modifications to files outside the checkout. | ||||
| """ | """ | ||||
| def walk(orig, self, match, subrepos, unknown, ignored, full=True): | def walk(orig, self, match, subrepos, unknown, ignored, full=True): | ||||
| # hack to not exclude explicitly-specified paths so that they can | # hack to not exclude explicitly-specified paths so that they can | ||||
| # be warned later on e.g. dirstate.add() | # be warned later on e.g. dirstate.add() | ||||
| em = matchmod.exact(match._root, match._cwd, match.files()) | em = matchmod.exact(None, None, match.files()) | ||||
| sm = matchmod.unionmatcher([self._sparsematcher, em]) | sm = matchmod.unionmatcher([self._sparsematcher, em]) | ||||
| match = matchmod.intersectmatchers(match, sm) | match = matchmod.intersectmatchers(match, sm) | ||||
| return orig(self, match, subrepos, unknown, ignored, full) | return orig(self, match, subrepos, unknown, ignored, full) | ||||
| extensions.wrapfunction(dirstate.dirstate, 'walk', walk) | extensions.wrapfunction(dirstate.dirstate, 'walk', walk) | ||||
| # dirstate.rebuild should not add non-matching files | # dirstate.rebuild should not add non-matching files | ||||
| def _rebuild(orig, self, parent, allfiles, changedfiles=None): | def _rebuild(orig, self, parent, allfiles, changedfiles=None): | ||||
| def matcher(self, patterns): | def matcher(self, patterns): | ||||
| return self.ctx.match(patterns, badfn=self._badfn) | return self.ctx.match(patterns, badfn=self._badfn) | ||||
| def predicate(self, predfn, predrepr=None, cache=False): | def predicate(self, predfn, predrepr=None, cache=False): | ||||
| """Create a matcher to select files by predfn(filename)""" | """Create a matcher to select files by predfn(filename)""" | ||||
| if cache: | if cache: | ||||
| predfn = util.cachefunc(predfn) | predfn = util.cachefunc(predfn) | ||||
| repo = self.ctx.repo() | return matchmod.predicatematcher(predfn, predrepr=predrepr, | ||||
| return matchmod.predicatematcher(repo.root, repo.getcwd(), predfn, | badfn=self._badfn) | ||||
| predrepr=predrepr, badfn=self._badfn) | |||||
| def fpredicate(self, predfn, predrepr=None, cache=False): | def fpredicate(self, predfn, predrepr=None, cache=False): | ||||
| """Create a matcher to select files by predfn(fctx) at the current | """Create a matcher to select files by predfn(fctx) at the current | ||||
| revision | revision | ||||
| Missing files are ignored. | Missing files are ignored. | ||||
| """ | """ | ||||
| ctx = self.ctx | ctx = self.ctx | ||||
| If `includeexact` is True, then any exact matches from `match` will | If `includeexact` is True, then any exact matches from `match` will | ||||
| be included even if they're outside the narrowspec. | be included even if they're outside the narrowspec. | ||||
| """ | """ | ||||
| if match: | if match: | ||||
| if includeexact and not self._narrowmatch.always(): | if includeexact and not self._narrowmatch.always(): | ||||
| # do not exclude explicitly-specified paths so that they can | # do not exclude explicitly-specified paths so that they can | ||||
| # be warned later on | # be warned later on | ||||
| em = matchmod.exact(match._root, match._cwd, match.files()) | em = matchmod.exact(None, None, match.files()) | ||||
| nm = matchmod.unionmatcher([self._narrowmatch, em]) | nm = matchmod.unionmatcher([self._narrowmatch, em]) | ||||
| return matchmod.intersectmatchers(match, nm) | return matchmod.intersectmatchers(match, nm) | ||||
| return matchmod.intersectmatchers(match, self._narrowmatch) | return matchmod.intersectmatchers(match, self._narrowmatch) | ||||
| return self._narrowmatch | return self._narrowmatch | ||||
| def setnarrowpats(self, newincludes, newexcludes): | def setnarrowpats(self, newincludes, newexcludes): | ||||
| narrowspec.save(self, newincludes, newexcludes) | narrowspec.save(self, newincludes, newexcludes) | ||||
| self.invalidate(clearfilecache=True) | self.invalidate(clearfilecache=True) | ||||
| matcher function''' | matcher function''' | ||||
| m = util.re.compile(regex) | m = util.re.compile(regex) | ||||
| try: | try: | ||||
| # slightly faster, provided by facebook's re2 bindings | # slightly faster, provided by facebook's re2 bindings | ||||
| return m.test_match | return m.test_match | ||||
| except AttributeError: | except AttributeError: | ||||
| return m.match | return m.match | ||||
| def _expandsets(root, cwd, kindpats, ctx, listsubrepos, badfn): | def _expandsets(kindpats, ctx, listsubrepos, badfn): | ||||
| '''Returns the kindpats list with the 'set' patterns expanded to matchers''' | '''Returns the kindpats list with the 'set' patterns expanded to matchers''' | ||||
| matchers = [] | matchers = [] | ||||
| other = [] | other = [] | ||||
| for kind, pat, source in kindpats: | for kind, pat, source in kindpats: | ||||
| if kind == 'set': | if kind == 'set': | ||||
| if ctx is None: | if ctx is None: | ||||
| raise error.ProgrammingError("fileset expression with no " | raise error.ProgrammingError("fileset expression with no " | ||||
| "context") | "context") | ||||
| matchers.append(ctx.matchfileset(pat, badfn=badfn)) | matchers.append(ctx.matchfileset(pat, badfn=badfn)) | ||||
| if listsubrepos: | if listsubrepos: | ||||
| for subpath in ctx.substate: | for subpath in ctx.substate: | ||||
| sm = ctx.sub(subpath).matchfileset(pat, badfn=badfn) | sm = ctx.sub(subpath).matchfileset(pat, badfn=badfn) | ||||
| pm = prefixdirmatcher(root, cwd, subpath, sm, badfn=badfn) | pm = prefixdirmatcher(subpath, sm, badfn=badfn) | ||||
| matchers.append(pm) | matchers.append(pm) | ||||
| continue | continue | ||||
| other.append((kind, pat, source)) | other.append((kind, pat, source)) | ||||
| return matchers, other | return matchers, other | ||||
| def _expandsubinclude(kindpats, root): | def _expandsubinclude(kindpats, root): | ||||
| '''Returns the list of subinclude matcher args and the kindpats without the | '''Returns the list of subinclude matcher args and the kindpats without the | ||||
| """"Checks whether the kindspats match everything, as e.g. | """"Checks whether the kindspats match everything, as e.g. | ||||
| 'relpath:.' does. | 'relpath:.' does. | ||||
| """ | """ | ||||
| for kind, pat, source in kindpats: | for kind, pat, source in kindpats: | ||||
| if pat != '' or kind not in ['relpath', 'glob']: | if pat != '' or kind not in ['relpath', 'glob']: | ||||
| return False | return False | ||||
| return True | return True | ||||
| def _buildkindpatsmatcher(matchercls, root, cwd, kindpats, ctx=None, | def _buildkindpatsmatcher(matchercls, root, kindpats, ctx=None, | ||||
| listsubrepos=False, badfn=None): | listsubrepos=False, badfn=None): | ||||
| matchers = [] | matchers = [] | ||||
| fms, kindpats = _expandsets(root, cwd, kindpats, ctx=ctx, | fms, kindpats = _expandsets(kindpats, ctx=ctx, | ||||
| listsubrepos=listsubrepos, badfn=badfn) | listsubrepos=listsubrepos, badfn=badfn) | ||||
| if kindpats: | if kindpats: | ||||
| m = matchercls(root, cwd, kindpats, badfn=badfn) | m = matchercls(root, kindpats, badfn=badfn) | ||||
| matchers.append(m) | matchers.append(m) | ||||
| if fms: | if fms: | ||||
| matchers.extend(fms) | matchers.extend(fms) | ||||
| if not matchers: | if not matchers: | ||||
| return nevermatcher(root, cwd, badfn=badfn) | return nevermatcher(badfn=badfn) | ||||
| if len(matchers) == 1: | if len(matchers) == 1: | ||||
| return matchers[0] | return matchers[0] | ||||
| return unionmatcher(matchers) | return unionmatcher(matchers) | ||||
| def match(root, cwd, patterns=None, include=None, exclude=None, default='glob', | def match(root, cwd, patterns=None, include=None, exclude=None, default='glob', | ||||
| auditor=None, ctx=None, listsubrepos=False, warn=None, | auditor=None, ctx=None, listsubrepos=False, warn=None, | ||||
| badfn=None, icasefs=False): | badfn=None, icasefs=False): | ||||
| """build an object to match a set of file patterns | """build an object to match a set of file patterns | ||||
| kindpats.append((kind, p, source)) | kindpats.append((kind, p, source)) | ||||
| kindpats.append((kind, pats, source)) | kindpats.append((kind, pats, source)) | ||||
| return kindpats | return kindpats | ||||
| if patterns: | if patterns: | ||||
| kindpats = normalize(patterns, default, root, cwd, auditor, warn) | kindpats = normalize(patterns, default, root, cwd, auditor, warn) | ||||
| if _kindpatsalwaysmatch(kindpats): | if _kindpatsalwaysmatch(kindpats): | ||||
| m = alwaysmatcher(root, cwd, badfn) | m = alwaysmatcher(badfn) | ||||
| else: | else: | ||||
| m = _buildkindpatsmatcher(patternmatcher, root, cwd, kindpats, | m = _buildkindpatsmatcher(patternmatcher, root, kindpats, ctx=ctx, | ||||
| ctx=ctx, listsubrepos=listsubrepos, | listsubrepos=listsubrepos, badfn=badfn) | ||||
| badfn=badfn) | |||||
| else: | else: | ||||
| # It's a little strange that no patterns means to match everything. | # It's a little strange that no patterns means to match everything. | ||||
| # Consider changing this to match nothing (probably using nevermatcher). | # Consider changing this to match nothing (probably using nevermatcher). | ||||
| m = alwaysmatcher(root, cwd, badfn) | m = alwaysmatcher(badfn) | ||||
| if include: | if include: | ||||
| kindpats = normalize(include, 'glob', root, cwd, auditor, warn) | kindpats = normalize(include, 'glob', root, cwd, auditor, warn) | ||||
| im = _buildkindpatsmatcher(includematcher, root, cwd, kindpats, ctx=ctx, | im = _buildkindpatsmatcher(includematcher, root, kindpats, ctx=ctx, | ||||
| listsubrepos=listsubrepos, badfn=None) | listsubrepos=listsubrepos, badfn=None) | ||||
| m = intersectmatchers(m, im) | m = intersectmatchers(m, im) | ||||
| if exclude: | if exclude: | ||||
| kindpats = normalize(exclude, 'glob', root, cwd, auditor, warn) | kindpats = normalize(exclude, 'glob', root, cwd, auditor, warn) | ||||
| em = _buildkindpatsmatcher(includematcher, root, cwd, kindpats, ctx=ctx, | em = _buildkindpatsmatcher(includematcher, root, kindpats, ctx=ctx, | ||||
| listsubrepos=listsubrepos, badfn=None) | listsubrepos=listsubrepos, badfn=None) | ||||
| m = differencematcher(m, em) | m = differencematcher(m, em) | ||||
| return m | return m | ||||
| def exact(root, cwd, files, badfn=None): | def exact(root, cwd, files, badfn=None): | ||||
| return exactmatcher(root, cwd, files, badfn=badfn) | return exactmatcher(files, badfn=badfn) | ||||
| def always(root, cwd, badfn=None): | def always(root, cwd, badfn=None): | ||||
| return alwaysmatcher(root, cwd, badfn=badfn) | return alwaysmatcher(badfn=badfn) | ||||
| def never(root, cwd, badfn=None): | def never(root, cwd, badfn=None): | ||||
| return nevermatcher(root, cwd, badfn=badfn) | return nevermatcher(badfn=badfn) | ||||
| def badmatch(match, badfn): | def badmatch(match, badfn): | ||||
| """Make a copy of the given matcher, replacing its bad method with the given | """Make a copy of the given matcher, replacing its bad method with the given | ||||
| one. | one. | ||||
| """ | """ | ||||
| m = copy.copy(match) | m = copy.copy(match) | ||||
| m.bad = badfn | m.bad = badfn | ||||
| return m | return m | ||||
| (pat, stringutil.forcebytestr(inst.strerror))) | (pat, stringutil.forcebytestr(inst.strerror))) | ||||
| continue | continue | ||||
| # else: re or relre - which cannot be normalized | # else: re or relre - which cannot be normalized | ||||
| kindpats.append((kind, pat, '')) | kindpats.append((kind, pat, '')) | ||||
| return kindpats | return kindpats | ||||
| class basematcher(object): | class basematcher(object): | ||||
| def __init__(self, root, cwd, badfn=None): | def __init__(self, badfn=None): | ||||
| self._root = root | |||||
| self._cwd = cwd | |||||
| if badfn is not None: | if badfn is not None: | ||||
| self.bad = badfn | self.bad = badfn | ||||
| def __call__(self, fn): | def __call__(self, fn): | ||||
| return self.matchfn(fn) | return self.matchfn(fn) | ||||
| def __iter__(self): | def __iter__(self): | ||||
| for f in self._files: | for f in self._files: | ||||
| yield f | yield f | ||||
| def anypats(self): | def anypats(self): | ||||
| '''None of .always(), .isexact(), and .prefix() is true -- | '''None of .always(), .isexact(), and .prefix() is true -- | ||||
| optimizations will be difficult.''' | optimizations will be difficult.''' | ||||
| return not self.always() and not self.isexact() and not self.prefix() | return not self.always() and not self.isexact() and not self.prefix() | ||||
| class alwaysmatcher(basematcher): | class alwaysmatcher(basematcher): | ||||
| '''Matches everything.''' | '''Matches everything.''' | ||||
| def __init__(self, root, cwd, badfn=None): | def __init__(self, badfn=None): | ||||
| super(alwaysmatcher, self).__init__(root, cwd, badfn) | super(alwaysmatcher, self).__init__(badfn) | ||||
| def always(self): | def always(self): | ||||
| return True | return True | ||||
| def matchfn(self, f): | def matchfn(self, f): | ||||
| return True | return True | ||||
| def visitdir(self, dir): | def visitdir(self, dir): | ||||
| return 'all' | return 'all' | ||||
| def visitchildrenset(self, dir): | def visitchildrenset(self, dir): | ||||
| return 'all' | return 'all' | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return r'<alwaysmatcher>' | return r'<alwaysmatcher>' | ||||
| class nevermatcher(basematcher): | class nevermatcher(basematcher): | ||||
| '''Matches nothing.''' | '''Matches nothing.''' | ||||
| def __init__(self, root, cwd, badfn=None): | def __init__(self, badfn=None): | ||||
| super(nevermatcher, self).__init__(root, cwd, badfn) | super(nevermatcher, self).__init__(badfn) | ||||
| # It's a little weird to say that the nevermatcher is an exact matcher | # It's a little weird to say that the nevermatcher is an exact matcher | ||||
| # or a prefix matcher, but it seems to make sense to let callers take | # or a prefix matcher, but it seems to make sense to let callers take | ||||
| # fast paths based on either. There will be no exact matches, nor any | # fast paths based on either. There will be no exact matches, nor any | ||||
| # prefixes (files() returns []), so fast paths iterating over them should | # prefixes (files() returns []), so fast paths iterating over them should | ||||
| # be efficient (and correct). | # be efficient (and correct). | ||||
| def isexact(self): | def isexact(self): | ||||
| return True | return True | ||||
| def prefix(self): | def prefix(self): | ||||
| return True | return True | ||||
| def visitdir(self, dir): | def visitdir(self, dir): | ||||
| return False | return False | ||||
| def visitchildrenset(self, dir): | def visitchildrenset(self, dir): | ||||
| return set() | return set() | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return r'<nevermatcher>' | return r'<nevermatcher>' | ||||
| class predicatematcher(basematcher): | class predicatematcher(basematcher): | ||||
| """A matcher adapter for a simple boolean function""" | """A matcher adapter for a simple boolean function""" | ||||
| def __init__(self, root, cwd, predfn, predrepr=None, badfn=None): | def __init__(self, predfn, predrepr=None, badfn=None): | ||||
| super(predicatematcher, self).__init__(root, cwd, badfn) | super(predicatematcher, self).__init__(badfn) | ||||
| self.matchfn = predfn | self.matchfn = predfn | ||||
| 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 | ||||
| class patternmatcher(basematcher): | class patternmatcher(basematcher): | ||||
| def __init__(self, root, cwd, kindpats, badfn=None): | def __init__(self, root, kindpats, badfn=None): | ||||
| super(patternmatcher, self).__init__(root, cwd, 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)) | {'.'} | ||||
| 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, cwd, kindpats, badfn=None): | def __init__(self, root, kindpats, badfn=None): | ||||
| super(includematcher, self).__init__(root, cwd, 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) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<includematcher includes=%r>' % pycompat.bytestr(self._pats)) | return ('<includematcher includes=%r>' % pycompat.bytestr(self._pats)) | ||||
| class exactmatcher(basematcher): | class exactmatcher(basematcher): | ||||
| '''Matches the input files exactly. They are interpreted as paths, not | '''Matches the input files exactly. They are interpreted as paths, not | ||||
| patterns (so no kind-prefixes). | patterns (so no kind-prefixes). | ||||
| ''' | ''' | ||||
| def __init__(self, root, cwd, files, badfn=None): | def __init__(self, files, badfn=None): | ||||
| super(exactmatcher, self).__init__(root, cwd, badfn) | super(exactmatcher, self).__init__(badfn) | ||||
| if isinstance(files, list): | if isinstance(files, list): | ||||
| self._files = files | self._files = files | ||||
| else: | else: | ||||
| self._files = list(files) | self._files = list(files) | ||||
| matchfn = basematcher.exact | matchfn = basematcher.exact | ||||
| @encoding.strmethod | @encoding.strmethod | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<exactmatcher files=%r>' % self._files) | return ('<exactmatcher files=%r>' % self._files) | ||||
| class differencematcher(basematcher): | class differencematcher(basematcher): | ||||
| '''Composes two matchers by matching if the first matches and the second | '''Composes two matchers by matching if the first matches and the second | ||||
| does not. | does not. | ||||
| The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, | The second matcher's non-matching-attributes (bad, explicitdir, | ||||
| traversedir) are ignored. | traversedir) are ignored. | ||||
| ''' | ''' | ||||
| def __init__(self, m1, m2): | def __init__(self, m1, m2): | ||||
| super(differencematcher, self).__init__(m1._root, m1._cwd) | super(differencematcher, self).__init__() | ||||
| self._m1 = m1 | self._m1 = m1 | ||||
| self._m2 = m2 | self._m2 = m2 | ||||
| self.bad = m1.bad | self.bad = m1.bad | ||||
| self.explicitdir = m1.explicitdir | self.explicitdir = m1.explicitdir | ||||
| self.traversedir = m1.traversedir | self.traversedir = m1.traversedir | ||||
| def matchfn(self, f): | def matchfn(self, f): | ||||
| return self._m1(f) and not self._m2(f) | return self._m1(f) and not self._m2(f) | ||||
| @encoding.strmethod | @encoding.strmethod | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)) | return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)) | ||||
| def intersectmatchers(m1, m2): | def intersectmatchers(m1, m2): | ||||
| '''Composes two matchers by matching if both of them match. | '''Composes two matchers by matching if both of them match. | ||||
| The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, | The second matcher's non-matching-attributes (bad, explicitdir, | ||||
| traversedir) are ignored. | traversedir) are ignored. | ||||
| ''' | ''' | ||||
| if m1 is None or m2 is None: | if m1 is None or m2 is None: | ||||
| return m1 or m2 | return m1 or m2 | ||||
| if m1.always(): | if m1.always(): | ||||
| m = copy.copy(m2) | m = copy.copy(m2) | ||||
| # TODO: Consider encapsulating these things in a class so there's only | # TODO: Consider encapsulating these things in a class so there's only | ||||
| # one thing to copy from m1. | # one thing to copy from m1. | ||||
| m.bad = m1.bad | m.bad = m1.bad | ||||
| m.explicitdir = m1.explicitdir | m.explicitdir = m1.explicitdir | ||||
| m.traversedir = m1.traversedir | m.traversedir = m1.traversedir | ||||
| return m | return m | ||||
| if m2.always(): | if m2.always(): | ||||
| m = copy.copy(m1) | m = copy.copy(m1) | ||||
| return m | return m | ||||
| return intersectionmatcher(m1, m2) | return intersectionmatcher(m1, m2) | ||||
| class intersectionmatcher(basematcher): | class intersectionmatcher(basematcher): | ||||
| def __init__(self, m1, m2): | def __init__(self, m1, m2): | ||||
| super(intersectionmatcher, self).__init__(m1._root, m1._cwd) | super(intersectionmatcher, self).__init__() | ||||
| self._m1 = m1 | self._m1 = m1 | ||||
| self._m2 = m2 | self._m2 = m2 | ||||
| self.bad = m1.bad | self.bad = m1.bad | ||||
| self.explicitdir = m1.explicitdir | self.explicitdir = m1.explicitdir | ||||
| self.traversedir = m1.traversedir | self.traversedir = m1.traversedir | ||||
| @propertycache | @propertycache | ||||
| def _files(self): | def _files(self): | ||||
| >>> def bad(f, msg): | >>> def bad(f, msg): | ||||
| ... print(pycompat.sysstr(b"%s: %s" % (f, msg))) | ... print(pycompat.sysstr(b"%s: %s" % (f, msg))) | ||||
| >>> m1.bad = bad | >>> m1.bad = bad | ||||
| >>> m2.bad(b'x.txt', b'No such file') | >>> m2.bad(b'x.txt', b'No such file') | ||||
| sub/x.txt: No such file | sub/x.txt: No such file | ||||
| """ | """ | ||||
| def __init__(self, path, matcher): | def __init__(self, path, matcher): | ||||
| super(subdirmatcher, self).__init__(matcher._root, matcher._cwd) | super(subdirmatcher, self).__init__() | ||||
| self._path = path | self._path = path | ||||
| self._matcher = matcher | self._matcher = matcher | ||||
| self._always = matcher.always() | self._always = matcher.always() | ||||
| self._files = [f[len(path) + 1:] for f in matcher._files | self._files = [f[len(path) + 1:] for f in matcher._files | ||||
| if f.startswith(path + "/")] | if f.startswith(path + "/")] | ||||
| # If the parent repo had a path to this subrepo and the matcher is | # If the parent repo had a path to this subrepo and the matcher is | ||||
| @encoding.strmethod | @encoding.strmethod | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<subdirmatcher path=%r, matcher=%r>' % | return ('<subdirmatcher path=%r, matcher=%r>' % | ||||
| (self._path, self._matcher)) | (self._path, self._matcher)) | ||||
| class prefixdirmatcher(basematcher): | class prefixdirmatcher(basematcher): | ||||
| """Adapt a matcher to work on a parent directory. | """Adapt a matcher to work on a parent directory. | ||||
| The matcher's non-matching-attributes (root, cwd, bad, explicitdir, | The matcher's non-matching-attributes (bad, explicitdir, traversedir) are | ||||
| traversedir) are ignored. | ignored. | ||||
| The prefix path should usually be the relative path from the root of | The prefix path should usually be the relative path from the root of | ||||
| this matcher to the root of the wrapped matcher. | this matcher to the root of the wrapped matcher. | ||||
| >>> m1 = match(util.localpath(b'root/d/e'), b'f', [b'../a.txt', b'b.txt']) | >>> m1 = match(util.localpath(b'root/d/e'), b'f', [b'../a.txt', b'b.txt']) | ||||
| >>> m2 = prefixdirmatcher(b'root', b'd/e/f', b'd/e', m1) | >>> m2 = prefixdirmatcher(b'd/e', m1) | ||||
| >>> bool(m2(b'a.txt'),) | >>> bool(m2(b'a.txt'),) | ||||
| False | False | ||||
| >>> bool(m2(b'd/e/a.txt')) | >>> bool(m2(b'd/e/a.txt')) | ||||
| True | True | ||||
| >>> bool(m2(b'd/e/b.txt')) | >>> bool(m2(b'd/e/b.txt')) | ||||
| False | False | ||||
| >>> m2.files() | >>> m2.files() | ||||
| ['d/e/a.txt', 'd/e/f/b.txt'] | ['d/e/a.txt', 'd/e/f/b.txt'] | ||||
| >>> m2.exact(b'd/e/a.txt') | >>> m2.exact(b'd/e/a.txt') | ||||
| True | True | ||||
| >>> m2.visitdir(b'd') | >>> m2.visitdir(b'd') | ||||
| True | True | ||||
| >>> m2.visitdir(b'd/e') | >>> m2.visitdir(b'd/e') | ||||
| True | True | ||||
| >>> m2.visitdir(b'd/e/f') | >>> m2.visitdir(b'd/e/f') | ||||
| True | True | ||||
| >>> m2.visitdir(b'd/e/g') | >>> m2.visitdir(b'd/e/g') | ||||
| False | False | ||||
| >>> m2.visitdir(b'd/ef') | >>> m2.visitdir(b'd/ef') | ||||
| False | False | ||||
| """ | """ | ||||
| def __init__(self, root, cwd, path, matcher, badfn=None): | def __init__(self, path, matcher, badfn=None): | ||||
| super(prefixdirmatcher, self).__init__(root, cwd, badfn) | super(prefixdirmatcher, self).__init__(badfn) | ||||
| if not path: | if not path: | ||||
| raise error.ProgrammingError('prefix path must not be empty') | raise error.ProgrammingError('prefix path must not be empty') | ||||
| self._path = path | self._path = path | ||||
| self._pathprefix = path + '/' | self._pathprefix = path + '/' | ||||
| self._matcher = matcher | self._matcher = matcher | ||||
| @propertycache | @propertycache | ||||
| def _files(self): | def _files(self): | ||||
| @encoding.strmethod | @encoding.strmethod | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<prefixdirmatcher path=%r, matcher=%r>' | return ('<prefixdirmatcher path=%r, matcher=%r>' | ||||
| % (pycompat.bytestr(self._path), self._matcher)) | % (pycompat.bytestr(self._path), self._matcher)) | ||||
| class unionmatcher(basematcher): | class unionmatcher(basematcher): | ||||
| """A matcher that is the union of several matchers. | """A matcher that is the union of several matchers. | ||||
| The non-matching-attributes (root, cwd, bad, explicitdir, traversedir) are | The non-matching-attributes (bad, explicitdir, traversedir) are taken from | ||||
| taken from the first matcher. | the first matcher. | ||||
| """ | """ | ||||
| def __init__(self, matchers): | def __init__(self, matchers): | ||||
| m1 = matchers[0] | m1 = matchers[0] | ||||
| super(unionmatcher, self).__init__(m1._root, m1._cwd) | super(unionmatcher, self).__init__() | ||||
| self.explicitdir = m1.explicitdir | self.explicitdir = m1.explicitdir | ||||
| self.traversedir = m1.traversedir | self.traversedir = m1.traversedir | ||||
| self._matchers = matchers | self._matchers = matchers | ||||
| def matchfn(self, f): | def matchfn(self, f): | ||||
| for match in self._matchers: | for match in self._matchers: | ||||
| if match(f): | if match(f): | ||||
| return True | return True | ||||
| msg = _('cleaned up %d temporarily added file(s) from the ' | msg = _('cleaned up %d temporarily added file(s) from the ' | ||||
| 'sparse checkout\n') | 'sparse checkout\n') | ||||
| repo.ui.status(msg % len(tempincludes)) | repo.ui.status(msg % len(tempincludes)) | ||||
| def forceincludematcher(matcher, includes): | def forceincludematcher(matcher, includes): | ||||
| """Returns a matcher that returns true for any of the forced includes | """Returns a matcher that returns true for any of the forced includes | ||||
| before testing against the actual matcher.""" | before testing against the actual matcher.""" | ||||
| kindpats = [('path', include, '') for include in includes] | kindpats = [('path', include, '') for include in includes] | ||||
| includematcher = matchmod.includematcher('', '', kindpats) | includematcher = matchmod.includematcher('', kindpats) | ||||
| return matchmod.unionmatcher([includematcher, matcher]) | return matchmod.unionmatcher([includematcher, matcher]) | ||||
| def matcher(repo, revs=None, includetemp=True): | def matcher(repo, revs=None, includetemp=True): | ||||
| """Obtain a matcher for sparse working directories for the given revs. | """Obtain a matcher for sparse working directories for the given revs. | ||||
| If multiple revisions are specified, the matcher is the union of all | If multiple revisions are specified, the matcher is the union of all | ||||
| revs. | revs. | ||||
| matchers = [ctx.matchfileset(expr, badfn=badfn)] | matchers = [ctx.matchfileset(expr, badfn=badfn)] | ||||
| for subpath in ctx.substate: | for subpath in ctx.substate: | ||||
| sub = ctx.sub(subpath) | sub = ctx.sub(subpath) | ||||
| try: | try: | ||||
| sm = sub.matchfileset(expr, badfn=badfn) | sm = sub.matchfileset(expr, badfn=badfn) | ||||
| pm = matchmod.prefixdirmatcher(repo.root, repo.getcwd(), | pm = matchmod.prefixdirmatcher(subpath, sm, badfn=badfn) | ||||
| subpath, sm, badfn=badfn) | |||||
| matchers.append(pm) | matchers.append(pm) | ||||
| except error.LookupError: | except error.LookupError: | ||||
| self.ui.status(_("skipping missing subrepository: %s\n") | self.ui.status(_("skipping missing subrepository: %s\n") | ||||
| % self.wvfs.reljoin(reporelpath(self), subpath)) | % self.wvfs.reljoin(reporelpath(self), subpath)) | ||||
| if len(matchers) == 1: | if len(matchers) == 1: | ||||
| return matchers[0] | return matchers[0] | ||||
| return matchmod.unionmatcher(matchers) | return matchmod.unionmatcher(matchers) | ||||
| 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(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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(b'', b'', 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(b'', b'', 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.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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.nevermatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.nevermatcher(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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') | ||||
| class IntersectionMatcherTests(unittest.TestCase): | class IntersectionMatcherTests(unittest.TestCase): | ||||
| def testVisitdirM2always(self): | def testVisitdirM2always(self): | ||||
| m1 = matchmod.alwaysmatcher(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.nevermatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.nevermatcher(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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/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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.nevermatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.nevermatcher() | ||||
| m2 = matchmod.alwaysmatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.nevermatcher(b'', b'') | 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(b'', b'') | m1 = matchmod.alwaysmatcher() | ||||
| m2 = matchmod.nevermatcher(b'', b'') | 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(b'', b'') | 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(b'', b'') | 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(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): | ||||
| def testVisitdir(self): | def testVisitdir(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'root', b'd/e/f', b'd', m) | pm = matchmod.prefixdirmatcher(b'd', m) | ||||
| # `m` elides 'd' because it's part of the root, and the rest of the | # `m` elides 'd' because it's part of the root, and the rest of the | ||||
| # patterns are relative. | # patterns are relative. | ||||
| self.assertEqual(bool(m(b'a.txt')), False) | self.assertEqual(bool(m(b'a.txt')), False) | ||||
| self.assertEqual(bool(m(b'b.txt')), False) | self.assertEqual(bool(m(b'b.txt')), False) | ||||
| self.assertEqual(bool(m(b'e/a.txt')), True) | self.assertEqual(bool(m(b'e/a.txt')), True) | ||||
| self.assertEqual(bool(m(b'e/b.txt')), False) | self.assertEqual(bool(m(b'e/b.txt')), False) | ||||
| self.assertEqual(bool(m(b'e/f/b.txt')), True) | self.assertEqual(bool(m(b'e/f/b.txt')), 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'root', b'd/e/f', 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()) | ||||