# templater.py - template expansion for output

#

# Copyright 2005, 2006 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, print_function

import os

import re

import types

from .i18n import _

from . import (

    color,

    config,

    encoding,

    error,

    minirst,

    obsutil,

    parser,

    pycompat,

    registrar,

    revset as revsetmod,

    revsetlang,

    scmutil,

    templatefilters,

    templatekw,

    util,

)

# template parsing

elements = {

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

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

    ".": (18, None, None, (".", 18), None),

    "%": (15, None, None, ("%", 15), None),

    "|": (15, None, None, ("|", 15), None),

    "*": (5, None, None, ("*", 5), None),

    "/": (5, None, None, ("/", 5), None),

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

    "-": (4, None, ("negate", 19), ("-", 4), None),

    "=": (3, None, None, ("keyvalue", 3), None),

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

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

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

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

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

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

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

}

def tokenize(program, start, end, term=None):

    """Parse a template expression into a stream of tokens, which must end

    with term if specified"""

    pos = start

    program = pycompat.bytestr(program)

    while pos < end:

        c = program[pos]

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

            pass

        elif c in "(=,).%|+-*/": # handle simple operators

            yield (c, None, pos)

        elif c in '"\'': # handle quoted templates

            s = pos + 1

            data, pos = _parsetemplate(program, s, end, c)

            yield ('template', data, s)

            pos -= 1

        elif c == 'r' and program[pos:pos + 2] in ("r'", 'r"'):

            # handle quoted strings

            c = program[pos + 1]

            s = pos = pos + 2

            while pos < end: # find closing quote

                d = program[pos]

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

                    pos += 2

                    continue

                if d == c:

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

                    break

                pos += 1

            else:

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

        elif c.isdigit():

            s = pos

            while pos < end:

                d = program[pos]

                if not d.isdigit():

                    break

                pos += 1

            yield ('integer', program[s:pos], s)

            pos -= 1

        elif (c == '\\' and program[pos:pos + 2] in (r"\'", r'\"')

              or c == 'r' and program[pos:pos + 3] in (r"r\'", r'r\"')):

            # handle escaped quoted strings for compatibility with 2.9.2-3.4,

            # where some of nested templates were preprocessed as strings and

            # then compiled. therefore, \"...\" was allowed. (issue4733)

            #

            # processing flow of _evalifliteral() at 5ab28a2e9962:

            # outer template string    -> stringify()  -> compiletemplate()

            # ------------------------    ------------    ------------------

            # {f("\\\\ {g(\"\\\"\")}"}    \\ {g("\"")}    [r'\\', {g("\"")}]

            #             ~~~~~~~~

            #             escaped quoted string

            if c == 'r':

                pos += 1

                token = 'string'

            else:

                token = 'template'

            quote = program[pos:pos + 2]

            s = pos = pos + 2

            while pos < end: # find closing escaped quote

                if program.startswith('\\\\\\', pos, end):

                    pos += 4 # skip over double escaped characters

                    continue

                if program.startswith(quote, pos, end):

                    # interpret as if it were a part of an outer string

                    data = parser.unescapestr(program[s:pos])

                    if token == 'template':

                        data = _parsetemplate(data, 0, len(data))[0]

                    yield (token, data, s)

                    pos += 1

                    break

                pos += 1

            else:

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

        elif c.isalnum() or c in '_':

            s = pos

            pos += 1

            while pos < end: # find end of symbol

                d = program[pos]

                if not (d.isalnum() or d == "_"):

                    break

                pos += 1

            sym = program[s:pos]

            yield ('symbol', sym, s)

            pos -= 1

        elif c == term:

            yield ('end', None, pos + 1)

            return

        else:

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

        pos += 1

    if term:

        raise error.ParseError(_("unterminated template expansion"), start)

    yield ('end', None, pos)

def _parsetemplate(tmpl, start, stop, quote=''):

    r"""

    >>> _parsetemplate(b'foo{bar}"baz', 0, 12)

    ([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12)

    >>> _parsetemplate(b'foo{bar}"baz', 0, 12, quote=b'"')

    ([('string', 'foo'), ('symbol', 'bar')], 9)

    >>> _parsetemplate(b'foo"{bar}', 0, 9, quote=b'"')

    ([('string', 'foo')], 4)

    >>> _parsetemplate(br'foo\"bar"baz', 0, 12, quote=b'"')

    ([('string', 'foo"'), ('string', 'bar')], 9)

    >>> _parsetemplate(br'foo\\"bar', 0, 10, quote=b'"')

    ([('string', 'foo\\')], 6)

    """

    parsed = []

    sepchars = '{' + quote

    pos = start

    p = parser.parser(elements)

    while pos < stop:

        n = min((tmpl.find(c, pos, stop) for c in sepchars),

                key=lambda n: (n < 0, n))

        if n < 0:

            parsed.append(('string', parser.unescapestr(tmpl[pos:stop])))

            pos = stop

            break

        c = tmpl[n:n + 1]

        bs = (n - pos) - len(tmpl[pos:n].rstrip('\\'))

        if bs % 2 == 1:

            # escaped (e.g. '\{', '\\\{', but not '\\{')

            parsed.append(('string', parser.unescapestr(tmpl[pos:n - 1]) + c))

            pos = n + 1

            continue

        if n > pos:

            parsed.append(('string', parser.unescapestr(tmpl[pos:n])))

        if c == quote:

            return parsed, n + 1

        parseres, pos = p.parse(tokenize(tmpl, n + 1, stop, '}'))

        parsed.append(parseres)

    if quote:

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

    return parsed, pos

def _unnesttemplatelist(tree):

    """Expand list of templates to node tuple

    >>> def f(tree):

    ...     print(pycompat.sysstr(prettyformat(_unnesttemplatelist(tree))))

    >>> f((b'template', []))

    (string '')

    >>> f((b'template', [(b'string', b'foo')]))

    (string 'foo')

    >>> f((b'template', [(b'string', b'foo'), (b'symbol', b'rev')]))

    (template

      (string 'foo')

      (symbol 'rev'))

    >>> f((b'template', [(b'symbol', b'rev')]))  # template(rev) -> str

    (template

      (symbol 'rev'))

    >>> f((b'template', [(b'template', [(b'string', b'foo')])]))

    (string 'foo')

    """

    if not isinstance(tree, tuple):

        return tree

    op = tree[0]

    if op != 'template':

        return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:])

    assert len(tree) == 2

    xs = tuple(_unnesttemplatelist(x) for x in tree[1])

    if not xs:

        return ('string', '')  # empty template ""

    elif len(xs) == 1 and xs[0][0] == 'string':

        return xs[0]  # fast path for string with no template fragment "x"

    else:

        return (op,) + xs

def parse(tmpl):

    """Parse template string into tree"""

    parsed, pos = _parsetemplate(tmpl, 0, len(tmpl))

    assert pos == len(tmpl), 'unquoted template should be consumed'

    return _unnesttemplatelist(('template', parsed))

def _parseexpr(expr):

    """Parse a template expression into tree

    >>> _parseexpr(b'"foo"')

    ('string', 'foo')

    >>> _parseexpr(b'foo(bar)')

    ('func', ('symbol', 'foo'), ('symbol', 'bar'))

    >>> _parseexpr(b'foo(')

    Traceback (most recent call last):

      ...

    ParseError: ('not a prefix: end', 4)

    >>> _parseexpr(b'"foo" "bar"')

    Traceback (most recent call last):

      ...

    ParseError: ('invalid token', 7)

    """

    p = parser.parser(elements)

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

    if pos != len(expr):

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

    return _unnesttemplatelist(tree)

def prettyformat(tree):

    return parser.prettyformat(tree, ('integer', 'string', 'symbol'))

def compileexp(exp, context, curmethods):

    """Compile parsed template tree to (func, data) pair"""

    t = exp[0]

    if t in curmethods:

        return curmethods[t](exp, context)

    raise error.ParseError(_("unknown method '%s'") % t)

# template evaluation

def getsymbol(exp):

    if exp[0] == 'symbol':

        return exp[1]

    raise error.ParseError(_("expected a symbol, got '%s'") % exp[0])

def getlist(x):

    if not x:

        return []

    if x[0] == 'list':

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

    return [x]

def gettemplate(exp, context):

    """Compile given template tree or load named template from map file;

    returns (func, data) pair"""

    if exp[0] in ('template', 'string'):

        return compileexp(exp, context, methods)

    if exp[0] == 'symbol':

        # unlike runsymbol(), here 'symbol' is always taken as template name

        # even if it exists in mapping. this allows us to override mapping

        # by web templates, e.g. 'changelogtag' is redefined in map file.

        return context._load(exp[1])

    raise error.ParseError(_("expected template specifier"))

def findsymbolicname(arg):

    """Find symbolic name for the given compiled expression; returns None

    if nothing found reliably"""

    while True:

        func, data = arg

        if func is runsymbol:

            return data

        elif func is runfilter:

            arg = data[0]

        else:

            return None

def evalrawexp(context, mapping, arg):

    """Evaluate given argument as a bare template object which may require

    further processing (such as folding generator of strings)"""

    func, data = arg

    return func(context, mapping, data)

def evalfuncarg(context, mapping, arg):

    """Evaluate given argument as value type"""

    thing = evalrawexp(context, mapping, arg)

    thing = templatekw.unwrapvalue(thing)

    # evalrawexp() may return string, generator of strings or arbitrary object

    # such as date tuple, but filter does not want generator.

    if isinstance(thing, types.GeneratorType):

        thing = stringify(thing)

    return thing

def evalboolean(context, mapping, arg):

    """Evaluate given argument as boolean, but also takes boolean literals"""

    func, data = arg

    if func is runsymbol:

        thing = func(context, mapping, data, default=None)

        if thing is None:

            # not a template keyword, takes as a boolean literal

            thing = util.parsebool(data)

    else:

        thing = func(context, mapping, data)

    thing = templatekw.unwrapvalue(thing)

    if isinstance(thing, bool):

        return thing

    # other objects are evaluated as strings, which means 0 is True, but

    # empty dict/list should be False as they are expected to be ''

    return bool(stringify(thing))

def evalinteger(context, mapping, arg, err=None):

    v = evalfuncarg(context, mapping, arg)

    try:

        return int(v)

    except (TypeError, ValueError):

        raise error.ParseError(err or _('not an integer'))

def evalstring(context, mapping, arg):

    return stringify(evalrawexp(context, mapping, arg))

def evalstringliteral(context, mapping, arg):

    """Evaluate given argument as string template, but returns symbol name

    if it is unknown"""

    func, data = arg

    if func is runsymbol:

        thing = func(context, mapping, data, default=data)

    else:

        thing = func(context, mapping, data)

    return stringify(thing)

_evalfuncbytype = {

    bool: evalboolean,

    bytes: evalstring,

    int: evalinteger,

}

def evalastype(context, mapping, arg, typ):

    """Evaluate given argument and coerce its type"""

    try:

        f = _evalfuncbytype[typ]

    except KeyError:

        raise error.ProgrammingError('invalid type specified: %r' % typ)

    return f(context, mapping, arg)