# templatefuncs.py - common template functions

#

# Copyright 2005, 2006 Olivia Mackall <olivia@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.

import re

from .i18n import _

from .node import bin

from . import (

    color,

    dagop,

    diffutil,

    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(b'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(_(b"date expects one or two arguments"))

    date = evaldate(

        context,

        mapping,

        args[0],

        # i18n: "date" is a keyword

        _(b"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(b'dict([[key=]value...])', argspec=b'*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[b'args']:

        k = templateutil.findsymbolicname(v)

        if not k:

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

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

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

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

    data.update(

        (k, evalfuncarg(context, mapping, v))

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

    )

    return templateutil.hybriddict(data)

@templatefunc(

    b'diff([includepattern [, excludepattern]])', requires={b'ctx', b'ui'}

)

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(_(b"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, b'ctx')

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

    diffopts = diffutil.diffallopts(ui)

    chunks = ctx.diff(

        match=ctx.match([], getpatterns(0), getpatterns(1)), opts=diffopts

    )

    return b''.join(chunks)

@templatefunc(

    b'extdata(source)', argspec=b'source', requires={b'ctx', b'cache'}

)

def extdata(context, mapping, args):

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

    if b'source' not in args:

        # i18n: "extdata" is a keyword

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

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

    if not source:

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

        if sym:

            raise error.ParseError(

                _(b'empty data source specified'),

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

            )

        else:

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

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

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

    if source in cache:

        data = cache[source]

    else:

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

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

@templatefunc(b'files(pattern)', requires={b'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(_(b"files expects one argument"))

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

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

    m = ctx.match([raw])

    files = list(ctx.matches(m))

    return templateutil.compatfileslist(context, mapping, b"file", files)

@templatefunc(b'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(_(b"fill expects one to four arguments"))

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

    width = 76

    initindent = b''

    hangindent = b''

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

        width = evalinteger(

            context,

            mapping,

            args[1],

            # i18n: "fill" is a keyword

            _(b"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(b'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(_(b"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(_(b"not filterable by expression"))

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

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

    return iterable.filter(context, mapping, select)

@templatefunc(b'formatnode(node)', requires={b'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(_(b"formatnode expects one argument"))

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

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

    if ui.debugflag:

        return node

    return templatefilters.short(node)

@templatefunc(b'mailmap(author)', requires={b'repo', b'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(_(b"mailmap expects one argument"))

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

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

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

    if b'mailmap' not in cache:

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

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

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

@templatefunc(

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

    argspec=b'text width fillchar left truncate',

)

def pad(context, mapping, args):

    """Pad text with a

    fill character."""

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

        # i18n: "pad" is a keyword

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

    width = evalinteger(

        context,

        mapping,

        args[b'width'],

        # i18n: "pad" is a keyword

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

    )

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

    truncate = False

    left = False

    fillchar = b' '

    if b'fillchar' in args:

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

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

            # i18n: "pad" is a keyword

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

    if b'left' in args:

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

    if b'truncate' in args:

        truncate = evalboolean(context, mapping, args[b'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(b'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(_(b"indent() expects two or three arguments"))

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

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

    firstline = indent

    if len(args) == 3:

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

    return templatefilters.indent(text, indent, firstline=firstline)

@templatefunc(b'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(_(b"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 = _(b"get() expects a dict as first argument")

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

@templatefunc(b'config(section, name[, default])', requires={b'ui'})

def config(context, mapping, args):

    """Returns the requested hgrc config option as a string."""

    fn = context.resource(mapping, b'ui').config

    return _config(context, mapping, args, fn, evalstring)

@templatefunc(b'configbool(section, name[, default])', requires={b'ui'})

def configbool(context, mapping, args):

    """Returns the requested hgrc config option as a boolean."""

    fn = context.resource(mapping, b'ui').configbool

    return _config(context, mapping, args, fn, evalboolean)

@templatefunc(b'configint(section, name[, default])', requires={b'ui'})

def configint(context, mapping, args):

    """Returns the requested hgrc config option as an integer."""

    fn = context.resource(mapping, b'ui').configint

    return _config(context, mapping, args, fn, evalinteger)

def _config(context, mapping, args, configfn, defaultfn):

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

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

    # The config option can come from any section, though we specifically

    # reserve the [templateconfig] section for dynamically defining options

    # for this function without also requiring an extension.