249 lines · 7.5 KB · Python
RawDownload
# match.py - filename matching##  Copyright 2008, 2009 Matt Mackall <mpm@selenic.com> and others## This software may be used and distributed according to the terms of the# GNU General Public License version 2, incorporated herein by reference. import reimport util class match(object):    def __init__(self, root, cwd, patterns, include=[], exclude=[],                 default='glob', exact=False):        """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        exclude - patterns to exclude        default - if a pattern in names has no explicit type, assume this one        exact - patterns are actually literals         a pattern is one of:        'glob:<glob>' - a glob relative to cwd        're:<regexp>' - a regular expression        'path:<path>' - a path relative to canonroot        '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        '<something>' - a pattern of the specified default type        """         self._root = root        self._cwd = cwd        self._files = []        self._anypats = bool(include or exclude)         if include:            im = _buildmatch(_normalize(include, 'glob', root, cwd), '(?:/|$)')        if exclude:            em = _buildmatch(_normalize(exclude, 'glob', root, cwd), '(?:/|$)')        if exact:            self._files = patterns            pm = self.exact        elif patterns:            pats = _normalize(patterns, default, root, cwd)            self._files = _roots(pats)            self._anypats = self._anypats or _anypats(pats)            pm = _buildmatch(pats, '$')         if patterns or exact:            if include:                if exclude:                    m = lambda f: im(f) and not em(f) and pm(f)                else:                    m = lambda f: im(f) and pm(f)            else:                if exclude:                    m = lambda f: not em(f) and pm(f)                else:                    m = pm        else:            if include:                if exclude:                    m = lambda f: im(f) and not em(f)                else:                    m = im            else:                if exclude:                    m = lambda f: not em(f)                else:                    m = lambda f: True         self.matchfn = m        self._fmap = set(self._files)     def __call__(self, fn):        return self.matchfn(fn)    def __iter__(self):        for f in self._files:            yield f    def bad(self, f, msg):        '''callback for each explicit file that can't be        found/accessed, with an error message        '''        pass    def dir(self, f):        pass    def missing(self, f):        pass    def exact(self, f):        return f in self._fmap    def rel(self, f):        return util.pathto(self._root, self._cwd, f)    def files(self):        return self._files    def anypats(self):        return self._anypats class exact(match):    def __init__(self, root, cwd, files):        match.__init__(self, root, cwd, files, exact = True) class always(match):    def __init__(self, root, cwd):        match.__init__(self, root, cwd, []) def patkind(pat):    return _patsplit(pat, None)[0] def _patsplit(pat, default):    """Split a string into an optional pattern kind prefix and the    actual pattern."""    if ':' in pat:        kind, val = pat.split(':', 1)        if kind in ('re', 'glob', 'path', 'relglob', 'relpath', 'relre'):            return kind, val    return default, pat def _globre(pat):    "convert a glob pattern into a regexp"    i, n = 0, len(pat)    res = ''    group = 0    escape = re.escape    def peek(): return i < n and pat[i]    while i < n:        c = pat[i]        i = i+1        if c not in '*?[{},\\':            res += escape(c)        elif c == '*':            if peek() == '*':                i += 1                res += '.*'            else:                res += '[^/]*'        elif c == '?':            res += '.'        elif c == '[':            j = i            if j < n and pat[j] in '!]':                j += 1            while j < n and pat[j] != ']':                j += 1            if j >= n:                res += '\\['            else:                stuff = pat[i:j].replace('\\','\\\\')                i = j + 1                if stuff[0] == '!':                    stuff = '^' + stuff[1:]                elif stuff[0] == '^':                    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                res += escape(p)            else:                res += escape(c)        else:            res += escape(c)    return res 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 '(?:|.*/)' + _globre(name) + tail    elif kind == 'relpath':        return re.escape(name) + '(?:/|$)'    elif kind == 'relre':        if name.startswith('^'):            return name        return '.*' + name    return _globre(name) + tail def _buildmatch(pats, tail):    """build a matching function from a set of patterns"""    try:        pat = '(?:%s)' % '|'.join([_regex(k, p, tail) for (k, p) in pats])        if len(pat) > 20000:            raise OverflowError()        return re.compile(pat).match    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        l = len(pats)        if l < 2:            raise        a, b = _buildmatch(pats[:l//2], tail), _buildmatch(pats[l//2:], tail)        return lambda s: a(s) or b(s)    except re.error:        for k, p in pats:            try:                re.compile('(?:%s)' % _regex(k, p, tail))            except re.error:                raise util.Abort("invalid pattern (%s): %s" % (k, p))        raise util.Abort("invalid pattern") def _normalize(names, default, root, cwd):    pats = []    for kind, name in [_patsplit(p, default) for p in names]:        if kind in ('glob', 'relpath'):            name = util.canonpath(root, cwd, name)        elif kind in ('relglob', 'path'):            name = util.normpath(name)         pats.append((kind, name))    return pats def _roots(patterns):    r = []    for kind, name in patterns:        if kind == 'glob': # find the non-glob prefix            root = []            for p in name.split('/'):                if '[' in p or '{' in p or '*' in p or '?' in p:                    break                root.append(p)            r.append('/'.join(root) or '.')        elif kind in ('relpath', 'path'):            r.append(name or '.')        elif kind == 'relglob':            r.append('.')    return r def _anypats(patterns):    for kind, name in patterns:        if kind in ('glob', 're', 'relglob', 'relre'):            return True

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t