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

    wdirid,

    wdirrev,

)

from . import (

    diffutil,

    encoding,

    error,

    hbisect,

    i18n,

    obsutil,

    patch,

    pycompat,

    registrar,

    scmutil,

    templateutil,

    util,

)

from .utils import stringutil

_hybrid = templateutil.hybrid

hybriddict = templateutil.hybriddict

hybridlist = templateutil.hybridlist

compatdict = templateutil.compatdict

compatlist = templateutil.compatlist

_showcompatlist = templateutil._showcompatlist

def getlatesttags(context, mapping, pattern=None):

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

    repo = context.resource(mapping, b'repo')

    ctx = context.resource(mapping, b'ctx')

    cache = context.resource(mapping, b'cache')

    cachename = b'latesttags'

    if pattern is not None:

        cachename += b'-' + pattern

        match = stringutil.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, [b'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) != b'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):

                        tag = x[2][0]

                        if ctx.rev() is None:

                            # only() doesn't support wdir

                            prevs = [c.rev() for c in ctx.parents()]

                            changes = repo.revs(b'only(%ld, %s)', prevs, tag)

                            changessincetag = len(changes) + 1

                        else:

                            changes = repo.revs(b'only(%d, %s)', ctx.rev(), tag)

                            changessincetag = len(changes)

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

    """Return a dict of log column labels"""

    _ = pycompat.identity  # temporarily disable gettext

    # i18n: column positioning for "hg log"

    columns = _(

        b'bookmark:    %s\n'

        b'branch:      %s\n'

        b'changeset:   %s\n'

        b'copies:      %s\n'

        b'date:        %s\n'

        b'extra:       %s=%s\n'

        b'files+:      %s\n'

        b'files-:      %s\n'

        b'files:       %s\n'

        b'instability: %s\n'

        b'manifest:    %s\n'

        b'obsolete:    %s\n'

        b'parent:      %s\n'

        b'phase:       %s\n'

        b'summary:     %s\n'

        b'tag:         %s\n'

        b'user:        %s\n'

    )

    return dict(

        zip(

            [s.split(b':', 1)[0] for s in columns.splitlines()],

            i18n._(columns).splitlines(True),

        )

    )

# basic internal templates

_changeidtmpl = b'{rev}:{node|formatnode}'

# default templates internally used for rendering of lists

defaulttempl = {

    b'parent': _changeidtmpl + b' ',

    b'manifest': _changeidtmpl,

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

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

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

}

# filecopy is preserved for compatibility reasons

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

# keywords are callables (see registrar.templatekeyword for details)

keywords = {}

templatekeyword = registrar.templatekeyword(keywords)

@templatekeyword(b'author', requires={b'ctx'})

def showauthor(context, mapping):

    """Alias for ``{user}``"""

    return showuser(context, mapping)

@templatekeyword(b'bisect', requires={b'repo', b'ctx'})

def showbisect(context, mapping):

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

    repo = context.resource(mapping, b'repo')

    ctx = context.resource(mapping, b'ctx')

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

@templatekeyword(b'branch', requires={b'ctx'})

def showbranch(context, mapping):

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

    committed.

    """

    ctx = context.resource(mapping, b'ctx')

    return ctx.branch()

@templatekeyword(b'branches', requires={b'ctx'})

def showbranches(context, mapping):

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

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

    default. (DEPRECATED)

    """

    ctx = context.resource(mapping, b'ctx')

    branch = ctx.branch()

    if branch != b'default':

        return compatlist(

            context, mapping, b'branch', [branch], plural=b'branches'

        )

    return compatlist(context, mapping, b'branch', [], plural=b'branches')

@templatekeyword(b'bookmarks', requires={b'repo', b'ctx'})

def showbookmarks(context, mapping):

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

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

    """

    repo = context.resource(mapping, b'repo')

    ctx = context.resource(mapping, b'ctx')

    bookmarks = ctx.bookmarks()

    active = repo._activebookmark

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

    f = _showcompatlist(context, mapping, b'bookmark', bookmarks)

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

@templatekeyword(b'children', requires={b'ctx'})

def showchildren(context, mapping):

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

    ctx = context.resource(mapping, b'ctx')

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

    return compatlist(

        context, mapping, b'children', childrevs, element=b'child'

    )

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

@templatekeyword(b'currentbookmark', requires={b'repo', b'ctx'})

def showcurrentbookmark(context, mapping):

    """String. The active bookmark, if it is associated with the changeset.

    (DEPRECATED)"""

    return showactivebookmark(context, mapping)

@templatekeyword(b'activebookmark', requires={b'repo', b'ctx'})

def showactivebookmark(context, mapping):

    """String. The active bookmark, if it is associated with the changeset."""

    repo = context.resource(mapping, b'repo')

    ctx = context.resource(mapping, b'ctx')

    active = repo._activebookmark

    if active and active in ctx.bookmarks():

        return active

    return b''

@templatekeyword(b'date', requires={b'ctx'})

def showdate(context, mapping):

    """Date information. The date when the changeset was committed."""

    ctx = context.resource(mapping, b'ctx')

    # the default string format is '<float(unixtime)><tzoffset>' because

    # python-hglib splits date at decimal separator.

    return templateutil.date(ctx.date(), showfmt=b'%d.0%d')

@templatekeyword(b'desc', requires={b'ctx'})

def showdescription(context, mapping):

    """String. The text of the changeset description."""

    ctx = context.resource(mapping, b'ctx')

    s = ctx.description()

    if isinstance(s, encoding.localstr):

        # try hard to preserve utf-8 bytes

        return encoding.tolocal(encoding.fromlocal(s).strip())

    elif isinstance(s, encoding.safelocalstr):

        return encoding.safelocalstr(s.strip())

    else:

        return s.strip()

@templatekeyword(b'diffstat', requires={b'ui', b'ctx'})

def showdiffstat(context, mapping):

    """String. Statistics of changes with the following format:

    "modified files: +added/-removed lines"

    """

    ui = context.resource(mapping, b'ui')

    ctx = context.resource(mapping, b'ctx')

    diffopts = diffutil.diffallopts(ui, {b'noprefix': False})

    diff = ctx.diff(opts=diffopts)

    stats = patch.diffstatdata(util.iterlines(diff))

    maxname, maxtotal, adds, removes, binary = patch.diffstatsum(stats)

    return b'%d: +%d/-%d' % (len(stats), adds, removes)

@templatekeyword(b'envvars', requires={b'ui'})

def showenvvars(context, mapping):

    """A dictionary of environment variables. (EXPERIMENTAL)"""

    ui = context.resource(mapping, b'ui')

    env = ui.exportableenviron()

    env = util.sortdict((k, env[k]) for k in sorted(env))

    return compatdict(context, mapping, b'envvar', env, plural=b'envvars')

@templatekeyword(b'extras', requires={b'ctx'})

def showextras(context, mapping):

    """List of dicts with key, value entries of the 'extras'

    field of this changeset."""

    ctx = context.resource(mapping, b'ctx')

    extras = ctx.extra()

    extras = util.sortdict((k, extras[k]) for k in sorted(extras))

    makemap = lambda k: {b'key': k, b'value': extras[k]}

    c = [makemap(k) for k in extras]

    f = _showcompatlist(context, mapping, b'extra', c, plural=b'extras')

    return _hybrid(

        f,

        extras,

        makemap,

        lambda k: b'%s=%s' % (k, stringutil.escapestr(extras[k])),

    )

def _getfilestatus(context, mapping, listall=False):

    ctx = context.resource(mapping, b'ctx')

    revcache = context.resource(mapping, b'revcache')

    if b'filestatus' not in revcache or revcache[b'filestatusall'] < listall:

        stat = ctx.p1().status(

            ctx, listignored=listall, listclean=listall, listunknown=listall

        )

        revcache[b'filestatus'] = stat

        revcache[b'filestatusall'] = listall

    return revcache[b'filestatus']

def _getfilestatusmap(context, mapping, listall=False):

    revcache = context.resource(mapping, b'revcache')

    if b'filestatusmap' not in revcache or revcache[b'filestatusall'] < listall:

        stat = _getfilestatus(context, mapping, listall=listall)

        revcache[b'filestatusmap'] = statmap = {}

        for char, files in zip(pycompat.iterbytestr(b'MAR!?IC'), stat):

            statmap.update((f, char) for f in files)

    return revcache[b'filestatusmap']  # {path: statchar}

@templatekeyword(

    b'file_copies', requires={b'repo', b'ctx', b'cache', b'revcache'}

)

def showfilecopies(context, mapping):

    """List of strings. Files copied in this changeset with

    their sources.

    """

    repo = context.resource(mapping, b'repo')

    ctx = context.resource(mapping, b'ctx')

    cache = context.resource(mapping, b'cache')

    copies = context.resource(mapping, b'revcache').get(b'copies')

    if copies is None:

        if b'getcopies' not in cache:

            cache[b'getcopies'] = scmutil.getcopiesfn(repo)

        getcopies = cache[b'getcopies']

        copies = getcopies(ctx)

    return templateutil.compatfilecopiesdict(

        context, mapping, b'file_copy', copies

    )

# showfilecopiesswitch() displays file copies only if copy records are

# provided before calling the templater, usually with a --copies

# command line switch.

@templatekeyword(b'file_copies_switch', requires={b'revcache'})

def showfilecopiesswitch(context, mapping):

    """List of strings. Like "file_copies" but displayed

    only if the --copied switch is set.

    """

    copies = context.resource(mapping, b'revcache').get(b'copies') or []