# templateutil.py - utility for template evaluation

#

# 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 abc

import types

from .i18n import _

from . import (

    error,

    pycompat,

    util,

)

from .utils import (

    dateutil,

    stringutil,

)

class ResourceUnavailable(error.Abort):

    pass

class TemplateNotFound(error.Abort):

    pass

class wrapped(object):

    """Object requiring extra conversion prior to displaying or processing

    as value

    Use unwrapvalue(), unwrapastype(), or unwraphybrid() to obtain the inner

    object.

    """

    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod

    def itermaps(self, context):

        """Yield each template mapping"""

    @abc.abstractmethod

    def join(self, context, mapping, sep):

        """Join items with the separator; Returns a bytes or (possibly nested)

        generator of bytes

        A pre-configured template may be rendered per item if this container

        holds unprintable items.

        """

    @abc.abstractmethod

    def show(self, context, mapping):

        """Return a bytes or (possibly nested) generator of bytes representing

        the underlying object

        A pre-configured template may be rendered if the underlying object is

        not printable.

        """

    @abc.abstractmethod

    def tovalue(self, context, mapping):

        """Move the inner value object out or create a value representation

        A returned value must be serializable by templaterfilters.json().

        """

# stub for representing a date type; may be a real date type that can

# provide a readable string value

class date(object):

    pass

class hybrid(wrapped):

    """Wrapper for list or dict to support legacy template

    This class allows us to handle both:

    - "{files}" (legacy command-line-specific list hack) and

    - "{files % '{file}\n'}" (hgweb-style with inlining and function support)

    and to access raw values:

    - "{ifcontains(file, files, ...)}", "{ifcontains(key, extras, ...)}"

    - "{get(extras, key)}"

    - "{files|json}"

    """

    def __init__(self, gen, values, makemap, joinfmt, keytype=None):

        self._gen = gen  # generator or function returning generator

        self._values = values

        self._makemap = makemap

        self._joinfmt = joinfmt

        self.keytype = keytype  # hint for 'x in y' where type(x) is unresolved

    def itermaps(self, context):

        makemap = self._makemap

        for x in self._values:

            yield makemap(x)

    def join(self, context, mapping, sep):

        # TODO: switch gen to (context, mapping) API?

        return joinitems((self._joinfmt(x) for x in self._values), sep)

    def show(self, context, mapping):

        # TODO: switch gen to (context, mapping) API?

        gen = self._gen

        if gen is None:

            return self.join(context, mapping, ' ')

        if callable(gen):

            return gen()

        return gen

    def tovalue(self, context, mapping):

        # TODO: return self._values and get rid of proxy methods

        return self

    def __contains__(self, x):

        return x in self._values

    def __getitem__(self, key):

        return self._values[key]

    def __len__(self):

        return len(self._values)

    def __iter__(self):

        return iter(self._values)

    def __getattr__(self, name):

        if name not in (r'get', r'items', r'iteritems', r'iterkeys',

                        r'itervalues', r'keys', r'values'):

            raise AttributeError(name)

        return getattr(self._values, name)

class mappable(wrapped):

    """Wrapper for non-list/dict object to support map operation

    This class allows us to handle both:

    - "{manifest}"

    - "{manifest % '{rev}:{node}'}"

    - "{manifest.rev}"

    Unlike a hybrid, this does not simulate the behavior of the underling

    value.

    """

    def __init__(self, gen, key, value, makemap):

        self._gen = gen  # generator or function returning generator

        self._key = key

        self._value = value  # may be generator of strings

        self._makemap = makemap

    def tomap(self):

        return self._makemap(self._key)

    def itermaps(self, context):

        yield self.tomap()

    def join(self, context, mapping, sep):

        # TODO: just copies the old behavior where a value was a generator

        # yielding one item, but reconsider about it. join() over a string

        # has no consistent result because a string may be a bytes, or a

        # generator yielding an item, or a generator yielding multiple items.

        # Preserving all of the current behaviors wouldn't make any sense.

        return self.show(context, mapping)

    def show(self, context, mapping):

        # TODO: switch gen to (context, mapping) API?

        gen = self._gen

        if gen is None:

            return pycompat.bytestr(self._value)

        if callable(gen):

            return gen()

        return gen

    def tovalue(self, context, mapping):

        return _unthunk(context, mapping, self._value)

class _mappingsequence(wrapped):

    """Wrapper for sequence of template mappings

    This represents an inner template structure (i.e. a list of dicts),

    which can also be rendered by the specified named/literal template.

    Template mappings may be nested.

    """

    def __init__(self, name=None, tmpl=None, sep=''):

        if name is not None and tmpl is not None:

            raise error.ProgrammingError('name and tmpl are mutually exclusive')

        self._name = name

        self._tmpl = tmpl

        self._defaultsep = sep

    def join(self, context, mapping, sep):

        mapsiter = _iteroverlaymaps(context, mapping, self.itermaps(context))

        if self._name:

            itemiter = (context.process(self._name, m) for m in mapsiter)

        elif self._tmpl:

            itemiter = (context.expand(self._tmpl, m) for m in mapsiter)

        else:

            raise error.ParseError(_('not displayable without template'))

        return joinitems(itemiter, sep)

    def show(self, context, mapping):

        return self.join(context, mapping, self._defaultsep)

    def tovalue(self, context, mapping):

        knownres = context.knownresourcekeys()

        items = []

        for nm in self.itermaps(context):

            # drop internal resources (recursively) which shouldn't be displayed

            lm = context.overlaymap(mapping, nm)

            items.append({k: unwrapvalue(context, lm, v)

                          for k, v in nm.iteritems() if k not in knownres})

        return items

class mappinggenerator(_mappingsequence):

    """Wrapper for generator of template mappings

    The function ``make(context, *args)`` should return a generator of

    mapping dicts.

    """

    def __init__(self, make, args=(), name=None, tmpl=None, sep=''):

        super(mappinggenerator, self).__init__(name, tmpl, sep)

        self._make = make

        self._args = args

    def itermaps(self, context):

        return self._make(context, *self._args)

class mappinglist(_mappingsequence):

    """Wrapper for list of template mappings"""

    def __init__(self, mappings, name=None, tmpl=None, sep=''):

        super(mappinglist, self).__init__(name, tmpl, sep)

        self._mappings = mappings

    def itermaps(self, context):

        return iter(self._mappings)

class mappedgenerator(wrapped):

    """Wrapper for generator of strings which acts as a list

    The function ``make(context, *args)`` should return a generator of

    byte strings, or a generator of (possibly nested) generators of byte

    strings (i.e. a generator for a list of byte strings.)

    """

    def __init__(self, make, args=()):

        self._make = make

        self._args = args

    def _gen(self, context):

        return self._make(context, *self._args)

    def itermaps(self, context):

        raise error.ParseError(_('list of strings is not mappable'))

    def join(self, context, mapping, sep):

        return joinitems(self._gen(context), sep)

    def show(self, context, mapping):

        return self.join(context, mapping, '')

    def tovalue(self, context, mapping):

        return [stringify(context, mapping, x) for x in self._gen(context)]

def hybriddict(data, key='key', value='value', fmt=None, gen=None):

    """Wrap data to support both dict-like and string-like operations"""

    prefmt = pycompat.identity

    if fmt is None:

        fmt = '%s=%s'

        prefmt = pycompat.bytestr

    return hybrid(gen, data, lambda k: {key: k, value: data[k]},

                  lambda k: fmt % (prefmt(k), prefmt(data[k])))

def hybridlist(data, name, fmt=None, gen=None):

    """Wrap data to support both list-like and string-like operations"""

    prefmt = pycompat.identity

    if fmt is None:

        fmt = '%s'

        prefmt = pycompat.bytestr

    return hybrid(gen, data, lambda x: {name: x}, lambda x: fmt % prefmt(x))

def unwraphybrid(context, mapping, thing):

    """Return an object which can be stringified possibly by using a legacy

    template"""

    if not isinstance(thing, wrapped):

        return thing

    return thing.show(context, mapping)

def wraphybridvalue(container, key, value):

    """Wrap an element of hybrid container to be mappable

    The key is passed to the makemap function of the given container, which

    should be an item generated by iter(container).

    """

    makemap = getattr(container, '_makemap', None)

    if makemap is None:

        return value

    if util.safehasattr(value, '_makemap'):

        # a nested hybrid list/dict, which has its own way of map operation

        return value

    return mappable(None, key, value, makemap)

def compatdict(context, mapping, name, data, key='key', value='value',

               fmt=None, plural=None, separator=' '):

    """Wrap data like hybriddict(), but also supports old-style list template

    This exists for backward compatibility with the old-style template. Use

    hybriddict() for new template keywords.

    """

    c = [{key: k, value: v} for k, v in data.iteritems()]

    f = _showcompatlist(context, mapping, name, c, plural, separator)

    return hybriddict(data, key=key, value=value, fmt=fmt, gen=f)

def compatlist(context, mapping, name, data, element=None, fmt=None,

               plural=None, separator=' '):

    """Wrap data like hybridlist(), but also supports old-style list template

    This exists for backward compatibility with the old-style template. Use

    hybridlist() for new template keywords.

    """

    f = _showcompatlist(context, mapping, name, data, plural, separator)

    return hybridlist(data, name=element or name, fmt=fmt, gen=f)

def _showcompatlist(context, mapping, name, values, plural=None, separator=' '):

    """Return a generator that renders old-style list template

    name is name of key in template map.

    values is list of strings or dicts.

    plural is plural of name, if not simply name + 's'.

    separator is used to join values as a string

    expansion works like this, given name 'foo'.

    if values is empty, expand 'no_foos'.

    if 'foo' not in template map, return values as a string,

    joined by 'separator'.

    expand 'start_foos'.

    for each value, expand 'foo'. if 'last_foo' in template

    map, expand it instead of 'foo' for last key.

    expand 'end_foos'.

    """

    if not plural:

        plural = name + 's'

    if not values:

        noname = 'no_' + plural

        if context.preload(noname):

            yield context.process(noname, mapping)

        return

    if not context.preload(name):

        if isinstance(values[0], bytes):

            yield separator.join(values)

        else:

            for v in values:

                r = dict(v)

                r.update(mapping)

                yield r

        return

    startname = 'start_' + plural

    if context.preload(startname):

        yield context.process(startname, mapping)

    def one(v, tag=name):

        vmapping = {}

        try:

            vmapping.update(v)

        # Python 2 raises ValueError if the type of v is wrong. Python

        # 3 raises TypeError.

        except (AttributeError, TypeError, ValueError):

            try:

                # Python 2 raises ValueError trying to destructure an e.g.

                # bytes. Python 3 raises TypeError.

                for a, b in v:

                    vmapping[a] = b

            except (TypeError, ValueError):

                vmapping[name] = v

        vmapping = context.overlaymap(mapping, vmapping)

        return context.process(tag, vmapping)

    lastname = 'last_' + name

    if context.preload(lastname):

        last = values.pop()

    else:

        last = None