# revset.py - revision 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 re

from .i18n import _

from . import (

    dagop,

    destutil,

    encoding,

    error,

    hbisect,

    match as matchmod,

    node,

    obsolete as obsmod,

    pathutil,

    phases,

    registrar,

    repoview,

    revsetlang,

    scmutil,

    smartset,

    util,

)

# helpers for processing parsed tree

getsymbol = revsetlang.getsymbol

getstring = revsetlang.getstring

getinteger = revsetlang.getinteger

getboolean = revsetlang.getboolean

getlist = revsetlang.getlist

getrange = revsetlang.getrange

getargs = revsetlang.getargs

getargsdict = revsetlang.getargsdict

# constants used as an argument of match() and matchany()

anyorder = revsetlang.anyorder

defineorder = revsetlang.defineorder

followorder = revsetlang.followorder

baseset = smartset.baseset

generatorset = smartset.generatorset

spanset = smartset.spanset

fullreposet = smartset.fullreposet

# helpers

def getset(repo, subset, x):

    if not x:

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

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

def _getrevsource(repo, r):

    extra = repo[r].extra()

    for label in ('source', 'transplant_source', 'rebase_source'):

        if label in extra:

            try:

                return repo[extra[label]].rev()

            except error.RepoLookupError:

                pass

    return None

# operator methods

def stringset(repo, subset, x):

    x = scmutil.intrev(repo[x])

    if (x in subset

        or x == node.nullrev and isinstance(subset, fullreposet)):

        return baseset([x])

    return baseset()

def rangeset(repo, subset, x, y, order):

    m = getset(repo, fullreposet(repo), x)

    n = getset(repo, fullreposet(repo), y)

    if not m or not n:

        return baseset()

    return _makerangeset(repo, subset, m.first(), n.last(), order)

def rangeall(repo, subset, x, order):

    assert x is None

    return _makerangeset(repo, subset, 0, len(repo) - 1, order)

def rangepre(repo, subset, y, order):

    # ':y' can't be rewritten to '0:y' since '0' may be hidden

    n = getset(repo, fullreposet(repo), y)

    if not n:

        return baseset()

    return _makerangeset(repo, subset, 0, n.last(), order)

def rangepost(repo, subset, x, order):

    m = getset(repo, fullreposet(repo), x)

    if not m:

        return baseset()

    return _makerangeset(repo, subset, m.first(), len(repo) - 1, order)

def _makerangeset(repo, subset, m, n, order):

    if m == n:

        r = baseset([m])

    elif n == node.wdirrev:

        r = spanset(repo, m, len(repo)) + baseset([n])

    elif m == node.wdirrev:

        r = baseset([m]) + spanset(repo, len(repo) - 1, n - 1)

    elif m < n:

        r = spanset(repo, m, n + 1)

    else:

        r = spanset(repo, m, n - 1)

    if order == defineorder:

        return r & subset

    else:

        # carrying the sorting over when possible would be more efficient

        return subset & r

def dagrange(repo, subset, x, y, order):

    r = fullreposet(repo)

    xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y),

                              includepath=True)

    return subset & xs

def andset(repo, subset, x, y, order):

    return getset(repo, getset(repo, subset, x), y)

def differenceset(repo, subset, x, y, order):

    return getset(repo, subset, x) - getset(repo, subset, y)

def _orsetlist(repo, subset, xs):

    assert xs

    if len(xs) == 1:

        return getset(repo, subset, xs[0])

    p = len(xs) // 2

    a = _orsetlist(repo, subset, xs[:p])

    b = _orsetlist(repo, subset, xs[p:])

    return a + b

def orset(repo, subset, x, order):

    xs = getlist(x)

    if order == followorder:

        # slow path to take the subset order

        return subset & _orsetlist(repo, fullreposet(repo), xs)

    else:

        return _orsetlist(repo, subset, xs)

def notset(repo, subset, x, order):

    return subset - getset(repo, subset, x)

def listset(repo, subset, *xs):

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

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

def keyvaluepair(repo, subset, k, v):

    raise error.ParseError(_("can't use a key-value pair in this context"))

def func(repo, subset, a, b, order):

    f = getsymbol(a)

    if f in symbols:

        func = symbols[f]

        if getattr(func, '_takeorder', False):

            return func(repo, subset, b, order)

        return func(repo, subset, 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(f, syms)

# functions

# symbols are callables like:

#   fn(repo, subset, x)

# with:

#   repo - current repository instance

#   subset - of revisions to be examined

#   x - argument in tree form

symbols = {}

# symbols which can't be used for a DoS attack for any given input

# (e.g. those which accept regexes as plain strings shouldn't be included)

# functions that just return a lot of changesets (like all) don't count here

safesymbols = set()

predicate = registrar.revsetpredicate()

@predicate('_destupdate')

def _destupdate(repo, subset, x):

    # experimental revset for update destination

    args = getargsdict(x, 'limit', 'clean')

    return subset & baseset([destutil.destupdate(repo, **args)[0]])

@predicate('_destmerge')

def _destmerge(repo, subset, x):

    # experimental revset for merge destination

    sourceset = None

    if x is not None:

        sourceset = getset(repo, fullreposet(repo), x)

    return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])

@predicate('adds(pattern)', safe=True)

def adds(repo, subset, x):

    """Changesets that add a file matching pattern.

    The pattern without explicit kind like ``glob:`` is expected to be

    relative to the current directory and match against a file or a

    directory.

    """

    # i18n: "adds" is a keyword

    pat = getstring(x, _("adds requires a pattern"))

    return checkstatus(repo, subset, pat, 1)

@predicate('ancestor(*changeset)', safe=True)

def ancestor(repo, subset, x):

    """A greatest common ancestor of the changesets.

    Accepts 0 or more changesets.

    Will return empty list when passed no args.

    Greatest common ancestor of a single changeset is that changeset.

    """

    # i18n: "ancestor" is a keyword

    l = getlist(x)

    rl = fullreposet(repo)

    anc = None

    # (getset(repo, rl, i) for i in l) generates a list of lists

    for revs in (getset(repo, rl, i) for i in l):

        for r in revs:

            if anc is None:

                anc = repo[r]

            else:

                anc = anc.ancestor(repo[r])

    if anc is not None and anc.rev() in subset:

        return baseset([anc.rev()])

    return baseset()

def _ancestors(repo, subset, x, followfirst=False):

    heads = getset(repo, fullreposet(repo), x)

    if not heads:

        return baseset()

    s = dagop.revancestors(repo, heads, followfirst)

    return subset & s

@predicate('ancestors(set)', safe=True)

def ancestors(repo, subset, x):

    """Changesets that are ancestors of a changeset in set.

    """

    return _ancestors(repo, subset, x)

@predicate('_firstancestors', safe=True)

def _firstancestors(repo, subset, x):

    # ``_firstancestors(set)``

    # Like ``ancestors(set)`` but follows only the first parents.

    return _ancestors(repo, subset, x, followfirst=True)

def _childrenspec(repo, subset, x, n, order):

    """Changesets that are the Nth child of a changeset

    in set.

    """

    cs = set()

    for r in getset(repo, fullreposet(repo), x):

        for i in range(n):

            c = repo[r].children()

            if len(c) == 0:

                break

            if len(c) > 1:

                raise error.RepoLookupError(

                    _("revision in set has more than one child"))

            r = c[0].rev()

        else:

            cs.add(r)

    return subset & cs

def ancestorspec(repo, subset, x, n, order):

    """``set~n``

    Changesets that are the Nth ancestor (first parents only) of a changeset

    in set.

    """

    n = getinteger(n, _("~ expects a number"))

    if n < 0:

        # children lookup

        return _childrenspec(repo, subset, x, -n, order)

    ps = set()

    cl = repo.changelog

    for r in getset(repo, fullreposet(repo), x):

        for i in range(n):

            try:

                r = cl.parentrevs(r)[0]

            except error.WdirUnsupported:

                r = repo[r].parents()[0].rev()

        ps.add(r)

    return subset & ps

@predicate('author(string)', safe=True)

def author(repo, subset, x):

    """Alias for ``user(string)``.

    """

    # i18n: "author" is a keyword

    n = getstring(x, _("author requires a string"))

    kind, pattern, matcher = _substringmatcher(n, casesensitive=False)

    return subset.filter(lambda x: matcher(repo[x].user()),

                         condrepr=('<user %r>', n))

@predicate('bisect(string)', safe=True)

def bisect(repo, subset, x):

    """Changesets marked in the specified bisect status:

    - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip

    - ``goods``, ``bads``      : csets topologically good/bad

    - ``range``              : csets taking part in the bisection

    - ``pruned``             : csets that are goods, bads or skipped

    - ``untested``           : csets whose fate is yet unknown

    - ``ignored``            : csets ignored due to DAG topology

    - ``current``            : the cset currently being bisected

    """

    # i18n: "bisect" is a keyword

    status = getstring(x, _("bisect requires a string")).lower()

    state = set(hbisect.get(repo, status))

    return subset & state

# Backward-compatibility

# - no help entry so that we do not advertise it any more

@predicate('bisected', safe=True)

def bisected(repo, subset, x):

    return bisect(repo, subset, x)

@predicate('bookmark([name])', safe=True)

def bookmark(repo, subset, x):

    """The named bookmark or all bookmarks.

    Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.

    """

    # i18n: "bookmark" is a keyword

    args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))

    if args:

        bm = getstring(args[0],

                       # i18n: "bookmark" is a keyword

                       _('the argument to bookmark must be a string'))

        kind, pattern, matcher = util.stringmatcher(bm)

        bms = set()

        if kind == 'literal':

            bmrev = repo._bookmarks.get(pattern, None)

            if not bmrev:

                raise error.RepoLookupError(_("bookmark '%s' does not exist")

                                            % pattern)

            bms.add(repo[bmrev].rev())

        else:

            matchrevs = set()

            for name, bmrev in repo._bookmarks.iteritems():

                if matcher(name):

                    matchrevs.add(bmrev)

            if not matchrevs:

                raise error.RepoLookupError(_("no bookmarks exist"

                                              " that match '%s'") % pattern)

            for bmrev in matchrevs:

                bms.add(repo[bmrev].rev())

    else:

        bms = {repo[r].rev() for r in repo._bookmarks.values()}

    bms -= {node.nullrev}

    return subset & bms