# 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 or any later version.

from __future__ import absolute_import, print_function

import copy

import itertools

import os

import re

from .i18n import _

from . import (

    encoding,

    error,

    pathutil,

    policy,

    pycompat,

    util,

)

from .utils import stringutil

rustmod = policy.importrust(r'filepatterns')

allpatternkinds = (

)

propertycache = util.propertycache

def _rematcher(regex):

    '''compile the regexp with the best available regexp engine and return a

    matcher function'''

    m = util.re.compile(regex)

    try:

        # slightly faster, provided by facebook's re2 bindings

        return m.test_match

    except AttributeError:

        return m.match

def _expandsets(kindpats, ctx=None, listsubrepos=False, badfn=None):

    '''Returns the kindpats list with the 'set' patterns expanded to matchers'''

    matchers = []

    other = []

    for kind, pat, source in kindpats:

            if ctx is None:

                raise error.ProgrammingError(

                )

            matchers.append(ctx.matchfileset(pat, badfn=badfn))

            if listsubrepos:

                for subpath in ctx.substate:

                    sm = ctx.sub(subpath).matchfileset(pat, badfn=badfn)

                    pm = prefixdirmatcher(subpath, sm, badfn=badfn)

                    matchers.append(pm)

            continue

        other.append((kind, pat, source))

    return matchers, other

def _expandsubinclude(kindpats, root):

    '''Returns the list of subinclude matcher args and the kindpats without the

    subincludes in it.'''

    relmatchers = []

    other = []

    for kind, pat, source in kindpats:

            sourceroot = pathutil.dirname(util.normpath(source))

            pat = util.pconvert(pat)

            path = pathutil.join(sourceroot, pat)

            newroot = pathutil.dirname(path)

            prefix = pathutil.canonpath(root, root, newroot)

            if prefix:

            relmatchers.append((prefix, matcherargs))

        else:

            other.append((kind, pat, source))

    return relmatchers, other

def _kindpatsalwaysmatch(kindpats):

    """"Checks whether the kindspats match everything, as e.g.

    'relpath:.' does.

    """

    for kind, pat, source in kindpats:

            return False

    return True

def _buildkindpatsmatcher(

    matchercls, root, kindpats, ctx=None, listsubrepos=False, badfn=None

):

    matchers = []

    fms, kindpats = _expandsets(

        kindpats, ctx=ctx, listsubrepos=listsubrepos, badfn=badfn

    )

    if kindpats:

        m = matchercls(root, kindpats, badfn=badfn)

        matchers.append(m)

    if fms:

        matchers.extend(fms)

    if not matchers:

        return nevermatcher(badfn=badfn)

    if len(matchers) == 1:

        return matchers[0]

    return unionmatcher(matchers)

def match(

    root,

    cwd,

    patterns=None,

    include=None,

    exclude=None,

    auditor=None,

    ctx=None,

    listsubrepos=False,

    warn=None,

    badfn=None,

    icasefs=False,

):

    r"""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

    auditor - optional path auditor

    ctx - optional changecontext

    listsubrepos - if True, recurse into subrepositories

    warn - optional function used for printing warnings

    badfn - optional bad() callback for this matcher instead of the default

    icasefs - make a matcher for wdir on case insensitive filesystems, which

        normalizes the given patterns to the case in the filesystem

    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

    Usually a patternmatcher is returned:

    >>> match(b'foo', b'.', [b're:.*\.c$', b'path:foo/a', b'*.py'])

    <patternmatcher patterns='.*\\.c$|foo/a(?:/|$)|[^/]*\\.py$'>

    Combining 'patterns' with 'include' (resp. 'exclude') gives an

    intersectionmatcher (resp. a differencematcher):

    >>> type(match(b'foo', b'.', [b're:.*\.c$'], include=[b'path:lib']))

    <class 'mercurial.match.intersectionmatcher'>

    >>> type(match(b'foo', b'.', [b're:.*\.c$'], exclude=[b'path:build']))

    <class 'mercurial.match.differencematcher'>

    Notice that, if 'patterns' is empty, an alwaysmatcher is returned:

    >>> match(b'foo', b'.', [])

    <alwaysmatcher>

    The 'default' argument determines which kind of pattern is assumed if a

    pattern has no prefix:

    >>> match(b'foo', b'.', [b'.*\.c$'], default=b're')

    <patternmatcher patterns='.*\\.c$'>

    >>> match(b'foo', b'.', [b'main.py'], default=b'relpath')

    <patternmatcher patterns='main\\.py(?:/|$)'>

    >>> match(b'foo', b'.', [b'main.py'], default=b're')

    <patternmatcher patterns='main.py'>

    The primary use of matchers is to check whether a value (usually a file

    name) matches againset one of the patterns given at initialization. There

    are two ways of doing this check.

    >>> m = match(b'foo', b'', [b're:.*\.c$', b'relpath:a'])

    1. Calling the matcher with a file name returns True if any pattern

    matches that file name:

    >>> m(b'a')

    True

    >>> m(b'main.c')

    True

    >>> m(b'test.py')

    False

    2. Using the exact() method only returns True if the file name matches one

    of the exact patterns (i.e. not re: or glob: patterns):

    >>> m.exact(b'a')

    True

    >>> m.exact(b'main.c')

    False

    """

    normalize = _donormalize

    if icasefs:

        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:

                    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

    if patterns:

        kindpats = normalize(patterns, default, root, cwd, auditor, warn)

        if _kindpatsalwaysmatch(kindpats):

            m = alwaysmatcher(badfn)

        else:

            m = _buildkindpatsmatcher(

                patternmatcher,

                root,

                kindpats,

                ctx=ctx,

                listsubrepos=listsubrepos,

                badfn=badfn,

            )

    else:

        # It's a little strange that no patterns means to match everything.

        # Consider changing this to match nothing (probably using nevermatcher).

        m = alwaysmatcher(badfn)

    if include:

        im = _buildkindpatsmatcher(

            includematcher,

            root,

            kindpats,

            ctx=ctx,

            listsubrepos=listsubrepos,

            badfn=None,

        )

        m = intersectmatchers(m, im)

    if exclude:

        em = _buildkindpatsmatcher(

            includematcher,

            root,

            kindpats,

            ctx=ctx,

            listsubrepos=listsubrepos,

            badfn=None,

        )

        m = differencematcher(m, em)

    return m

def exact(files, badfn=None):

    return exactmatcher(files, badfn=badfn)

def always(badfn=None):

    return alwaysmatcher(badfn)

def never(badfn=None):

    return nevermatcher(badfn)

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

def _donormalize(patterns, default, root, cwd, auditor=None, warn=None):

    '''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 cwdrelativepatternkinds:

            pat = pathutil.canonpath(root, cwd, pat, auditor=auditor)

            pat = util.normpath(pat)

            try:

                files = util.readfile(pat)

                else:

                    files = files.splitlines()

                files = [f for f in files if f]

            except EnvironmentError:

            for k, p, source in _donormalize(

                files, default, root, cwd, auditor, warn

            ):

                kindpats.append((k, p, pat))

            continue

            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:

            except IOError as inst:

                if warn:

                    warn(

                        % (pat, stringutil.forcebytestr(inst.strerror))

                    )

            continue

        # else: re or relre - which cannot be normalized

    return kindpats

class basematcher(object):

    def __init__(self, badfn=None):

        if badfn is not None:

            self.bad = badfn

    def __call__(self, fn):

        return self.matchfn(fn)

    # 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.'''

    # 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

    @propertycache

    def _files(self):

        return []

    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):