# match.py - filename matching

#

#  Copyright 2008, 2009 Olivia Mackall <olivia@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 bisect

import copy

import itertools

import os

import re

from .i18n import _

from .pycompat import open

from . import (

    encoding,

    error,

    pathutil,

    policy,

    pycompat,

    util,

)

from .utils import stringutil

rustmod = policy.importrust('dirstate')

allpatternkinds = (

    b're',

    b'glob',

    b'path',

    b'relglob',

    b'relpath',

    b'relre',

    b'rootglob',

    b'listfile',

    b'listfile0',

    b'set',

    b'include',

    b'subinclude',

    b'rootfilesin',

)

cwdrelativepatternkinds = (b'relpath', b'glob')

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(cwd, 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 kind == b'set':

            if ctx is None:

                raise error.ProgrammingError(

                    b"fileset expression with no context"

                )

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

            if listsubrepos:

                for subpath in ctx.substate:

                    sm = ctx.sub(subpath).matchfileset(cwd, 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:

        if kind == b'subinclude':

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

            pat = util.pconvert(pat)

            path = pathutil.join(sourceroot, pat)

            newroot = pathutil.dirname(path)

            matcherargs = (newroot, b'', [], [b'include:%s' % path])

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

            if prefix:

                prefix += b'/'

            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:

        if pat != b'' or kind not in [b'relpath', b'glob']:

            return False

    return True

def _buildkindpatsmatcher(

    matchercls,

    root,

    cwd,

    kindpats,

    ctx=None,

    listsubrepos=False,

    badfn=None,

):

    matchers = []

    fms, kindpats = _expandsets(

        cwd,

        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,

    default=b'glob',

    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

    >>> def _match(root, *args, **kwargs):

    ...     return match(util.localpath(root), *args, **kwargs)

    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

    """

    assert os.path.isabs(root)

    cwd = os.path.join(root, util.localpath(cwd))

    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:

                if kind not in (b're', b'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

    if patterns:

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

        if _kindpatsalwaysmatch(kindpats):

            m = alwaysmatcher(badfn)

        else:

            m = _buildkindpatsmatcher(

                patternmatcher,

                root,

                cwd,

                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:

        kindpats = normalize(include, b'glob', root, cwd, auditor, warn)

        im = _buildkindpatsmatcher(

            includematcher,

            root,

            cwd,

            kindpats,

            ctx=ctx,

            listsubrepos=listsubrepos,

            badfn=None,

        )

        m = intersectmatchers(m, im)

    if exclude:

        kindpats = normalize(exclude, b'glob', root, cwd, auditor, warn)

        em = _buildkindpatsmatcher(

            includematcher,

            root,

            cwd,

            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)

        elif kind in (b'relglob', b'path', b'rootfilesin', b'rootglob'):

            pat = util.normpath(pat)

        elif kind in (b'listfile', b'listfile0'):

            try:

                files = util.readfile(pat)

                if kind == b'listfile0':

                    files = files.split(b'\0')

                else:

                    files = files.splitlines()

                files = [f for f in files if f]

            except EnvironmentError:

                raise error.Abort(_(b"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 == b'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(

                    b'%s: %s'

                    % (

                        pat,

                        inst.message,

                    )  # pytype: disable=unsupported-operands

                )

            except IOError as inst:

                if warn:

                    warn(

                        _(b"skipping unreadable pattern file '%s': %s\n")

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

                    )

            continue

        # else: re or relre - which cannot be normalized

        kindpats.append((kind, pat, b''))

    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)