comparison mercurial/match.py @ 32401:284b18303f61

match: replace icasefsmatch() function by flag to regular match()

match() will soon gain more logic and we don't want to duplicate that
in icasefsmatch(), so merge the two functions instead and use a flag
to get case-insensitive behavior.

32400:8802c63599e1

            return False
    return True

def match(root, cwd, patterns, include=None, exclude=None, default='glob',
          exact=False, auditor=None, ctx=None, listsubrepos=False, warn=None,
          badfn=None):
    """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

    exclude - patterns to exclude (even if they are included)
    default - if a pattern in patterns has no explicit type, assume this one
    exact - patterns are actually filenames (include/exclude still apply)
    warn - optional function used for printing warnings
    badfn - optional bad() callback for this matcher instead of the default

    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

    '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
    """
    return matcher(root, cwd, _donormalize, patterns, include=include,
                   exclude=exclude, default=default, exact=exact,
                   auditor=auditor, ctx=ctx, listsubrepos=listsubrepos,
                   warn=warn, badfn=badfn)

def icasefsmatch(root, cwd, patterns, include=None, exclude=None,
                 default='glob', auditor=None, ctx=None,
                 listsubrepos=False, badfn=None):
    """A matcher for wdir on case insensitive filesystems, which normalizes the
    given patterns to the case in the filesystem.
    """
    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 ('re', '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

    return matcher(root, cwd, normalize, patterns=patterns, include=include,
                   exclude=exclude, default=default, auditor=auditor, ctx=ctx,
                   listsubrepos=listsubrepos, badfn=badfn)

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

def always(root, cwd):

32401:284b18303f61

            return False
    return True

def match(root, cwd, patterns, include=None, exclude=None, default='glob',
          exact=False, auditor=None, ctx=None, listsubrepos=False, warn=None,
          badfn=None, icasefs=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

    exclude - patterns to exclude (even if they are included)
    default - if a pattern in patterns has no explicit type, assume this one
    exact - patterns are actually filenames (include/exclude still apply)
    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

    '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
    """
    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 ('re', '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

    return matcher(root, cwd, normalize, patterns, include=include,
                   exclude=exclude, default=default, exact=exact,
                   auditor=auditor, ctx=ctx, listsubrepos=listsubrepos,
                   warn=warn, badfn=badfn)

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

def always(root, cwd):