# keyword.py - $Keyword$ expansion for Mercurial

#

# Copyright 2007, 2008 Christian Ebert <blacktrash@gmx.net>

#

# This software may be used and distributed according to the terms

# of the GNU General Public License, incorporated herein by reference.

#

# $Id$

#

# Keyword expansion hack against the grain of a DSCM

#

# There are many good reasons why this is not needed in a distributed

# SCM, still it may be useful in very small projects based on single

# files (like LaTeX packages), that are mostly addressed to an audience

# not running a version control system.

#

# For in-depth discussion refer to

# <http://www.selenic.com/mercurial/wiki/index.cgi/KeywordPlan>.

#

# Keyword expansion is based on Mercurial's changeset template mappings.

#

# Binary files are not touched.

#

# Setup in hgrc:

#

#   [extensions]

#   # enable extension

#   keyword = /full/path/to/hgkw/keyword.py

#   # or, if script in canonical hgext folder:

#   # hgext.keyword =

#

# Files to act upon/ignore are specified in the [keyword] section.

# Customized keyword template mappings in the [keywordmaps] section.

#

# Run "hg help keyword" and "hg kwdemo" to get info on configuration.

'''keyword expansion in local repositories

This extension expands RCS/CVS-like or self-customized $Keywords$

in tracked text files selected by your configuration.

Keywords are only expanded in local repositories and not stored in

the change history. The mechanism can be regarded as a convenience

for the current user or for archive distribution.

Configuration is done in the [keyword] and [keywordmaps] sections

of hgrc files.

Example:

    [keyword]

    # expand keywords in every python file except those matching "x*"

    **.py =

    x*    = ignore

Note: the more specific you are in your filename patterns

      the less you lose speed in huge repos.

For [keywordmaps] template mapping and expansion demonstration and

control run "hg kwdemo".

An additional date template filter {date|utcdate} is provided.

The default template mappings (view with "hg kwdemo -d") can be replaced

with customized keywords and templates.

Again, run "hg kwdemo" to control the results of your config changes.

Before changing/disabling active keywords, run "hg kwshrink" to avoid

the risk of inadvertedly storing expanded keywords in the change history.

To force expansion after enabling it, or a configuration change, run

"hg kwexpand".

Also, when committing with the record extension or using mq's qrecord, be aware

that keywords cannot be updated. Again, run "hg kwexpand" on the files in

question to update keyword expansions after all changes have been checked in.

Expansions spanning more than one line and incremental expansions,

like CVS' $Log$, are not supported. A keyword template map

"Log = {desc}" expands to the first line of the changeset description.

Caveat: With Mercurial versions prior to 4574925db5c0 "hg import" might

        cause rejects if the patch context contains an active keyword.

        In that case run "hg kwshrink", and then reimport.

        Or, better, use bundle/unbundle to share changes.

'''

from mercurial import commands, cmdutil, context, fancyopts, filelog

from mercurial import localrepo, patch, revlog, templater, util

from mercurial.node import *

from mercurial.i18n import gettext as _

import getopt, os, re, shutil, tempfile, time

commands.optionalrepo += ' kwdemo'

# hg commands that do not act on keywords

nokwcommands = ('add addremove bundle copy export grep identify incoming init'

                ' log outgoing push remove rename rollback tip'

                ' convert email glog')

# hg commands that trigger expansion only when writing to working dir,

# not when reading filelog, and unexpand when reading from working dir

restricted = 'record qfold qimport qnew qpush qrefresh qrecord'

def utcdate(date):

    '''Returns hgdate in cvs-like UTC format.'''

    return time.strftime('%Y/%m/%d %H:%M:%S', time.gmtime(date[0]))

# make keyword tools accessible

kwx = { 'templater': None, 'hgcmd': None }

# monkeypatches and backwards compatibility hacks

try:

    # cmdutil.parse moves to dispatch._parse in 18a9fbb5cd78

    from mercurial import dispatch

    _dispatch_parse = dispatch._parse

except ImportError:

    try:

        # commands.parse moves to cmdutil.parse in 0c61124ad877

        _dispatch_parse = cmdutil.parse

    except AttributeError:

        _dispatch_parse = commands.parse

def _kwdispatch_parse(ui, args):

    '''Monkeypatch dispatch._parse to obtain running hg command.'''

    cmd, func, args, options, cmdoptions = _dispatch_parse(ui, args)

    kwx['hgcmd'] = cmd

    return cmd, func, args, options, cmdoptions

try:

    setattr(dispatch, '_parse', _kwdispatch_parse)

except (NameError, ImportError):

    # 0.9.4 needs ImportError

    if hasattr(cmdutil, 'parse'):

        cmdutil.parse = _kwdispatch_parse

    else:

        commands.parse = _kwdispatch_parse

try:

    # avoid spurious rejects if patchfile is available

    _patchfile_init = patch.patchfile.__init__

    def _kwpatchfile_init(self, ui, fname, missing=False):

        '''Monkeypatch/wrap patch.patchfile.__init__ to avoid

        rejects or conflicts due to expanded keywords in working dir.'''

        try:

            _patchfile_init(self, ui, fname, missing=missing)

        except TypeError:

            # "missing" arg added in e90e72c6b4c7

            _patchfile_init(self, ui, fname)

        self.lines = kwx['templater'].shrinklines(self.fname, self.lines)

except AttributeError:

    pass

_patch_diff = patch.diff

def _kw_diff(repo, node1=None, node2=None, files=None, match=util.always,

             fp=None, changes=None, opts=None):

    # only expand if comparing against working dir

    if node2 is not None:

        kwx['templater'].matcher = util.never

    elif node1 is not None and node1 != repo.changectx().node():

        kwx['templater'].restrict = True

    _patch_diff(repo, node1=node1, node2=node2, files=files, match=match,

                fp=fp, changes=changes, opts=opts)

try:

    from mercurial.hgweb import webcommands

    def _kwweb_changeset(web, req, tmpl):

        '''Wraps webcommands.changeset turning off keyword expansion.'''

        if kwx['templater']:

            kwx['templater'].matcher = util.neve

        return web.changeset(tmpl, web.changectx(req))

    def _kwweb_filediff(web, req, tmpl):

        '''Wraps webcommands.filediff turning off keyword expansion.'''

        if kwx['templater']:

            kwx['templater'].matcher = util.neve

        return web.filediff(tmpl, web.filectx(req))

    webcommands.changeset = webcommands.rev = _kwweb_changeset

    webcommands.filediff = webcommands.diff = _kwweb_filediff

except ImportError:

    from mercurial.hgweb.hgweb_mod import hgweb

    def _kwweb_do_changeset(self, req):

        if kwx['templater']:

            kwx['templater'].matcher = util.never

        req.write(self.changeset(self.changectx(req)))

    def _kwweb_do_filediff(self, req):

        if kwx['templater']:

            kwx['templater'].matcher = util.never

        req.write(self.filediff(self.filectx(req)))

    hgweb.do_changeset = hgweb.do_rev = _kwweb_do_changeset

    hgweb.do_filediff = hgweb.do_diff = _kwweb_do_filediff

try:

    # templatefilters module introduced in 9f1e6ab76069

    from mercurial import templatefilters

    template_filters = templatefilters.filters

    template_firstline = templatefilters.firstline

except ImportError:

    template_filters = templater.common_filters

    template_firstline = templater.firstline

def _wwrite(repo, f, data, mf):

    '''Makes repo.wwrite backwards compatible.'''

    # 656e06eebda7 removed file descriptor argument

    # 67982d3ee76c added flags argument

    try:

        repo.wwrite(f, data, mf.flags(f))

    except (AttributeError, TypeError):

        repo.wwrite(f, data)

def _normal(repo, files):

    '''Backwards compatible repo.dirstate.normal/update.'''

    # 6fd953d5faea introduced dirstate.normal()

    try:

        for f in files:

            repo.dirstate.normal(f)

    except AttributeError:

        repo.dirstate.update(files, 'n')

def _pathto(repo, f, cwd=None):

    '''kwfiles behaves similar to status, using pathto since 78b6add1f966.'''

    try:

        return repo.pathto(f, cwd)

    except AttributeError:

        return f

# commands.parse/cmdutil.parse returned nothing for

# "hg diff --rev" before 88803a69b24a due to bug in fancyopts

def _fancyopts(args, options, state):

    '''Fixed fancyopts from a9b7e425674f.'''

    namelist = []

    shortlist = ''

    argmap = {}

    defmap = {}

    for short, name, default, comment in options:

        # convert opts to getopt format

        oname = name

        name = name.replace('-', '_')

        argmap['-' + short] = argmap['--' + oname] = name

        defmap[name] = default

        # copy defaults to state

        if isinstance(default, list):

            state[name] = default[:]

        elif callable(default):

            print "whoa", name, default

            state[name] = None

        else:

            state[name] = default

        # does it take a parameter?

        if not (default is None or default is True or default is False):

            if short: short += ':'

            if oname: oname += '='

        if short:

            shortlist += short

        if name:

            namelist.append(oname)

    # parse arguments

    opts, args = getopt.getopt(args, shortlist, namelist)

    # transfer result to state

    for opt, val in opts:

        name = argmap[opt]

        t = type(defmap[name])

        if t is type(fancyopts):

            state[name] = defmap[name](val)

        elif t is type(1):

            state[name] = int(val)

        elif t is type(''):

            state[name] = val

        elif t is type([]):

            state[name].append(val)

        elif t is type(None) or t is type(False):

            state[name] = True

    # return unparsed args

    return args

fancyopts.fancyopts = _fancyopts

class kwtemplater(object):

    '''

    Sets up keyword templates, corresponding keyword regex, and

    provides keyword substitution functions.

    '''

    templates = {

        'Revision': '{node|short}',

        'Author': '{author|user}',

        'Date': '{date|utcdate}',

        'RCSFile': '{file|basename},v',

        'Source': '{root}/{file},v',

        'Id': '{file|basename},v {node|short} {date|utcdate} {author|user}',

        'Header': '{root}/{file},v {node|short} {date|utcdate} {author|user}',

    }

    def __init__(self, ui, repo, inc, exc):

        self.ui = ui

        self.repo = repo

        self.matcher = util.matcher(repo.root, inc=inc, exc=exc)[1]

        self.restrict = kwx['hgcmd'] in restricted.split()

        kwmaps = self.ui.configitems('keywordmaps')

        if kwmaps: # override default templates

            kwmaps = [(k, templater.parsestring(v, quoted=False))

                      for (k, v) in kwmaps]

            self.templates = dict(kwmaps)

        escaped = map(re.escape, self.templates.keys())

        kwpat = r'\$(%s)(: [^$\n\r]*? )??\$' % '|'.join(escaped)

        self.re_kw = re.compile(kwpat)

        template_filters['utcdate'] = utcdate

        self.ct = self._changeset_templater()

    def _changeset_templater(self):

        '''Backwards compatible cmdutil.changeset_templater.'''

        # before 1e0b94cfba0e there was an extra "brinfo" argument

        try:

            return cmdutil.changeset_templater(self.ui, self.repo,

                                               False, '', False)

        except TypeError:

            return cmdutil.changeset_templater(self.ui, self.repo,

                                               False, None, '', False)

    def getnode(self, path, fnode):

        '''Derives changenode from file context.'''

        c = context.filectx(self.repo, path, fileid=fnode)

        return c.node()

    def substitute(self, data, path, node, subfunc):

        '''Replaces keywords in data with expanded template.'''

        def kwsub(mobj):

            kw = mobj.group(1)

            self.ct.use_template(self.templates[kw])

            self.ui.pushbuffer()

            self.ct.show(changenode=node, root=self.repo.root, file=path)

            return '$%s: %s $' % (kw, template_firstline(self.ui.popbuffer()))

        return subfunc(kwsub, data)

    def expand(self, path, node, data):

        '''Returns data with keywords expanded.'''

        if not self.restrict and self.matcher(path) and not util.binary(data):

            changenode = self.getnode(path, node)

            return self.substitute(data, path, changenode, self.re_kw.sub)

        return data

    def iskwfile(self, path, islink):

        '''Returns true if path matches [keyword] pattern

        and is not a symbolic link.

        Caveat: localrepository._link fails on Windows.'''

        return self.matcher(path) and not islink(path)

    def overwrite(self, node=None, expand=True, files=None):

        '''Overwrites selected files expanding/shrinking keywords.'''

        ctx = self.repo.changectx(node)

        mf = ctx.manifest()

        if node is not None:     # commit

            files = [f for f in ctx.files() if f in mf]

            notify = self.ui.debug

        else:                    # kwexpand/kwshrink

            notify = self.ui.note

        candidates = [f for f in files if self.iskwfile(f, mf.linkf)]

        if candidates:

            self.restrict = True # do not expand when reading

            candidates.sort()

            action = expand and 'expanding' or 'shrinking'

            overwritten = []

            for f in candidates:

                fp = self.repo.file(f)