# 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 = {

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

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

    "|": (5, None, ("|", 5)),

    "%": (6, None, ("%", 6)),

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

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

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

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

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

}

def tokenizer(data):

    program, start, end = data

    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 '"\'' or c == 'r' and

              program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings

            if c == 'r':

                pos += 1

                c = program[pos]

                decode = False

            else:

                decode = True

            pos += 1

            s = pos

            while pos < end: # find closing quote

                d = program[pos]

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

                    pos += 2

                    continue

                if d == c:

                    if not decode:

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

                        break

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

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

            pos += 1

            break

        else:

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

        pos += 1

    yield ('end', None, pos)

def compiletemplate(tmpl, context, strtoken="string"):

    parsed = []

    pos, stop = 0, len(tmpl)

    p = parser.parser(tokenizer, elements)

    while pos < stop:

        n = tmpl.find('{', pos)

        if n < 0:

            parsed.append((strtoken, tmpl[pos:]))

            break

        if n > 0 and tmpl[n - 1] == '\\':

            # escaped

            parsed.append((strtoken, (tmpl[pos:n - 1] + "{")))

            pos = n + 1

            continue

        if n > pos:

            parsed.append((strtoken, tmpl[pos:n]))

        pd = [tmpl, n + 1, stop]

        parseres, pos = p.parse(pd)

        parsed.append(parseres)

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

def compileexp(exp, context):

    t = exp[0]

    if t in methods:

        return methods[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] == 'string' or exp[0] == 'rawstring':

        return compiletemplate(exp[1], context, strtoken=exp[0])

    if exp[0] == 'symbol':

        return context._load(exp[1])

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

def runstring(context, mapping, data):

    return data.decode("string-escape")

def runrawstring(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)

        mapping[key] = v

        return v

    return v

def buildfilter(exp, context):

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

    filt = getfilter(exp[2], context)

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

def runfilter(context, mapping, data):

    func, data, filt = data

    try:

        return filt(func(context, mapping, data))

    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)

    ctmpl = gettemplate(exp[2], context)

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

def runtemplate(context, mapping, template):

    for func, data in template:

        yield func(context, mapping, data)

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

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

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

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

    if len(args) == 2:

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

        return util.datestr(date, fmt)

    return util.datestr(date)

def diff(context, mapping, args):

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

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

        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:

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

        except ValueError:

            raise error.ParseError(_("fill expects an integer width"))

        try:

            initindent = stringify(_evalifliteral(args[2], context, mapping))

            hangindent = stringify(_evalifliteral(args[3], context, mapping))

        except IndexError:

            pass

    return templatefilters.fill(text, width, initindent, hangindent)

def pad(context, mapping, args):

    """usage: pad(text, width, fillchar=' ', right=False)

    """

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

        raise error.ParseError(_("pad() expects two to four arguments"))

    width = int(args[1][1])

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

    if args[0][0] == runstring:

        text = stringify(runtemplate(context, mapping,

            compiletemplate(text, context)))

    right = False

    fillchar = ' '

    if len(args) > 2:

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

    if len(args) > 3:

        right = util.parsebool(args[3][1])

    if right:

        return text.rjust(width, fillchar)

    else:

        return text.ljust(width, fillchar)

def get(context, mapping, args):

    if len(args) != 2:

        # i18n: "get" is a keyword

        raise error.ParseError(_("get() expects two arguments"))

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

    if not util.safehasattr(dictarg, 'get'):

        # i18n: "get" is a keyword

        raise error.ParseError(_("get() expects a dict as first argument"))

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

    yield dictarg.get(key)

def _evalifliteral(arg, context, mapping):

    t = stringify(arg[0](context, mapping, arg[1]))

    if arg[0] == runstring or arg[0] == runrawstring:

        yield runtemplate(context, mapping,

                          compiletemplate(t, context, strtoken='rawstring'))

    else:

        yield t

def if_(context, mapping, args):

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

        # i18n: "if" is a keyword

        raise error.ParseError(_("if expects two or three arguments"))

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

    if test:

        yield _evalifliteral(args[1], context, mapping)

    elif len(args) == 3:

        yield _evalifliteral(args[2], context, mapping)

def ifcontains(context, mapping, args):

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

        # i18n: "ifcontains" is a keyword

        raise error.ParseError(_("ifcontains expects three or four arguments"))

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

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

    # Iterating over items gives a formatted string, so we iterate

    # directly over the raw values.

    if ((callable(items) and item in [i.values()[0] for i in items()]) or

        (isinstance(items, str) and item in items)):

        yield _evalifliteral(args[2], context, mapping)

    elif len(args) == 4:

        yield _evalifliteral(args[3], context, mapping)

def ifeq(context, mapping, args):

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

        # i18n: "ifeq" is a keyword

        raise error.ParseError(_("ifeq expects three or four arguments"))

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

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