# fileset.py - file set queries for mercurial

#

# Copyright 2010 Matt Mackall <mpm@selenic.com>

#

# 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

import errno

import re

from .i18n import _

from . import (

    error,

    match as matchmod,

    merge,

    parser,

    pycompat,

    registrar,

    scmutil,

    util,

)

from .utils import (

    stringutil,

)

elements = {

    # token-type: binding-strength, primary, prefix, infix, suffix

    "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),

    ":": (15, None, None, ("kindpat", 15), None),

    "-": (5, None, ("negate", 19), ("minus", 5), None),

    "not": (10, None, ("not", 10), None, None),

    "!": (10, None, ("not", 10), None, None),

    "and": (5, None, None, ("and", 5), None),

    "&": (5, None, None, ("and", 5), None),

    "or": (4, None, None, ("or", 4), None),

    "|": (4, None, None, ("or", 4), None),

    "+": (4, None, None, ("or", 4), None),

    ",": (2, None, None, ("list", 2), None),

    ")": (0, None, None, None, None),

    "symbol": (0, "symbol", None, None, None),

    "string": (0, "string", None, None, None),

    "end": (0, None, None, None, None),

}

keywords = {'and', 'or', 'not'}

globchars = ".*{}[]?/\\_"

def tokenize(program):

    pos, l = 0, len(program)

    program = pycompat.bytestr(program)

    while pos < l:

        c = program[pos]

        if c.isspace(): # skip inter-token whitespace

            pass

        elif c in "(),-:|&+!": # handle simple operators

            yield (c, None, pos)

        elif (c in '"\'' or c == 'r' and

              program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings

            if c == 'r':

                pos += 1

                c = program[pos]

                decode = lambda x: x

            else:

                decode = parser.unescapestr

            pos += 1

            s = pos

            while pos < l: # find closing quote

                d = program[pos]

                if d == '\\': # skip over escaped characters

                    pos += 2

                    continue

                if d == c:

                    yield ('string', decode(program[s:pos]), s)

                    break

                pos += 1

            else:

                raise error.ParseError(_("unterminated string"), s)

        elif c.isalnum() or c in globchars or ord(c) > 127:

            # gather up a symbol/keyword

            s = pos

            pos += 1

            while pos < l: # find end of symbol

                d = program[pos]

                if not (d.isalnum() or d in globchars or ord(d) > 127):

                    break

                pos += 1

            sym = program[s:pos]

            if sym in keywords: # operator keywords

                yield (sym, None, s)

            else:

                yield ('symbol', sym, s)

            pos -= 1

        else:

            raise error.ParseError(_("syntax error"), pos)

        pos += 1

    yield ('end', None, pos)

def parse(expr):

    p = parser.parser(elements)

    tree, pos = p.parse(tokenize(expr))

    if pos != len(expr):

        raise error.ParseError(_("invalid token"), pos)

    return tree

def getsymbol(x):

    if x and x[0] == 'symbol':

        return x[1]

    raise error.ParseError(_('not a symbol'))

def getstring(x, err):

    if x and (x[0] == 'string' or x[0] == 'symbol'):

        return x[1]

    raise error.ParseError(err)

def _getkindpat(x, y, allkinds, err):

    kind = getsymbol(x)

    pat = getstring(y, err)

    if kind not in allkinds:

        raise error.ParseError(_("invalid pattern kind: %s") % kind)

    return '%s:%s' % (kind, pat)

def getpattern(x, allkinds, err):

    if x and x[0] == 'kindpat':

        return _getkindpat(x[1], x[2], allkinds, err)

    return getstring(x, err)

def getlist(x):

    if not x:

        return []

    if x[0] == 'list':

        return getlist(x[1]) + [x[2]]

    return [x]

def getargs(x, min, max, err):

    l = getlist(x)

    if len(l) < min or len(l) > max:

        raise error.ParseError(err)

    return l

def getmatch(mctx, x):

    if not x:

        raise error.ParseError(_("missing argument"))

    return methods[x[0]](mctx, *x[1:])

def stringmatch(mctx, x):

    return mctx.matcher([x])

def kindpatmatch(mctx, x, y):

    return stringmatch(mctx, _getkindpat(x, y, matchmod.allpatternkinds,

                                         _("pattern must be a string")))

def andmatch(mctx, x, y):

    xm = getmatch(mctx, x)

    ym = getmatch(mctx, y)

    return matchmod.intersectmatchers(xm, ym)

def ormatch(mctx, x, y):

    xm = getmatch(mctx, x)

    ym = getmatch(mctx, y)

    return matchmod.unionmatcher([xm, ym])

def notmatch(mctx, x):

    m = getmatch(mctx, x)

    return mctx.predicate(lambda f: not m(f), predrepr=('<not %r>', m))

def minusmatch(mctx, x, y):

    xm = getmatch(mctx, x)

    ym = getmatch(mctx, y)

    return matchmod.differencematcher(xm, ym)

def negatematch(mctx, x):

    raise error.ParseError(_("can't use negate operator in this context"))

def listmatch(mctx, x, y):

    raise error.ParseError(_("can't use a list in this context"),

                           hint=_('see hg help "filesets.x or y"'))

def func(mctx, a, b):

    funcname = getsymbol(a)

    if funcname in symbols:

        return symbols[funcname](mctx, b)

    keep = lambda fn: getattr(fn, '__doc__', None) is not None

    syms = [s for (s, fn) in symbols.items() if keep(fn)]

    raise error.UnknownIdentifier(funcname, syms)

# symbols are callable like:

#  fun(mctx, x)

# with:

#  mctx - current matchctx instance

#  x - argument in tree form

symbols = {}

# filesets using matchctx.status()

_statuscallers = set()

predicate = registrar.filesetpredicate()

@predicate('modified()', callstatus=True)

def modified(mctx, x):

    """File that is modified according to :hg:`status`.

    """

    # i18n: "modified" is a keyword

    getargs(x, 0, 0, _("modified takes no arguments"))

    s = set(mctx.status().modified)

    return mctx.predicate(s.__contains__, predrepr='modified')

@predicate('added()', callstatus=True)

def added(mctx, x):

    """File that is added according to :hg:`status`.

    """

    # i18n: "added" is a keyword

    getargs(x, 0, 0, _("added takes no arguments"))

    s = set(mctx.status().added)

    return mctx.predicate(s.__contains__, predrepr='added')

@predicate('removed()', callstatus=True)

def removed(mctx, x):

    """File that is removed according to :hg:`status`.

    """

    # i18n: "removed" is a keyword

    getargs(x, 0, 0, _("removed takes no arguments"))

    s = set(mctx.status().removed)

    return mctx.predicate(s.__contains__, predrepr='removed')

@predicate('deleted()', callstatus=True)

def deleted(mctx, x):

    """Alias for ``missing()``.

    """

    # i18n: "deleted" is a keyword

    getargs(x, 0, 0, _("deleted takes no arguments"))

    s = set(mctx.status().deleted)

    return mctx.predicate(s.__contains__, predrepr='deleted')

@predicate('missing()', callstatus=True)

def missing(mctx, x):

    """File that is missing according to :hg:`status`.

    """

    # i18n: "missing" is a keyword

    getargs(x, 0, 0, _("missing takes no arguments"))

    s = set(mctx.status().deleted)

    return mctx.predicate(s.__contains__, predrepr='deleted')

@predicate('unknown()', callstatus=True)

def unknown(mctx, x):

    """File that is unknown according to :hg:`status`."""

    # i18n: "unknown" is a keyword

    getargs(x, 0, 0, _("unknown takes no arguments"))

    s = set(mctx.status().unknown)

    return mctx.predicate(s.__contains__, predrepr='unknown')

@predicate('ignored()', callstatus=True)

def ignored(mctx, x):

    """File that is ignored according to :hg:`status`."""

    # i18n: "ignored" is a keyword

    getargs(x, 0, 0, _("ignored takes no arguments"))

    s = set(mctx.status().ignored)

    return mctx.predicate(s.__contains__, predrepr='ignored')

@predicate('clean()', callstatus=True)

def clean(mctx, x):

    """File that is clean according to :hg:`status`.

    """

    # i18n: "clean" is a keyword

    getargs(x, 0, 0, _("clean takes no arguments"))

    s = set(mctx.status().clean)

    return mctx.predicate(s.__contains__, predrepr='clean')

@predicate('tracked()')

def tracked(mctx, x):

    """File that is under Mercurial control."""

    # i18n: "tracked" is a keyword

    getargs(x, 0, 0, _("tracked takes no arguments"))

    return mctx.predicate(mctx.ctx.__contains__, predrepr='tracked')

@predicate('binary()')

def binary(mctx, x):

    """File that appears to be binary (contains NUL bytes).

    """

    # i18n: "binary" is a keyword

    getargs(x, 0, 0, _("binary takes no arguments"))

    return mctx.fpredicate(lambda fctx: fctx.isbinary(),

                           predrepr='binary', cache=True)

@predicate('exec()')

def exec_(mctx, x):

    """File that is marked as executable.

    """

    # i18n: "exec" is a keyword

    getargs(x, 0, 0, _("exec takes no arguments"))

    ctx = mctx.ctx

    return mctx.predicate(lambda f: ctx.flags(f) == 'x', predrepr='exec')

@predicate('symlink()')

def symlink(mctx, x):

    """File that is marked as a symlink.

    """

    # i18n: "symlink" is a keyword

    getargs(x, 0, 0, _("symlink takes no arguments"))

    ctx = mctx.ctx

    return mctx.predicate(lambda f: ctx.flags(f) == 'l', predrepr='symlink')

@predicate('resolved()')

def resolved(mctx, x):

    """File that is marked resolved according to :hg:`resolve -l`.

    """

    # i18n: "resolved" is a keyword

    getargs(x, 0, 0, _("resolved takes no arguments"))

    if mctx.ctx.rev() is not None:

        return mctx.never()

    ms = merge.mergestate.read(mctx.ctx.repo())

    return mctx.predicate(lambda f: f in ms and ms[f] == 'r',

                          predrepr='resolved')

@predicate('unresolved()')

def unresolved(mctx, x):

    """File that is marked unresolved according to :hg:`resolve -l`.

    """

    # i18n: "unresolved" is a keyword

    getargs(x, 0, 0, _("unresolved takes no arguments"))

    if mctx.ctx.rev() is not None:

        return mctx.never()

    ms = merge.mergestate.read(mctx.ctx.repo())

    return mctx.predicate(lambda f: f in ms and ms[f] == 'u',

                          predrepr='unresolved')

@predicate('hgignore()')

def hgignore(mctx, x):

    """File that matches the active .hgignore pattern.

    """

    # i18n: "hgignore" is a keyword

    getargs(x, 0, 0, _("hgignore takes no arguments"))

    return mctx.ctx.repo().dirstate._ignore

@predicate('portable()')

def portable(mctx, x):

    """File that has a portable name. (This doesn't include filenames with case

    collisions.)

    """

    # i18n: "portable" is a keyword

    getargs(x, 0, 0, _("portable takes no arguments"))

    return mctx.predicate(lambda f: util.checkwinfilename(f) is None,

                          predrepr='portable')

@predicate('grep(regex)')

def grep(mctx, x):

    """File contains the given regular expression.

    """

    try: