Show More
@@ -216,7 +216,7 b' def _narrow(ui, repo, remote, commoninc,' | |||
|
216 | 216 | todelete.append(f) |
|
217 | 217 | elif f.startswith('meta/'): |
|
218 | 218 | dir = f[5:-13] |
|
219 |
dirs = [' |
|
|
219 | dirs = [''] + sorted(util.dirs({dir})) + [dir] | |
|
220 | 220 | include = True |
|
221 | 221 | for d in dirs: |
|
222 | 222 | visit = newmatch.visitdir(d) |
@@ -1061,7 +1061,7 b' class cgpacker(object):' | |||
|
1061 | 1061 | while tmfnodes: |
|
1062 | 1062 | tree, nodes = tmfnodes.popitem() |
|
1063 | 1063 | |
|
1064 |
should_visit = self._matcher.visitdir(tree[:-1] |
|
|
1064 | should_visit = self._matcher.visitdir(tree[:-1]) | |
|
1065 | 1065 | if tree and not should_visit: |
|
1066 | 1066 | continue |
|
1067 | 1067 | |
@@ -1093,7 +1093,7 b' class cgpacker(object):' | |||
|
1093 | 1093 | fullclnodes=self._fullclnodes, |
|
1094 | 1094 | precomputedellipsis=self._precomputedellipsis) |
|
1095 | 1095 | |
|
1096 |
if not self._oldmatcher.visitdir(store.tree[:-1] |
|
|
1096 | if not self._oldmatcher.visitdir(store.tree[:-1]): | |
|
1097 | 1097 | yield tree, deltas |
|
1098 | 1098 | else: |
|
1099 | 1099 | # 'deltas' is a generator and we need to consume it even if |
@@ -757,10 +757,10 b' class dirstate(object):' | |||
|
757 | 757 | del files[i] |
|
758 | 758 | j += 1 |
|
759 | 759 | |
|
760 |
if not files or ' |
|
|
761 |
files = [' |
|
|
760 | if not files or '' in files: | |
|
761 | files = [''] | |
|
762 | 762 | # constructing the foldmap is expensive, so don't do it for the |
|
763 |
# common case where files is [' |
|
|
763 | # common case where files is [''] | |
|
764 | 764 | normalize = None |
|
765 | 765 | results = dict.fromkeys(subrepos) |
|
766 | 766 | results['.hg'] = None |
@@ -910,9 +910,7 b' class dirstate(object):' | |||
|
910 | 910 | if visitentries == 'this' or visitentries == 'all': |
|
911 | 911 | visitentries = None |
|
912 | 912 | skip = None |
|
913 |
if nd |
|
|
914 | nd = '' | |
|
915 | else: | |
|
913 | if nd != '': | |
|
916 | 914 | skip = '.hg' |
|
917 | 915 | try: |
|
918 | 916 | entries = listdir(join(nd), stat=True, skip=skip) |
@@ -466,9 +466,9 b' class manifestdict(object):' | |||
|
466 | 466 | if match(fn): |
|
467 | 467 | yield fn |
|
468 | 468 | |
|
469 |
# for dirstate.walk, files=[' |
|
|
469 | # for dirstate.walk, files=[''] means "walk the whole tree". | |
|
470 | 470 | # follow that here, too |
|
471 |
fset.discard(' |
|
|
471 | fset.discard('') | |
|
472 | 472 | |
|
473 | 473 | for fn in sorted(fset): |
|
474 | 474 | if not self.hasdir(fn): |
@@ -1038,9 +1038,9 b' class treemanifest(object):' | |||
|
1038 | 1038 | fset.remove(fn) |
|
1039 | 1039 | yield fn |
|
1040 | 1040 | |
|
1041 |
# for dirstate.walk, files=[' |
|
|
1041 | # for dirstate.walk, files=[''] means "walk the whole tree". | |
|
1042 | 1042 | # follow that here, too |
|
1043 |
fset.discard(' |
|
|
1043 | fset.discard('') | |
|
1044 | 1044 | |
|
1045 | 1045 | for fn in sorted(fset): |
|
1046 | 1046 | if not self.hasdir(fn): |
@@ -1048,7 +1048,7 b' class treemanifest(object):' | |||
|
1048 | 1048 | |
|
1049 | 1049 | def _walk(self, match): |
|
1050 | 1050 | '''Recursively generates matching file names for walk().''' |
|
1051 |
visit = match.visitchildrenset(self._dir[:-1] |
|
|
1051 | visit = match.visitchildrenset(self._dir[:-1]) | |
|
1052 | 1052 | if not visit: |
|
1053 | 1053 | return |
|
1054 | 1054 | |
@@ -1076,7 +1076,7 b' class treemanifest(object):' | |||
|
1076 | 1076 | '''recursively generate a new manifest filtered by the match argument. |
|
1077 | 1077 | ''' |
|
1078 | 1078 | |
|
1079 |
visit = match.visitchildrenset(self._dir[:-1] |
|
|
1079 | visit = match.visitchildrenset(self._dir[:-1]) | |
|
1080 | 1080 | if visit == 'all': |
|
1081 | 1081 | return self.copy() |
|
1082 | 1082 | ret = treemanifest(self._dir) |
@@ -1235,7 +1235,7 b' class treemanifest(object):' | |||
|
1235 | 1235 | return m._dirs.get(d, emptytree)._node |
|
1236 | 1236 | |
|
1237 | 1237 | # let's skip investigating things that `match` says we do not need. |
|
1238 |
visit = match.visitchildrenset(self._dir[:-1] |
|
|
1238 | visit = match.visitchildrenset(self._dir[:-1]) | |
|
1239 | 1239 | visit = self._loadchildrensetlazy(visit) |
|
1240 | 1240 | if visit == 'this' or visit == 'all': |
|
1241 | 1241 | visit = None |
@@ -1254,7 +1254,7 b' class treemanifest(object):' | |||
|
1254 | 1254 | |
|
1255 | 1255 | If `matcher` is provided, it only returns subtrees that match. |
|
1256 | 1256 | """ |
|
1257 |
if matcher and not matcher.visitdir(self._dir[:-1] |
|
|
1257 | if matcher and not matcher.visitdir(self._dir[:-1]): | |
|
1258 | 1258 | return |
|
1259 | 1259 | if not matcher or matcher(self._dir[:-1]): |
|
1260 | 1260 | yield self |
@@ -1685,7 +1685,7 b' class manifestlog(object):' | |||
|
1685 | 1685 | return self._dirmancache[tree][node] |
|
1686 | 1686 | |
|
1687 | 1687 | if not self._narrowmatch.always(): |
|
1688 |
if not self._narrowmatch.visitdir(tree[:-1] |
|
|
1688 | if not self._narrowmatch.visitdir(tree[:-1]): | |
|
1689 | 1689 | return excludeddirmanifestctx(tree, node) |
|
1690 | 1690 | if tree: |
|
1691 | 1691 | if self._rootstore._treeondisk: |
@@ -1878,7 +1878,7 b' class treemanifestctx(object):' | |||
|
1878 | 1878 | def _storage(self): |
|
1879 | 1879 | narrowmatch = self._manifestlog._narrowmatch |
|
1880 | 1880 | if not narrowmatch.always(): |
|
1881 |
if not narrowmatch.visitdir(self._dir[:-1] |
|
|
1881 | if not narrowmatch.visitdir(self._dir[:-1]): | |
|
1882 | 1882 | return excludedmanifestrevlog(self._dir) |
|
1883 | 1883 | return self._manifestlog.getstorage(self._dir) |
|
1884 | 1884 |
@@ -380,7 +380,7 b' class basematcher(object):' | |||
|
380 | 380 | the following values (assuming the implementation of visitchildrenset |
|
381 | 381 | is capable of recognizing this; some implementations are not). |
|
382 | 382 | |
|
383 |
' |
|
|
383 | '' -> {'foo', 'qux'} | |
|
384 | 384 | 'baz' -> set() |
|
385 | 385 | 'foo' -> {'bar'} |
|
386 | 386 | # Ideally this would be 'all', but since the prefix nature of matchers |
@@ -483,6 +483,14 b' class predicatematcher(basematcher):' | |||
|
483 | 483 | or pycompat.byterepr(self.matchfn)) |
|
484 | 484 | return '<predicatenmatcher pred=%s>' % s |
|
485 | 485 | |
|
486 | def normalizerootdir(dir, funcname): | |
|
487 | if dir == '.': | |
|
488 | util.nouideprecwarn("match.%s() no longer accepts " | |
|
489 | "'.', use '' instead." % funcname, '5.1') | |
|
490 | return '' | |
|
491 | return dir | |
|
492 | ||
|
493 | ||
|
486 | 494 | class patternmatcher(basematcher): |
|
487 | 495 | """Matches a set of (kind, pat, source) against a 'root' directory. |
|
488 | 496 | |
@@ -507,7 +515,7 b' class patternmatcher(basematcher):' | |||
|
507 | 515 | True |
|
508 | 516 | |
|
509 | 517 | >>> m.files() |
|
510 |
[' |
|
|
518 | ['', 'foo/a', 'b', ''] | |
|
511 | 519 | >>> m.exact(b'foo/a') |
|
512 | 520 | True |
|
513 | 521 | >>> m.exact(b'b') |
@@ -525,12 +533,13 b' class patternmatcher(basematcher):' | |||
|
525 | 533 | |
|
526 | 534 | @propertycache |
|
527 | 535 | def _dirs(self): |
|
528 |
return set(util.dirs(self._fileset)) | {' |
|
|
536 | return set(util.dirs(self._fileset)) | {''} | |
|
529 | 537 | |
|
530 | 538 | def visitdir(self, dir): |
|
539 | dir = normalizerootdir(dir, 'visitdir') | |
|
531 | 540 | if self._prefix and dir in self._fileset: |
|
532 | 541 | return 'all' |
|
533 |
return (' |
|
|
542 | return ('' in self._fileset or | |
|
534 | 543 | dir in self._fileset or |
|
535 | 544 | dir in self._dirs or |
|
536 | 545 | any(parentdir in self._fileset |
@@ -564,7 +573,7 b' class _dirchildren(object):' | |||
|
564 | 573 | addpath(f) |
|
565 | 574 | |
|
566 | 575 | def addpath(self, path): |
|
567 |
if path == ' |
|
|
576 | if path == '': | |
|
568 | 577 | return |
|
569 | 578 | dirs = self._dirs |
|
570 | 579 | findsplitdirs = _dirchildren._findsplitdirs |
@@ -580,14 +589,14 b' class _dirchildren(object):' | |||
|
580 | 589 | # - produces a (dirname, basename) tuple, not just 'dirname' |
|
581 | 590 | # - includes root dir |
|
582 | 591 | # Unlike manifest._splittopdir, this does not suffix `dirname` with a |
|
583 | # slash, and produces '.' for the root instead of ''. | |
|
592 | # slash. | |
|
584 | 593 | oldpos = len(path) |
|
585 | 594 | pos = path.rfind('/') |
|
586 | 595 | while pos != -1: |
|
587 | 596 | yield path[:pos], path[pos + 1:oldpos] |
|
588 | 597 | oldpos = pos |
|
589 | 598 | pos = path.rfind('/', 0, pos) |
|
590 |
yield ' |
|
|
599 | yield '', path[:oldpos] | |
|
591 | 600 | |
|
592 | 601 | def get(self, path): |
|
593 | 602 | return self._dirs.get(path, set()) |
@@ -609,9 +618,10 b' class includematcher(basematcher):' | |||
|
609 | 618 | self._parents = set(parents) |
|
610 | 619 | |
|
611 | 620 | def visitdir(self, dir): |
|
621 | dir = normalizerootdir(dir, 'visitdir') | |
|
612 | 622 | if self._prefix and dir in self._roots: |
|
613 | 623 | return 'all' |
|
614 |
return (' |
|
|
624 | return ('' in self._roots or | |
|
615 | 625 | dir in self._roots or |
|
616 | 626 | dir in self._dirs or |
|
617 | 627 | dir in self._parents or |
@@ -635,7 +645,7 b' class includematcher(basematcher):' | |||
|
635 | 645 | return 'all' |
|
636 | 646 | # Note: this does *not* include the 'dir in self._parents' case from |
|
637 | 647 | # visitdir, that's handled below. |
|
638 |
if (' |
|
|
648 | if ('' in self._roots or | |
|
639 | 649 | dir in self._roots or |
|
640 | 650 | dir in self._dirs or |
|
641 | 651 | any(parentdir in self._roots |
@@ -683,22 +693,25 b' class exactmatcher(basematcher):' | |||
|
683 | 693 | |
|
684 | 694 | @propertycache |
|
685 | 695 | def _dirs(self): |
|
686 |
return set(util.dirs(self._fileset)) | {' |
|
|
696 | return set(util.dirs(self._fileset)) | {''} | |
|
687 | 697 | |
|
688 | 698 | def visitdir(self, dir): |
|
699 | dir = normalizerootdir(dir, 'visitdir') | |
|
689 | 700 | return dir in self._dirs |
|
690 | 701 | |
|
691 | 702 | def visitchildrenset(self, dir): |
|
703 | dir = normalizerootdir(dir, 'visitchildrenset') | |
|
704 | ||
|
692 | 705 | if not self._fileset or dir not in self._dirs: |
|
693 | 706 | return set() |
|
694 | 707 | |
|
695 |
candidates = self._fileset | self._dirs - {' |
|
|
696 |
if dir != ' |
|
|
708 | candidates = self._fileset | self._dirs - {''} | |
|
709 | if dir != '': | |
|
697 | 710 | d = dir + '/' |
|
698 | 711 | candidates = set(c[len(d):] for c in candidates if |
|
699 | 712 | c.startswith(d)) |
|
700 | 713 | # self._dirs includes all of the directories, recursively, so if |
|
701 |
# we're attempting to match foo/bar/baz.txt, it'll have ' |
|
|
714 | # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo', | |
|
702 | 715 | # 'foo/bar' in it. Thus we can safely ignore a candidate that has a |
|
703 | 716 | # '/' in it, indicating a it's for a subdir-of-a-subdir; the |
|
704 | 717 | # immediate subdir will be in there without a slash. |
@@ -772,7 +785,7 b' class differencematcher(basematcher):' | |||
|
772 | 785 | # Possible values for m1: set(...), set() |
|
773 | 786 | # Possible values for m2: 'this', set(...) |
|
774 | 787 | # We ignore m2's set results. They're possibly incorrect: |
|
775 |
# m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(' |
|
|
788 | # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''): | |
|
776 | 789 | # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd |
|
777 | 790 | # return set(), which is *not* correct, we still need to visit 'dir'! |
|
778 | 791 | return m1_set |
@@ -918,14 +931,16 b' class subdirmatcher(basematcher):' | |||
|
918 | 931 | return self._matcher.matchfn(self._path + "/" + f) |
|
919 | 932 | |
|
920 | 933 | def visitdir(self, dir): |
|
921 | if dir == '.': | |
|
934 | dir = normalizerootdir(dir, 'visitdir') | |
|
935 | if dir == '': | |
|
922 | 936 | dir = self._path |
|
923 | 937 | else: |
|
924 | 938 | dir = self._path + "/" + dir |
|
925 | 939 | return self._matcher.visitdir(dir) |
|
926 | 940 | |
|
927 | 941 | def visitchildrenset(self, dir): |
|
928 | if dir == '.': | |
|
942 | dir = normalizerootdir(dir, 'visitchildrenset') | |
|
943 | if dir == '': | |
|
929 | 944 | dir = self._path |
|
930 | 945 | else: |
|
931 | 946 | dir = self._path + "/" + dir |
@@ -994,18 +1009,18 b' class prefixdirmatcher(basematcher):' | |||
|
994 | 1009 | |
|
995 | 1010 | @propertycache |
|
996 | 1011 | def _pathdirs(self): |
|
997 |
return set(util.finddirs(self._path)) | {' |
|
|
1012 | return set(util.finddirs(self._path)) | {''} | |
|
998 | 1013 | |
|
999 | 1014 | def visitdir(self, dir): |
|
1000 | 1015 | if dir == self._path: |
|
1001 |
return self._matcher.visitdir(' |
|
|
1016 | return self._matcher.visitdir('') | |
|
1002 | 1017 | if dir.startswith(self._pathprefix): |
|
1003 | 1018 | return self._matcher.visitdir(dir[len(self._pathprefix):]) |
|
1004 | 1019 | return dir in self._pathdirs |
|
1005 | 1020 | |
|
1006 | 1021 | def visitchildrenset(self, dir): |
|
1007 | 1022 | if dir == self._path: |
|
1008 |
return self._matcher.visitchildrenset(' |
|
|
1023 | return self._matcher.visitchildrenset('') | |
|
1009 | 1024 | if dir.startswith(self._pathprefix): |
|
1010 | 1025 | return self._matcher.visitchildrenset(dir[len(self._pathprefix):]) |
|
1011 | 1026 | if dir in self._pathdirs: |
@@ -1197,7 +1212,7 b' def _regex(kind, pat, globsuffix):' | |||
|
1197 | 1212 | 'not a regex pattern: %s:%s' % (kind, pat) |
|
1198 | 1213 | ) |
|
1199 | 1214 | |
|
1200 | if not pat: | |
|
1215 | if not pat and kind in ('glob', 'relpath'): | |
|
1201 | 1216 | return '' |
|
1202 | 1217 | if kind == 're': |
|
1203 | 1218 | return pat |
@@ -1341,13 +1356,17 b' def _patternrootsanddirs(kindpats):' | |||
|
1341 | 1356 | if '[' in p or '{' in p or '*' in p or '?' in p: |
|
1342 | 1357 | break |
|
1343 | 1358 | root.append(p) |
|
1344 |
r.append('/'.join(root) |
|
|
1359 | r.append('/'.join(root)) | |
|
1345 | 1360 | elif kind in ('relpath', 'path'): |
|
1346 |
|
|
|
1361 | if pat == '.': | |
|
1362 | pat = '' | |
|
1363 | r.append(pat) | |
|
1347 | 1364 | elif kind in ('rootfilesin',): |
|
1348 |
|
|
|
1365 | if pat == '.': | |
|
1366 | pat = '' | |
|
1367 | d.append(pat) | |
|
1349 | 1368 | else: # relglob, re, relre |
|
1350 |
r.append(' |
|
|
1369 | r.append('') | |
|
1351 | 1370 | return r, d |
|
1352 | 1371 | |
|
1353 | 1372 | def _roots(kindpats): |
@@ -1367,18 +1386,18 b' def _rootsdirsandparents(kindpats):' | |||
|
1367 | 1386 | >>> _rootsdirsandparents( |
|
1368 | 1387 | ... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''), |
|
1369 | 1388 | ... (b'glob', b'g*', b'')]) |
|
1370 |
(['g/h', 'g/h', ' |
|
|
1389 | (['g/h', 'g/h', ''], [], ['g', '']) | |
|
1371 | 1390 | >>> _rootsdirsandparents( |
|
1372 | 1391 | ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')]) |
|
1373 |
([], ['g/h', ' |
|
|
1392 | ([], ['g/h', ''], ['g', '']) | |
|
1374 | 1393 | >>> _rootsdirsandparents( |
|
1375 | 1394 | ... [(b'relpath', b'r', b''), (b'path', b'p/p', b''), |
|
1376 | 1395 | ... (b'path', b'', b'')]) |
|
1377 |
(['r', 'p/p', ' |
|
|
1396 | (['r', 'p/p', ''], [], ['p', '']) | |
|
1378 | 1397 | >>> _rootsdirsandparents( |
|
1379 | 1398 | ... [(b'relglob', b'rg*', b''), (b're', b're/', b''), |
|
1380 | 1399 | ... (b'relre', b'rr', b'')]) |
|
1381 |
([' |
|
|
1400 | (['', '', ''], [], ['']) | |
|
1382 | 1401 | ''' |
|
1383 | 1402 | r, d = _patternrootsanddirs(kindpats) |
|
1384 | 1403 | |
@@ -1388,7 +1407,7 b' def _rootsdirsandparents(kindpats):' | |||
|
1388 | 1407 | p.extend(util.dirs(d)) |
|
1389 | 1408 | p.extend(util.dirs(r)) |
|
1390 | 1409 | # util.dirs() does not include the root directory, so add it manually |
|
1391 |
p.append(' |
|
|
1410 | p.append('') | |
|
1392 | 1411 | |
|
1393 | 1412 | # FIXME: all uses of this function convert these to sets, do so before |
|
1394 | 1413 | # returning. |
@@ -40,7 +40,7 b' def _matchtrackedpath(path, matcher):' | |||
|
40 | 40 | if path.startswith('data/'): |
|
41 | 41 | return matcher(path[len('data/'):-len('.i')]) |
|
42 | 42 | elif path.startswith('meta/'): |
|
43 |
return matcher.visitdir(path[len('meta/'):-len('/00manifest.i')] |
|
|
43 | return matcher.visitdir(path[len('meta/'):-len('/00manifest.i')]) | |
|
44 | 44 | |
|
45 | 45 | raise error.ProgrammingError("cannot decode path %s" % path) |
|
46 | 46 |
@@ -29,3 +29,6 b'' | |||
|
29 | 29 | == Internal API Changes == |
|
30 | 30 | |
|
31 | 31 | * Matchers are no longer iterable. Use `match.files()` instead. |
|
32 | ||
|
33 | * `match.visitdir()` and `match.visitchildrenset()` now expect the | |
|
34 | empty string instead of '.' to indicate the root directory. |
@@ -13,36 +13,36 b' class BaseMatcherTests(unittest.TestCase' | |||
|
13 | 13 | |
|
14 | 14 | def testVisitdir(self): |
|
15 | 15 | m = matchmod.basematcher() |
|
16 |
self.assertTrue(m.visitdir(b' |
|
|
16 | self.assertTrue(m.visitdir(b'')) | |
|
17 | 17 | self.assertTrue(m.visitdir(b'dir')) |
|
18 | 18 | |
|
19 | 19 | def testVisitchildrenset(self): |
|
20 | 20 | m = matchmod.basematcher() |
|
21 |
self.assertEqual(m.visitchildrenset(b' |
|
|
21 | self.assertEqual(m.visitchildrenset(b''), b'this') | |
|
22 | 22 | self.assertEqual(m.visitchildrenset(b'dir'), b'this') |
|
23 | 23 | |
|
24 | 24 | class AlwaysMatcherTests(unittest.TestCase): |
|
25 | 25 | |
|
26 | 26 | def testVisitdir(self): |
|
27 | 27 | m = matchmod.alwaysmatcher() |
|
28 |
self.assertEqual(m.visitdir(b' |
|
|
28 | self.assertEqual(m.visitdir(b''), b'all') | |
|
29 | 29 | self.assertEqual(m.visitdir(b'dir'), b'all') |
|
30 | 30 | |
|
31 | 31 | def testVisitchildrenset(self): |
|
32 | 32 | m = matchmod.alwaysmatcher() |
|
33 |
self.assertEqual(m.visitchildrenset(b' |
|
|
33 | self.assertEqual(m.visitchildrenset(b''), b'all') | |
|
34 | 34 | self.assertEqual(m.visitchildrenset(b'dir'), b'all') |
|
35 | 35 | |
|
36 | 36 | class NeverMatcherTests(unittest.TestCase): |
|
37 | 37 | |
|
38 | 38 | def testVisitdir(self): |
|
39 | 39 | m = matchmod.nevermatcher() |
|
40 |
self.assertFalse(m.visitdir(b' |
|
|
40 | self.assertFalse(m.visitdir(b'')) | |
|
41 | 41 | self.assertFalse(m.visitdir(b'dir')) |
|
42 | 42 | |
|
43 | 43 | def testVisitchildrenset(self): |
|
44 | 44 | m = matchmod.nevermatcher() |
|
45 |
self.assertEqual(m.visitchildrenset(b' |
|
|
45 | self.assertEqual(m.visitchildrenset(b''), set()) | |
|
46 | 46 | self.assertEqual(m.visitchildrenset(b'dir'), set()) |
|
47 | 47 | |
|
48 | 48 | class PredicateMatcherTests(unittest.TestCase): |
@@ -51,12 +51,12 b' class PredicateMatcherTests(unittest.Tes' | |||
|
51 | 51 | |
|
52 | 52 | def testVisitdir(self): |
|
53 | 53 | m = matchmod.predicatematcher(lambda *a: False) |
|
54 |
self.assertTrue(m.visitdir(b' |
|
|
54 | self.assertTrue(m.visitdir(b'')) | |
|
55 | 55 | self.assertTrue(m.visitdir(b'dir')) |
|
56 | 56 | |
|
57 | 57 | def testVisitchildrenset(self): |
|
58 | 58 | m = matchmod.predicatematcher(lambda *a: False) |
|
59 |
self.assertEqual(m.visitchildrenset(b' |
|
|
59 | self.assertEqual(m.visitchildrenset(b''), b'this') | |
|
60 | 60 | self.assertEqual(m.visitchildrenset(b'dir'), b'this') |
|
61 | 61 | |
|
62 | 62 | class PatternMatcherTests(unittest.TestCase): |
@@ -64,7 +64,7 b' class PatternMatcherTests(unittest.TestC' | |||
|
64 | 64 | def testVisitdirPrefix(self): |
|
65 | 65 | m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir']) |
|
66 | 66 | assert isinstance(m, matchmod.patternmatcher) |
|
67 |
self.assertTrue(m.visitdir(b' |
|
|
67 | self.assertTrue(m.visitdir(b'')) | |
|
68 | 68 | self.assertTrue(m.visitdir(b'dir')) |
|
69 | 69 | self.assertEqual(m.visitdir(b'dir/subdir'), b'all') |
|
70 | 70 | # OPT: This should probably be 'all' if its parent is? |
@@ -74,7 +74,7 b' class PatternMatcherTests(unittest.TestC' | |||
|
74 | 74 | def testVisitchildrensetPrefix(self): |
|
75 | 75 | m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir']) |
|
76 | 76 | assert isinstance(m, matchmod.patternmatcher) |
|
77 |
self.assertEqual(m.visitchildrenset(b' |
|
|
77 | self.assertEqual(m.visitchildrenset(b''), b'this') | |
|
78 | 78 | self.assertEqual(m.visitchildrenset(b'dir'), b'this') |
|
79 | 79 | self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all') |
|
80 | 80 | # OPT: This should probably be 'all' if its parent is? |
@@ -84,7 +84,7 b' class PatternMatcherTests(unittest.TestC' | |||
|
84 | 84 | def testVisitdirRootfilesin(self): |
|
85 | 85 | m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir']) |
|
86 | 86 | assert isinstance(m, matchmod.patternmatcher) |
|
87 |
self.assertTrue(m.visitdir(b' |
|
|
87 | self.assertTrue(m.visitdir(b'')) | |
|
88 | 88 | self.assertFalse(m.visitdir(b'dir/subdir/x')) |
|
89 | 89 | self.assertFalse(m.visitdir(b'folder')) |
|
90 | 90 | # FIXME: These should probably be True. |
@@ -94,7 +94,7 b' class PatternMatcherTests(unittest.TestC' | |||
|
94 | 94 | def testVisitchildrensetRootfilesin(self): |
|
95 | 95 | m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir']) |
|
96 | 96 | assert isinstance(m, matchmod.patternmatcher) |
|
97 |
self.assertEqual(m.visitchildrenset(b' |
|
|
97 | self.assertEqual(m.visitchildrenset(b''), b'this') | |
|
98 | 98 | self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) |
|
99 | 99 | self.assertEqual(m.visitchildrenset(b'folder'), set()) |
|
100 | 100 | # FIXME: These should probably be {'subdir'} and 'this', respectively, |
@@ -105,7 +105,7 b' class PatternMatcherTests(unittest.TestC' | |||
|
105 | 105 | def testVisitdirGlob(self): |
|
106 | 106 | m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*']) |
|
107 | 107 | assert isinstance(m, matchmod.patternmatcher) |
|
108 |
self.assertTrue(m.visitdir(b' |
|
|
108 | self.assertTrue(m.visitdir(b'')) | |
|
109 | 109 | self.assertTrue(m.visitdir(b'dir')) |
|
110 | 110 | self.assertFalse(m.visitdir(b'folder')) |
|
111 | 111 | # OPT: these should probably be False. |
@@ -115,7 +115,7 b' class PatternMatcherTests(unittest.TestC' | |||
|
115 | 115 | def testVisitchildrensetGlob(self): |
|
116 | 116 | m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*']) |
|
117 | 117 | assert isinstance(m, matchmod.patternmatcher) |
|
118 |
self.assertEqual(m.visitchildrenset(b' |
|
|
118 | self.assertEqual(m.visitchildrenset(b''), b'this') | |
|
119 | 119 | self.assertEqual(m.visitchildrenset(b'folder'), set()) |
|
120 | 120 | self.assertEqual(m.visitchildrenset(b'dir'), b'this') |
|
121 | 121 | # OPT: these should probably be set(). |
@@ -127,7 +127,7 b' class IncludeMatcherTests(unittest.TestC' | |||
|
127 | 127 | def testVisitdirPrefix(self): |
|
128 | 128 | m = matchmod.match(b'x', b'', include=[b'path:dir/subdir']) |
|
129 | 129 | assert isinstance(m, matchmod.includematcher) |
|
130 |
self.assertTrue(m.visitdir(b' |
|
|
130 | self.assertTrue(m.visitdir(b'')) | |
|
131 | 131 | self.assertTrue(m.visitdir(b'dir')) |
|
132 | 132 | self.assertEqual(m.visitdir(b'dir/subdir'), b'all') |
|
133 | 133 | # OPT: This should probably be 'all' if its parent is? |
@@ -137,7 +137,7 b' class IncludeMatcherTests(unittest.TestC' | |||
|
137 | 137 | def testVisitchildrensetPrefix(self): |
|
138 | 138 | m = matchmod.match(b'x', b'', include=[b'path:dir/subdir']) |
|
139 | 139 | assert isinstance(m, matchmod.includematcher) |
|
140 |
self.assertEqual(m.visitchildrenset(b' |
|
|
140 | self.assertEqual(m.visitchildrenset(b''), {b'dir'}) | |
|
141 | 141 | self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) |
|
142 | 142 | self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all') |
|
143 | 143 | # OPT: This should probably be 'all' if its parent is? |
@@ -147,7 +147,7 b' class IncludeMatcherTests(unittest.TestC' | |||
|
147 | 147 | def testVisitdirRootfilesin(self): |
|
148 | 148 | m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir']) |
|
149 | 149 | assert isinstance(m, matchmod.includematcher) |
|
150 |
self.assertTrue(m.visitdir(b' |
|
|
150 | self.assertTrue(m.visitdir(b'')) | |
|
151 | 151 | self.assertTrue(m.visitdir(b'dir')) |
|
152 | 152 | self.assertTrue(m.visitdir(b'dir/subdir')) |
|
153 | 153 | self.assertFalse(m.visitdir(b'dir/subdir/x')) |
@@ -156,7 +156,7 b' class IncludeMatcherTests(unittest.TestC' | |||
|
156 | 156 | def testVisitchildrensetRootfilesin(self): |
|
157 | 157 | m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir']) |
|
158 | 158 | assert isinstance(m, matchmod.includematcher) |
|
159 |
self.assertEqual(m.visitchildrenset(b' |
|
|
159 | self.assertEqual(m.visitchildrenset(b''), {b'dir'}) | |
|
160 | 160 | self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) |
|
161 | 161 | self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') |
|
162 | 162 | self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) |
@@ -165,7 +165,7 b' class IncludeMatcherTests(unittest.TestC' | |||
|
165 | 165 | def testVisitdirGlob(self): |
|
166 | 166 | m = matchmod.match(b'x', b'', include=[b'glob:dir/z*']) |
|
167 | 167 | assert isinstance(m, matchmod.includematcher) |
|
168 |
self.assertTrue(m.visitdir(b' |
|
|
168 | self.assertTrue(m.visitdir(b'')) | |
|
169 | 169 | self.assertTrue(m.visitdir(b'dir')) |
|
170 | 170 | self.assertFalse(m.visitdir(b'folder')) |
|
171 | 171 | # OPT: these should probably be False. |
@@ -175,7 +175,7 b' class IncludeMatcherTests(unittest.TestC' | |||
|
175 | 175 | def testVisitchildrensetGlob(self): |
|
176 | 176 | m = matchmod.match(b'x', b'', include=[b'glob:dir/z*']) |
|
177 | 177 | assert isinstance(m, matchmod.includematcher) |
|
178 |
self.assertEqual(m.visitchildrenset(b' |
|
|
178 | self.assertEqual(m.visitchildrenset(b''), {b'dir'}) | |
|
179 | 179 | self.assertEqual(m.visitchildrenset(b'folder'), set()) |
|
180 | 180 | self.assertEqual(m.visitchildrenset(b'dir'), b'this') |
|
181 | 181 | # OPT: these should probably be set(). |
@@ -187,7 +187,7 b' class ExactMatcherTests(unittest.TestCas' | |||
|
187 | 187 | def testVisitdir(self): |
|
188 | 188 | m = matchmod.exact(files=[b'dir/subdir/foo.txt']) |
|
189 | 189 | assert isinstance(m, matchmod.exactmatcher) |
|
190 |
self.assertTrue(m.visitdir(b' |
|
|
190 | self.assertTrue(m.visitdir(b'')) | |
|
191 | 191 | self.assertTrue(m.visitdir(b'dir')) |
|
192 | 192 | self.assertTrue(m.visitdir(b'dir/subdir')) |
|
193 | 193 | self.assertFalse(m.visitdir(b'dir/subdir/foo.txt')) |
@@ -198,7 +198,7 b' class ExactMatcherTests(unittest.TestCas' | |||
|
198 | 198 | def testVisitchildrenset(self): |
|
199 | 199 | m = matchmod.exact(files=[b'dir/subdir/foo.txt']) |
|
200 | 200 | assert isinstance(m, matchmod.exactmatcher) |
|
201 |
self.assertEqual(m.visitchildrenset(b' |
|
|
201 | self.assertEqual(m.visitchildrenset(b''), {b'dir'}) | |
|
202 | 202 | self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) |
|
203 | 203 | self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'}) |
|
204 | 204 | self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) |
@@ -212,7 +212,7 b' class ExactMatcherTests(unittest.TestCas' | |||
|
212 | 212 | # no file in a/b/c |
|
213 | 213 | b'a/b/c/d/file4.txt']) |
|
214 | 214 | assert isinstance(m, matchmod.exactmatcher) |
|
215 |
self.assertEqual(m.visitchildrenset(b' |
|
|
215 | self.assertEqual(m.visitchildrenset(b''), {b'a', b'rootfile.txt'}) | |
|
216 | 216 | self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'}) |
|
217 | 217 | self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'}) |
|
218 | 218 | self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'}) |
@@ -227,7 +227,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
227 | 227 | m2 = matchmod.alwaysmatcher() |
|
228 | 228 | dm = matchmod.differencematcher(m1, m2) |
|
229 | 229 | # dm should be equivalent to a nevermatcher. |
|
230 |
self.assertFalse(dm.visitdir(b' |
|
|
230 | self.assertFalse(dm.visitdir(b'')) | |
|
231 | 231 | self.assertFalse(dm.visitdir(b'dir')) |
|
232 | 232 | self.assertFalse(dm.visitdir(b'dir/subdir')) |
|
233 | 233 | self.assertFalse(dm.visitdir(b'dir/subdir/z')) |
@@ -240,7 +240,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
240 | 240 | m2 = matchmod.alwaysmatcher() |
|
241 | 241 | dm = matchmod.differencematcher(m1, m2) |
|
242 | 242 | # dm should be equivalent to a nevermatcher. |
|
243 |
self.assertEqual(dm.visitchildrenset(b' |
|
|
243 | self.assertEqual(dm.visitchildrenset(b''), set()) | |
|
244 | 244 | self.assertEqual(dm.visitchildrenset(b'dir'), set()) |
|
245 | 245 | self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set()) |
|
246 | 246 | self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), set()) |
@@ -258,7 +258,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
258 | 258 | # assertTrue does NOT verify that it's a bool, just that it's truthy. |
|
259 | 259 | # While we may want to eventually make these return 'all', they should |
|
260 | 260 | # not currently do so. |
|
261 |
self.assertEqual(dm.visitdir(b' |
|
|
261 | self.assertEqual(dm.visitdir(b''), b'all') | |
|
262 | 262 | self.assertEqual(dm.visitdir(b'dir'), b'all') |
|
263 | 263 | self.assertEqual(dm.visitdir(b'dir/subdir'), b'all') |
|
264 | 264 | self.assertEqual(dm.visitdir(b'dir/subdir/z'), b'all') |
@@ -271,7 +271,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
271 | 271 | m2 = matchmod.nevermatcher() |
|
272 | 272 | dm = matchmod.differencematcher(m1, m2) |
|
273 | 273 | # dm should be equivalent to a alwaysmatcher. |
|
274 |
self.assertEqual(dm.visitchildrenset(b' |
|
|
274 | self.assertEqual(dm.visitchildrenset(b''), b'all') | |
|
275 | 275 | self.assertEqual(dm.visitchildrenset(b'dir'), b'all') |
|
276 | 276 | self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all') |
|
277 | 277 | self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all') |
@@ -283,7 +283,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
283 | 283 | m1 = matchmod.alwaysmatcher() |
|
284 | 284 | m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) |
|
285 | 285 | dm = matchmod.differencematcher(m1, m2) |
|
286 |
self.assertEqual(dm.visitdir(b' |
|
|
286 | self.assertEqual(dm.visitdir(b''), True) | |
|
287 | 287 | self.assertEqual(dm.visitdir(b'dir'), True) |
|
288 | 288 | self.assertFalse(dm.visitdir(b'dir/subdir')) |
|
289 | 289 | # OPT: We should probably return False for these; we don't because |
@@ -298,7 +298,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
298 | 298 | m1 = matchmod.alwaysmatcher() |
|
299 | 299 | m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) |
|
300 | 300 | dm = matchmod.differencematcher(m1, m2) |
|
301 |
self.assertEqual(dm.visitchildrenset(b' |
|
|
301 | self.assertEqual(dm.visitchildrenset(b''), b'this') | |
|
302 | 302 | self.assertEqual(dm.visitchildrenset(b'dir'), b'this') |
|
303 | 303 | self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set()) |
|
304 | 304 | self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all') |
@@ -315,7 +315,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
315 | 315 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
316 | 316 | m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) |
|
317 | 317 | dm = matchmod.differencematcher(m1, m2) |
|
318 |
self.assertEqual(dm.visitdir(b' |
|
|
318 | self.assertEqual(dm.visitdir(b''), True) | |
|
319 | 319 | self.assertEqual(dm.visitdir(b'dir'), True) |
|
320 | 320 | self.assertEqual(dm.visitdir(b'dir/subdir'), b'all') |
|
321 | 321 | self.assertFalse(dm.visitdir(b'dir/foo')) |
@@ -330,7 +330,7 b' class DifferenceMatcherTests(unittest.Te' | |||
|
330 | 330 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
331 | 331 | m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) |
|
332 | 332 | dm = matchmod.differencematcher(m1, m2) |
|
333 |
self.assertEqual(dm.visitchildrenset(b' |
|
|
333 | self.assertEqual(dm.visitchildrenset(b''), {b'dir'}) | |
|
334 | 334 | self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'}) |
|
335 | 335 | self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all') |
|
336 | 336 | self.assertEqual(dm.visitchildrenset(b'dir/foo'), set()) |
@@ -348,7 +348,7 b' class IntersectionMatcherTests(unittest.' | |||
|
348 | 348 | m2 = matchmod.alwaysmatcher() |
|
349 | 349 | im = matchmod.intersectmatchers(m1, m2) |
|
350 | 350 | # im should be equivalent to a alwaysmatcher. |
|
351 |
self.assertEqual(im.visitdir(b' |
|
|
351 | self.assertEqual(im.visitdir(b''), b'all') | |
|
352 | 352 | self.assertEqual(im.visitdir(b'dir'), b'all') |
|
353 | 353 | self.assertEqual(im.visitdir(b'dir/subdir'), b'all') |
|
354 | 354 | self.assertEqual(im.visitdir(b'dir/subdir/z'), b'all') |
@@ -361,7 +361,7 b' class IntersectionMatcherTests(unittest.' | |||
|
361 | 361 | m2 = matchmod.alwaysmatcher() |
|
362 | 362 | im = matchmod.intersectmatchers(m1, m2) |
|
363 | 363 | # im should be equivalent to a alwaysmatcher. |
|
364 |
self.assertEqual(im.visitchildrenset(b' |
|
|
364 | self.assertEqual(im.visitchildrenset(b''), b'all') | |
|
365 | 365 | self.assertEqual(im.visitchildrenset(b'dir'), b'all') |
|
366 | 366 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all') |
|
367 | 367 | self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'all') |
@@ -374,7 +374,7 b' class IntersectionMatcherTests(unittest.' | |||
|
374 | 374 | m2 = matchmod.nevermatcher() |
|
375 | 375 | im = matchmod.intersectmatchers(m1, m2) |
|
376 | 376 | # im should be equivalent to a nevermatcher. |
|
377 |
self.assertFalse(im.visitdir(b' |
|
|
377 | self.assertFalse(im.visitdir(b'')) | |
|
378 | 378 | self.assertFalse(im.visitdir(b'dir')) |
|
379 | 379 | self.assertFalse(im.visitdir(b'dir/subdir')) |
|
380 | 380 | self.assertFalse(im.visitdir(b'dir/subdir/z')) |
@@ -387,7 +387,7 b' class IntersectionMatcherTests(unittest.' | |||
|
387 | 387 | m2 = matchmod.nevermatcher() |
|
388 | 388 | im = matchmod.intersectmatchers(m1, m2) |
|
389 | 389 | # im should be equivalent to a nevermqtcher. |
|
390 |
self.assertEqual(im.visitchildrenset(b' |
|
|
390 | self.assertEqual(im.visitchildrenset(b''), set()) | |
|
391 | 391 | self.assertEqual(im.visitchildrenset(b'dir'), set()) |
|
392 | 392 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) |
|
393 | 393 | self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) |
@@ -399,7 +399,7 b' class IntersectionMatcherTests(unittest.' | |||
|
399 | 399 | m1 = matchmod.alwaysmatcher() |
|
400 | 400 | m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) |
|
401 | 401 | im = matchmod.intersectmatchers(m1, m2) |
|
402 |
self.assertEqual(im.visitdir(b' |
|
|
402 | self.assertEqual(im.visitdir(b''), True) | |
|
403 | 403 | self.assertEqual(im.visitdir(b'dir'), True) |
|
404 | 404 | self.assertEqual(im.visitdir(b'dir/subdir'), b'all') |
|
405 | 405 | self.assertFalse(im.visitdir(b'dir/foo')) |
@@ -414,7 +414,7 b' class IntersectionMatcherTests(unittest.' | |||
|
414 | 414 | m1 = matchmod.alwaysmatcher() |
|
415 | 415 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
416 | 416 | im = matchmod.intersectmatchers(m1, m2) |
|
417 |
self.assertEqual(im.visitchildrenset(b' |
|
|
417 | self.assertEqual(im.visitchildrenset(b''), {b'dir'}) | |
|
418 | 418 | self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) |
|
419 | 419 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all') |
|
420 | 420 | self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) |
@@ -429,7 +429,7 b' class IntersectionMatcherTests(unittest.' | |||
|
429 | 429 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
430 | 430 | m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) |
|
431 | 431 | im = matchmod.intersectmatchers(m1, m2) |
|
432 |
self.assertEqual(im.visitdir(b' |
|
|
432 | self.assertEqual(im.visitdir(b''), True) | |
|
433 | 433 | self.assertEqual(im.visitdir(b'dir'), True) |
|
434 | 434 | self.assertFalse(im.visitdir(b'dir/subdir')) |
|
435 | 435 | self.assertFalse(im.visitdir(b'dir/foo')) |
@@ -441,7 +441,7 b' class IntersectionMatcherTests(unittest.' | |||
|
441 | 441 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
442 | 442 | m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) |
|
443 | 443 | im = matchmod.intersectmatchers(m1, m2) |
|
444 |
self.assertEqual(im.visitchildrenset(b' |
|
|
444 | self.assertEqual(im.visitchildrenset(b''), {b'dir'}) | |
|
445 | 445 | self.assertEqual(im.visitchildrenset(b'dir'), b'this') |
|
446 | 446 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) |
|
447 | 447 | self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) |
@@ -456,7 +456,7 b' class IntersectionMatcherTests(unittest.' | |||
|
456 | 456 | m2 = matchmod.match(b'', b'', include=[b'path:folder']) |
|
457 | 457 | im = matchmod.intersectmatchers(m1, m2) |
|
458 | 458 | # FIXME: is True correct here? |
|
459 |
self.assertEqual(im.visitdir(b' |
|
|
459 | self.assertEqual(im.visitdir(b''), True) | |
|
460 | 460 | self.assertFalse(im.visitdir(b'dir')) |
|
461 | 461 | self.assertFalse(im.visitdir(b'dir/subdir')) |
|
462 | 462 | self.assertFalse(im.visitdir(b'dir/foo')) |
@@ -469,7 +469,7 b' class IntersectionMatcherTests(unittest.' | |||
|
469 | 469 | m2 = matchmod.match(b'', b'', include=[b'path:folder']) |
|
470 | 470 | im = matchmod.intersectmatchers(m1, m2) |
|
471 | 471 | # FIXME: is set() correct here? |
|
472 |
self.assertEqual(im.visitchildrenset(b' |
|
|
472 | self.assertEqual(im.visitchildrenset(b''), set()) | |
|
473 | 473 | self.assertEqual(im.visitchildrenset(b'dir'), set()) |
|
474 | 474 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) |
|
475 | 475 | self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) |
@@ -483,7 +483,7 b' class IntersectionMatcherTests(unittest.' | |||
|
483 | 483 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) |
|
484 | 484 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
485 | 485 | im = matchmod.intersectmatchers(m1, m2) |
|
486 |
self.assertEqual(im.visitdir(b' |
|
|
486 | self.assertEqual(im.visitdir(b''), True) | |
|
487 | 487 | self.assertEqual(im.visitdir(b'dir'), True) |
|
488 | 488 | self.assertEqual(im.visitdir(b'dir/subdir'), True) |
|
489 | 489 | self.assertFalse(im.visitdir(b'dir/foo')) |
@@ -496,7 +496,7 b' class IntersectionMatcherTests(unittest.' | |||
|
496 | 496 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) |
|
497 | 497 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
498 | 498 | im = matchmod.intersectmatchers(m1, m2) |
|
499 |
self.assertEqual(im.visitchildrenset(b' |
|
|
499 | self.assertEqual(im.visitchildrenset(b''), {b'dir'}) | |
|
500 | 500 | self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) |
|
501 | 501 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'}) |
|
502 | 502 | self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) |
@@ -512,7 +512,7 b' class IntersectionMatcherTests(unittest.' | |||
|
512 | 512 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) |
|
513 | 513 | im = matchmod.intersectmatchers(m1, m2) |
|
514 | 514 | # OPT: these next three could probably be False as well. |
|
515 |
self.assertEqual(im.visitdir(b' |
|
|
515 | self.assertEqual(im.visitdir(b''), True) | |
|
516 | 516 | self.assertEqual(im.visitdir(b'dir'), True) |
|
517 | 517 | self.assertEqual(im.visitdir(b'dir/subdir'), True) |
|
518 | 518 | self.assertFalse(im.visitdir(b'dir/foo')) |
@@ -525,7 +525,7 b' class IntersectionMatcherTests(unittest.' | |||
|
525 | 525 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) |
|
526 | 526 | im = matchmod.intersectmatchers(m1, m2) |
|
527 | 527 | # OPT: these next two could probably be set() as well. |
|
528 |
self.assertEqual(im.visitchildrenset(b' |
|
|
528 | self.assertEqual(im.visitchildrenset(b''), {b'dir'}) | |
|
529 | 529 | self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) |
|
530 | 530 | self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) |
|
531 | 531 | self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) |
@@ -540,7 +540,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
540 | 540 | m2 = matchmod.alwaysmatcher() |
|
541 | 541 | um = matchmod.unionmatcher([m1, m2]) |
|
542 | 542 | # um should be equivalent to a alwaysmatcher. |
|
543 |
self.assertEqual(um.visitdir(b' |
|
|
543 | self.assertEqual(um.visitdir(b''), b'all') | |
|
544 | 544 | self.assertEqual(um.visitdir(b'dir'), b'all') |
|
545 | 545 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
546 | 546 | self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') |
@@ -553,7 +553,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
553 | 553 | m2 = matchmod.alwaysmatcher() |
|
554 | 554 | um = matchmod.unionmatcher([m1, m2]) |
|
555 | 555 | # um should be equivalent to a alwaysmatcher. |
|
556 |
self.assertEqual(um.visitchildrenset(b' |
|
|
556 | self.assertEqual(um.visitchildrenset(b''), b'all') | |
|
557 | 557 | self.assertEqual(um.visitchildrenset(b'dir'), b'all') |
|
558 | 558 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
559 | 559 | self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') |
@@ -566,7 +566,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
566 | 566 | m2 = matchmod.alwaysmatcher() |
|
567 | 567 | um = matchmod.unionmatcher([m1, m2]) |
|
568 | 568 | # um should be equivalent to a alwaysmatcher. |
|
569 |
self.assertEqual(um.visitdir(b' |
|
|
569 | self.assertEqual(um.visitdir(b''), b'all') | |
|
570 | 570 | self.assertEqual(um.visitdir(b'dir'), b'all') |
|
571 | 571 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
572 | 572 | self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') |
@@ -579,7 +579,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
579 | 579 | m2 = matchmod.alwaysmatcher() |
|
580 | 580 | um = matchmod.unionmatcher([m1, m2]) |
|
581 | 581 | # um should be equivalent to a alwaysmatcher. |
|
582 |
self.assertEqual(um.visitchildrenset(b' |
|
|
582 | self.assertEqual(um.visitchildrenset(b''), b'all') | |
|
583 | 583 | self.assertEqual(um.visitchildrenset(b'dir'), b'all') |
|
584 | 584 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
585 | 585 | self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') |
@@ -592,7 +592,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
592 | 592 | m2 = matchmod.nevermatcher() |
|
593 | 593 | um = matchmod.unionmatcher([m1, m2]) |
|
594 | 594 | # um should be equivalent to a alwaysmatcher. |
|
595 |
self.assertEqual(um.visitdir(b' |
|
|
595 | self.assertEqual(um.visitdir(b''), b'all') | |
|
596 | 596 | self.assertEqual(um.visitdir(b'dir'), b'all') |
|
597 | 597 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
598 | 598 | self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') |
@@ -605,7 +605,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
605 | 605 | m2 = matchmod.nevermatcher() |
|
606 | 606 | um = matchmod.unionmatcher([m1, m2]) |
|
607 | 607 | # um should be equivalent to a alwaysmatcher. |
|
608 |
self.assertEqual(um.visitchildrenset(b' |
|
|
608 | self.assertEqual(um.visitchildrenset(b''), b'all') | |
|
609 | 609 | self.assertEqual(um.visitchildrenset(b'dir'), b'all') |
|
610 | 610 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
611 | 611 | self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') |
@@ -617,7 +617,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
617 | 617 | m1 = matchmod.alwaysmatcher() |
|
618 | 618 | m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir']) |
|
619 | 619 | um = matchmod.unionmatcher([m1, m2]) |
|
620 |
self.assertEqual(um.visitdir(b' |
|
|
620 | self.assertEqual(um.visitdir(b''), b'all') | |
|
621 | 621 | self.assertEqual(um.visitdir(b'dir'), b'all') |
|
622 | 622 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
623 | 623 | self.assertEqual(um.visitdir(b'dir/foo'), b'all') |
@@ -629,7 +629,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
629 | 629 | m1 = matchmod.alwaysmatcher() |
|
630 | 630 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
631 | 631 | um = matchmod.unionmatcher([m1, m2]) |
|
632 |
self.assertEqual(um.visitchildrenset(b' |
|
|
632 | self.assertEqual(um.visitchildrenset(b''), b'all') | |
|
633 | 633 | self.assertEqual(um.visitchildrenset(b'dir'), b'all') |
|
634 | 634 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
635 | 635 | self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') |
@@ -643,7 +643,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
643 | 643 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
644 | 644 | m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) |
|
645 | 645 | um = matchmod.unionmatcher([m1, m2]) |
|
646 |
self.assertEqual(um.visitdir(b' |
|
|
646 | self.assertEqual(um.visitdir(b''), True) | |
|
647 | 647 | self.assertEqual(um.visitdir(b'dir'), True) |
|
648 | 648 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
649 | 649 | self.assertFalse(um.visitdir(b'dir/foo')) |
@@ -656,7 +656,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
656 | 656 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
657 | 657 | m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir']) |
|
658 | 658 | um = matchmod.unionmatcher([m1, m2]) |
|
659 |
self.assertEqual(um.visitchildrenset(b' |
|
|
659 | self.assertEqual(um.visitchildrenset(b''), {b'dir'}) | |
|
660 | 660 | self.assertEqual(um.visitchildrenset(b'dir'), b'this') |
|
661 | 661 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
662 | 662 | self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) |
@@ -671,7 +671,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
671 | 671 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
672 | 672 | m2 = matchmod.match(b'', b'', include=[b'path:folder']) |
|
673 | 673 | um = matchmod.unionmatcher([m1, m2]) |
|
674 |
self.assertEqual(um.visitdir(b' |
|
|
674 | self.assertEqual(um.visitdir(b''), True) | |
|
675 | 675 | self.assertEqual(um.visitdir(b'dir'), True) |
|
676 | 676 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
677 | 677 | self.assertFalse(um.visitdir(b'dir/foo')) |
@@ -684,7 +684,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
684 | 684 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
685 | 685 | m2 = matchmod.match(b'', b'', include=[b'path:folder']) |
|
686 | 686 | um = matchmod.unionmatcher([m1, m2]) |
|
687 |
self.assertEqual(um.visitchildrenset(b' |
|
|
687 | self.assertEqual(um.visitchildrenset(b''), {b'folder', b'dir'}) | |
|
688 | 688 | self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) |
|
689 | 689 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
690 | 690 | self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) |
@@ -699,7 +699,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
699 | 699 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) |
|
700 | 700 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
701 | 701 | um = matchmod.unionmatcher([m1, m2]) |
|
702 |
self.assertEqual(um.visitdir(b' |
|
|
702 | self.assertEqual(um.visitdir(b''), True) | |
|
703 | 703 | self.assertEqual(um.visitdir(b'dir'), True) |
|
704 | 704 | self.assertEqual(um.visitdir(b'dir/subdir'), b'all') |
|
705 | 705 | self.assertFalse(um.visitdir(b'dir/foo')) |
@@ -712,7 +712,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
712 | 712 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) |
|
713 | 713 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
714 | 714 | um = matchmod.unionmatcher([m1, m2]) |
|
715 |
self.assertEqual(um.visitchildrenset(b' |
|
|
715 | self.assertEqual(um.visitchildrenset(b''), {b'dir'}) | |
|
716 | 716 | self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) |
|
717 | 717 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') |
|
718 | 718 | self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) |
@@ -728,7 +728,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
728 | 728 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) |
|
729 | 729 | um = matchmod.unionmatcher([m1, m2]) |
|
730 | 730 | # OPT: these next three could probably be False as well. |
|
731 |
self.assertEqual(um.visitdir(b' |
|
|
731 | self.assertEqual(um.visitdir(b''), True) | |
|
732 | 732 | self.assertEqual(um.visitdir(b'dir'), True) |
|
733 | 733 | self.assertEqual(um.visitdir(b'dir/subdir'), True) |
|
734 | 734 | self.assertFalse(um.visitdir(b'dir/foo')) |
@@ -740,7 +740,7 b' class UnionMatcherTests(unittest.TestCas' | |||
|
740 | 740 | m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x']) |
|
741 | 741 | m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z']) |
|
742 | 742 | um = matchmod.unionmatcher([m1, m2]) |
|
743 |
self.assertEqual(um.visitchildrenset(b' |
|
|
743 | self.assertEqual(um.visitchildrenset(b''), {b'dir'}) | |
|
744 | 744 | self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) |
|
745 | 745 | self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'}) |
|
746 | 746 | self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) |
@@ -754,7 +754,7 b' class SubdirMatcherTests(unittest.TestCa' | |||
|
754 | 754 | m = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
755 | 755 | sm = matchmod.subdirmatcher(b'dir', m) |
|
756 | 756 | |
|
757 |
self.assertEqual(sm.visitdir(b' |
|
|
757 | self.assertEqual(sm.visitdir(b''), True) | |
|
758 | 758 | self.assertEqual(sm.visitdir(b'subdir'), b'all') |
|
759 | 759 | # OPT: These next two should probably be 'all' not True. |
|
760 | 760 | self.assertEqual(sm.visitdir(b'subdir/x'), True) |
@@ -765,7 +765,7 b' class SubdirMatcherTests(unittest.TestCa' | |||
|
765 | 765 | m = matchmod.match(b'', b'', include=[b'path:dir/subdir']) |
|
766 | 766 | sm = matchmod.subdirmatcher(b'dir', m) |
|
767 | 767 | |
|
768 |
self.assertEqual(sm.visitchildrenset(b' |
|
|
768 | self.assertEqual(sm.visitchildrenset(b''), {b'subdir'}) | |
|
769 | 769 | self.assertEqual(sm.visitchildrenset(b'subdir'), b'all') |
|
770 | 770 | # OPT: These next two should probably be 'all' not 'this'. |
|
771 | 771 | self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this') |
@@ -795,12 +795,12 b' class PrefixdirMatcherTests(unittest.Tes' | |||
|
795 | 795 | self.assertEqual(bool(pm(b'd/e/b.txt')), False) |
|
796 | 796 | self.assertEqual(bool(pm(b'd/e/f/b.txt')), True) |
|
797 | 797 | |
|
798 |
self.assertEqual(m.visitdir(b' |
|
|
798 | self.assertEqual(m.visitdir(b''), True) | |
|
799 | 799 | self.assertEqual(m.visitdir(b'e'), True) |
|
800 | 800 | self.assertEqual(m.visitdir(b'e/f'), True) |
|
801 | 801 | self.assertEqual(m.visitdir(b'e/f/g'), False) |
|
802 | 802 | |
|
803 |
self.assertEqual(pm.visitdir(b' |
|
|
803 | self.assertEqual(pm.visitdir(b''), True) | |
|
804 | 804 | self.assertEqual(pm.visitdir(b'd'), True) |
|
805 | 805 | self.assertEqual(pm.visitdir(b'd/e'), True) |
|
806 | 806 | self.assertEqual(pm.visitdir(b'd/e/f'), True) |
@@ -814,7 +814,7 b' class PrefixdirMatcherTests(unittest.Tes' | |||
|
814 | 814 | # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these |
|
815 | 815 | # next two, respectively; patternmatcher does not have this |
|
816 | 816 | # optimization. |
|
817 |
self.assertEqual(m.visitchildrenset(b' |
|
|
817 | self.assertEqual(m.visitchildrenset(b''), b'this') | |
|
818 | 818 | self.assertEqual(m.visitchildrenset(b'e'), b'this') |
|
819 | 819 | self.assertEqual(m.visitchildrenset(b'e/f'), b'this') |
|
820 | 820 | self.assertEqual(m.visitchildrenset(b'e/f/g'), set()) |
@@ -822,7 +822,7 b' class PrefixdirMatcherTests(unittest.Tes' | |||
|
822 | 822 | # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'} |
|
823 | 823 | # for these next three, respectively; patternmatcher does not have this |
|
824 | 824 | # optimization. |
|
825 |
self.assertEqual(pm.visitchildrenset(b' |
|
|
825 | self.assertEqual(pm.visitchildrenset(b''), b'this') | |
|
826 | 826 | self.assertEqual(pm.visitchildrenset(b'd'), b'this') |
|
827 | 827 | self.assertEqual(pm.visitchildrenset(b'd/e'), b'this') |
|
828 | 828 | self.assertEqual(pm.visitchildrenset(b'd/e/f'), b'this') |
General Comments 0
You need to be logged in to leave comments.
Login now