# templatefilters.py - common template expansion filters

#

# Copyright 2005-2008 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 os

import re

import time

from .i18n import _

from . import (

    encoding,

    error,

    node,

    pycompat,

    registrar,

    templateutil,

    url,

    util,

)

from .utils import (

    cborutil,

    dateutil,

    stringutil,

)

urlerr = util.urlerr

urlreq = util.urlreq

if pycompat.ispy3:

    long = int

# filters are callables like:

#   fn(obj)

# with:

#   obj - object to be filtered (text, date, list and so on)

filters = {}

templatefilter = registrar.templatefilter(filters)

@templatefilter(b'addbreaks', intype=bytes)

def addbreaks(text):

    """Any text. Add an XHTML "<br />" tag before the end of

    every line except the last.

    """

    return text.replace(b'\n', b'<br/>\n')

agescales = [

    (b"year", 3600 * 24 * 365, b'Y'),

    (b"month", 3600 * 24 * 30, b'M'),

    (b"week", 3600 * 24 * 7, b'W'),

    (b"day", 3600 * 24, b'd'),

    (b"hour", 3600, b'h'),

    (b"minute", 60, b'm'),

    (b"second", 1, b's'),

]

@templatefilter(b'age', intype=templateutil.date)

def age(date, abbrev=False):

    """Date. Returns a human-readable date/time difference between the

    given date/time and the current date/time.

    """

    def plural(t, c):

        if c == 1:

            return t

        return t + b"s"

    def fmt(t, c, a):

        if abbrev:

            return b"%d%s" % (c, a)

        return b"%d %s" % (c, plural(t, c))

    now = time.time()

    then = date[0]

    future = False

    if then > now:

        future = True

        delta = max(1, int(then - now))

        if delta > agescales[0][1] * 30:

            return b'in the distant future'

    else:

        delta = max(1, int(now - then))

        if delta > agescales[0][1] * 2:

            return dateutil.shortdate(date)

    for t, s, a in agescales:

        n = delta // s

        if n >= 2 or s == 1:

            if future:

                return b'%s from now' % fmt(t, n, a)

            return b'%s ago' % fmt(t, n, a)

@templatefilter(b'basename', intype=bytes)

def basename(path):

    """Any text. Treats the text as a path, and returns the last

    component of the path after splitting by the path separator.

    For example, "foo/bar/baz" becomes "baz" and "foo/bar//" becomes "".

    """

    return os.path.basename(path)

@templatefilter(b'cbor')

def cbor(obj):

    """Any object. Serializes the object to CBOR bytes."""

    return b''.join(cborutil.streamencode(obj))

@templatefilter(b'commondir')

def commondir(filelist):

    """List of text. Treats each list item as file name with /

    as path separator and returns the longest common directory

    prefix shared by all list items.

    Returns the empty string if no common prefix exists.

    The list items are not normalized, i.e. "foo/../bar" is handled as

    file "bar" in the directory "foo/..". Leading slashes are ignored.

    For example, ["foo/bar/baz", "foo/baz/bar"] becomes "foo" and

    ["foo/bar", "baz"] becomes "".

    """

    def common(a, b):

        if len(a) > len(b):

            a = b[: len(a)]

        elif len(b) > len(a):

            b = b[: len(a)]

        if a == b:

            return a

        for i in pycompat.xrange(len(a)):

            if a[i] != b[i]:

                return a[:i]

        return a

    try:

        if not filelist:

            return b""

        dirlist = [f.lstrip(b'/').split(b'/')[:-1] for f in filelist]

        if len(dirlist) == 1:

            return b'/'.join(dirlist[0])

        a = min(dirlist)

        b = max(dirlist)

        # The common prefix of a and b is shared with all

        # elements of the list since Python sorts lexicographical

        # and [1, x] after [1].

        return b'/'.join(common(a, b))

    except TypeError:

        raise error.ParseError(_(b'argument is not a list of text'))

@templatefilter(b'count')

def count(i):

    """List or text. Returns the length as an integer."""

    try:

        return len(i)

    except TypeError:

        raise error.ParseError(_(b'not countable'))

@templatefilter(b'dirname', intype=bytes)

def dirname(path):

    """Any text. Treats the text as a path, and strips the last

    component of the path after splitting by the path separator.

    """

    return os.path.dirname(path)

@templatefilter(b'domain', intype=bytes)

def domain(author):

    """Any text. Finds the first string that looks like an email

    address, and extracts just the domain component. Example: ``User

    <user@example.com>`` becomes ``example.com``.

    """

    f = author.find(b'@')

    if f == -1:

        return b''

    author = author[f + 1 :]

    f = author.find(b'>')

    if f >= 0:

        author = author[:f]

    return author

@templatefilter(b'email', intype=bytes)

def email(text):

    """Any text. Extracts the first string that looks like an email

    address. Example: ``User <user@example.com>`` becomes

    ``user@example.com``.

    """

    return stringutil.email(text)

@templatefilter(b'escape', intype=bytes)

def escape(text):

    """Any text. Replaces the special XML/XHTML characters "&", "<"

    and ">" with XML entities, and filters out NUL characters.

    """

    return url.escape(text.replace(b'\0', b''), True)

para_re = None

space_re = None

def fill(text, width, initindent=b'', hangindent=b''):

    '''fill many paragraphs with optional indentation.'''

    global para_re, space_re

    if para_re is None:

        para_re = re.compile(b'(\n\n|\n\\s*[-*]\\s*)', re.M)

        space_re = re.compile(br'  +')

    def findparas():

        start = 0

        while True:

            m = para_re.search(text, start)

            if not m:

                uctext = encoding.unifromlocal(text[start:])

                w = len(uctext)

                while w > 0 and uctext[w - 1].isspace():

                    w -= 1

                yield (

                    encoding.unitolocal(uctext[:w]),

                    encoding.unitolocal(uctext[w:]),

                )

                break

            yield text[start : m.start(0)], m.group(1)

            start = m.end(1)

    return b"".join(

        [

            stringutil.wrap(

                space_re.sub(b' ', stringutil.wrap(para, width)),

                width,

                initindent,

                hangindent,

            )

            + rest

            for para, rest in findparas()

        ]

    )

@templatefilter(b'fill68', intype=bytes)

def fill68(text):

    """Any text. Wraps the text to fit in 68 columns."""

    return fill(text, 68)

@templatefilter(b'fill76', intype=bytes)

def fill76(text):

    """Any text. Wraps the text to fit in 76 columns."""

    return fill(text, 76)

@templatefilter(b'firstline', intype=bytes)

def firstline(text):

    """Any text. Returns the first line of text."""

    try:

        return text.splitlines(True)[0].rstrip(b'\r\n')

    except IndexError:

        return b''

@templatefilter(b'hex', intype=bytes)

def hexfilter(text):

    """Any text. Convert a binary Mercurial node identifier into

    its long hexadecimal representation.

    """

    return node.hex(text)

@templatefilter(b'hgdate', intype=templateutil.date)

def hgdate(text):

    """Date. Returns the date as a pair of numbers: "1157407993

    25200" (Unix timestamp, timezone offset).

    """

    return b"%d %d" % text

@templatefilter(b'isodate', intype=templateutil.date)

def isodate(text):

    """Date. Returns the date in ISO 8601 format: "2009-08-18 13:00

    +0200".

    """

    return dateutil.datestr(text, b'%Y-%m-%d %H:%M %1%2')

@templatefilter(b'isodatesec', intype=templateutil.date)

def isodatesec(text):

    """Date. Returns the date in ISO 8601 format, including

    seconds: "2009-08-18 13:00:13 +0200". See also the rfc3339date

    filter.

    """

    return dateutil.datestr(text, b'%Y-%m-%d %H:%M:%S %1%2')

def indent(text, prefix):

    '''indent each non-empty line of text after first with prefix.'''

    lines = text.splitlines()

    num_lines = len(lines)

    endswithnewline = text[-1:] == b'\n'

    def indenter():

        for i in pycompat.xrange(num_lines):

            l = lines[i]

            if i and l.strip():

                yield prefix

            yield l

            if i < num_lines - 1 or endswithnewline:

                yield b'\n'

    return b"".join(indenter())

@templatefilter(b'json')

def json(obj, paranoid=True):

    """Any object. Serializes the object to a JSON formatted text."""

    if obj is None:

        return b'null'

    elif obj is False:

        return b'false'

    elif obj is True:

        return b'true'

    elif isinstance(obj, (int, long, float)):

        return pycompat.bytestr(obj)

    elif isinstance(obj, bytes):

        return b'"%s"' % encoding.jsonescape(obj, paranoid=paranoid)

    elif isinstance(obj, type(u'')):

        raise error.ProgrammingError(

            b'Mercurial only does output with bytes: %r' % obj

        )

    elif util.safehasattr(obj, b'keys'):

        out = [

            b'"%s": %s'

            % (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid))

        ]

        return b'{' + b', '.join(out) + b'}'

    elif util.safehasattr(obj, b'__iter__'):

        out = [json(i, paranoid) for i in obj]

        return b'[' + b', '.join(out) + b']'

    raise error.ProgrammingError(b'cannot encode %r' % obj)

@templatefilter(b'lower', intype=bytes)

def lower(text):

    """Any text. Converts the text to lowercase."""

    return encoding.lower(text)

@templatefilter(b'nonempty', intype=bytes)

def nonempty(text):

    """Any text. Returns '(none)' if the string is empty."""

    return text or b"(none)"

@templatefilter(b'obfuscate', intype=bytes)

def obfuscate(text):

    """Any text. Returns the input text rendered as a sequence of

    XML entities.

    """

    text = pycompat.unicode(

        text, pycompat.sysstr(encoding.encoding), r'replace'

    )

    return b''.join([b'&#%d;' % ord(c) for c in text])

@templatefilter(b'permissions', intype=bytes)

def permissions(flags):

    if b"l" in flags: