mercurial: comparison mercurial/match.py

equal deleted inserted replaced

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

changeset 42341	27d6956d386b
parent 42329	c7652f7440d9
child 42343	d8e55c0c642c