# 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 i18n import _

elements = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

keywords = set(['and', 'or', 'not'])

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

def tokenize(program):

    pos, l = 0, len(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 = lambda x: x.decode('string-escape')

            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)

parse = parser.parser(tokenize, elements).parse

def getstring(x, err):

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

        return x[1]

    raise error.ParseError(err)

def getset(mctx, x):

    if not x:

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

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

def stringset(mctx, x):

    m = mctx.matcher([x])

    return [f for f in mctx.subset if m(f)]

def andset(mctx, x, y):

    return getset(mctx.narrow(getset(mctx, x)), y)

def orset(mctx, x, y):

    # needs optimizing

    xl = getset(mctx, x)

    yl = getset(mctx, y)

    return xl + [f for f in yl if f not in xl]

def notset(mctx, x):

    s = set(getset(mctx, x))

    return [r for r in mctx.subset if r not in s]

def listset(mctx, a, b):

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

def modified(mctx, x):

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

    s = mctx.status()[0]

    return [f for f in mctx.subset if f in s]

def added(mctx, x):

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

    s = mctx.status()[1]

    return [f for f in mctx.subset if f in s]

def removed(mctx, x):

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

    s = mctx.status()[2]

    return [f for f in mctx.subset if f in s]

def deleted(mctx, x):

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

    s = mctx.status()[3]

    return [f for f in mctx.subset if f in s]

def unknown(mctx, x):

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

    s = mctx.status()[4]

    return [f for f in mctx.subset if f in s]

def ignored(mctx, x):

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

    s = mctx.status()[5]

    return [f for f in mctx.subset if f in s]

def clean(mctx, x):

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

    s = mctx.status()[6]

    return [f for f in mctx.subset if f in s]

def func(mctx, a, b):

    if a[0] == 'symbol' and a[1] in symbols:

        return symbols[a[1]](mctx, b)

    raise error.ParseError(_("not a function: %s") % a[1])

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 binary(mctx, x):

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

    return [f for f in mctx.subset if util.binary(mctx.ctx[f].data())]

def exec_(mctx, x):

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

    return [f for f in mctx.subset if mctx.ctx.flags(f) == 'x']

def symlink(mctx, x):

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

    return [f for f in mctx.subset if mctx.ctx.flags(f) == 'l']

symbols = {

    'added': added,

    'binary': binary,

    'clean': clean,

    'deleted': deleted,

    'exec': exec_,

    'ignored': ignored,

    'modified': modified,

    'removed': removed,

    'symlink': symlink,

    'unknown': unknown,

}

methods = {

    'string': stringset,

    'symbol': stringset,

    'and': andset,

    'or': orset,

    'list': listset,

    'group': getset,

    'not': notset,

    'func': func,

}

class matchctx(object):

    def __init__(self, ctx, subset=None, status=None):

        self.ctx = ctx

        self.subset = subset

        self._status = status

    def status(self):

        return self._status

    def matcher(self, patterns):

        return self.ctx.match(patterns)

    def filter(self, files):

        return [f for f in files if f in self.subset]

    def narrow(self, files):

        return matchctx(self.ctx, self.filter(files), self._status)

def _intree(funcs, tree):

    if isinstance(tree, tuple):

        if tree[0] == 'func' and tree[1][0] == 'symbol':

            if tree[1][1] in funcs:

                return True

        for s in tree[1:]:

            if _intree(funcs, s):

                return True

    return False

def getfileset(ctx, expr):

    tree, pos = parse(expr)

    if (pos != len(expr)):

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

    # do we need status info?

    if _intree(['modified', 'added', 'removed', 'deleted',

                'unknown', 'ignored', 'clean'], tree):

        unknown = _intree(['unknown'], tree)

        ignored = _intree(['ignored'], tree)

        r = ctx._repo

        status = r.status(ctx.p1(), ctx,

                          unknown=unknown, ignored=ignored, clean=True)

        subset = []

        for c in status:

            subset.extend(c)

    else:

        status = None

        subset = ctx.walk(ctx.match([]))

    return getset(matchctx(ctx, subset, status), tree)