# 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() or unwrapastype() to obtain the inner object.

    """

    __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 tobool(self, context, mapping):

        """Return a boolean representation of the inner value"""

    @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 mappable(object):

    """Object which can be converted to a single template mapping"""

    def itermaps(self, context):

        yield self.tomap(context)

    @abc.abstractmethod

    def tomap(self, context):

        """Create a single template mapping representing this"""

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

        return bool(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):

        if self._value is None:

            return b''

        return pycompat.bytestr(self._value)

    def tobool(self, context, mapping):

        if self._value is None:

            return False

        if isinstance(self._value, bool):

            return self._value

        # otherwise evaluate as string, which means 0 is True

        return bool(pycompat.bytestr(self._value))

    def tovalue(self, context, mapping):

        return self._value

class date(mappable, wrapped):

    """Wrapper for date tuple"""

    def __init__(self, value, showfmt='%d %d'):

        # value may be (float, int), but public interface shouldn't support

        # floating-point timestamp

        self._unixtime, self._tzoffset = map(int, value)

        self._showfmt = showfmt

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

        raise error.ParseError(_('date is not iterable'))

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

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

    def getmin(self, context, mapping):

        raise error.ParseError(_('date is not iterable'))

    def getmax(self, context, mapping):

        raise error.ParseError(_('date is not iterable'))

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

        raise error.ParseError(_("date is not iterable"))

    def show(self, context, mapping):

        return self._showfmt % (self._unixtime, self._tzoffset)

    def tomap(self, context):

        return {'unixtime': self._unixtime, 'tzoffset': self._tzoffset}

    def tobool(self, context, mapping):

        return True

    def tovalue(self, context, mapping):

        return (self._unixtime, self._tzoffset)

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 hybriditem(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 tobool(self, context, mapping):

        return bool(self._values)

    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 hybriditem(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, context):

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

        return bool(self.tovalue(context, mapping))

    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):