# 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 i18n import _

import os, re

import util, config, templatefilters, templatekw, parser, error

import revset as revsetmod

import types

import minirst

# template parsing

elements = {

}

def tokenize(program, start, end):

    pos = start

    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() or c == '-':

            s = pos

            if c == '-': # simply take negate operator as part of integer

                pos += 1

            if pos >= end or not program[pos].isdigit():

                raise error.ParseError(_("integer literal without digits"), s)

            pos += 1

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

                    try:

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

                        data = program[s:pos].decode('string-escape')

                    except ValueError: # unbalanced escapes

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

                    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 == '}':

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

            return

        else:

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

        pos += 1

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

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

    r"""

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

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

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

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

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

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

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

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

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

    ([('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', tmpl[pos:stop].decode('string-escape')))

            pos = stop

            break

        c = tmpl[n]

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

        if bs % 2 == 1:

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

            parsed.append(('string',

                           tmpl[pos:n - 1].decode('string-escape') + c))

            pos = n + 1

            continue

        if n > pos:

            parsed.append(('string', tmpl[pos:n].decode('string-escape')))

        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 compiletemplate(tmpl, context):

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

    return [compileexp(e, context, methods) for e in parsed]

def compileexp(exp, context, curmethods):

    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 getfilter(exp, context):

    f = getsymbol(exp)

    if f not in context._filters:

        raise error.ParseError(_("unknown function '%s'") % f)

    return context._filters[f]

def gettemplate(exp, context):

    if exp[0] == 'template':

        return [compileexp(e, context, methods) for e in exp[1]]

    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 runinteger(context, mapping, data):

    return int(data)

def runstring(context, mapping, data):

    return data

def runsymbol(context, mapping, key):

    v = mapping.get(key)

    if v is None:

        v = context._defaults.get(key)

    if v is None:

        try:

            v = context.process(key, mapping)

        except TemplateNotFound:

            v = ''

    if callable(v):

        return v(**mapping)

    if isinstance(v, types.GeneratorType):

        v = list(v)

    return v

def buildtemplate(exp, context):

    ctmpl = [compileexp(e, context, methods) for e in exp[1]]

    if len(ctmpl) == 1:

        return ctmpl[0]  # fast path for string with no template fragment

    return (runtemplate, ctmpl)

def runtemplate(context, mapping, template):

    for func, data in template:

        yield func(context, mapping, data)

def buildfilter(exp, context):

    func, data = compileexp(exp[1], context, methods)

    filt = getfilter(exp[2], context)

    return (runfilter, (func, data, filt))

def runfilter(context, mapping, data):

    func, data, filt = data

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

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

    thing = func(context, mapping, data)

    if isinstance(thing, types.GeneratorType):

        thing = stringify(thing)

    try:

        return filt(thing)

    except (ValueError, AttributeError, TypeError):

        if isinstance(data, tuple):

            dt = data[1]

        else:

            dt = data

        raise util.Abort(_("template filter '%s' is not compatible with "

                           "keyword '%s'") % (filt.func_name, dt))

def buildmap(exp, context):

    func, data = compileexp(exp[1], context, methods)

    ctmpl = gettemplate(exp[2], context)

    return (runmap, (func, data, ctmpl))

def runmap(context, mapping, data):

    func, data, ctmpl = data

    d = func(context, mapping, data)

    if callable(d):

        d = d()

    lm = mapping.copy()

    for i in d:

        if isinstance(i, dict):

            lm.update(i)

            lm['originalnode'] = mapping.get('node')

            yield runtemplate(context, lm, ctmpl)

        else:

            # v is not an iterable of dicts, this happen when 'key'

            # has been fully expanded already and format is useless.

            # If so, return the expanded value.

            yield i

def buildfunc(exp, context):

    n = getsymbol(exp[1])

    args = [compileexp(x, context, exprmethods) for x in getlist(exp[2])]

    if n in funcs:

        f = funcs[n]

        return (f, args)

    if n in context._filters:

        if len(args) != 1:

            raise error.ParseError(_("filter %s expects one argument") % n)

        f = context._filters[n]

        return (runfilter, (args[0][0], args[0][1], f))

    raise error.ParseError(_("unknown function '%s'") % n)

def date(context, mapping, args):

    """:date(date[, fmt]): Format a date. See :hg:`help dates` for formatting

    strings."""

    if not (1 <= len(args) <= 2):

        # i18n: "date" is a keyword

        raise error.ParseError(_("date expects one or two arguments"))

    date = args[0][0](context, mapping, args[0][1])

    fmt = None

    if len(args) == 2:

        fmt = stringify(args[1][0](context, mapping, args[1][1]))

    try:

        if fmt is None:

            return util.datestr(date)

        else:

            return util.datestr(date, fmt)

    except (TypeError, ValueError):

        # i18n: "date" is a keyword

        raise error.ParseError(_("date expects a date information"))

def diff(context, mapping, args):

    """:diff([includepattern [, excludepattern]]): Show a diff, optionally

    specifying files to include or exclude."""

    if len(args) > 2:

        # i18n: "diff" is a keyword

        raise error.ParseError(_("diff expects one, two or no arguments"))

    def getpatterns(i):

        if i < len(args):

            s = stringify(args[i][0](context, mapping, args[i][1])).strip()

            if s:

                return [s]

        return []

    ctx = mapping['ctx']

    chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1)))

    return ''.join(chunks)

def fill(context, mapping, args):

    """:fill(text[, width[, initialident[, hangindent]]]): Fill many

    paragraphs with optional indentation. See the "fill" filter."""

    if not (1 <= len(args) <= 4):

        # i18n: "fill" is a keyword

        raise error.ParseError(_("fill expects one to four arguments"))

    text = stringify(args[0][0](context, mapping, args[0][1]))

    width = 76

    initindent = ''

    hangindent = ''

    if 2 <= len(args) <= 4:

        try: