# templatefuncs.py - common template functions

#

# 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

import re

from .i18n import _

from . import (

    color,

    encoding,

    error,

    minirst,

    obsutil,

    pycompat,

    registrar,

    revset as revsetmod,

    revsetlang,

    scmutil,

    templatefilters,

    templatekw,

    templateutil,

    util,

)

evalrawexp = templateutil.evalrawexp

evalfuncarg = templateutil.evalfuncarg

evalboolean = templateutil.evalboolean

evalinteger = templateutil.evalinteger

evalstring = templateutil.evalstring

evalstringliteral = templateutil.evalstringliteral

# dict of template built-in functions

funcs = {}

templatefunc = registrar.templatefunc(funcs)

@templatefunc('date(date[, fmt])')

def date(context, mapping, args):

    """Format a date. See :hg:`help dates` for formatting

    strings. The default is a Unix date format, including the timezone:

    "Mon Sep 04 15:13:13 2006 0700"."""

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

        # i18n: "date" is a keyword

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

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

    fmt = None

    if len(args) == 2:

        fmt = evalstring(context, mapping, args[1])

    try:

        if fmt is None:

            return dateutil.datestr(date)

        else:

            return dateutil.datestr(date, fmt)

    except (TypeError, ValueError):

        # i18n: "date" is a keyword

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

@templatefunc('dict([[key=]value...])', argspec='*args **kwargs')

def dict_(context, mapping, args):

    """Construct a dict from key-value pairs. A key may be omitted if

    a value expression can provide an unambiguous name."""

    data = util.sortdict()

    for v in args['args']:

        k = templateutil.findsymbolicname(v)

        if not k:

            raise error.ParseError(_('dict key cannot be inferred'))

        if k in data or k in args['kwargs']:

            raise error.ParseError(_("duplicated dict key '%s' inferred") % k)

        data[k] = evalfuncarg(context, mapping, v)

    data.update((k, evalfuncarg(context, mapping, v))

                for k, v in args['kwargs'].iteritems())

    return templateutil.hybriddict(data)

@templatefunc('diff([includepattern [, excludepattern]])')

def diff(context, mapping, args):

    """Show a diff, optionally

    specifying files to include or exclude."""

    if len(args) > 2:

        # i18n: "diff" is a keyword

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

    def getpatterns(i):

        if i < len(args):

            s = evalstring(context, mapping, args[i]).strip()

            if s:

                return [s]

        return []

    ctx = context.resource(mapping, 'ctx')

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

    return ''.join(chunks)

@templatefunc('extdata(source)', argspec='source')

def extdata(context, mapping, args):

    """Show a text read from the specified extdata source. (EXPERIMENTAL)"""

    if 'source' not in args:

        # i18n: "extdata" is a keyword

        raise error.ParseError(_('extdata expects one argument'))

    source = evalstring(context, mapping, args['source'])

    cache = context.resource(mapping, 'cache').setdefault('extdata', {})

    ctx = context.resource(mapping, 'ctx')

    if source in cache:

        data = cache[source]

    else:

        data = cache[source] = scmutil.extdatasource(ctx.repo(), source)

    return data.get(ctx.rev(), '')

@templatefunc('files(pattern)')

def files(context, mapping, args):

    """All files of the current changeset matching the pattern. See

    :hg:`help patterns`."""

    if not len(args) == 1:

        # i18n: "files" is a keyword

        raise error.ParseError(_("files expects one argument"))

    raw = evalstring(context, mapping, args[0])

    ctx = context.resource(mapping, 'ctx')

    m = ctx.match([raw])

    files = list(ctx.matches(m))

    return templateutil.compatlist(context, mapping, "file", files)

@templatefunc('fill(text[, width[, initialident[, hangindent]]])')

def fill(context, mapping, args):

    """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 = evalstring(context, mapping, args[0])

    width = 76

    initindent = ''

    hangindent = ''

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

        width = evalinteger(context, mapping, args[1],

                            # i18n: "fill" is a keyword

                            _("fill expects an integer width"))

        try:

            initindent = evalstring(context, mapping, args[2])

            hangindent = evalstring(context, mapping, args[3])

        except IndexError:

            pass

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

@templatefunc('formatnode(node)')

def formatnode(context, mapping, args):

    """Obtain the preferred form of a changeset hash. (DEPRECATED)"""

    if len(args) != 1:

        # i18n: "formatnode" is a keyword

        raise error.ParseError(_("formatnode expects one argument"))

    ui = context.resource(mapping, 'ui')

    node = evalstring(context, mapping, args[0])

    if ui.debugflag:

        return node

    return templatefilters.short(node)

@templatefunc('pad(text, width[, fillchar=\' \'[, left=False]])',

              argspec='text width fillchar left')

def pad(context, mapping, args):

    """Pad text with a

    fill character."""

    if 'text' not in args or 'width' not in args:

        # i18n: "pad" is a keyword

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

    width = evalinteger(context, mapping, args['width'],

                        # i18n: "pad" is a keyword

                        _("pad() expects an integer width"))

    text = evalstring(context, mapping, args['text'])

    left = False

    fillchar = ' '

    if 'fillchar' in args:

        fillchar = evalstring(context, mapping, args['fillchar'])

        if len(color.stripeffects(fillchar)) != 1:

            # i18n: "pad" is a keyword

            raise error.ParseError(_("pad() expects a single fill character"))

    if 'left' in args:

        left = evalboolean(context, mapping, args['left'])

    fillwidth = width - encoding.colwidth(color.stripeffects(text))

    if fillwidth <= 0:

        return text

    if left:

        return fillchar * fillwidth + text

    else:

        return text + fillchar * fillwidth

@templatefunc('indent(text, indentchars[, firstline])')

def indent(context, mapping, args):

    """Indents all non-empty lines

    with the characters given in the indentchars string. An optional

    third parameter will override the indent for the first line only

    if present."""

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

        # i18n: "indent" is a keyword

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

    text = evalstring(context, mapping, args[0])

    indent = evalstring(context, mapping, args[1])

    if len(args) == 3:

        firstline = evalstring(context, mapping, args[2])

    else:

        firstline = indent

    # the indent function doesn't indent the first line, so we do it here

    return templatefilters.indent(firstline + text, indent)

@templatefunc('get(dict, key)')

def get(context, mapping, args):

    """Get an attribute/key from an object. Some keywords

    are complex types. This function allows you to obtain the value of an

    attribute on these types."""

    if len(args) != 2:

        # i18n: "get" is a keyword

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

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

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

        # i18n: "get" is a keyword

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

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

    return templateutil.getdictitem(dictarg, key)

@templatefunc('if(expr, then[, else])')

def if_(context, mapping, args):

    """Conditionally execute based on the result of

    an expression."""

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

        # i18n: "if" is a keyword

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

    test = evalboolean(context, mapping, args[0])

    if test:

        return evalrawexp(context, mapping, args[1])

    elif len(args) == 3:

        return evalrawexp(context, mapping, args[2])

@templatefunc('ifcontains(needle, haystack, then[, else])')

def ifcontains(context, mapping, args):

    """Conditionally execute based

    on whether the item "needle" is in "haystack"."""

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

        # i18n: "ifcontains" is a keyword

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

    haystack = evalfuncarg(context, mapping, args[1])

    keytype = getattr(haystack, 'keytype', None)

    try:

        needle = evalrawexp(context, mapping, args[0])

        needle = templateutil.unwrapastype(needle, keytype or bytes)

        found = (needle in haystack)

    except error.ParseError:

        found = False

    if found:

        return evalrawexp(context, mapping, args[2])

    elif len(args) == 4:

        return evalrawexp(context, mapping, args[3])

@templatefunc('ifeq(expr1, expr2, then[, else])')

def ifeq(context, mapping, args):

    """Conditionally execute based on

    whether 2 items are equivalent."""

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

        # i18n: "ifeq" is a keyword

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

    test = evalstring(context, mapping, args[0])

    match = evalstring(context, mapping, args[1])

    if test == match:

        return evalrawexp(context, mapping, args[2])

    elif len(args) == 4:

        return evalrawexp(context, mapping, args[3])

@templatefunc('join(list, sep)')

def join(context, mapping, args):

    """Join items in a list with a delimiter."""

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

        # i18n: "join" is a keyword

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

    # TODO: perhaps this should be evalfuncarg(), but it can't because hgweb

    # abuses generator as a keyword that returns a list of dicts.

    joinset = evalrawexp(context, mapping, args[0])

    joinset = templateutil.unwrapvalue(joinset)

    joinfmt = getattr(joinset, 'joinfmt', pycompat.identity)

    joiner = " "

    if len(args) > 1:

        joiner = evalstring(context, mapping, args[1])

    first = True

    for x in pycompat.maybebytestr(joinset):

        if first:

            first = False

        else:

            yield joiner

        yield joinfmt(x)

@templatefunc('label(label, expr)')

def label(context, mapping, args):

    """Apply a label to generated content. Content with

    a label applied can result in additional post-processing, such as

    automatic colorization."""

    if len(args) != 2:

        # i18n: "label" is a keyword

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

    ui = context.resource(mapping, 'ui')

    thing = evalstring(context, mapping, args[1])

    # preserve unknown symbol as literal so effects like 'red', 'bold',

    # etc. don't need to be quoted

    label = evalstringliteral(context, mapping, args[0])

    return ui.label(thing, label)

@templatefunc('latesttag([pattern])')

def latesttag(context, mapping, args):

    """The global tags matching the given pattern on the

    most recent globally tagged ancestor of this changeset.

    If no such tags exist, the "{tag}" template resolves to

    the string "null"."""

    if len(args) > 1:

        # i18n: "latesttag" is a keyword

        raise error.ParseError(_("latesttag expects at most one argument"))

    pattern = None

    if len(args) == 1:

        pattern = evalstring(context, mapping, args[0])

    return templatekw.showlatesttags(context, mapping, pattern)