# templatekw.py - common changeset template keywords

#

# Copyright 2005-2009 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

from .i18n import _

from .node import (

    hex,

    nullid,

)

from . import (

    encoding,

    error,

    hbisect,

    obsutil,

    patch,

    pycompat,

    registrar,

    scmutil,

    util,

)

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)

    and to access raw values:

    - "{ifcontains(file, files, ...)}", "{ifcontains(key, extras, ...)}"

    - "{get(extras, key)}"

    - "{files|json}"

    """

    def __init__(self, gen, values, makemap, joinfmt):

        if gen is not None:

            self.gen = gen  # generator or function returning generator

        self._values = values

        self._makemap = makemap

        self.joinfmt = joinfmt

    def gen(self):

        """Default generator to stringify this as {join(self, ' ')}"""

        for i, x in enumerate(self._values):

            if i > 0:

                yield ' '

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

        return len(self._values)

    def __iter__(self):

        return iter(self._values)

    def __getattr__(self, name):

        if name not in ('get', 'items', 'iteritems', 'iterkeys', 'itervalues',

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

    - "{manifest.rev}"

    Unlike a _hybrid, this does not simulate the behavior of the underling

    value. Use unwrapvalue() or unwraphybrid() to obtain the inner object.

    """

    def __init__(self, gen, key, value, makemap):

        if gen is not None:

            self.gen = gen  # generator or function returning generator

        self._key = key

        self._value = value  # may be generator of strings

        self._makemap = makemap

    def gen(self):

        yield pycompat.bytestr(self._value)

    def tomap(self):

        return self._makemap(self._key)

    def itermaps(self):

        yield self.tomap()

def hybriddict(data, key='key', value='value', fmt='%s=%s', gen=None):

    """Wrap data to support both dict-like and string-like operations"""

    return _hybrid(gen, data, lambda k: {key: k, value: data[k]},

                   lambda k: fmt % (k, data[k]))

def hybridlist(data, name, fmt='%s', gen=None):

    """Wrap data to support both list-like and string-like operations"""

    return _hybrid(gen, data, lambda x: {name: x}, lambda x: fmt % x)

def unwraphybrid(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

    return thing._value

def wraphybridvalue(container, key, value):

    """Wrap an element of hybrid container to be mappable

    The key is passed to the makemap function of the given container, which

    should be an item generated by iter(container).

    """

    makemap = getattr(container, '_makemap', None)

    if makemap is None:

        return value

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

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

        return value

    return _mappable(None, key, value, makemap)

def showdict(name, data, mapping, plural=None, key='key', value='value',

             fmt='%s=%s', separator=' '):

    c = [{key: k, value: v} for k, v in data.iteritems()]

    f = _showlist(name, c, mapping, plural, separator)

    return hybriddict(data, key=key, value=value, fmt=fmt, gen=f)

def showlist(name, values, mapping, plural=None, element=None, separator=' '):

    if not element:

        element = name

    f = _showlist(name, values, mapping, plural, separator)

    return hybridlist(values, name=element, gen=f)

def _showlist(name, values, mapping, plural=None, separator=' '):

    '''expand set of values.

    name is name of key in template map.

    values is list of strings or dicts.

    plural is plural of name, if not simply name + 's'.

    separator is used to join values as a string

    expansion works like this, given name 'foo'.

    if values is empty, expand 'no_foos'.

    if 'foo' not in template map, return values as a string,

    joined by 'separator'.

    expand 'start_foos'.

    for each value, expand 'foo'. if 'last_foo' in template

    map, expand it instead of 'foo' for last key.

    expand 'end_foos'.

    '''

    templ = mapping['templ']

    strmapping = pycompat.strkwargs(mapping)

    if not plural:

        plural = name + 's'

    if not values:

        noname = 'no_' + plural

        if noname in templ:

            yield templ(noname, **strmapping)

        return

    if name not in templ:

        if isinstance(values[0], bytes):

            yield separator.join(values)

        else:

            for v in values:

                yield dict(v, **strmapping)

        return

    startname = 'start_' + plural

    if startname in templ:

        yield templ(startname, **strmapping)

    vmapping = mapping.copy()

    def one(v, tag=name):

        try:

            vmapping.update(v)

        except (AttributeError, ValueError):

            try:

                for a, b in v:

                    vmapping[a] = b

            except ValueError:

                vmapping[name] = v

        return templ(tag, **pycompat.strkwargs(vmapping))

    lastname = 'last_' + name

    if lastname in templ:

        last = values.pop()

    else:

        last = None

    for v in values:

        yield one(v)

    if last is not None:

        yield one(last, tag=lastname)

    endname = 'end_' + plural

    if endname in templ:

        yield templ(endname, **strmapping)

def getfiles(repo, ctx, revcache):

    if 'files' not in revcache:

        revcache['files'] = repo.status(ctx.p1(), ctx)[:3]

    return revcache['files']

def getlatesttags(repo, ctx, cache, pattern=None):

    '''return date, distance and name for the latest tag of rev'''

    cachename = 'latesttags'

    if pattern is not None:

        cachename += '-' + pattern

        match = util.stringmatcher(pattern)[2]

    else:

        match = util.always

    if cachename not in cache:

        # Cache mapping from rev to a tuple with tag date, tag

        # distance and tag name

        cache[cachename] = {-1: (0, 0, ['null'])}

    latesttags = cache[cachename]

    rev = ctx.rev()

    todo = [rev]

    while todo:

        rev = todo.pop()

        if rev in latesttags:

            continue

        ctx = repo[rev]

        tags = [t for t in ctx.tags()

                if (repo.tagtype(t) and repo.tagtype(t) != 'local'

                    and match(t))]

        if tags:

            latesttags[rev] = ctx.date()[0], 0, [t for t in sorted(tags)]

            continue

        try:

            ptags = [latesttags[p.rev()] for p in ctx.parents()]

            if len(ptags) > 1:

                if ptags[0][2] == ptags[1][2]:

                    # The tuples are laid out so the right one can be found by

                    # comparison in this case.

                    pdate, pdist, ptag = max(ptags)

                else:

                    def key(x):

                        changessincetag = len(repo.revs('only(%d, %s)',

                                                        ctx.rev(), x[2][0]))

                        # Smallest number of changes since tag wins. Date is

                        # used as tiebreaker.

                        return [-changessincetag, x[0]]

                    pdate, pdist, ptag = max(ptags, key=key)

            else:

                pdate, pdist, ptag = ptags[0]

        except KeyError:

            # Cache miss - recurse

            todo.append(rev)

            todo.extend(p.rev() for p in ctx.parents())

            continue

        latesttags[rev] = pdate, pdist + 1, ptag

    return latesttags[rev]

def getrenamedfn(repo, endrev=None):

    rcache = {}

    if endrev is None:

        endrev = len(repo)

    def getrenamed(fn, rev):

        '''looks up all renames for a file (up to endrev) the first

        time the file is given. It indexes on the changerev and only

        parses the manifest if linkrev != changerev.

        Returns rename info for fn at changerev rev.'''

        if fn not in rcache:

            rcache[fn] = {}

            fl = repo.file(fn)

            for i in fl:

                lr = fl.linkrev(i)

                renamed = fl.renamed(fl.node(i))

                rcache[fn][lr] = renamed

                if lr >= endrev:

                    break

        if rev in rcache[fn]:

            return rcache[fn][rev]

        # If linkrev != rev (i.e. rev not found in rcache) fallback to

        # filectx logic.

        try:

            return repo[rev][fn].renamed()

        except error.LookupError:

            return None

    return getrenamed

# default templates internally used for rendering of lists

defaulttempl = {

    'parent': '{rev}:{node|formatnode} ',

    'manifest': '{rev}:{node|formatnode}',

    'file_copy': '{name} ({source})',

    'envvar': '{key}={value}',

    'extra': '{key}={value|stringescape}'

}

# filecopy is preserved for compatibility reasons

defaulttempl['filecopy'] = defaulttempl['file_copy']

# keywords are callables like:

# fn(repo, ctx, templ, cache, revcache, **args)

# with:

# repo - current repository instance

# ctx - the changectx being displayed

# templ - the templater instance

# cache - a cache dictionary for the whole templater run

# revcache - a cache dictionary for the current revision

keywords = {}

templatekeyword = registrar.templatekeyword(keywords)

@templatekeyword('author')

def showauthor(repo, ctx, templ, **args):

    """String. The unmodified author of the changeset."""

    return ctx.user()

@templatekeyword('bisect')

def showbisect(repo, ctx, templ, **args):

    """String. The changeset bisection status."""

    return hbisect.label(repo, ctx.node())

@templatekeyword('branch')

def showbranch(**args):

    """String. The name of the branch on which the changeset was

    committed.

    """

    return args[r'ctx'].branch()

@templatekeyword('branches')

def showbranches(**args):

    """List of strings. The name of the branch on which the

    changeset was committed. Will be empty if the branch name was

    default. (DEPRECATED)

    """

    args = pycompat.byteskwargs(args)

    branch = args['ctx'].branch()

    if branch != 'default':

        return showlist('branch', [branch], args, plural='branches')

    return showlist('branch', [], args, plural='branches')

@templatekeyword('bookmarks')

def showbookmarks(**args):

    """List of strings. Any bookmarks associated with the

    changeset. Also sets 'active', the name of the active bookmark.

    """

    args = pycompat.byteskwargs(args)

    repo = args['ctx']._repo

    bookmarks = args['ctx'].bookmarks()

    active = repo._activebookmark

    makemap = lambda v: {'bookmark': v, 'active': active, 'current': active}

    f = _showlist('bookmark', bookmarks, args)

    return _hybrid(f, bookmarks, makemap, pycompat.identity)

@templatekeyword('children')

def showchildren(**args):

    """List of strings. The children of the changeset."""

    args = pycompat.byteskwargs(args)

    ctx = args['ctx']

    childrevs = ['%d:%s' % (cctx, cctx) for cctx in ctx.children()]

    return showlist('children', childrevs, args, element='child')

# Deprecated, but kept alive for help generation a purpose.