mercurial-crew-with-dirclash: comparison mercurial/util.py

equal deleted inserted replaced

-:ba51a8225a60
+:b5d1eaade333
 break
 name = dirname
 raise Abort('%s not under root' % myname)
-def matcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head='', src=None):
+def matcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None):
-return _matcher(canonroot, cwd, names, inc, exc, head, 'glob', src)
+return _matcher(canonroot, cwd, names, inc, exc, 'glob', src)
-def cmdmatcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head='',
+def cmdmatcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None,
-src=None, globbed=False):
+globbed=False, default=None):
-if not globbed:
+default = default or 'relpath'
+if default == 'relpath' and not globbed:
 names = expand_glob(names)
-return _matcher(canonroot, cwd, names, inc, exc, head, 'relpath', src)
+return _matcher(canonroot, cwd, names, inc, exc, default, src)
-def _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat, src):
+def _matcher(canonroot, cwd, names, inc, exc, dflt_pat, src):
 """build a function to match a set of file patterns
 arguments:
 canonroot - the canonical root of the tree you're matching against
 cwd - the current working directory, if relevant
 names - patterns to find
 inc - patterns to include
 exc - patterns to exclude
-head - a regex to prepend to patterns to control whether a match is rooted
+dflt_pat - if a pattern in names has no explicit type, assume this one
+src - where these patterns came from (e.g. .hgignore)
 a pattern is one of:
-'glob:<rooted glob>'
+'glob:<glob>' - a glob relative to cwd
-'re:<rooted regexp>'
+'re:<regexp>' - a regular expression
-'path:<rooted path>'
+'path:<path>' - a path relative to canonroot
-'relglob:<relative glob>'
+'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs)
-'relpath:<relative path>'
+'relpath:<path>' - a path relative to cwd
-'relre:<relative regexp>'
+'relre:<regexp>' - a regexp that doesn't have to match the start of a name
-'<rooted path or regexp>'
+'<something>' - one of the cases above, selected by the dflt_pat argument
 returns:
 a 3-tuple containing
-- list of explicit non-pattern names passed in
+- list of roots (places where one should start a recursive walk of the fs);
+this often matches the explicit non-pattern names passed in, but also
+includes the initial part of glob: patterns that has no glob characters
 - a bool match(filename) function
 - a bool indicating if any patterns were passed in
-todo:
-make head regex a rooted bool
 """
+# a common case: no patterns at all
+if not names and not inc and not exc:
+return [], always, False
 def contains_glob(name):
 for c in name:
 if c in _globchars: return True
 return False
 def regex(kind, name, tail):
 '''convert a pattern into a regular expression'''
+if not name:
+return ''
 if kind == 're':
 return name
 elif kind == 'path':
 return '^' + re.escape(name) + '(?:/|$)'
 elif kind == 'relglob':
-return head + globre(name, '(?:|.*/)', tail)
+return globre(name, '(?:|.*/)', '(?:/|$)')
 elif kind == 'relpath':
-return head + re.escape(name) + tail
+return re.escape(name) + '(?:/|$)'
 elif kind == 'relre':
 if name.startswith('^'):
 return name
 return '.*' + name
-return head + globre(name, '', tail)
+return globre(name, '', tail)
 def matchfn(pats, tail):
 """build a matching function from a set of patterns"""
 if not pats:
 return
 return buildfn
 def globprefix(pat):
 '''return the non-glob prefix of a path, e.g. foo/* -> foo'''
 root = []
-for p in pat.split(os.sep):
+for p in pat.split('/'):
 if contains_glob(p): break
 root.append(p)
-return '/'.join(root)
+return '/'.join(root) or '.'
-pats = []
+def normalizepats(names, default):
-files = []
+pats = []
-roots = []
+files = []
-for kind, name in [patkind(p, dflt_pat) for p in names]:
+roots = []
-if kind in ('glob', 'relpath'):
+anypats = False
-name = canonpath(canonroot, cwd, name)
+for kind, name in [patkind(p, default) for p in names]:
-if name == '':
+if kind in ('glob', 'relpath'):
-kind, name = 'glob', '**'
+name = canonpath(canonroot, cwd, name)
-if kind in ('glob', 'path', 're'):
+elif kind in ('relglob', 'path'):
-pats.append((kind, name))
+name = normpath(name)
-if kind == 'glob':
+if kind in ('glob', 're', 'relglob', 'relre'):
-root = globprefix(name)
+pats.append((kind, name))
-if root: roots.append(root)
+anypats = True
-elif kind == 'relpath':
+if kind == 'glob':
-files.append((kind, name))
+root = globprefix(name)
-roots.append(name)
+roots.append(root)
+elif kind in ('relpath', 'path'):
+files.append((kind, name))
+roots.append(name)
+elif kind == 'relglob':
+roots.append('.')
+return roots, pats + files, anypats
+roots, pats, anypats = normalizepats(names, dflt_pat)
 patmatch = matchfn(pats, '$') or always
-filematch = matchfn(files, '(?:/|$)') or always
 incmatch = always
 if inc:
-inckinds = [patkind(canonpath(canonroot, cwd, i)) for i in inc]
+dummy, inckinds, dummy = normalizepats(inc, 'glob')
 incmatch = matchfn(inckinds, '(?:/|$)')
 excmatch = lambda fn: False
 if exc:
-exckinds = [patkind(canonpath(canonroot, cwd, x)) for x in exc]
+dummy, exckinds, dummy = normalizepats(exc, 'glob')
 excmatch = matchfn(exckinds, '(?:/|$)')
-return (roots,
+if not names and inc and not exc:
-lambda fn: (incmatch(fn) and not excmatch(fn) and
+# common case: hgignore patterns
-(fn.endswith('/') or
+match = incmatch
-(not pats and not files) or
+else:
-(pats and patmatch(fn)) or
+match = lambda fn: incmatch(fn) and not excmatch(fn) and patmatch(fn)
-(files and filematch(fn)))),
-(inc or exc or (pats and pats != [('glob', '**')])) and True)
+return (roots, match, (inc or exc or anypats) and True)
 def system(cmd, environ={}, cwd=None, onerr=None, errprefix=None):
 '''enhanced shell command execution.
 run with environment maybe modified, maybe in different dir.

changeset 4195	b5d1eaade333
parent 4134	9dc64c8414ca
parent 4194	ec932167c3a7
child 4232	0d51eb296fb9