# 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 version 2, 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.

'''expand keywords in tracked files

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 repositories.

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 inadvertently 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, fancyopts, filelog

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

from mercurial.node import nullid, hex

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 annotate bundle copy export grep incoming init'

                ' log outgoing push rename rollback tip verify'

                ' 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 = 'merge record resolve 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]))

def textsafe(s):

    '''Safe version of util.binary with reversed logic.

    Note: argument may not be None, which is allowed for util.binary.'''

    return '\0' not in s

# make keyword tools accessible

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

# monkeypatch argument parsing

# due to backwards compatibility this can't be done in uisetup

# uisetup introduced with extensions module in 930ed513c864

def _kwdispatch_parse(ui, args):

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

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

    kwtools['hgcmd'] = cmd

    return cmd, func, args, options, cmdoptions

try:

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

    from mercurial import dispatch

    _dispatch_parse = dispatch._parse

    dispatch._parse = _kwdispatch_parse

except ImportError:

    try:

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

        _dispatch_parse = cmdutil.parse

        cmdutil.parse = _kwdispatch_parse

    except AttributeError:

        _dispatch_parse = commands.parse

        commands.parse = _kwdispatch_parse

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

'''Default match argument for commit, depending on version.'''

if hasattr(cmdutil, 'match'):

    _defmatch = None

else:

    _defmatch = util.always

# 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 = kwtools['hgcmd'] in restricted.split()

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

        if kwmaps: # override default templates

            kwmaps = [(k, templater.parsestring(v, 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 path and filenode.'''

        # used by kwfilelog.read and kwexpand

        c = self.repo.filectx(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 textsafe(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, expand, files):

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

        # repo[changeid] introduced in f6c00b17387c

        if node is not None:     # commit

            try:

                ctx = self.repo[node]

            except TypeError:

                ctx = self.repo.changectx(node)

            mf = ctx.manifest()

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

            notify = self.ui.debug

        else:                    # kwexpand/kwshrink

            try:

                ctx = self.repo['.']

            except TypeError:

                ctx = self.repo.changectx()

            mf = ctx.manifest()

            notify = self.ui.note

        if hasattr(ctx, 'flags'):

            # 51b0e799352f

            islink = lambda p: 'l' in ctx.flags(p)

        else:

            islink = mf.linkf

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

        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)

                data = fp.read(mf[f])

                if not textsafe(data):

                    continue

                if expand:

                    changenode = node or self.getnode(f, mf[f])

                    data, found = self.substitute(data, f, changenode,

                                                  self.re_kw.subn)

                else:

                    found = self.re_kw.search(data)

                if found:

                    notify(_('overwriting %s %s keywords\n') % (f, action))

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

                    overwritten.append(f)

            _normal(self.repo, overwritten)

            self.restrict = False

    def shrinktext(self, text):

        '''Unconditionally removes all keyword substitutions from text.'''

        return self.re_kw.sub(r'$\1$', text)

    def shrink(self, fname, text):

        '''Returns text with all keyword substitutions removed.'''

        if self.matcher(fname) and textsafe(text):

            return self.shrinktext(text)

        return text

    def shrinklines(self, fname, lines):

        '''Returns lines with keyword substitutions removed.'''

        if self.matcher(fname):

            text = ''.join(lines)

            if textsafe(text):

                return self.shrinktext(text).splitlines(True)

        return lines

    def wread(self, fname, data):

        '''If in restricted mode returns data read from wdir with

        keyword substitutions removed.'''

        return self.restrict and self.shrink(fname, data) or data

class kwfilelog(filelog.filelog):

    '''