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

import re

import parser, error, util, merge

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)

def parse(expr):

    p = parser.parser(tokenize, elements)

    return p.parse(expr)

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

    xl = getset(mctx, x)

    yl = set(getset(mctx, y))

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

def listset(mctx, a, b):

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

def modified(mctx, x):

    """``modified()``

    File that is modified according to status.

    """

    # i18n: "modified" is a keyword

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

    s = mctx.status().modified

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

def added(mctx, x):

    """``added()``

    File that is added according to status.

    """

    # i18n: "added" is a keyword

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

    s = mctx.status().added

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

def removed(mctx, x):

    """``removed()``

    File that is removed according to status.

    """

    # i18n: "removed" is a keyword

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

    s = mctx.status().removed

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

def deleted(mctx, x):

    """``deleted()``

    File that is deleted according to status.

    """

    # i18n: "deleted" is a keyword

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

    s = mctx.status().deleted

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

def unknown(mctx, x):

    """``unknown()``

    File that is unknown according to status. These files will only be

    considered if this predicate is used.

    """

    # i18n: "unknown" is a keyword

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

    s = mctx.status().unknown

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

def ignored(mctx, x):

    """``ignored()``

    File that is ignored according to status. These files will only be

    considered if this predicate is used.

    """

    # i18n: "ignored" is a keyword

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

    s = mctx.status().ignored

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

def clean(mctx, x):

    """``clean()``

    File that is clean according to status.

    """

    # i18n: "clean" is a keyword

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

    s = mctx.status().clean

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

    """``binary()``

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

    """

    # i18n: "binary" is a keyword

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

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

def exec_(mctx, x):

    """``exec()``

    File that is marked as executable.

    """

    # i18n: "exec" is a keyword

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

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

def symlink(mctx, x):

    """``symlink()``

    File that is marked as a symlink.

    """

    # i18n: "symlink" is a keyword

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

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

def resolved(mctx, x):

    """``resolved()``

    File that is marked resolved according to the resolve state.

    """

    # i18n: "resolved" is a keyword

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

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

        return []

    ms = merge.mergestate(mctx.ctx._repo)

    return [f for f in mctx.subset if f in ms and ms[f] == 'r']

def unresolved(mctx, x):

    """``unresolved()``

    File that is marked unresolved according to the resolve state.

    """

    # i18n: "unresolved" is a keyword

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

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

        return []

    ms = merge.mergestate(mctx.ctx._repo)

    return [f for f in mctx.subset if f in ms and ms[f] == 'u']

def hgignore(mctx, x):

    """``hgignore()``

    File that matches the active .hgignore pattern.

    """

    # i18n: "hgignore" is a keyword

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

    ignore = mctx.ctx._repo.dirstate._ignore

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

def grep(mctx, x):

    """``grep(regex)``

    File contains the given regular expression.

    """

    try:

        # i18n: "grep" is a keyword

        r = re.compile(getstring(x, _("grep requires a pattern")))

    except re.error, e:

        raise error.ParseError(_('invalid match pattern: %s') % e)

    return [f for f in mctx.existing() if r.search(mctx.ctx[f].data())]

def _sizetomax(s):

    try:

        s = s.strip()

        for k, v in util._sizeunits:

            if s.endswith(k):

                # max(4k) = 5k - 1, max(4.5k) = 4.6k - 1

                n = s[:-len(k)]

                inc = 1.0

                if "." in n:

                    inc /= 10 ** len(n.split(".")[1])

                return int((float(n) + inc) * v) - 1

        # no extension, this is a precise value

        return int(s)

    except ValueError:

        raise error.ParseError(_("couldn't parse size: %s") % s)

def size(mctx, x):

    """``size(expression)``

    File size matches the given expression. Examples:

    - 1k (files from 1024 to 2047 bytes)

    - < 20k (files less than 20480 bytes)

    - >= .5MB (files at least 524288 bytes)

    - 4k - 1MB (files from 4096 bytes to 1048576 bytes)

    """

    # i18n: "size" is a keyword

    expr = getstring(x, _("size requires an expression")).strip()

    if '-' in expr: # do we have a range?

        a, b = expr.split('-', 1)

        a = util.sizetoint(a)

        b = util.sizetoint(b)

        m = lambda x: x >= a and x <= b

    elif expr.startswith("<="):

        a = util.sizetoint(expr[2:])

        m = lambda x: x <= a

    elif expr.startswith("<"):

        a = util.sizetoint(expr[1:])

        m = lambda x: x < a

    elif expr.startswith(">="):

        a = util.sizetoint(expr[2:])

        m = lambda x: x >= a

    elif expr.startswith(">"):

        a = util.sizetoint(expr[1:])

        m = lambda x: x > a

    elif expr[0].isdigit or expr[0] == '.':

        a = util.sizetoint(expr)

        b = _sizetomax(expr)

        m = lambda x: x >= a and x <= b

    else:

        raise error.ParseError(_("couldn't parse size: %s") % expr)

    return [f for f in mctx.existing() if m(mctx.ctx[f].size())]

def encoding(mctx, x):

    """``encoding(name)``

    File can be successfully decoded with the given character

    encoding. May not be useful for encodings other than ASCII and

    UTF-8.

    """

    # i18n: "encoding" is a keyword

    enc = getstring(x, _("encoding requires an encoding name"))

    s = []

    for f in mctx.existing():

        d = mctx.ctx[f].data()

        try:

            d.decode(enc)

        except LookupError:

            raise util.Abort(_("unknown encoding '%s'") % enc)

        except UnicodeDecodeError:

            continue

        s.append(f)

    return s

def eol(mctx, x):

    """``eol(style)``

    File contains newlines of the given style (dos, unix, mac). Binary

    files are excluded, files with mixed line endings match multiple

    styles.

    """

    # i18n: "encoding" is a keyword

    enc = getstring(x, _("encoding requires an encoding name"))

    s = []

    for f in mctx.existing():

        d = mctx.ctx[f].data()

        if util.binary(d):