# 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, 'repo')

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

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

    cachename = 'latesttags'

    if pattern is not None:

        cachename += '-' + 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, ['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 and renamed[0]

                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:

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

            return renamed and renamed[0]

        except error.LookupError:

            return None

    return getrenamed

def getlogcolumns():

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

    _ = pycompat.identity  # temporarily disable gettext

    # i18n: column positioning for "hg log"

    columns = _('bookmark:    %s\n'

                'branch:      %s\n'

                'changeset:   %s\n'

                'copies:      %s\n'

                'date:        %s\n'

                'extra:       %s=%s\n'

                'files+:      %s\n'

                'files-:      %s\n'

                'files:       %s\n'

                'instability: %s\n'

                'manifest:    %s\n'

                'obsolete:    %s\n'

                'parent:      %s\n'

                'phase:       %s\n'

                'summary:     %s\n'

                'tag:         %s\n'

                'user:        %s\n')

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

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

# basic internal templates

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

# default templates internally used for rendering of lists

defaulttempl = {

    'parent': _changeidtmpl + ' ',

    'manifest': _changeidtmpl,

    '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 (see registrar.templatekeyword for details)

keywords = {}

templatekeyword = registrar.templatekeyword(keywords)

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

def showauthor(context, mapping):

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

    return showuser(context, mapping)

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

def showbisect(context, mapping):

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

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

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

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

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

def showbranch(context, mapping):

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

    committed.

    """

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

    return ctx.branch()

@templatekeyword('branches', requires={'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, 'ctx')

    branch = ctx.branch()

    if branch != 'default':

        return compatlist(context, mapping, 'branch', [branch],

                          plural='branches')

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

@templatekeyword('bookmarks', requires={'repo', '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, 'repo')

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

    bookmarks = ctx.bookmarks()

    active = repo._activebookmark

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

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

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

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

def showchildren(context, mapping):

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

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

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

    return compatlist(context, mapping, 'children', childrevs, element='child')

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

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

def showcurrentbookmark(context, mapping):

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

    (DEPRECATED)"""

    return showactivebookmark(context, mapping)

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

def showactivebookmark(context, mapping):

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

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

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

    active = repo._activebookmark

    if active and active in ctx.bookmarks():

        return active

    return ''

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

def showdate(context, mapping):

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

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

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

    # python-hglib splits date at decimal separator.

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

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

def showdescription(context, mapping):

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

    ctx = context.resource(mapping, '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('diffstat', requires={'ui', 'ctx'})

def showdiffstat(context, mapping):

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

    "modified files: +added/-removed lines"

    """

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

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

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

    diff = ctx.diff(opts=diffopts)

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

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

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

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

def showenvvars(context, mapping):

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

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

    env = ui.exportableenviron()

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

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

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

def showextras(context, mapping):

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

    field of this changeset."""

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

    extras = ctx.extra()

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

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

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

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

    return _hybrid(f, extras, makemap,

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

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

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

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

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

        stat = ctx.p1().status(ctx, listignored=listall, listclean=listall,

                               listunknown=listall)

        revcache['filestatus'] = stat

        revcache['filestatusall'] = listall

    return revcache['filestatus']

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

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

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

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

        revcache['filestatusmap'] = statmap = {}

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

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

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

def _showfilesbystat(context, mapping, name, index):

    stat = _getfilestatus(context, mapping)

    files = stat[index]

    return templateutil.compatfileslist(context, mapping, name, files)

@templatekeyword('file_adds', requires={'ctx', 'revcache'})

def showfileadds(context, mapping):

    """List of strings. Files added by this changeset."""

    return _showfilesbystat(context, mapping, 'file_add', 1)

@templatekeyword('file_copies',

                 requires={'repo', 'ctx', 'cache', 'revcache'})

def showfilecopies(context, mapping):

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

    their sources.

    """

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

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

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

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

    if copies is None:

        if 'getrenamed' not in cache:

            cache['getrenamed'] = getrenamedfn(repo)

        copies = []

        getrenamed = cache['getrenamed']

        for fn in ctx.files():

            rename = getrenamed(fn, ctx.rev())

            if rename:

                copies.append((fn, rename))

    return templateutil.compatfilecopiesdict(context, mapping, '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('file_copies_switch', requires={'revcache'})

def showfilecopiesswitch(context, mapping):

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

    only if the --copied switch is set.

    """

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