keyword.py
550 lines
| 20.7 KiB
| text/x-python
|
PythonLexer
/ hgext / keyword.py
|
r5815 | # keyword.py - $Keyword$ expansion for Mercurial | ||
# | ||||
|
r9305 | # Copyright 2007-2009 Christian Ebert <blacktrash@gmx.net> | ||
|
r5815 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
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 | |||
|
r9264 | This extension expands RCS/CVS-like or self-customized $Keywords$ in | ||
tracked text files selected by your configuration. | ||||
|
r5815 | |||
|
r9264 | 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 | |||
|
r9264 | Configuration is done in the [keyword] and [keywordmaps] sections of | ||
hgrc files. | ||||
|
r5815 | |||
|
r9157 | Example:: | ||
|
r5815 | |||
[keyword] | ||||
# expand keywords in every python file except those matching "x*" | ||||
**.py = | ||||
x* = ignore | ||||
|
r9264 | NOTE: the more specific you are in your filename patterns the less you | ||
lose speed in huge repositories. | ||||
|
r5815 | |||
|
r9264 | For [keywordmaps] template mapping and expansion demonstration and | ||
|
r9307 | control run "hg kwdemo". See "hg help templates" for a list of | ||
available templates and filters. | ||||
|
r5815 | |||
|
r9307 | An additional date template filter {date|utcdate} is provided. It | ||
returns a date like "2006/09/18 15:13:13". | ||||
|
r5815 | |||
|
r9264 | 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 | |||
|
r9264 | Before changing/disabling active keywords, run "hg kwshrink" to avoid | ||
the risk of inadvertently storing expanded keywords in the change | ||||
history. | ||||
|
r5815 | |||
|
r9264 | To force expansion after enabling it, or a configuration change, run | ||
"hg kwexpand". | ||||
|
r5815 | |||
|
r9264 | 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 | |||
|
r9264 | 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. | ||||
|
r5815 | ''' | ||
|
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 | ||
|
r9027 | from mercurial.node import nullid | ||
|
r5815 | from mercurial.i18n import _ | ||
|
r9308 | import re, shutil, tempfile | ||
|
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 | ||||
|
r10117 | restricted = ('merge record resolve qfold qimport qnew qpush qrefresh qrecord' | ||
' transplant') | ||||
|
r5961 | |||
|
r9308 | # provide cvs-like UTC date filter | ||
|
r10332 | utcdate = lambda x: util.datestr((x[0], 0), '%Y/%m/%d %H:%M:%S') | ||
|
r5815 | |||
|
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}', | ||||
|
r9943 | 'RCSfile': '{file|basename},v', | ||
|
r9950 | 'RCSFile': '{file|basename},v', # kept for backwards compatibility | ||
# with hg-keyword | ||||
|
r5815 | '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 | ||||
|
r9081 | self.templates = dict((k, templater.parsestring(v, False)) | ||
for k, v in kwmaps) | ||||
|
r5815 | 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)) | ||
|
r8996 | if node is None: | ||
self.repo.dirstate.normal(f) | ||||
|
r6114 | 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) | ||||
|
r9491 | def _status(ui, repo, kwt, *pats, **opts): | ||
|
r5815 | '''Bails out if [keyword] configuration is not active. | ||
Returns status of working directory.''' | ||||
|
r6115 | if kwt: | ||
|
r9492 | unknown = (opts.get('unknown') or opts.get('all') | ||
or opts.get('untracked')) | ||||
|
r9491 | return repo.status(match=cmdutil.match(repo, pats, opts), clean=True, | ||
unknown=unknown) | ||||
|
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'] | ||
|
r9491 | status = _status(ui, repo, kwt, *pats, **opts) | ||
|
r6760 | 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 | |||
|
r9281 | Extend the current configuration by specifying maps as arguments | ||
and using -f/--rcfile to source an external hgrc file. | ||||
|
r5815 | |||
|
r9281 | Use -d/--default to disable current configuration. | ||
|
r9307 | |||
See "hg help templates" for information on templates and filters. | ||||
|
r5815 | ''' | ||
def demoitems(section, items): | ||||
ui.write('[%s]\n' % section) | ||||
|
r9942 | for k, v in sorted(items): | ||
|
r5815 | ui.write('%s = %s\n' % (k, v)) | ||
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, '') | ||
|
r9281 | |||
uikwmaps = ui.configitems('keywordmaps') | ||||
|
r5815 | if args or opts.get('rcfile'): | ||
|
r9281 | ui.status(_('\n\tconfiguration using custom keyword template maps\n')) | ||
if uikwmaps: | ||||
ui.status(_('\textending current template maps\n')) | ||||
if opts.get('default') or not uikwmaps: | ||||
ui.status(_('\toverriding default template maps\n')) | ||||
if opts.get('rcfile'): | ||||
ui.readconfig(opts.get('rcfile')) | ||||
if 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')) | ||||
kwmaps = dict(ui.configitems('keywordmaps')) | ||||
elif opts.get('default'): | ||||
ui.status(_('\n\tconfiguration using default keyword template maps\n')) | ||||
|
r5815 | kwmaps = kwtemplater.templates | ||
|
r9281 | if uikwmaps: | ||
ui.status(_('\tdisabling current template maps\n')) | ||||
|
r5946 | for k, v in kwmaps.iteritems(): | ||
|
r5815 | ui.setconfig('keywordmaps', k, v) | ||
|
r9281 | else: | ||
ui.status(_('\n\tconfiguration using current keyword template maps\n')) | ||||
kwmaps = dict(uikwmaps) 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 | ||||
ui.write('[extensions]\n%s\n' % extension) | ||||
demoitems('keyword', ui.configitems('keyword')) | ||||
|
r5946 | demoitems('keywordmaps', kwmaps.iteritems()) | ||
|
r9942 | keywords = '$' + '$\n$'.join(sorted(kwmaps.keys())) + '$\n' | ||
|
r5815 | repo.wopener(fn, 'w').write(keywords) | ||
repo.add([fn]) | ||||
path = repo.wjoin(fn) | ||||
|
r9281 | ui.note(_('\nkeywords written to %s:\n') % path) | ||
|
r5815 | 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')) | ||||
|
r10499 | msg = _('hg keyword configuration and expansion example') | ||
ui.note("hg -R '%s' ci -m '%s'\n" % (tmpdir, msg)) | ||||
|
r5815 | repo.commit(text=msg) | ||
|
r9281 | ui.status(_('\n\tkeywords expanded\n')) | ||
|
r5815 | ui.write(repo.wread(fn)) | ||
|
r9467 | 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 | |||
|
r9264 | List which files in the working directory are matched by the | ||
[keyword] configuration patterns. | ||||
|
r5815 | |||
|
r9264 | Useful to prevent inadvertent keyword expansion and to speed up | ||
execution by including only files that are actual candidates for | ||||
expansion. | ||||
|
r8950 | |||
|
r9264 | See "hg help keyword" on how to construct patterns both for | ||
inclusion and exclusion of files. | ||||
|
r8957 | |||
|
r9494 | With -A/--all and -v/--verbose the codes used to show the status | ||
|
r9264 | of files are:: | ||
|
r9195 | |||
K = keyword expansion candidate | ||||
|
r9491 | k = keyword expansion candidate (not tracked) | ||
|
r9195 | I = ignored | ||
|
r9491 | i = ignored (not tracked) | ||
|
r5815 | ''' | ||
|
r6115 | kwt = kwtools['templater'] | ||
|
r9491 | status = _status(ui, repo, kwt, *pats, **opts) | ||
|
r9493 | cwd = pats and repo.getcwd() or '' | ||
|
r5815 | modified, added, removed, deleted, unknown, ignored, clean = status | ||
|
r9493 | files = [] | ||
if not (opts.get('unknown') or opts.get('untracked')) or opts.get('all'): | ||||
files = sorted(modified + added + clean) | ||||
|
r6747 | wctx = repo[None] | ||
|
r6749 | kwfiles = [f for f in files if kwt.iskwfile(f, wctx.flags)] | ||
|
r9491 | kwunknown = [f for f in unknown if kwt.iskwfile(f, wctx.flags)] | ||
|
r9493 | if not opts.get('ignore') or opts.get('all'): | ||
showfiles = kwfiles, kwunknown | ||||
else: | ||||
showfiles = [], [] | ||||
|
r5815 | if opts.get('all') or opts.get('ignore'): | ||
|
r9493 | showfiles += ([f for f in files if f not in kwfiles], | ||
[f for f in unknown if f not in kwunknown]) | ||||
for char, filenames in zip('KkIi', showfiles): | ||||
|
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 | |||
|
r9096 | def commit(self, *args, **opts): | ||
|
r8996 | # use custom commitctx for user commands | ||
# other extensions can still wrap repo.commitctx directly | ||||
|
r9096 | self.commitctx = self.kwcommitctx | ||
try: | ||||
|
r10495 | return super(kwrepo, self).commit(*args, **opts) | ||
|
r9096 | finally: | ||
del self.commitctx | ||||
|
r8996 | |||
def kwcommitctx(self, ctx, error=False): | ||||
|
r5815 | wlock = lock = None | ||
try: | ||||
wlock = self.wlock() | ||||
lock = self.lock() | ||||
|
r8996 | n = super(kwrepo, self).commitctx(ctx, error) | ||
kwt.overwrite(n, True, None) | ||||
|
r6504 | return n | ||
|
r5815 | finally: | ||
|
r8112 | release(lock, wlock) | ||
|
r5815 | |||
|
r6503 | # monkeypatches | ||
|
r9013 | 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) | ||
|
r10116 | if not kwt.restrict: | ||
extensions.wrapfunction(patch, 'diff', kw_diff) | ||||
|
r7216 | 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')), | ||||
|
r9190 | ('f', 'rcfile', '', _('read maps from rcfile'))], | ||
|
r5815 | _('hg kwdemo [-d] [-f RCFILE] [TEMPLATEMAP]...')), | ||
'kwexpand': (expand, commands.walkopts, | ||||
_('hg kwexpand [OPTION]... [FILE]...')), | ||||
'kwfiles': | ||||
(files, | ||||
|
r9494 | [('A', 'all', None, _('show keyword status flags of all files')), | ||
|
r5815 | ('i', 'ignore', None, _('show files excluded from expansion')), | ||
|
r9493 | ('u', 'unknown', None, _('only show unknown (not tracked) files')), | ||
|
r9494 | ('a', 'all', None, | ||
_('show keyword status flags of all files (DEPRECATED)')), | ||||
|
r9493 | ('u', 'untracked', None, _('only show untracked files (DEPRECATED)')), | ||
|
r5815 | ] + commands.walkopts, | ||
_('hg kwfiles [OPTION]... [FILE]...')), | ||||
'kwshrink': (shrink, commands.walkopts, | ||||
_('hg kwshrink [OPTION]... [FILE]...')), | ||||
} | ||||