comparison mercurial/match.py @ 32466:12e241b2713c

match: remove support for excludes from matcher class

The support is now provided by differencematcher() and still available
via the match() function.

32465:a83a7d27911e

                        kindpats.append((kind, p, source))

                kindpats.append((kind, pats, source))
            return kindpats

    m = matcher(root, cwd, normalize, patterns, include=include, exclude=None,
                default=default, exact=exact, auditor=auditor, ctx=ctx,
                listsubrepos=listsubrepos, warn=warn, badfn=badfn)
    if exclude:
        em = matcher(root, cwd, normalize, [], include=exclude, exclude=None,
                     default=default, exact=False, auditor=auditor, ctx=ctx,
                     listsubrepos=listsubrepos, warn=warn, badfn=None)
        m = differencematcher(m, em)
    return m

def exact(root, cwd, files, badfn=None):

        return not self.always() and not self.isexact() and not self.anypats()

class matcher(basematcher):

    def __init__(self, root, cwd, normalize, patterns, include=None,
                 exclude=None, default='glob', exact=False, auditor=None,
                 ctx=None, listsubrepos=False, warn=None, badfn=None):
        super(matcher, self).__init__(root, cwd, badfn)
        if include is None:
            include = []
        if exclude is None:
            exclude = []

        self._anypats = bool(include or exclude)
        self._anyincludepats = False
        self._always = False
        self._pathrestricted = bool(include or exclude or patterns)
        self.patternspat = None
        self.includepat = None
        self.excludepat = None

        # roots are directories which are recursively included/excluded.
        self._includeroots = set()
        self._excluderoots = set()
        # dirs are directories which are non-recursively included.
        self._includedirs = set()

        matchfns = []
        if include:

            self._anyincludepats = _anypats(kindpats)
            roots, dirs = _rootsanddirs(kindpats)
            self._includeroots.update(roots)
            self._includedirs.update(dirs)
            matchfns.append(im)
        if exclude:
            kindpats = normalize(exclude, 'glob', root, cwd, auditor, warn)
            self.excludepat, em = _buildmatch(ctx, kindpats, '(?:/|$)',
                                              listsubrepos, root)
            if not _anypats(kindpats):
                # Only consider recursive excludes as such - if a non-recursive
                # exclude is used, we must still recurse into the excluded
                # directory, at least to find subdirectories. In such a case,
                # the regex still won't match the non-recursively-excluded
                # files.
                self._excluderoots.update(_roots(kindpats))
            matchfns.append(lambda f: not em(f))
        if exact:
            if isinstance(patterns, list):
                self._files = patterns
            else:
                self._files = list(patterns)

        return set(util.dirs(self._fileset)) | {'.'}

    def visitdir(self, dir):
        if self.prefix() and dir in self._fileset:
            return 'all'
        if dir in self._excluderoots:
            return False
        if self._includeroots or self._includedirs:
            if (not self._anyincludepats and
                not self._excluderoots 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

    def isexact(self):
        return self.matchfn == self.exact

    def __repr__(self):
        return ('<matcher files=%r, patterns=%r, includes=%r, excludes=%r>' %
                (self._files, self.patternspat, self.includepat,
                 self.excludepat))

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

32466:12e241b2713c

                        kindpats.append((kind, p, source))

                kindpats.append((kind, pats, source))
            return kindpats

    m = matcher(root, cwd, normalize, patterns, include=include,
                default=default, exact=exact, auditor=auditor, ctx=ctx,
                listsubrepos=listsubrepos, warn=warn, badfn=badfn)
    if exclude:
        em = matcher(root, cwd, normalize, [], include=exclude, default=default,
                     exact=False, auditor=auditor, ctx=ctx,
                     listsubrepos=listsubrepos, warn=warn, badfn=None)
        m = differencematcher(m, em)
    return m

def exact(root, cwd, files, badfn=None):

        return not self.always() and not self.isexact() and not self.anypats()

class matcher(basematcher):

    def __init__(self, root, cwd, normalize, patterns, include=None,
                 default='glob', exact=False, auditor=None, ctx=None,
                 listsubrepos=False, warn=None, badfn=None):
        super(matcher, self).__init__(root, cwd, badfn)
        if include is None:
            include = []

        self._anypats = bool(include)
        self._anyincludepats = False
        self._always = False
        self._pathrestricted = bool(include or patterns)
        self.patternspat = None
        self.includepat = None

        # roots are directories which are recursively included.
        self._includeroots = set()
        # dirs are directories which are non-recursively included.
        self._includedirs = set()

        matchfns = []
        if include:

            self._anyincludepats = _anypats(kindpats)
            roots, dirs = _rootsanddirs(kindpats)
            self._includeroots.update(roots)
            self._includedirs.update(dirs)
            matchfns.append(im)
        if exact:
            if isinstance(patterns, list):
                self._files = patterns
            else:
                self._files = list(patterns)

        return set(util.dirs(self._fileset)) | {'.'}

    def visitdir(self, dir):
        if self.prefix() and dir in self._fileset:
            return 'all'
        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

    def isexact(self):
        return self.matchfn == self.exact

    def __repr__(self):
        return ('<matcher files=%r, patterns=%r, includes=%r>' %
                (self._files, self.patternspat, self.includepat))

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