comparison mercurial/match.py @ 32504:2ba4d3b74ba8

match: remove support for includes from patternmatcher

Includes (and excludes) are now delegated to the includematcher.

32503:361808a2b0b8

            return kindpats

    if exact:
        m = exactmatcher(root, cwd, patterns, badfn)
    else:
        m = patternmatcher(root, cwd, normalize, patterns, include=None,
                           default=default, auditor=auditor, ctx=ctx,
                           listsubrepos=listsubrepos, warn=warn, badfn=badfn)
    if include:
        im = includematcher(root, cwd, normalize, include, auditor=auditor,
                            ctx=ctx, listsubrepos=listsubrepos, warn=warn,
                            badfn=None)
        m = intersectmatchers(m, im)

    def prefix(self):
        return not self.always() and not self.isexact() and not self.anypats()

class patternmatcher(basematcher):

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

        self._anypats = bool(include)
        self._anyincludepats = False
        self._always = False
        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:
            kindpats = normalize(include, 'glob', root, cwd, auditor, warn)
            self.includepat, im = _buildmatch(ctx, kindpats, '(?:/|$)',
                                              listsubrepos, root)
            self._anyincludepats = _anypats(kindpats)
            roots, dirs = _rootsanddirs(kindpats)
            self._includeroots.update(roots)
            self._includedirs.update(dirs)
            matchfns.append(im)
        if patterns:
            kindpats = normalize(patterns, default, root, cwd, auditor, warn)
            if not _kindpatsalwaysmatch(kindpats):
                self._files = _explicitfiles(kindpats)
                self._anypats = self._anypats or _anypats(kindpats)

        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
                dir not in self._includedirs and
                not any(parent in self._includeroots
                        for parent in util.finddirs(dir))):
                return False
        return (not self._fileset or
                '.' in self._fileset or
                dir in self._fileset or
                dir in self._dirs or
                any(parentdir in self._fileset

    def always(self):
        return self._always

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

class includematcher(basematcher):

    def __init__(self, root, cwd, normalize, include, auditor=None, ctx=None,
                 listsubrepos=False, warn=None, badfn=None):

32504:2ba4d3b74ba8

            return kindpats

    if exact:
        m = exactmatcher(root, cwd, patterns, badfn)
    else:
        m = patternmatcher(root, cwd, normalize, patterns, default=default,
                           auditor=auditor, ctx=ctx, listsubrepos=listsubrepos,
                           warn=warn, badfn=badfn)
    if include:
        im = includematcher(root, cwd, normalize, include, auditor=auditor,
                            ctx=ctx, listsubrepos=listsubrepos, warn=warn,
                            badfn=None)
        m = intersectmatchers(m, im)

    def prefix(self):
        return not self.always() and not self.isexact() and not self.anypats()

class patternmatcher(basematcher):

    def __init__(self, root, cwd, normalize, patterns, default='glob',
                 auditor=None, ctx=None, listsubrepos=False, warn=None,
                 badfn=None):
        super(patternmatcher, self).__init__(root, cwd, badfn,
                                             relativeuipath=bool(patterns))

        self._anypats = False
        self._always = False
        self.patternspat = None

        matchfns = []
        if patterns:
            kindpats = normalize(patterns, default, root, cwd, auditor, warn)
            if not _kindpatsalwaysmatch(kindpats):
                self._files = _explicitfiles(kindpats)
                self._anypats = self._anypats or _anypats(kindpats)

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

    def visitdir(self, dir):
        if self.prefix() and dir in self._fileset:
            return 'all'
        return (not self._fileset or
                '.' in self._fileset or
                dir in self._fileset or
                dir in self._dirs or
                any(parentdir in self._fileset

    def always(self):
        return self._always

    def __repr__(self):
        return ('<patternmatcher patterns=%r>' % self.patternspat)

class includematcher(basematcher):

    def __init__(self, root, cwd, normalize, include, auditor=None, ctx=None,
                 listsubrepos=False, warn=None, badfn=None):