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

)

from .utils import dateutil

class ResourceUnavailable(error.Abort):

    pass

class TemplateNotFound(error.Abort):

    pass

# 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 (br"\'", br'\"')

              or c == 'r' and program[pos:pos + 3] in (br"r\'", br'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 = []

    for typ, val, pos in _scantemplate(tmpl, start, stop, quote):

        if typ == 'string':

            parsed.append((typ, val))

        elif typ == 'template':

            parsed.append(val)

        elif typ == 'end':

            return parsed, pos

        else:

            raise error.ProgrammingError('unexpected type: %s' % typ)

    raise error.ProgrammingError('unterminated scanning of template')

def scantemplate(tmpl, raw=False):

    r"""Scan (type, start, end) positions of outermost elements in template

    If raw=True, a backslash is not taken as an escape character just like

    r'' string in Python. Note that this is different from r'' literal in

    template in that no template fragment can appear in r'', e.g. r'{foo}'

    is a literal '{foo}', but ('{foo}', raw=True) is a template expression

    'foo'.

    >>> list(scantemplate(b'foo{bar}"baz'))

    [('string', 0, 3), ('template', 3, 8), ('string', 8, 12)]

    >>> list(scantemplate(b'outer{"inner"}outer'))

    [('string', 0, 5), ('template', 5, 14), ('string', 14, 19)]

    >>> list(scantemplate(b'foo\\{escaped}'))

    [('string', 0, 5), ('string', 5, 13)]

    >>> list(scantemplate(b'foo\\{escaped}', raw=True))

    [('string', 0, 4), ('template', 4, 13)]

    """

    last = None

    for typ, val, pos in _scantemplate(tmpl, 0, len(tmpl), raw=raw):

        if last:

            yield last + (pos,)

        if typ == 'end':

            return

        else:

            last = (typ, pos)

    raise error.ProgrammingError('unterminated scanning of template')

def _scantemplate(tmpl, start, stop, quote='', raw=False):

    """Parse template string into chunks of strings and template expressions"""

    sepchars = '{' + quote

    unescape = [parser.unescapestr, pycompat.identity][raw]

    pos = start

    p = parser.parser(elements)

    yield ('end', None, 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"""

    if not exp:

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

    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