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

"""Slightly complicated template engine for commands and hgweb

This module provides low-level interface to the template engine. See the

formatter and cmdutil modules if you are looking for high-level functions

such as ``cmdutil.rendertemplate(ctx, tmpl)``.

Internal Data Types

-------------------

Template keywords and functions take a dictionary of current symbols and

resources (a "mapping") and return result. Inputs and outputs must be one

of the following data types:

bytes

    a byte string, which is generally a human-readable text in local encoding.

generator

    a lazily-evaluated byte string, which is a possibly nested generator of

    values of any printable types, and  will be folded by ``stringify()``

    or ``flatten()``.

    BUG: hgweb overloads this type for mappings (i.e. some hgweb keywords

    returns a generator of dicts.)

None

    sometimes represents an empty value, which can be stringified to ''.

True, False, int, float

    can be stringified as such.

date tuple

    a (unixtime, offset) tuple, which produces no meaningful output by itself.

hybrid

    represents a list/dict of printable values, which can also be converted

    to mappings by % operator.

mappable

    represents a scalar printable value, also supports % operator.

mappinggenerator, mappinglist

    represents mappings (i.e. a list of dicts), which may have default

    output format.

mappedgenerator

    a lazily-evaluated list of byte strings, which is e.g. a result of %

    operation.

"""

from __future__ import absolute_import, print_function

import abc

import os

from .i18n import _

from . import (

    config,

    encoding,

    error,

    parser,

    pycompat,

    templatefilters,

    templatefuncs,

    templateutil,

    util,

)

from .utils import (

    stringutil,

)

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

            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)

    try:

        while pos < stop:

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

            if n < 0:

                yield ('string', unescape(tmpl[pos:stop]), pos)

                pos = stop

                break

            c = tmpl[n:n + 1]

            bs = 0  # count leading backslashes

            if not raw:

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

            if bs % 2 == 1:

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

                yield ('string', unescape(tmpl[pos:n - 1]) + c, pos)

                pos = n + 1

                continue

            if n > pos:

                yield ('string', unescape(tmpl[pos:n]), pos)

            if c == quote:

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

                return

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

            if not tmpl.startswith('}', pos):

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

            yield ('template', parseres, n)

            pos += 1

        if quote:

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

    except error.ParseError as inst:

        if len(inst.args) > 1:  # has location

            loc = inst.args[1]

            # Offset the caret location by the number of newlines before the

            # location of the error, since we will replace one-char newlines

            # with the two-char literal r'\n'.

            offset = tmpl[:loc].count('\n')

            tmpl = tmpl.replace('\n', br'\n')

            # We want the caret to point to the place in the template that

            # failed to parse, but in a hint we get a open paren at the

            # start. Therefore, we print "loc + 1" spaces (instead of "loc")

            # to line up the caret with the location of the error.

            inst.hint = (tmpl + '\n'

                         + ' ' * (loc + 1 + offset) + '^ ' + _('here'))

        raise

    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