comparison mercurial/templateutil.py @ 38297:8d6109b49b31

templater: introduce a wrapper for date tuple (BC)

Strictly speaking, this is BC, but I believe the original string format
(str(float(unixtime)) + str(int(tzoffset))) was just plain wrong.

38296:e72697893c93

        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:

    a (unixtime, offset) tuple"""
    thing = evalrawexp(context, mapping, arg)
    return unwrapdate(context, mapping, thing, err)

def unwrapdate(context, mapping, thing, err=None):
    thing = unwrapvalue(context, mapping, thing)
    try:
        return dateutil.parsedate(thing)
    except AttributeError:
        raise error.ParseError(err or _('not a date tuple nor a string'))

38297:8d6109b49b31

        return pycompat.bytestr(self._value)

    def tovalue(self, context, mapping):
        return self._value

class date(wrapped):
    """Wrapper for date tuple"""

    def __init__(self, value):
        # value may be (float, int), but public interface shouldn't support
        # floating-point timestamp
        self._unixtime, self._tzoffset = map(int, value)

    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 itermaps(self, context):
        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 '%d %d' % (self._unixtime, self._tzoffset)

    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:

    a (unixtime, offset) tuple"""
    thing = evalrawexp(context, mapping, arg)
    return unwrapdate(context, mapping, thing, err)

def unwrapdate(context, mapping, thing, err=None):
    if isinstance(thing, date):
        return thing.tovalue(context, mapping)
    # TODO: update hgweb to not return bare tuple; then just stringify 'thing'
    thing = unwrapvalue(context, mapping, thing)
    try:
        return dateutil.parsedate(thing)
    except AttributeError:
        raise error.ParseError(err or _('not a date tuple nor a string'))