keyword.py
543 lines
| 20.5 KiB
| text/x-python
|
PythonLexer
/ hgext / keyword.py
|
r5815 | # keyword.py - $Keyword$ expansion for Mercurial | ||
# | ||||
|
r5831 | # Copyright 2007, 2008 Christian Ebert <blacktrash@gmx.net> | ||
|
r5815 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
# GNU General Public License version 2, incorporated herein by reference. | ||||
|
r5815 | # | ||
# $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 | ||||
|
r7993 | # files (like LaTeX packages), that are mostly addressed to an | ||
# audience not running a version control system. | ||||
|
r5815 | # | ||
# For in-depth discussion refer to | ||||
|
r8936 | # <http://mercurial.selenic.com/wiki/KeywordPlan>. | ||
|
r5815 | # | ||
# Keyword expansion is based on Mercurial's changeset template mappings. | ||||
# | ||||
# Binary files are not touched. | ||||
# | ||||
# 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. | ||||
|
r8894 | '''expand keywords in tracked files | ||
|
r5815 | |||
|
r7993 | This extension expands RCS/CVS-like or self-customized $Keywords$ in | ||
tracked text files selected by your configuration. | ||||
|
r5815 | |||
|
r7993 | 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. | ||||
|
r5815 | |||
|
r7993 | Configuration is done in the [keyword] and [keywordmaps] sections of | ||
hgrc files. | ||||
|
r5815 | |||
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 | ||||
|
r8027 | the less you lose speed in huge repositories. | ||
|
r5815 | |||
For [keywordmaps] template mapping and expansion demonstration and | ||||
control run "hg kwdemo". | ||||
An additional date template filter {date|utcdate} is provided. | ||||
|
r7993 | 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. | ||||
|
r5815 | |||
Before changing/disabling active keywords, run "hg kwshrink" to avoid | ||||
|
r8668 | the risk of inadvertently storing expanded keywords in the change | ||
|
r7993 | history. | ||
|
r5815 | |||
To force expansion after enabling it, or a configuration change, run | ||||
"hg kwexpand". | ||||
|
r7993 | 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. | ||||
|
r5884 | |||
|
r5815 | 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. | ||||
''' | ||||
|
r7216 | from mercurial import commands, cmdutil, dispatch, filelog, revlog, extensions | ||
|
r8566 | from mercurial import patch, localrepo, templater, templatefilters, util, match | ||
|
r6072 | from mercurial.hgweb import webcommands | ||
|
r8112 | from mercurial.lock import release | ||
|
r6211 | from mercurial.node import nullid, hex | ||
|
r5815 | from mercurial.i18n import _ | ||
|
r6069 | import re, shutil, tempfile, time | ||
|
r5815 | |||
commands.optionalrepo += ' kwdemo' | ||||
|
r6024 | # hg commands that do not act on keywords | ||
|
r6667 | nokwcommands = ('add addremove annotate bundle copy export grep incoming init' | ||
|
r6867 | ' log outgoing push rename rollback tip verify' | ||
|
r6082 | ' convert email glog') | ||
|
r6024 | |||
|
r5961 | # hg commands that trigger expansion only when writing to working dir, | ||
# not when reading filelog, and unexpand when reading from working dir | ||||
|
r6933 | restricted = 'merge record resolve qfold qimport qnew qpush qrefresh qrecord' | ||
|
r5961 | |||
|
r5815 | def utcdate(date): | ||
'''Returns hgdate in cvs-like UTC format.''' | ||||
return time.strftime('%Y/%m/%d %H:%M:%S', time.gmtime(date[0])) | ||||
|
r6115 | # make keyword tools accessible | ||
|
r6502 | kwtools = {'templater': None, 'hgcmd': '', 'inc': [], 'exc': ['.hg*']} | ||
|
r6114 | |||
|
r5815 | |||
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}', | ||||
} | ||||
|
r6502 | def __init__(self, ui, repo): | ||
|
r5815 | self.ui = ui | ||
self.repo = repo | ||||
|
r8638 | self.match = match.match(repo.root, '', [], | ||
kwtools['inc'], kwtools['exc']) | ||||
|
r6115 | self.restrict = kwtools['hgcmd'] in restricted.split() | ||
|
r5815 | |||
kwmaps = self.ui.configitems('keywordmaps') | ||||
if kwmaps: # override default templates | ||||
|
r6504 | kwmaps = [(k, templater.parsestring(v, False)) | ||
|
r5815 | 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) | ||||
|
r5976 | templatefilters.filters['utcdate'] = utcdate | ||
|
r5815 | self.ct = cmdutil.changeset_templater(self.ui, self.repo, | ||
|
r7762 | False, None, '', False) | ||
|
r5815 | |||
|
r7375 | def substitute(self, data, path, ctx, subfunc): | ||
|
r6114 | '''Replaces keywords in data with expanded template.''' | ||
|
r5815 | def kwsub(mobj): | ||
kw = mobj.group(1) | ||||
self.ct.use_template(self.templates[kw]) | ||||
self.ui.pushbuffer() | ||||
|
r7375 | self.ct.show(ctx, root=self.repo.root, file=path) | ||
|
r6023 | ekw = templatefilters.firstline(self.ui.popbuffer()) | ||
return '$%s: %s $' % (kw, ekw) | ||||
|
r5815 | return subfunc(kwsub, data) | ||
|
r6114 | def expand(self, path, node, data): | ||
|
r5815 | '''Returns data with keywords expanded.''' | ||
|
r8638 | if not self.restrict and self.match(path) and not util.binary(data): | ||
|
r7375 | ctx = self.repo.filectx(path, fileid=node).changectx() | ||
return self.substitute(data, path, ctx, self.re_kw.sub) | ||||
|
r6114 | return data | ||
|
r6749 | def iskwfile(self, path, flagfunc): | ||
|
r6114 | '''Returns true if path matches [keyword] pattern | ||
and is not a symbolic link. | ||||
Caveat: localrepository._link fails on Windows.''' | ||||
|
r8638 | return self.match(path) and not 'l' in flagfunc(path) | ||
|
r5815 | |||
|
r6505 | def overwrite(self, node, expand, files): | ||
|
r6114 | '''Overwrites selected files expanding/shrinking keywords.''' | ||
|
r7378 | ctx = self.repo[node] | ||
mf = ctx.manifest() | ||||
|
r6114 | 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 | ||||
|
r6749 | candidates = [f for f in files if self.iskwfile(f, ctx.flags)] | ||
|
r6114 | if candidates: | ||
self.restrict = True # do not expand when reading | ||||
|
r8098 | msg = (expand and _('overwriting %s expanding keywords\n') | ||
or _('overwriting %s shrinking keywords\n')) | ||||
|
r6114 | for f in candidates: | ||
fp = self.repo.file(f) | ||||
data = fp.read(mf[f]) | ||||
|
r6508 | if util.binary(data): | ||
|
r6114 | continue | ||
if expand: | ||||
|
r7375 | if node is None: | ||
ctx = self.repo.filectx(f, fileid=mf[f]).changectx() | ||||
data, found = self.substitute(data, f, ctx, | ||||
|
r6114 | self.re_kw.subn) | ||
else: | ||||
found = self.re_kw.search(data) | ||||
if found: | ||||
|
r8089 | notify(msg % f) | ||
|
r6114 | self.repo.wwrite(f, data, mf.flags(f)) | ||
self.repo.dirstate.normal(f) | ||||
self.restrict = False | ||||
|
r5815 | |||
|
r6114 | def shrinktext(self, text): | ||
'''Unconditionally removes all keyword substitutions from text.''' | ||||
return self.re_kw.sub(r'$\1$', text) | ||||
def shrink(self, fname, text): | ||||
|
r5815 | '''Returns text with all keyword substitutions removed.''' | ||
|
r8638 | if self.match(fname) and not util.binary(text): | ||
|
r6114 | return self.shrinktext(text) | ||
return text | ||||
def shrinklines(self, fname, lines): | ||||
'''Returns lines with keyword substitutions removed.''' | ||||
|
r8638 | if self.match(fname): | ||
|
r6114 | text = ''.join(lines) | ||
|
r6508 | if not util.binary(text): | ||
|
r6114 | 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 | ||||
|
r5815 | |||
class kwfilelog(filelog.filelog): | ||||
''' | ||||
Subclass of filelog to hook into its read, add, cmp methods. | ||||
Keywords are "stored" unexpanded, and processed on reading. | ||||
''' | ||||
|
r6503 | def __init__(self, opener, kwt, path): | ||
|
r5815 | super(kwfilelog, self).__init__(opener, path) | ||
|
r6503 | self.kwt = kwt | ||
|
r6114 | self.path = path | ||
|
r5815 | |||
def read(self, node): | ||||
'''Expands keywords when reading filelog.''' | ||||
data = super(kwfilelog, self).read(node) | ||||
|
r6115 | return self.kwt.expand(self.path, node, data) | ||
|
r5815 | |||
def add(self, text, meta, tr, link, p1=None, p2=None): | ||||
'''Removes keyword substitutions when adding to filelog.''' | ||||
|
r6115 | text = self.kwt.shrink(self.path, text) | ||
|
r6504 | return super(kwfilelog, self).add(text, meta, tr, link, p1, p2) | ||
|
r5815 | |||
def cmp(self, node, text): | ||||
'''Removes keyword substitutions for comparison.''' | ||||
|
r6115 | text = self.kwt.shrink(self.path, text) | ||
|
r5815 | if self.renamed(node): | ||
t2 = super(kwfilelog, self).read(node) | ||||
return t2 != text | ||||
return revlog.revlog.cmp(self, node, text) | ||||
|
r6760 | def _status(ui, repo, kwt, unknown, *pats, **opts): | ||
|
r5815 | '''Bails out if [keyword] configuration is not active. | ||
Returns status of working directory.''' | ||||
|
r6115 | if kwt: | ||
|
r8638 | match = cmdutil.match(repo, pats, opts) | ||
return repo.status(match=match, unknown=unknown, clean=True) | ||||
|
r5815 | if ui.configitems('keyword'): | ||
raise util.Abort(_('[keyword] patterns cannot match')) | ||||
raise util.Abort(_('no [keyword] patterns configured')) | ||||
def _kwfwrite(ui, repo, expand, *pats, **opts): | ||||
|
r6114 | '''Selects files and passes them to kwtemplater.overwrite.''' | ||
|
r6672 | if repo.dirstate.parents()[1] != nullid: | ||
raise util.Abort(_('outstanding uncommitted merge')) | ||||
|
r6115 | kwt = kwtools['templater'] | ||
|
r6760 | status = _status(ui, repo, kwt, False, *pats, **opts) | ||
modified, added, removed, deleted = status[:4] | ||||
|
r5815 | if modified or added or removed or deleted: | ||
|
r6672 | raise util.Abort(_('outstanding uncommitted changes')) | ||
|
r5815 | wlock = lock = None | ||
try: | ||||
wlock = repo.wlock() | ||||
lock = repo.lock() | ||||
|
r6760 | kwt.overwrite(None, expand, status[6]) | ||
|
r5815 | finally: | ||
|
r8112 | release(lock, wlock) | ||
|
r5815 | |||
def demo(ui, repo, *args, **opts): | ||||
'''print [keywordmaps] configuration and an expansion example | ||||
|
r7993 | Show current, custom, or default keyword template maps and their | ||
|
r8763 | expansions. | ||
|
r5815 | |||
|
r7993 | Extend current configuration by specifying maps as arguments and | ||
optionally by reading from an additional hgrc file. | ||||
|
r5815 | |||
Override current keyword template maps with "default" option. | ||||
''' | ||||
def demoitems(section, items): | ||||
ui.write('[%s]\n' % section) | ||||
for k, v in items: | ||||
ui.write('%s = %s\n' % (k, v)) | ||||
msg = 'hg keyword config and expansion example' | ||||
kwstatus = 'current' | ||||
fn = 'demo.txt' | ||||
branchname = 'demobranch' | ||||
tmpdir = tempfile.mkdtemp('', 'kwdemo.') | ||||
|
r8027 | ui.note(_('creating temporary repository at %s\n') % tmpdir) | ||
|
r6504 | repo = localrepo.localrepository(ui, tmpdir, True) | ||
|
r5815 | ui.setconfig('keyword', fn, '') | ||
if args or opts.get('rcfile'): | ||||
kwstatus = 'custom' | ||||
if opts.get('rcfile'): | ||||
ui.readconfig(opts.get('rcfile')) | ||||
if opts.get('default'): | ||||
kwstatus = 'default' | ||||
kwmaps = kwtemplater.templates | ||||
if ui.configitems('keywordmaps'): | ||||
# override maps from optional rcfile | ||||
|
r5946 | for k, v in kwmaps.iteritems(): | ||
|
r5815 | ui.setconfig('keywordmaps', k, v) | ||
elif args: | ||||
# simulate hgrc parsing | ||||
rcmaps = ['[keywordmaps]\n'] + [a + '\n' for a in args] | ||||
fp = repo.opener('hgrc', 'w') | ||||
fp.writelines(rcmaps) | ||||
fp.close() | ||||
ui.readconfig(repo.join('hgrc')) | ||||
if not opts.get('default'): | ||||
kwmaps = dict(ui.configitems('keywordmaps')) or kwtemplater.templates | ||||
|
r6502 | uisetup(ui) | ||
|
r5815 | reposetup(ui, repo) | ||
for k, v in ui.configitems('extensions'): | ||||
if k.endswith('keyword'): | ||||
extension = '%s = %s' % (k, v) | ||||
break | ||||
|
r8939 | ui.status(_('\n\tconfig using %s keyword template maps\n') % kwstatus) | ||
|
r5815 | ui.write('[extensions]\n%s\n' % extension) | ||
demoitems('keyword', ui.configitems('keyword')) | ||||
|
r5946 | demoitems('keywordmaps', kwmaps.iteritems()) | ||
|
r5815 | keywords = '$' + '$\n$'.join(kwmaps.keys()) + '$\n' | ||
repo.wopener(fn, 'w').write(keywords) | ||||
repo.add([fn]) | ||||
path = repo.wjoin(fn) | ||||
ui.note(_('\n%s keywords written to %s:\n') % (kwstatus, path)) | ||||
ui.note(keywords) | ||||
ui.note('\nhg -R "%s" branch "%s"\n' % (tmpdir, branchname)) | ||||
# silence branch command if not verbose | ||||
quiet = ui.quiet | ||||
|
r5825 | ui.quiet = not ui.verbose | ||
|
r5815 | commands.branch(ui, repo, branchname) | ||
ui.quiet = quiet | ||||
for name, cmd in ui.configitems('hooks'): | ||||
if name.split('.', 1)[0].find('commit') > -1: | ||||
repo.ui.setconfig('hooks', name, '') | ||||
ui.note(_('unhooked all commit hooks\n')) | ||||
ui.note('hg -R "%s" ci -m "%s"\n' % (tmpdir, msg)) | ||||
repo.commit(text=msg) | ||||
|
r7417 | fmt = ui.verbose and ' in %s' % path or '' | ||
|
r8939 | ui.status(_('\n\t%s keywords expanded%s\n') % (kwstatus, fmt)) | ||
|
r5815 | ui.write(repo.wread(fn)) | ||
|
r8027 | ui.debug(_('\nremoving temporary repository %s\n') % tmpdir) | ||
|
r5815 | shutil.rmtree(tmpdir, ignore_errors=True) | ||
def expand(ui, repo, *pats, **opts): | ||||
|
r8763 | '''expand keywords in the working directory | ||
|
r5815 | |||
Run after (re)enabling keyword expansion. | ||||
kwexpand refuses to run if given files contain local changes. | ||||
''' | ||||
# 3rd argument sets expansion to True | ||||
_kwfwrite(ui, repo, True, *pats, **opts) | ||||
def files(ui, repo, *pats, **opts): | ||||
|
r8957 | '''show files configured for keyword expansion | ||
|
r8950 | |||
|
r8957 | List which files in the working directory are matched by the | ||
|
r8950 | [keyword] configuration patterns. | ||
|
r5815 | |||
|
r8950 | Useful to prevent inadvertent keyword expansion and to speed up | ||
|
r8957 | execution by including only files that are actual candidates | ||
|
r8950 | for expansion. | ||
|
r8957 | See "hg help keyword" on how to construct patterns both for | ||
inclusion and exclusion of files. | ||||
Use -u/--untracked to list untracked files as well. | ||||
|
r8956 | |||
With -a/--all and -v/--verbose the codes used to show the status | ||||
of files are: | ||||
K = keyword expansion candidate | ||||
k = keyword expansion candidate (untracked) | ||||
I = ignored | ||||
i = ignored (untracked) | ||||
|
r5815 | ''' | ||
|
r6115 | kwt = kwtools['templater'] | ||
|
r6760 | status = _status(ui, repo, kwt, opts.get('untracked'), *pats, **opts) | ||
|
r5815 | modified, added, removed, deleted, unknown, ignored, clean = status | ||
|
r8956 | files = sorted(modified + added + clean) | ||
|
r6747 | wctx = repo[None] | ||
|
r6749 | kwfiles = [f for f in files if kwt.iskwfile(f, wctx.flags)] | ||
|
r8956 | kwuntracked = [f for f in unknown if kwt.iskwfile(f, wctx.flags)] | ||
|
r5815 | cwd = pats and repo.getcwd() or '' | ||
|
r8956 | kwfstats = (not opts.get('ignore') and | ||
(('K', kwfiles), ('k', kwuntracked),) or ()) | ||||
|
r5815 | if opts.get('all') or opts.get('ignore'): | ||
|
r8956 | kwfstats += (('I', [f for f in files if f not in kwfiles]), | ||
('i', [f for f in unknown if f not in kwuntracked]),) | ||||
|
r5815 | for char, filenames in kwfstats: | ||
|
r7417 | fmt = (opts.get('all') or ui.verbose) and '%s %%s\n' % char or '%s\n' | ||
|
r5815 | for f in filenames: | ||
|
r7417 | ui.write(fmt % repo.pathto(f, cwd)) | ||
|
r5815 | |||
def shrink(ui, repo, *pats, **opts): | ||||
|
r8763 | '''revert expanded keywords in the working directory | ||
|
r5815 | |||
|
r7993 | Run before changing/disabling active keywords or if you experience | ||
problems with "hg import" or "hg merge". | ||||
|
r5815 | |||
kwshrink refuses to run if given files contain local changes. | ||||
''' | ||||
# 3rd argument sets expansion to False | ||||
_kwfwrite(ui, repo, False, *pats, **opts) | ||||
|
r6502 | def uisetup(ui): | ||
'''Collects [keyword] config in kwtools. | ||||
Monkeypatches dispatch._parse if needed.''' | ||||
for pat, opt in ui.configitems('keyword'): | ||||
if opt != 'ignore': | ||||
kwtools['inc'].append(pat) | ||||
else: | ||||
kwtools['exc'].append(pat) | ||||
if kwtools['inc']: | ||||
|
r7216 | def kwdispatch_parse(orig, ui, args): | ||
|
r6502 | '''Monkeypatch dispatch._parse to obtain running hg command.''' | ||
|
r7216 | cmd, func, args, options, cmdoptions = orig(ui, args) | ||
|
r6502 | kwtools['hgcmd'] = cmd | ||
return cmd, func, args, options, cmdoptions | ||||
|
r7216 | extensions.wrapfunction(dispatch, '_parse', kwdispatch_parse) | ||
|
r6502 | |||
|
r5815 | def reposetup(ui, repo): | ||
'''Sets up repo as kwrepo for keyword substitution. | ||||
Overrides file method to return kwfilelog instead of filelog | ||||
if file matches user configuration. | ||||
Wraps commit to overwrite configured files with updated | ||||
keyword substitutions. | ||||
|
r6503 | Monkeypatches patch and webcommands.''' | ||
|
r5815 | |||
|
r7853 | try: | ||
if (not repo.local() or not kwtools['inc'] | ||||
or kwtools['hgcmd'] in nokwcommands.split() | ||||
or '.hg' in util.splitpath(repo.root) | ||||
or repo._url.startswith('bundle:')): | ||||
return | ||||
except AttributeError: | ||||
pass | ||||
|
r5815 | |||
|
r6502 | kwtools['templater'] = kwt = kwtemplater(ui, repo) | ||
|
r5815 | |||
class kwrepo(repo.__class__): | ||||
|
r6114 | def file(self, f): | ||
|
r5815 | if f[0] == '/': | ||
f = f[1:] | ||||
|
r6503 | return kwfilelog(self.sopener, kwt, f) | ||
|
r5815 | |||
|
r5884 | def wread(self, filename): | ||
data = super(kwrepo, self).wread(filename) | ||||
|
r6115 | return kwt.wread(filename, data) | ||
|
r5884 | |||
|
r8706 | def commit(self, text='', user=None, date=None, match=None, | ||
force=False, editor=None, extra={}): | ||||
|
r5815 | wlock = lock = None | ||
_p1 = _p2 = None | ||||
try: | ||||
wlock = self.wlock() | ||||
lock = self.lock() | ||||
# store and postpone commit hooks | ||||
|
r5946 | commithooks = {} | ||
|
r5815 | for name, cmd in ui.configitems('hooks'): | ||
if name.split('.', 1)[0] == 'commit': | ||||
|
r5946 | commithooks[name] = cmd | ||
|
r5815 | ui.setconfig('hooks', name, None) | ||
if commithooks: | ||||
# store parents for commit hook environment | ||||
|
r8403 | _p1, _p2 = repo.dirstate.parents() | ||
|
r5815 | _p1 = hex(_p1) | ||
if _p2 == nullid: | ||||
_p2 = '' | ||||
else: | ||||
_p2 = hex(_p2) | ||||
|
r8706 | n = super(kwrepo, self).commit(text, user, date, match, force, | ||
editor, extra) | ||||
|
r5815 | |||
# restore commit hooks | ||||
|
r5946 | for name, cmd in commithooks.iteritems(): | ||
|
r5815 | ui.setconfig('hooks', name, cmd) | ||
|
r6504 | if n is not None: | ||
|
r6505 | kwt.overwrite(n, True, None) | ||
|
r6504 | repo.hook('commit', node=n, parent1=_p1, parent2=_p2) | ||
return n | ||||
|
r5815 | finally: | ||
|
r8112 | release(lock, wlock) | ||
|
r5815 | |||
|
r6503 | # monkeypatches | ||
|
r8810 | def kwpatchfile_init(orig, self, ui, fname, opener, missing=False, eol=None): | ||
|
r6503 | '''Monkeypatch/wrap patch.patchfile.__init__ to avoid | ||
rejects or conflicts due to expanded keywords in working dir.''' | ||||
|
r8810 | orig(self, ui, fname, opener, missing, eol) | ||
|
r6503 | # shrink keywords read from working dir | ||
self.lines = kwt.shrinklines(self.fname, self.lines) | ||||
|
r7308 | def kw_diff(orig, repo, node1=None, node2=None, match=None, changes=None, | ||
opts=None): | ||||
|
r6503 | '''Monkeypatch patch.diff to avoid expansion except when | ||
comparing against working dir.''' | ||||
if node2 is not None: | ||||
|
r8638 | kwt.match = util.never | ||
|
r6747 | elif node1 is not None and node1 != repo['.'].node(): | ||
|
r6503 | kwt.restrict = True | ||
|
r7308 | return orig(repo, node1, node2, match, changes, opts) | ||
|
r6667 | |||
|
r7216 | def kwweb_skip(orig, web, req, tmpl): | ||
'''Wraps webcommands.x turning off keyword expansion.''' | ||||
|
r8638 | kwt.match = util.never | ||
|
r7216 | return orig(web, req, tmpl) | ||
|
r6503 | |||
|
r5815 | repo.__class__ = kwrepo | ||
|
r6503 | |||
|
r7216 | extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init) | ||
extensions.wrapfunction(patch, 'diff', kw_diff) | ||||
for c in 'annotate changeset rev filediff diff'.split(): | ||||
extensions.wrapfunction(webcommands, c, kwweb_skip) | ||||
|
r5815 | |||
cmdtable = { | ||||
'kwdemo': | ||||
(demo, | ||||
[('d', 'default', None, _('show default keyword template maps')), | ||||
('f', 'rcfile', [], _('read maps from rcfile'))], | ||||
_('hg kwdemo [-d] [-f RCFILE] [TEMPLATEMAP]...')), | ||||
'kwexpand': (expand, commands.walkopts, | ||||
_('hg kwexpand [OPTION]... [FILE]...')), | ||||
'kwfiles': | ||||
(files, | ||||
[('a', 'all', None, _('show keyword status flags of all files')), | ||||
('i', 'ignore', None, _('show files excluded from expansion')), | ||||
('u', 'untracked', None, _('additionally show untracked files')), | ||||
] + commands.walkopts, | ||||
_('hg kwfiles [OPTION]... [FILE]...')), | ||||
'kwshrink': (shrink, commands.walkopts, | ||||
_('hg kwshrink [OPTION]... [FILE]...')), | ||||
} | ||||