# 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 .node import (

    bin,

    wdirid,

)

from . import (

    color,

    encoding,

    error,

    minirst,

    obsutil,

    pycompat,

    registrar,

    revset as revsetmod,

    revsetlang,

    scmutil,

    templatefilters,

    templatekw,

    templateutil,

    util,

)

from .utils import (

    dateutil,

    stringutil,

)

evalrawexp = templateutil.evalrawexp

evalwrapped = templateutil.evalwrapped

evalfuncarg = templateutil.evalfuncarg

evalboolean = templateutil.evalboolean

evaldate = templateutil.evaldate

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

                    # i18n: "date" is a keyword

                    _("date expects a date information"))

    fmt = None

    if len(args) == 2:

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

    if fmt is None:

        return dateutil.datestr(date)

    else:

        return dateutil.datestr(date, fmt)

@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]])', requires={'ctx'})

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', requires={'ctx', 'cache'})

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'])

    if not source:

        sym = templateutil.findsymbolicname(args['source'])

        if sym:

            raise error.ParseError(_('empty data source specified'),

                                   hint=_("did you mean extdata('%s')?") % sym)

        else:

            raise error.ParseError(_('empty data source specified'))

    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)', requires={'ctx'})

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.compatfileslist(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('filter(iterable[, expr])')

def filter_(context, mapping, args):

    """Remove empty elements from a list or a dict. If expr specified, it's

    applied to each element to test emptiness."""

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

        # i18n: "filter" is a keyword

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

    iterable = evalwrapped(context, mapping, args[0])

    if len(args) == 1:

        def select(w):

            return w.tobool(context, mapping)

    else:

        def select(w):

            if not isinstance(w, templateutil.mappable):

                raise error.ParseError(_("not filterable by expression"))

            lm = context.overlaymap(mapping, w.tomap(context))

            return evalboolean(context, lm, args[1])

    return iterable.filter(context, mapping, select)

@templatefunc('formatnode(node)', requires={'ui'})

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('mailmap(author)', requires={'repo', 'cache'})

def mailmap(context, mapping, args):

    """Return the author, updated according to the value

    set in the .mailmap file"""

    if len(args) != 1:

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

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

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

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

    if 'mailmap' not in cache:

        data = repo.wvfs.tryread('.mailmap')

        cache['mailmap'] = stringutil.parsemailmap(data)

    return stringutil.mapname(cache['mailmap'], author)

@templatefunc(

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

    argspec='text width fillchar left truncate')

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'])

    truncate = False

    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'])

    if 'truncate' in args:

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

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

    if fillwidth < 0 and truncate:

        return encoding.trim(color.stripeffects(text), width, leftside=left)

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

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

    try:

        return dictarg.getmember(context, mapping, key)

    except error.ParseError as err:

        # i18n: "get" is a keyword

        hint = _("get() expects a dict as first argument")

        raise error.ParseError(bytes(err), hint=hint)

@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 = evalwrapped(context, mapping, args[1])

    try:

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

        found = haystack.contains(context, mapping, needle)

    except error.ParseError:

        found = False

    if found:

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