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

    diffutil,

    encoding,

    error,

    hbisect,

    match as matchmod,

    node,

    obsolete as obsmod,

    obsutil,

    pathutil,

    phases,

    pycompat,

    registrar,

    repoview,

    revsetlang,

    scmutil,

    smartset,

    stack as stackmod,

    util,

)

from .utils import (

    dateutil,

    stringutil,

)

# 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

baseset = smartset.baseset

generatorset = smartset.generatorset

spanset = smartset.spanset

fullreposet = smartset.fullreposet

# Constants for ordering requirement, used in getset():

#

# If 'define', any nested functions and operations MAY change the ordering of

# the entries in the set (but if changes the ordering, it MUST ALWAYS change

# it). If 'follow', any nested functions and operations MUST take the ordering

# specified by the first operand to the '&' operator.

#

# For instance,

#

#   X & (Y | Z)

#   ^   ^^^^^^^

#   |   follow

#   define

#

# will be evaluated as 'or(y(x()), z(x()))', where 'x()' can change the order

# of the entries in the set, but 'y()', 'z()' and 'or()' shouldn't.

#

# 'any' means the order doesn't matter. For instance,

#

#   (X & !Y) | ancestors(Z)

#         ^              ^

#         any            any

#

# For 'X & !Y', 'X' decides the order and 'Y' is subtracted from 'X', so the

# order of 'Y' does not matter. For 'ancestors(Z)', Z's order does not matter

# since 'ancestors' does not care about the order of its argument.

#

# Currently, most revsets do not care about the order, so 'define' is

# equivalent to 'follow' for them, and the resulting order is based on the

# 'subset' parameter passed down to them:

#

#   m = revset.match(...)

#   m(repo, subset, order=defineorder)

#           ^^^^^^

#      For most revsets, 'define' means using the order this subset provides

#

# There are a few revsets that always redefine the order if 'define' is

# specified: 'sort(X)', 'reverse(X)', 'x:y'.

anyorder = 'any'        # don't care the order, could be even random-shuffled

defineorder = 'define'  # ALWAYS redefine, or ALWAYS follow the current order

followorder = 'follow'  # MUST follow the current order

# helpers

def getset(repo, subset, x, order=defineorder):

    if not x:

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

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

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

def _sortedb(xs):

    return sorted(pycompat.rapply(pycompat.maybebytestr, xs))

# operator methods

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

    if not x:

        raise error.ParseError(_("empty string is not a valid revision"))

    x = scmutil.intrev(scmutil.revsymbol(repo, x))

    if (x in subset

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

        return baseset([x])

    return baseset()

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

    """argument is already a smartset, use that directly"""

    if order == followorder:

        return subset & x

    else:

        return x & subset

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, repo.changelog.tiprev(), 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(), repo.changelog.tiprev(),

                         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, repo.changelog.tiprev(), 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):

    if order == anyorder:

        yorder = anyorder

    else:

        yorder = followorder

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

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

    # 'andsmally(x, y)' is equivalent to 'and(x, y)', but faster when y is small

    if order == anyorder:

        yorder = anyorder

    else:

        yorder = followorder

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

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

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

def _orsetlist(repo, subset, xs, order):

    assert xs

    if len(xs) == 1:

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

    p = len(xs) // 2

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

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

    return a + b

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

    xs = getlist(x)

    if not xs:

        return baseset()

    if order == followorder:

        # slow path to take the subset order

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

    else:

        return _orsetlist(repo, subset, xs, order)

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

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

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

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

def _splitrange(a, b):

    """Split range with bounds a and b into two ranges at 0 and return two

    tuples of numbers for use as startdepth and stopdepth arguments of

    revancestors and revdescendants.

    >>> _splitrange(-10, -5)     # [-10:-5]

    ((5, 11), (None, None))

    >>> _splitrange(5, 10)       # [5:10]

    ((None, None), (5, 11))

    >>> _splitrange(-10, 10)     # [-10:10]

    ((0, 11), (0, 11))

    >>> _splitrange(-10, 0)      # [-10:0]

    ((0, 11), (None, None))

    >>> _splitrange(0, 10)       # [0:10]

    ((None, None), (0, 11))

    >>> _splitrange(0, 0)        # [0:0]

    ((0, 1), (None, None))

    >>> _splitrange(1, -1)       # [1:-1]

    ((None, None), (None, None))

    """

    ancdepths = (None, None)

    descdepths = (None, None)

    if a == b == 0:

        ancdepths = (0, 1)

    if a < 0:

        ancdepths = (-min(b, 0), -a + 1)

    if b > 0:

        descdepths = (max(a, 0), b + 1)

    return ancdepths, descdepths

def generationsrel(repo, subset, x, rel, a, b, order):

    # TODO: rewrite tests, and drop startdepth argument from ancestors() and

    # descendants() predicates

    if a is None:

        a = -(dagop.maxlogdepth - 1)

    if b is None:

        b = +(dagop.maxlogdepth - 1)

    (ancstart, ancstop), (descstart, descstop) = _splitrange(a, b)

    if ancstart is None and descstart is None:

        return baseset()

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

    if not revs:

        return baseset()

    if ancstart is not None and descstart is not None:

        s = dagop.revancestors(repo, revs, False, ancstart, ancstop)

        s += dagop.revdescendants(repo, revs, False, descstart, descstop)

    elif ancstart is not None:

        s = dagop.revancestors(repo, revs, False, ancstart, ancstop)

    elif descstart is not None:

        s = dagop.revdescendants(repo, revs, False, descstart, descstop)

    return subset & s

def relsubscriptset(repo, subset, x, y, z, order):

    # this is pretty basic implementation of 'x#y[z]' operator, still

    # experimental so undocumented. see the wiki for further ideas.

    # https://www.mercurial-scm.org/wiki/RevsetOperatorPlan

    rel = getsymbol(y)

    try:

        a, b = getrange(z, '')

    except error.ParseError:

        a = getinteger(z, _("relation subscript must be an integer"))

        b = a

    else:

        def getbound(i):

            if i is None:

                return None

            msg = _("relation subscript bounds must be integers")

            return getinteger(i, msg)

        a, b = [getbound(i) for i in (a, b)]

    if rel in subscriptrelations:

        return subscriptrelations[rel](repo, subset, x, rel, a, b, order)

    relnames = [r for r in subscriptrelations.keys() if len(r) > 1]

    raise error.UnknownIdentifier(rel, relnames)

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

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

def listset(repo, subset, *xs, **opts):

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

    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 = revsetlang.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,

                            **pycompat.strkwargs(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, weight=30)

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