# 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

    """

    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod

    def contains(self, context, mapping, item):

        """Test if the specified item is in self

        The item argument may be a wrapped object.

        """

    @abc.abstractmethod

    def getmember(self, context, mapping, key):

        """Return a member item for the specified key

        The key argument may be a wrapped object.

        A returned object may be either a wrapped object or a pure value

        depending on the self type.

        """

    @abc.abstractmethod

    def getmin(self, context, mapping):

        """Return the smallest item, which may be either a wrapped or a pure

        value depending on the self type"""

    @abc.abstractmethod

    def getmax(self, context, mapping):

        """Return the largest item, which may be either a wrapped or a pure

        value depending on the self type"""

    @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().

        """

class wrappedbytes(wrapped):

    """Wrapper for byte string"""

    def __init__(self, value):

        self._value = value

    def contains(self, context, mapping, item):

        item = stringify(context, mapping, item)

        return item in self._value

    def getmember(self, context, mapping, key):

        raise error.ParseError(_('%r is not a dictionary')

                               % pycompat.bytestr(self._value))

    def getmin(self, context, mapping):

        return self._getby(context, mapping, min)

    def getmax(self, context, mapping):

        return self._getby(context, mapping, max)

    def _getby(self, context, mapping, func):

        if not self._value:

            raise error.ParseError(_('empty string'))

        return func(pycompat.iterbytestr(self._value))

    def itermaps(self, context):

        raise error.ParseError(_('%r is not iterable of mappings')

                               % pycompat.bytestr(self._value))

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

        return joinitems(pycompat.iterbytestr(self._value), sep)

    def show(self, context, mapping):

        return self._value

    def tovalue(self, context, mapping):

        return self._value

class wrappedvalue(wrapped):

    """Generic wrapper for pure non-list/dict/bytes value"""

    def __init__(self, value):

        self._value = value

    def contains(self, context, mapping, item):

        raise error.ParseError(_("%r is not iterable") % self._value)

    def getmember(self, context, mapping, key):

        raise error.ParseError(_('%r is not a dictionary') % self._value)

    def getmin(self, context, mapping):

        raise error.ParseError(_("%r is not iterable") % self._value)

    def getmax(self, context, mapping):

        raise error.ParseError(_("%r is not iterable") % self._value)

    def itermaps(self, context):

        raise error.ParseError(_('%r is not iterable of mappings')

                               % self._value)

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

        raise error.ParseError(_('%r is not iterable') % self._value)

    def show(self, context, mapping):

        return pycompat.bytestr(self._value)

    def tovalue(self, context, mapping):

        return self._value

# 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 contains(self, context, mapping, item):

        item = unwrapastype(context, mapping, item, self._keytype)

        return item in self._values

    def getmember(self, context, mapping, key):

        # TODO: maybe split hybrid list/dict types?

        if not util.safehasattr(self._values, 'get'):

            raise error.ParseError(_('not a dictionary'))

        key = unwrapastype(context, mapping, key, self._keytype)

        return self._wrapvalue(key, self._values.get(key))

    def getmin(self, context, mapping):

        return self._getby(context, mapping, min)

    def getmax(self, context, mapping):

        return self._getby(context, mapping, max)

    def _getby(self, context, mapping, func):

        if not self._values:

            raise error.ParseError(_('empty sequence'))

        val = func(self._values)

        return self._wrapvalue(val, val)

    def _wrapvalue(self, key, val):

        if val is None:

            return

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

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

            return val

        return mappable(None, key, val, self._makemap)

    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: make it non-recursive for trivial lists/dicts

        xs = self._values

        if util.safehasattr(xs, 'get'):

            return {k: unwrapvalue(context, mapping, v)

                    for k, v in xs.iteritems()}

        return [unwrapvalue(context, mapping, x) for x in xs]

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}"

    """

    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 contains(self, context, mapping, item):

        w = makewrapped(context, mapping, self._value)

        return w.contains(context, mapping, item)

    def getmember(self, context, mapping, key):

        w = makewrapped(context, mapping, self._value)

        return w.getmember(context, mapping, key)

    def getmin(self, context, mapping):

        w = makewrapped(context, mapping, self._value)

        return w.getmin(context, mapping)

    def getmax(self, context, mapping):

        w = makewrapped(context, mapping, self._value)

        return w.getmax(context, mapping)

    def itermaps(self, context):

        yield self.tomap()

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

        w = makewrapped(context, mapping, self._value)

        return w.join(context, mapping, sep)

    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 contains(self, context, mapping, item):

        raise error.ParseError(_('not comparable'))

    def getmember(self, context, mapping, key):

        raise error.ParseError(_('not a dictionary'))

    def getmin(self, context, mapping):

        raise error.ParseError(_('not comparable'))

    def getmax(self, context, mapping):

        raise error.ParseError(_('not comparable'))

    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