mercurial/templateutil.py

37272:7d3bc1d4e871

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

from .i18n import _
from . import (
    error,

    pass

class TemplateNotFound(error.Abort):
    pass

# 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(object):
    """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)

            yield self.joinfmt(x)
    def itermaps(self):
        makemap = self._makemap
        for x in self._values:
            yield makemap(x)
    def __contains__(self, x):
        return x in self._values
    def __getitem__(self, key):
        return self._values[key]
    def __len__(self):

        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(object):
    """Wrapper for non-list/dict object to support map operation

    This class allows us to handle both:
    - "{manifest}"
    - "{manifest % '{rev}:{node}'}"

    def tomap(self):
        return self._makemap(self._key)

    def itermaps(self):
        yield self.tomap()

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:

    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"""
    gen = getattr(thing, 'gen', None)
    if gen is None:
        return thing
    if callable(gen):
        return gen()
    return gen

def unwrapvalue(thing):
    """Move the inner value object out of the wrapper"""
    if not util.safehasattr(thing, '_value'):
        return thing

37273:83e1bbd48991

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

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

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

            yield self.joinfmt(x)
    def itermaps(self):
        makemap = self._makemap
        for x in self._values:
            yield makemap(x)

    def show(self, context, mapping):
        # TODO: switch gen to (context, mapping) API?
        gen = self.gen
        if callable(gen):
            return gen()
        return gen

    def __contains__(self, x):
        return x in self._values
    def __getitem__(self, key):
        return self._values[key]
    def __len__(self):

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

    def tomap(self):
        return self._makemap(self._key)

    def itermaps(self):
        yield self.tomap()

    def show(self, context, mapping):
        # TODO: switch gen to (context, mapping) API?
        gen = self.gen
        if callable(gen):
            return gen()
        return gen

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:

    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 unwrapvalue(thing):
    """Move the inner value object out of the wrapper"""
    if not util.safehasattr(thing, '_value'):
        return thing