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

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

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

keywords = {}

templatekeyword = registrar.templatekeyword(keywords)

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

def showauthor(context, mapping):

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

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

    return ctx.user()

@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={'ctx'})

def showdiffstat(context, mapping):

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

    "modified files: +added/-removed lines"

    """

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

    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 _showfilesbystat(context, mapping, name, index):

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

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

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

    if 'files' not in revcache:

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

    files = revcache['files'][index]

    return compatlist(context, mapping, name, files, element='file')

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

    copies = util.sortdict(copies)

    return compatdict(context, mapping, 'file_copy', copies,

                      key='name', value='source', fmt='%s (%s)',

                      plural='file_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 []

    copies = util.sortdict(copies)

    return compatdict(context, mapping, 'file_copy', copies,

                      key='name', value='source', fmt='%s (%s)',

                      plural='file_copies')

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

def showfiledels(context, mapping):

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

    return _showfilesbystat(context, mapping, 'file_del', 2)

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

def showfilemods(context, mapping):

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

    return _showfilesbystat(context, mapping, 'file_mod', 0)

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

def showfiles(context, mapping):

    """List of strings. All files modified, added, or removed by this

    changeset.

    """

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

    return compatlist(context, mapping, 'file', ctx.files())

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

def showgraphnode(context, mapping):

    """String. The character representing the changeset node in an ASCII

    revision graph."""

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

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

    return getgraphnode(repo, ctx)

def getgraphnode(repo, ctx):

    return getgraphnodecurrent(repo, ctx) or getgraphnodesymbol(ctx)

def getgraphnodecurrent(repo, ctx):

    wpnodes = repo.dirstate.parents()

    if wpnodes[1] == nullid:

        wpnodes = wpnodes[:1]

    if ctx.node() in wpnodes:

        return '@'

    else:

        return ''

def getgraphnodesymbol(ctx):

    if ctx.obsolete():

        return 'x'

    elif ctx.isunstable():

        return '*'

    elif ctx.closesbranch():

        return '_'

    else:

        return 'o'

@templatekeyword('graphwidth', requires=())

def showgraphwidth(context, mapping):

    """Integer. The width of the graph drawn by 'log --graph' or zero."""

    # just hosts documentation; should be overridden by template mapping

    return 0

@templatekeyword('index', requires=())

def showindex(context, mapping):

    """Integer. The current iteration of the loop. (0 indexed)"""

    # just hosts documentation; should be overridden by template mapping

    raise error.Abort(_("can't use index in this context"))

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

def showlatesttag(context, mapping):

    """List of strings. The global tags on the most recent globally

    tagged ancestor of this changeset.  If no such tags exist, the list

    consists of the single string "null".

    """

    return showlatesttags(context, mapping, None)

def showlatesttags(context, mapping, pattern):

    """helper method for the latesttag keyword and function"""

    latesttags = getlatesttags(context, mapping, pattern)

    # latesttag[0] is an implementation detail for sorting csets on different

    # branches in a stable manner- it is the date the tagged cset was created,

    # not the date the tag was created.  Therefore it isn't made visible here.

    makemap = lambda v: {

        'changes': _showchangessincetag,

        'distance': latesttags[1],

        'latesttag': v,   # BC with {latesttag % '{latesttag}'}

        'tag': v

    }

    tags = latesttags[2]

    f = _showcompatlist(context, mapping, 'latesttag', tags, separator=':')

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

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

def showlatesttagdistance(context, mapping):

    """Integer. Longest path to the latest tag."""

    return getlatesttags(context, mapping)[1]

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

def showchangessincelatesttag(context, mapping):

    """Integer. All ancestors not in the latest tag."""

    tag = getlatesttags(context, mapping)[2][0]

    mapping = context.overlaymap(mapping, {'tag': tag})

    return _showchangessincetag(context, mapping)

def _showchangessincetag(context, mapping):

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

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

    offset = 0

    revs = [ctx.rev()]

    tag = context.symbol(mapping, 'tag')

    # The only() revset doesn't currently support wdir()

    if ctx.rev() is None:

        offset = 1

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

    return len(repo.revs('only(%ld, %s)', revs, tag)) + offset

# teach templater latesttags.changes is switched to (context, mapping) API

_showchangessincetag._requires = {'repo', 'ctx'}

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

def showmanifest(context, mapping):

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

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

    mnode = ctx.manifestnode()

    if mnode is None:

        # just avoid crash, we might want to use the 'ff...' hash in future

        return

    mrev = repo.manifestlog._revlog.rev(mnode)

    mhex = hex(mnode)

    mapping = context.overlaymap(mapping, {'rev': mrev, 'node': mhex})

    f = context.process('manifest', mapping)

    # TODO: perhaps 'ctx' should be dropped from mapping because manifest

    # rev and node are completely different from changeset's.

    return templateutil.hybriditem(f, None, f,

                                   lambda x: {'rev': mrev, 'node': mhex})

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

def showobsfate(context, mapping):

    # this function returns a list containing pre-formatted obsfate strings.

    #

    # This function will be replaced by templates fragments when we will have