##// END OF EJS Templates
perfphases: add 'perfphases' command...
perfphases: add 'perfphases' command This commands benchmark the time spend computing the data in a repository.

File last commit:

r32466:12e241b2 default
r32467:ad37c569 default
Show More
match.py
877 lines | 29.9 KiB | text/x-python | PythonLexer
timeless
Generally replace "file name" with "filename" in help and comments.
r8761 # match.py - filename matching
Martin Geisler
match: add copyright and license header
r8231 #
# Copyright 2008, 2009 Matt Mackall <mpm@selenic.com> and others
#
# This software may be used and distributed according to the terms of the
Matt Mackall
Update license to GPLv2+
r10263 # GNU General Public License version 2 or any later version.
Martin Geisler
match: add copyright and license header
r8231
Gregory Szorc
match: use absolute_import
r25958 from __future__ import absolute_import
import copy
import os
import re
from .i18n import _
from . import (
Pierre-Yves David
error: get Abort from 'error' instead of 'util'...
r26587 error,
Gregory Szorc
match: use absolute_import
r25958 pathutil,
util,
)
Matt Mackall
walk: introduce match objects
r6576
Drew Gottlieb
treemanifest: further optimize treemanifest.matches()...
r24636 propertycache = util.propertycache
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 def _rematcher(regex):
'''compile the regexp with the best available regexp engine and return a
matcher function'''
Siddharth Agarwal
match: use util.re.compile instead of util.compilere
r21909 m = util.re.compile(regex)
Bryan O'Sullivan
matcher: use re2 bindings if available...
r16943 try:
# slightly faster, provided by facebook's re2 bindings
return m.test_match
except AttributeError:
return m.match
Matt Harbison
match: resolve filesets in subrepos for commands given the '-S' argument...
r25122 def _expandsets(kindpats, ctx, listsubrepos):
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 '''Returns the kindpats list with the 'set' patterns expanded.'''
Matt Mackall
match: introduce basic fileset support
r14675 fset = set()
other = []
Durham Goode
match: add source to kindpats list...
r25213 for kind, pat, source in kindpats:
Matt Mackall
match: introduce basic fileset support
r14675 if kind == 'set':
if not ctx:
Martin von Zweigbergk
match: use ProgrammingError where appropriate
r32444 raise error.ProgrammingError("fileset expression with no "
"context")
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 s = ctx.getfileset(pat)
Matt Mackall
match: introduce basic fileset support
r14675 fset.update(s)
Matt Harbison
match: resolve filesets in subrepos for commands given the '-S' argument...
r25122
if listsubrepos:
for subpath in ctx.substate:
s = ctx.sub(subpath).getfileset(pat)
fset.update(subpath + '/' + f for f in s)
Matt Mackall
match: introduce basic fileset support
r14675 continue
Durham Goode
match: add source to kindpats list...
r25213 other.append((kind, pat, source))
Matt Mackall
match: introduce basic fileset support
r14675 return fset, other
Durham Goode
match: enable 'subinclude:' syntax...
r25283 def _expandsubinclude(kindpats, root):
Durham Goode
match: make subinclude construction lazy...
r32132 '''Returns the list of subinclude matcher args and the kindpats without the
Durham Goode
match: enable 'subinclude:' syntax...
r25283 subincludes in it.'''
relmatchers = []
other = []
for kind, pat, source in kindpats:
if kind == 'subinclude':
Matt Harbison
match: normpath the ignore source when expanding the 'subinclude' kind...
r25301 sourceroot = pathutil.dirname(util.normpath(source))
Durham Goode
match: enable 'subinclude:' syntax...
r25283 pat = util.pconvert(pat)
path = pathutil.join(sourceroot, pat)
newroot = pathutil.dirname(path)
Durham Goode
match: make subinclude construction lazy...
r32132 matcherargs = (newroot, '', [], ['include:%s' % path])
Durham Goode
match: enable 'subinclude:' syntax...
r25283
prefix = pathutil.canonpath(root, root, newroot)
if prefix:
prefix += '/'
Durham Goode
match: make subinclude construction lazy...
r32132 relmatchers.append((prefix, matcherargs))
Durham Goode
match: enable 'subinclude:' syntax...
r25283 else:
other.append((kind, pat, source))
return relmatchers, other
Martin von Zweigbergk
matcher: make e.g. 'relpath:.' lead to fast paths...
r24447 def _kindpatsalwaysmatch(kindpats):
""""Checks whether the kindspats match everything, as e.g.
'relpath:.' does.
"""
Durham Goode
match: add source to kindpats list...
r25213 for kind, pat, source in kindpats:
Martin von Zweigbergk
matcher: make e.g. 'relpath:.' lead to fast paths...
r24447 if pat != '' or kind not in ['relpath', 'glob']:
return False
return True
Martin von Zweigbergk
match: replace match class by match function (API)...
r32394 def match(root, cwd, patterns, include=None, exclude=None, default='glob',
exact=False, auditor=None, ctx=None, listsubrepos=False, warn=None,
Martin von Zweigbergk
match: replace icasefsmatch() function by flag to regular match()...
r32400 badfn=None, icasefs=False):
Martin von Zweigbergk
match: replace match class by match function (API)...
r32394 """build an object to match a set of file patterns
arguments:
root - the canonical root of the tree you're matching against
cwd - the current working directory, if relevant
patterns - patterns to find
include - patterns to include (unless they are excluded)
exclude - patterns to exclude (even if they are included)
default - if a pattern in patterns has no explicit type, assume this one
exact - patterns are actually filenames (include/exclude still apply)
warn - optional function used for printing warnings
badfn - optional bad() callback for this matcher instead of the default
Martin von Zweigbergk
match: replace icasefsmatch() function by flag to regular match()...
r32400 icasefs - make a matcher for wdir on case insensitive filesystems, which
normalizes the given patterns to the case in the filesystem
Martin von Zweigbergk
match: replace match class by match function (API)...
r32394
a pattern is one of:
'glob:<glob>' - a glob relative to cwd
're:<regexp>' - a regular expression
'path:<path>' - a path relative to repository root, which is matched
recursively
'rootfilesin:<path>' - a path relative to repository root, which is
matched non-recursively (will not match subdirectories)
'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs)
'relpath:<path>' - a path relative to cwd
'relre:<regexp>' - a regexp that needn't match the start of a name
'set:<fileset>' - a fileset expression
'include:<path>' - a file of patterns to read and include
'subinclude:<path>' - a file of patterns to match against files under
the same directory
'<something>' - a pattern of the specified default type
"""
Martin von Zweigbergk
match: replace icasefsmatch() function by flag to regular match()...
r32400 normalize = _donormalize
if icasefs:
Martin von Zweigbergk
match: catch attempts to create case-insenstive exact matchers...
r32415 if exact:
Martin von Zweigbergk
match: use ProgrammingError where appropriate
r32444 raise error.ProgrammingError("a case-insensitive exact matcher "
"doesn't make sense")
Martin von Zweigbergk
match: replace icasefsmatch() function by flag to regular match()...
r32400 dirstate = ctx.repo().dirstate
dsnormalize = dirstate.normalize
def normalize(patterns, default, root, cwd, auditor, warn):
kp = _donormalize(patterns, default, root, cwd, auditor, warn)
kindpats = []
for kind, pats, source in kp:
if kind not in ('re', 'relre'): # regex can't be normalized
p = pats
pats = dsnormalize(pats)
# Preserve the original to handle a case only rename.
if p != pats and p in dirstate:
kindpats.append((kind, p, source))
kindpats.append((kind, pats, source))
return kindpats
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 m = matcher(root, cwd, normalize, patterns, include=include,
Martin von Zweigbergk
match: handle excludes using new differencematcher...
r32465 default=default, exact=exact, auditor=auditor, ctx=ctx,
listsubrepos=listsubrepos, warn=warn, badfn=badfn)
if exclude:
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 em = matcher(root, cwd, normalize, [], include=exclude, default=default,
exact=False, auditor=auditor, ctx=ctx,
Martin von Zweigbergk
match: handle excludes using new differencematcher...
r32465 listsubrepos=listsubrepos, warn=warn, badfn=None)
m = differencematcher(m, em)
return m
Martin von Zweigbergk
match: replace match class by match function (API)...
r32394
def exact(root, cwd, files, badfn=None):
return match(root, cwd, files, exact=True, badfn=badfn)
def always(root, cwd):
return match(root, cwd, [])
def badmatch(match, badfn):
"""Make a copy of the given matcher, replacing its bad method with the given
one.
"""
m = copy.copy(match)
m.bad = badfn
return m
Martin von Zweigbergk
match: move body of _normalize() to a static function...
r32396 def _donormalize(patterns, default, root, cwd, auditor, warn):
'''Convert 'kind:pat' from the patterns list to tuples with kind and
normalized and rooted patterns and with listfiles expanded.'''
kindpats = []
for kind, pat in [_patsplit(p, default) for p in patterns]:
if kind in ('glob', 'relpath'):
pat = pathutil.canonpath(root, cwd, pat, auditor)
elif kind in ('relglob', 'path', 'rootfilesin'):
pat = util.normpath(pat)
elif kind in ('listfile', 'listfile0'):
try:
files = util.readfile(pat)
if kind == 'listfile0':
files = files.split('\0')
else:
files = files.splitlines()
files = [f for f in files if f]
except EnvironmentError:
raise error.Abort(_("unable to read file list (%s)") % pat)
for k, p, source in _donormalize(files, default, root, cwd,
auditor, warn):
kindpats.append((k, p, pat))
continue
elif kind == 'include':
try:
fullpath = os.path.join(root, util.localpath(pat))
includepats = readpatternfile(fullpath, warn)
for k, p, source in _donormalize(includepats, default,
root, cwd, auditor, warn):
kindpats.append((k, p, source or pat))
except error.Abort as inst:
raise error.Abort('%s: %s' % (pat, inst[0]))
except IOError as inst:
if warn:
warn(_("skipping unreadable pattern file '%s': %s\n") %
(pat, inst.strerror))
continue
# else: re or relre - which cannot be normalized
kindpats.append((kind, pat, ''))
return kindpats
Martin von Zweigbergk
match: extract base class for matchers...
r32454 class basematcher(object):
def __init__(self, root, cwd, badfn=None):
self._root = root
self._cwd = cwd
if badfn is not None:
self.bad = badfn
def __call__(self, fn):
return self.matchfn(fn)
def __iter__(self):
for f in self._files:
yield f
# Callbacks related to how the matcher is used by dirstate.walk.
# Subscribers to these events must monkeypatch the matcher object.
def bad(self, f, msg):
'''Callback from dirstate.walk for each explicit file that can't be
found/accessed, with an error message.'''
pass
# If an explicitdir is set, it will be called when an explicitly listed
# directory is visited.
explicitdir = None
# If an traversedir is set, it will be called when a directory discovered
# by recursive traversal is visited.
traversedir = None
def abs(self, f):
'''Convert a repo path back to path that is relative to the root of the
matcher.'''
return f
def rel(self, f):
'''Convert repo path back to path that is relative to cwd of matcher.'''
return util.pathto(self._root, self._cwd, f)
def uipath(self, f):
'''Convert repo path to a display path. If patterns or -I/-X were used
to create this matcher, the display path will be relative to cwd.
Otherwise it is relative to the root of the repo.'''
return self.rel(f)
Martin von Zweigbergk
match: make basematcher._files a @propertycache...
r32455 @propertycache
def _files(self):
return []
Martin von Zweigbergk
match: extract base class for matchers...
r32454 def files(self):
'''Explicitly listed files or patterns or roots:
if no patterns or .always(): empty list,
if exact: list exact files,
if not .anypats(): list all files and dirs,
else: optimal roots'''
return self._files
@propertycache
def _fileset(self):
return set(self._files)
def exact(self, f):
'''Returns True if f is in .files().'''
return f in self._fileset
Martin von Zweigbergk
match: make matchfn a method on the class...
r32463 def matchfn(self, f):
return False
Martin von Zweigbergk
match: extract base class for matchers...
r32454 def visitdir(self, dir):
'''Decides whether a directory should be visited based on whether it
has potential matches in it or one of its subdirectories. This is
based on the match's primary, included, and excluded patterns.
Returns the string 'all' if the given directory and all subdirectories
should be visited. Otherwise returns True or False indicating whether
the given directory should be visited.
This function's behavior is undefined if it has returned False for
one of the dir's parent directories.
'''
return False
def anypats(self):
'''Matcher uses patterns or include/exclude.'''
return False
def always(self):
'''Matcher will match everything and .files() will be empty
- optimization might be possible and necessary.'''
return False
def isexact(self):
return False
def prefix(self):
return not self.always() and not self.isexact() and not self.anypats()
class matcher(basematcher):
Martin von Zweigbergk
match: replace match class by match function (API)...
r32394
Martin von Zweigbergk
match: pass in normalize() function to matchers...
r32398 def __init__(self, root, cwd, normalize, patterns, include=None,
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 default='glob', exact=False, auditor=None, ctx=None,
listsubrepos=False, warn=None, badfn=None):
Martin von Zweigbergk
match: extract base class for matchers...
r32454 super(matcher, self).__init__(root, cwd, badfn)
Pierre-Yves David
match: explicitly tests for None...
r31433 if include is None:
include = []
Matt Mackall
match: fold _matcher into match.__init__
r8581
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 self._anypats = bool(include)
Martin von Zweigbergk
match: fix visitdir for roots of includes...
r32457 self._anyincludepats = False
Bryan O'Sullivan
match: more accurately report when we're always going to match...
r18713 self._always = False
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 self._pathrestricted = bool(include or patterns)
Martin von Zweigbergk
match: implement __repr__() and update users (API)...
r32406 self.patternspat = None
self.includepat = None
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 # roots are directories which are recursively included.
Drew Gottlieb
match: have visitdir() consider includes and excludes...
r25231 self._includeroots = set()
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 # dirs are directories which are non-recursively included.
Martin von Zweigbergk
match: optimize visitdir() for patterns matching only root directory...
r32176 self._includedirs = set()
Matt Mackall
match: fold _matcher into match.__init__
r8581
Martin von Zweigbergk
match: simplify brittle predicate construction...
r22513 matchfns = []
Matt Mackall
match: add exact flag to match() to unify all match forms
r8586 if include:
Martin von Zweigbergk
match: pass in normalize() function to matchers...
r32398 kindpats = normalize(include, 'glob', root, cwd, auditor, warn)
Matt Harbison
match: resolve filesets in subrepos for commands given the '-S' argument...
r25122 self.includepat, im = _buildmatch(ctx, kindpats, '(?:/|$)',
Durham Goode
match: add root to _buildmatch...
r25238 listsubrepos, root)
Martin von Zweigbergk
match: fix visitdir for roots of includes...
r32457 self._anyincludepats = _anypats(kindpats)
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 roots, dirs = _rootsanddirs(kindpats)
self._includeroots.update(roots)
self._includedirs.update(dirs)
Martin von Zweigbergk
match: simplify brittle predicate construction...
r22513 matchfns.append(im)
Matt Mackall
match: add exact flag to match() to unify all match forms
r8586 if exact:
FUJIWARA Katsunori
match: make 'match.files()' return list object always...
r16789 if isinstance(patterns, list):
self._files = patterns
else:
self._files = list(patterns)
Martin von Zweigbergk
match: simplify brittle predicate construction...
r22513 matchfns.append(self.exact)
Matt Mackall
match: add exact flag to match() to unify all match forms
r8586 elif patterns:
Martin von Zweigbergk
match: pass in normalize() function to matchers...
r32398 kindpats = normalize(patterns, default, root, cwd, auditor, warn)
Martin von Zweigbergk
matcher: make e.g. 'relpath:.' lead to fast paths...
r24447 if not _kindpatsalwaysmatch(kindpats):
Rodrigo Damazio Bovendorp
match: adding support for matching files inside a directory...
r31012 self._files = _explicitfiles(kindpats)
Martin von Zweigbergk
matcher: make e.g. 'relpath:.' lead to fast paths...
r24447 self._anypats = self._anypats or _anypats(kindpats)
Matt Harbison
match: resolve filesets in subrepos for commands given the '-S' argument...
r25122 self.patternspat, pm = _buildmatch(ctx, kindpats, '$',
Durham Goode
match: add root to _buildmatch...
r25238 listsubrepos, root)
Martin von Zweigbergk
matcher: make e.g. 'relpath:.' lead to fast paths...
r24447 matchfns.append(pm)
Matt Mackall
match: fold _matcher into match.__init__
r8581
Martin von Zweigbergk
match: simplify brittle predicate construction...
r22513 if not matchfns:
m = util.always
self._always = True
elif len(matchfns) == 1:
m = matchfns[0]
Matt Mackall
match: fold _matcher into match.__init__
r8581 else:
Martin von Zweigbergk
match: simplify brittle predicate construction...
r22513 def m(f):
for matchfn in matchfns:
if not matchfn(f):
return False
return True
Matt Mackall
match: fold _matcher into match.__init__
r8581
Matt Mackall
match: fold match into _match base class
r8587 self.matchfn = m
Matt Harbison
match: introduce uipath() to properly style a file path...
r23480 def uipath(self, f):
Matt Harbison
narrowmatcher: propagate the rel() method...
r23686 return (self._pathrestricted and self.rel(f)) or self.abs(f)
Matt Harbison
match: introduce uipath() to properly style a file path...
r23480
Martin von Zweigbergk
match: make _fileroots a @propertycache and rename it to _fileset...
r32323 @propertycache
Drew Gottlieb
treemanifest: further optimize treemanifest.matches()...
r24636 def _dirs(self):
Martin von Zweigbergk
match: make _fileroots a @propertycache and rename it to _fileset...
r32323 return set(util.dirs(self._fileset)) | {'.'}
Drew Gottlieb
treemanifest: further optimize treemanifest.matches()...
r24636
def visitdir(self, dir):
Martin von Zweigbergk
match: make _fileroots a @propertycache and rename it to _fileset...
r32323 if self.prefix() and dir in self._fileset:
Martin von Zweigbergk
treemanifest: don't iterate entire matching submanifests on match()...
r27343 return 'all'
Martin von Zweigbergk
match: fix visitdir for roots of includes...
r32457 if self._includeroots or self._includedirs:
if (not self._anyincludepats and
dir in self._includeroots):
# The condition above is essentially self.prefix() for includes
return 'all'
if ('.' not in self._includeroots and
dir not in self._includeroots and
dir not in self._includedirs and
not any(parent in self._includeroots
for parent in util.finddirs(dir))):
return False
Martin von Zweigbergk
match: make _fileroots a @propertycache and rename it to _fileset...
r32323 return (not self._fileset or
'.' in self._fileset or
dir in self._fileset or
Martin von Zweigbergk
match: break boolean expressions into one operand per line...
r25576 dir in self._dirs or
Martin von Zweigbergk
match: make _fileroots a @propertycache and rename it to _fileset...
r32323 any(parentdir in self._fileset
Martin von Zweigbergk
match: drop optimization (?) of 'parentdirs' calculation...
r25577 for parentdir in util.finddirs(dir)))
Drew Gottlieb
treemanifest: further optimize treemanifest.matches()...
r24636
Matt Mackall
match: fold match into _match base class
r8587 def anypats(self):
return self._anypats
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111
Jesse Glick
localrepo: optimize internode status calls using match.always...
r16645 def always(self):
Bryan O'Sullivan
match: more accurately report when we're always going to match...
r18713 return self._always
Matt Mackall
match: refactor patkind...
r8568
Martin von Zweigbergk
match: add isexact() method to hide internals...
r24448 def isexact(self):
return self.matchfn == self.exact
Martin von Zweigbergk
match: implement __repr__() and update users (API)...
r32406 def __repr__(self):
Martin von Zweigbergk
match: remove support for excludes from matcher class...
r32466 return ('<matcher files=%r, patterns=%r, includes=%r>' %
(self._files, self.patternspat, self.includepat))
Martin von Zweigbergk
match: implement __repr__() and update users (API)...
r32406
Martin von Zweigbergk
match: handle excludes using new differencematcher...
r32465 class differencematcher(basematcher):
'''Composes two matchers by matching if the first matches and the second
does not. Well, almost... If the user provides a pattern like "-X foo foo",
Mercurial actually does match "foo" against that. That's because exact
matches are treated specially. So, since this differencematcher is used for
excludes, it needs to special-case exact matching.
The second matcher's non-matching-attributes (root, cwd, bad, explicitdir,
traversedir) are ignored.
TODO: If we want to keep the behavior described above for exact matches, we
should consider instead treating the above case something like this:
union(exact(foo), difference(pattern(foo), include(foo)))
'''
def __init__(self, m1, m2):
super(differencematcher, self).__init__(m1._root, m1._cwd)
self._m1 = m1
self._m2 = m2
self.bad = m1.bad
self.explicitdir = m1.explicitdir
self.traversedir = m1.traversedir
def matchfn(self, f):
return self._m1(f) and (not self._m2(f) or self._m1.exact(f))
@propertycache
def _files(self):
if self.isexact():
return [f for f in self._m1.files() if self(f)]
# If m1 is not an exact matcher, we can't easily figure out the set of
# files, because its files() are not always files. For example, if
# m1 is "path:dir" and m2 is "rootfileins:.", we don't
# want to remove "dir" from the set even though it would match m2,
# because the "dir" in m1 may not be a file.
return self._m1.files()
def visitdir(self, dir):
if self._m2.visitdir(dir) == 'all':
# There's a bug here: If m1 matches file 'dir/file' and m2 excludes
# 'dir' (recursively), we should still visit 'dir' due to the
# exception we have for exact matches.
return False
return bool(self._m1.visitdir(dir))
def isexact(self):
return self._m1.isexact()
def anypats(self):
return self._m1.anypats() or self._m2.anypats()
def prefix(self):
return not self.always() and not self.isexact() and not self.anypats()
def __repr__(self):
return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2))
Martin von Zweigbergk
match: make subdirmatcher extend basematcher...
r32456 class subdirmatcher(basematcher):
Martin Geisler
match: add narrowmatcher class...
r12165 """Adapt a matcher to work on a subdirectory only.
The paths are remapped to remove/insert the path as needed:
>>> m1 = match('root', '', ['a.txt', 'sub/b.txt'])
Martin von Zweigbergk
match: rename "narrowmatcher" to "subdirmatcher" (API)...
r28017 >>> m2 = subdirmatcher('sub', m1)
Martin Geisler
match: add narrowmatcher class...
r12165 >>> bool(m2('a.txt'))
False
>>> bool(m2('b.txt'))
True
>>> bool(m2.matchfn('a.txt'))
False
>>> bool(m2.matchfn('b.txt'))
True
>>> m2.files()
['b.txt']
>>> m2.exact('b.txt')
True
Matt Harbison
narrowmatcher: propagate the rel() method...
r23686 >>> util.pconvert(m2.rel('b.txt'))
'sub/b.txt'
Martin Geisler
narrowmatcher: propagate bad method...
r12268 >>> def bad(f, msg):
... print "%s: %s" % (f, msg)
>>> m1.bad = bad
>>> m2.bad('x.txt', 'No such file')
sub/x.txt: No such file
Matt Harbison
match: add the abs() method...
r23685 >>> m2.abs('c.txt')
'sub/c.txt'
Martin Geisler
match: add narrowmatcher class...
r12165 """
def __init__(self, path, matcher):
Martin von Zweigbergk
match: make subdirmatcher extend basematcher...
r32456 super(subdirmatcher, self).__init__(matcher._root, matcher._cwd)
Martin Geisler
match: add narrowmatcher class...
r12165 self._path = path
self._matcher = matcher
Martin von Zweigbergk
match: make subdirmatcher extend basematcher...
r32456 self._always = matcher.always()
Martin Geisler
match: add narrowmatcher class...
r12165
self._files = [f[len(path) + 1:] for f in matcher._files
if f.startswith(path + "/")]
Matt Harbison
match: explicitly naming a subrepo implies always() for the submatcher...
r25194
Martin von Zweigbergk
match: use match.prefix() in subdirmatcher...
r32326 # If the parent repo had a path to this subrepo and the matcher is
# a prefix matcher, this submatcher always matches.
if matcher.prefix():
Matt Mackall
merge with stable
r25195 self._always = any(f == path for f in matcher._files)
Matt Harbison
match: explicitly naming a subrepo implies always() for the submatcher...
r25194
Martin von Zweigbergk
match: avoid accessing match._pathrestricted from subdirmatcher...
r32325 def bad(self, f, msg):
self._matcher.bad(self._path + "/" + f, msg)
Matt Harbison
match: add the abs() method...
r23685 def abs(self, f):
return self._matcher.abs(self._path + "/" + f)
Matt Harbison
narrowmatcher: propagate the rel() method...
r23686 def rel(self, f):
return self._matcher.rel(self._path + "/" + f)
Martin von Zweigbergk
match: avoid accessing match._pathrestricted from subdirmatcher...
r32325 def uipath(self, f):
return self._matcher.uipath(self._path + "/" + f)
Martin von Zweigbergk
match: override matchfn() the usual way in subdirmatcher
r32464 def matchfn(self, f):
# Some information is lost in the superclass's constructor, so we
# can not accurately create the matching function for the subdirectory
# 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)
Martin von Zweigbergk
match: override visitdir() the usual way in subdirmatcher...
r32324 def visitdir(self, dir):
if dir == '.':
dir = self._path
else:
dir = self._path + "/" + dir
return self._matcher.visitdir(dir)
Martin von Zweigbergk
match: make subdirmatcher extend basematcher...
r32456 def always(self):
return self._always
def anypats(self):
return self._matcher.anypats()
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 def patkind(pattern, default=None):
'''If pattern is 'kind:pat' with a known kind, return kind.'''
return _patsplit(pattern, default)[0]
Matt Mackall
match: move util match functions over
r8570
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 def _patsplit(pattern, default):
"""Split a string into the optional pattern kind prefix and the actual
pattern."""
if ':' in pattern:
kind, pat = pattern.split(':', 1)
Steve Borho
match: support reading pattern lists from files
r13218 if kind in ('re', 'glob', 'path', 'relglob', 'relpath', 'relre',
Rodrigo Damazio Bovendorp
match: adding support for matching files inside a directory...
r31012 'listfile', 'listfile0', 'set', 'include', 'subinclude',
'rootfilesin'):
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 return kind, pat
return default, pattern
Matt Mackall
match: move util match functions over
r8570
Matt Mackall
match: remove head and tail args from _globre
r8582 def _globre(pat):
Mads Kiilerich
match: _globre doctests
r21112 r'''Convert an extended glob string to a regexp string.
>>> print _globre(r'?')
.
>>> print _globre(r'*')
[^/]*
>>> print _globre(r'**')
.*
Siddharth Agarwal
match: make glob '**/' match the empty string...
r21815 >>> print _globre(r'**/a')
(?:.*/)?a
>>> print _globre(r'a/**/b')
a\/(?:.*/)?b
Mads Kiilerich
match: _globre doctests
r21112 >>> print _globre(r'[a*?!^][^b][!c]')
[a*?!^][\^b][^c]
>>> print _globre(r'{a,b}')
(?:a|b)
>>> print _globre(r'.\*\?')
\.\*\?
'''
Matt Mackall
match: move util match functions over
r8570 i, n = 0, len(pat)
res = ''
group = 0
Siddharth Agarwal
match: use util.re.escape instead of re.escape...
r21915 escape = util.re.escape
Matt Mackall
many, many trivial check-code fixups
r10282 def peek():
Pulkit Goyal
match: slice over bytes to get the byteschr instead of ascii value
r31421 return i < n and pat[i:i + 1]
Matt Mackall
match: move util match functions over
r8570 while i < n:
Pulkit Goyal
match: slice over bytes to get the byteschr instead of ascii value
r31421 c = pat[i:i + 1]
Matt Mackall
many, many trivial check-code fixups
r10282 i += 1
Matt Mackall
match: optimize escaping in _globre...
r8583 if c not in '*?[{},\\':
res += escape(c)
elif c == '*':
Matt Mackall
match: move util match functions over
r8570 if peek() == '*':
i += 1
Siddharth Agarwal
match: make glob '**/' match the empty string...
r21815 if peek() == '/':
i += 1
res += '(?:.*/)?'
else:
res += '.*'
Matt Mackall
match: move util match functions over
r8570 else:
res += '[^/]*'
elif c == '?':
res += '.'
elif c == '[':
j = i
Pulkit Goyal
match: slice over bytes to get the byteschr instead of ascii value
r31421 if j < n and pat[j:j + 1] in '!]':
Matt Mackall
match: move util match functions over
r8570 j += 1
Pulkit Goyal
match: slice over bytes to get the byteschr instead of ascii value
r31421 while j < n and pat[j:j + 1] != ']':
Matt Mackall
match: move util match functions over
r8570 j += 1
if j >= n:
res += '\\['
else:
stuff = pat[i:j].replace('\\','\\\\')
i = j + 1
Pulkit Goyal
match: slice over bytes to get the byteschr instead of ascii value
r31421 if stuff[0:1] == '!':
Matt Mackall
match: move util match functions over
r8570 stuff = '^' + stuff[1:]
Pulkit Goyal
match: slice over bytes to get the byteschr instead of ascii value
r31421 elif stuff[0:1] == '^':
Matt Mackall
match: move util match functions over
r8570 stuff = '\\' + stuff
res = '%s[%s]' % (res, stuff)
elif c == '{':
group += 1
res += '(?:'
elif c == '}' and group:
res += ')'
group -= 1
elif c == ',' and group:
res += '|'
elif c == '\\':
p = peek()
if p:
i += 1
Matt Mackall
match: optimize escaping in _globre...
r8583 res += escape(p)
Matt Mackall
match: move util match functions over
r8570 else:
Matt Mackall
match: optimize escaping in _globre...
r8583 res += escape(c)
Matt Mackall
match: move util match functions over
r8570 else:
Matt Mackall
match: optimize escaping in _globre...
r8583 res += escape(c)
Matt Mackall
match: remove head and tail args from _globre
r8582 return res
Matt Mackall
match: move util match functions over
r8570
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 def _regex(kind, pat, globsuffix):
'''Convert a (normalized) pattern of any kind into a regular expression.
globsuffix is appended to the regexp of globs.'''
if not pat:
Matt Mackall
match: unnest functions in _matcher
r8574 return ''
if kind == 're':
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 return pat
if kind == 'path':
Matt Harbison
match: let 'path:.' and 'path:' match everything (issue4687)...
r25636 if pat == '.':
return ''
Siddharth Agarwal
match: use util.re.escape instead of re.escape...
r21915 return '^' + util.re.escape(pat) + '(?:/|$)'
Rodrigo Damazio Bovendorp
match: adding support for matching files inside a directory...
r31012 if kind == 'rootfilesin':
if pat == '.':
escaped = ''
else:
# Pattern is a directory name.
escaped = util.re.escape(pat) + '/'
# Anything after the pattern must be a non-directory.
return '^' + escaped + '[^/]+$'
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 if kind == 'relglob':
return '(?:|.*/)' + _globre(pat) + globsuffix
if kind == 'relpath':
Siddharth Agarwal
match: use util.re.escape instead of re.escape...
r21915 return util.re.escape(pat) + '(?:/|$)'
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 if kind == 'relre':
if pat.startswith('^'):
return pat
return '.*' + pat
return _globre(pat) + globsuffix
Matt Mackall
match: unnest functions in _matcher
r8574
Durham Goode
match: add root to _buildmatch...
r25238 def _buildmatch(ctx, kindpats, globsuffix, listsubrepos, root):
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 '''Return regexp string and a matcher function for kindpats.
globsuffix is appended to the regexp of globs.'''
Durham Goode
match: allow unioning arbitrary match functions...
r25239 matchfuncs = []
Durham Goode
match: enable 'subinclude:' syntax...
r25283 subincludes, kindpats = _expandsubinclude(kindpats, root)
if subincludes:
Durham Goode
match: make subinclude construction lazy...
r32132 submatchers = {}
Durham Goode
match: enable 'subinclude:' syntax...
r25283 def matchsubinclude(f):
Durham Goode
match: make subinclude construction lazy...
r32132 for prefix, matcherargs in subincludes:
if f.startswith(prefix):
mf = submatchers.get(prefix)
if mf is None:
mf = match(*matcherargs)
submatchers[prefix] = mf
if mf(f[len(prefix):]):
return True
Durham Goode
match: enable 'subinclude:' syntax...
r25283 return False
matchfuncs.append(matchsubinclude)
Matt Mackall
match: introduce basic fileset support
r14675
Matt Harbison
match: resolve filesets in subrepos for commands given the '-S' argument...
r25122 fset, kindpats = _expandsets(kindpats, ctx, listsubrepos)
Matt Mackall
match: introduce basic fileset support
r14675 if fset:
Durham Goode
match: allow unioning arbitrary match functions...
r25239 matchfuncs.append(fset.__contains__)
Matt Mackall
match: introduce basic fileset support
r14675
Durham Goode
match: allow unioning arbitrary match functions...
r25239 regex = ''
if kindpats:
regex, mf = _buildregexmatch(kindpats, globsuffix)
matchfuncs.append(mf)
if len(matchfuncs) == 1:
return regex, matchfuncs[0]
else:
return regex, lambda f: any(mf(f) for mf in matchfuncs)
Matt Mackall
match: introduce basic fileset support
r14675
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 def _buildregexmatch(kindpats, globsuffix):
"""Build a match function from a list of kinds and kindpats,
return regexp string and a matcher function."""
Matt Mackall
match: unnest functions in _matcher
r8574 try:
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 regex = '(?:%s)' % '|'.join([_regex(k, p, globsuffix)
Durham Goode
match: add source to kindpats list...
r25213 for (k, p, s) in kindpats])
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 if len(regex) > 20000:
Brodie Rao
cleanup: "raise SomeException()" -> "raise SomeException"
r16687 raise OverflowError
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 return regex, _rematcher(regex)
Matt Mackall
match: unnest functions in _matcher
r8574 except OverflowError:
# We're using a Python with a tiny regex engine and we
# made it explode, so we'll divide the pattern list in two
# until it works
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 l = len(kindpats)
Matt Mackall
match: unnest functions in _matcher
r8574 if l < 2:
raise
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 regexa, a = _buildregexmatch(kindpats[:l//2], globsuffix)
regexb, b = _buildregexmatch(kindpats[l//2:], globsuffix)
Yuya Nishihara
match: fix NameError 'pat' on overflow of regex pattern length...
r21191 return regex, lambda s: a(s) or b(s)
Matt Mackall
match: unnest functions in _matcher
r8574 except re.error:
Durham Goode
match: add source to kindpats list...
r25213 for k, p, s in kindpats:
Matt Mackall
match: unnest functions in _matcher
r8574 try:
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 _rematcher('(?:%s)' % _regex(k, p, globsuffix))
Matt Mackall
match: unnest functions in _matcher
r8574 except re.error:
Durham Goode
match: add source to kindpats list...
r25213 if s:
Pierre-Yves David
error: get Abort from 'error' instead of 'util'...
r26587 raise error.Abort(_("%s: invalid pattern (%s): %s") %
Durham Goode
match: add source to kindpats list...
r25213 (s, k, p))
else:
Pierre-Yves David
error: get Abort from 'error' instead of 'util'...
r26587 raise error.Abort(_("invalid pattern (%s): %s") % (k, p))
raise error.Abort(_("invalid pattern"))
Matt Mackall
match: unnest functions in _matcher
r8574
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 def _patternrootsanddirs(kindpats):
'''Returns roots and directories corresponding to each pattern.
Mads Kiilerich
match: make it more clear what _roots do and that it ends up in match()._files
r21079
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 This calculates the roots and directories exactly matching the patterns and
returns a tuple of (roots, dirs) for each. It does not return other
directories which may also need to be considered, like the parent
directories.
Mads Kiilerich
match: make it more clear what _roots do and that it ends up in match()._files
r21079 '''
Matt Mackall
match: split up _normalizepats
r8576 r = []
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 d = []
Durham Goode
match: add source to kindpats list...
r25213 for kind, pat, source in kindpats:
Matt Mackall
match: fold _globprefix into _roots
r8584 if kind == 'glob': # find the non-glob prefix
root = []
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 for p in pat.split('/'):
Matt Mackall
match: fold _globprefix into _roots
r8584 if '[' in p or '{' in p or '*' in p or '?' in p:
break
root.append(p)
r.append('/'.join(root) or '.')
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 elif kind in ('relpath', 'path'):
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 r.append(pat or '.')
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 elif kind in ('rootfilesin',):
d.append(pat or '.')
Mads Kiilerich
match: fix root calculation for combining regexps with simple paths...
r19107 else: # relglob, re, relre
Matt Mackall
match: split up _normalizepats
r8576 r.append('.')
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 return r, d
def _roots(kindpats):
'''Returns root directories to match recursively from the given patterns.'''
roots, dirs = _patternrootsanddirs(kindpats)
return roots
def _rootsanddirs(kindpats):
'''Returns roots and exact directories from patterns.
roots are directories to match recursively, whereas exact directories should
be matched non-recursively. The returned (roots, dirs) tuple will also
include directories that need to be implicitly considered as either, such as
parent directories.
>>> _rootsanddirs(\
[('glob', 'g/h/*', ''), ('glob', 'g/h', ''), ('glob', 'g*', '')])
Martin von Zweigbergk
match: optimize visitdir() for patterns matching only root directory...
r32176 (['g/h', 'g/h', '.'], ['g', '.'])
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 >>> _rootsanddirs(\
[('rootfilesin', 'g/h', ''), ('rootfilesin', '', '')])
Martin von Zweigbergk
match: optimize visitdir() for patterns matching only root directory...
r32176 ([], ['g/h', '.', 'g', '.'])
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 >>> _rootsanddirs(\
[('relpath', 'r', ''), ('path', 'p/p', ''), ('path', '', '')])
Martin von Zweigbergk
match: optimize visitdir() for patterns matching only root directory...
r32176 (['r', 'p/p', '.'], ['p', '.'])
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 >>> _rootsanddirs(\
[('relglob', 'rg*', ''), ('re', 're/', ''), ('relre', 'rr', '')])
Martin von Zweigbergk
match: optimize visitdir() for patterns matching only root directory...
r32176 (['.', '.', '.'], ['.'])
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013 '''
r, d = _patternrootsanddirs(kindpats)
# Append the parents as non-recursive/exact directories, since they must be
# scanned to get to either the roots or the other exact directories.
d.extend(util.dirs(d))
d.extend(util.dirs(r))
Martin von Zweigbergk
match: optimize visitdir() for patterns matching only root directory...
r32176 # util.dirs() does not include the root directory, so add it manually
d.append('.')
Rodrigo Damazio Bovendorp
match: making visitdir() deal with non-recursive entries...
r31013
return r, d
Matt Mackall
match: split up _normalizepats
r8576
Rodrigo Damazio Bovendorp
match: adding support for matching files inside a directory...
r31012 def _explicitfiles(kindpats):
'''Returns the potential explicit filenames from the patterns.
>>> _explicitfiles([('path', 'foo/bar', '')])
['foo/bar']
>>> _explicitfiles([('rootfilesin', 'foo/bar', '')])
[]
'''
# Keep only the pattern kinds where one can specify filenames (vs only
# directory names).
filable = [kp for kp in kindpats if kp[0] not in ('rootfilesin',)]
return _roots(filable)
Mads Kiilerich
match: improve documentation - docstrings and more descriptive variable naming...
r21111 def _anypats(kindpats):
Durham Goode
match: add source to kindpats list...
r25213 for kind, pat, source in kindpats:
Rodrigo Damazio Bovendorp
match: adding support for matching files inside a directory...
r31012 if kind in ('glob', 're', 'relglob', 'relre', 'set', 'rootfilesin'):
Matt Mackall
match: split up _normalizepats
r8576 return True
Durham Goode
ignore: move readpatternfile to match.py...
r25167
_commentre = None
Laurent Charignon
match: add option to return line and lineno from readpattern...
r27595 def readpatternfile(filepath, warn, sourceinfo=False):
Durham Goode
ignore: move readpatternfile to match.py...
r25167 '''parse a pattern file, returning a list of
patterns. These patterns should be given to compile()
Durham Goode
ignore: use 'include:' rules instead of custom syntax...
r25216 to be validated and converted into a match function.
trailing white space is dropped.
the escape character is backslash.
comments start with #.
empty lines are skipped.
lines can be of the following formats:
syntax: regexp # defaults following lines to non-rooted regexps
syntax: glob # defaults following lines to non-rooted globs
re:pattern # non-rooted regular expression
glob:pattern # non-rooted glob
Laurent Charignon
match: add option to return line and lineno from readpattern...
r27595 pattern # pattern of the current default type
if sourceinfo is set, returns a list of tuples:
(pattern, lineno, originalline). This is useful to debug ignore patterns.
'''
Durham Goode
ignore: use 'include:' rules instead of custom syntax...
r25216
Durham Goode
match: add 'include:' syntax...
r25215 syntaxes = {'re': 'relre:', 'regexp': 'relre:', 'glob': 'relglob:',
Durham Goode
match: enable 'subinclude:' syntax...
r25283 'include': 'include', 'subinclude': 'subinclude'}
Durham Goode
ignore: move readpatternfile to match.py...
r25167 syntax = 'relre:'
patterns = []
Rishabh Madan
py3: open file in rb mode
r31403 fp = open(filepath, 'rb')
Jun Wu
match: migrate to util.iterfile
r30399 for lineno, line in enumerate(util.iterfile(fp), start=1):
Durham Goode
ignore: move readpatternfile to match.py...
r25167 if "#" in line:
global _commentre
if not _commentre:
Pulkit Goyal
match: make regular expression bytes to prevent TypeError
r31420 _commentre = util.re.compile(br'((?:^|[^\\])(?:\\\\)*)#.*')
Durham Goode
ignore: move readpatternfile to match.py...
r25167 # remove comments prefixed by an even number of escapes
Bryan O'Sullivan
match: use re2 in readpatternfile if possible...
r27327 m = _commentre.search(line)
if m:
line = line[:m.end(1)]
Durham Goode
ignore: move readpatternfile to match.py...
r25167 # fixup properly escaped comments that survived the above
line = line.replace("\\#", "#")
line = line.rstrip()
if not line:
continue
if line.startswith('syntax:'):
s = line[7:].strip()
try:
syntax = syntaxes[s]
except KeyError:
Durham Goode
match: add optional warn argument...
r25214 if warn:
warn(_("%s: ignoring invalid syntax '%s'\n") %
(filepath, s))
Durham Goode
ignore: move readpatternfile to match.py...
r25167 continue
linesyntax = syntax
for s, rels in syntaxes.iteritems():
if line.startswith(rels):
linesyntax = rels
line = line[len(rels):]
break
elif line.startswith(s+':'):
linesyntax = rels
line = line[len(s) + 1:]
break
Laurent Charignon
match: add option to return line and lineno from readpattern...
r27595 if sourceinfo:
patterns.append((linesyntax + line, lineno, line))
else:
patterns.append(linesyntax + line)
Durham Goode
ignore: move readpatternfile to match.py...
r25167 fp.close()
return patterns