test: comparison hgkw/keyword.py

equal deleted inserted replaced

-:0ae62443e644
+:67c17a447d99
 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.
 '''
-from mercurial import commands, cmdutil, dispatch, filelog, revlog, extensions
+from mercurial import commands, cmdutil, dispatch, filelog, extensions
-from mercurial import patch, localrepo, templater, templatefilters, util, match
+from mercurial import localrepo, match, patch, templatefilters, templater, util
 from mercurial.hgweb import webcommands
 from mercurial.i18n import _
 import re, shutil, tempfile
 commands.optionalrepo += ' kwdemo'
 # hg commands that do not act on keywords
-nokwcommands = ('add addremove annotate bundle copy export grep incoming init'
+nokwcommands = ('add addremove annotate bundle export grep incoming init log'
-' log outgoing push rename tip verify convert email glog')
+' outgoing push 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 qrecord resolve transplant'
+restricted = 'merge kwexpand kwshrink record qrecord resolve transplant'
-# commands using dorecord
-recordcommands = 'record qrecord'
 # names of extensions using dorecord
 recordextensions = 'record'
 # date like in cvs' $Date
 utcdate = lambda x: util.datestr((x[0], 0), '%Y/%m/%d %H:%M:%S')
 'LastChangedDate': '{date|svnisodate}',
 })
 templates.update(kwsets[ui.configbool('keywordset', 'svn')])
 return templates
+def _shrinktext(text, subfunc):
+'''Helper for keyword expansion removal in text.
+Depending on subfunc also returns number of substitutions.'''
+return subfunc(r'$\1$', text)
 class kwtemplater(object):
 '''
 Sets up keyword templates, corresponding keyword regex, and
 provides keyword substitution functions.
 '''
 def __init__(self, ui, repo, inc, exc):
 self.ui = ui
 self.repo = repo
 self.match = match.match(repo.root, '', [], inc, exc)
 self.restrict = kwtools['hgcmd'] in restricted.split()
-self.record = kwtools['hgcmd'] in recordcommands.split()
+self.record = False
 kwmaps = self.ui.configitems('keywordmaps')
 if kwmaps: # override default templates
 self.templates = dict((k, templater.parsestring(v, False))
 for k, v in kwmaps)
 else:
 self.templates = _defaultkwmaps(self.ui)
-escaped = map(re.escape, self.templates.keys())
+escaped = '|'.join(map(re.escape, self.templates.keys()))
-kwpat = r'\$(%s)(: [^$\n\r]*? )??\$' % '|'.join(escaped)
+self.re_kw = re.compile(r'\$(%s)\$' % escaped)
-self.re_kw = re.compile(kwpat)
+self.re_kwexp = re.compile(r'\$(%s): [^$\n\r]*? \$' % escaped)
 templatefilters.filters.update({'utcdate': utcdate,
 'svnisodate': svnisodate,
 'svnutcdate': svnutcdate})
 if not self.restrict and self.match(path) and not util.binary(data):
 ctx = self.repo.filectx(path, fileid=node).changectx()
 return self.substitute(data, path, ctx, self.re_kw.sub)
 return data
-def iskwfile(self, path, flagfunc):
+def iskwfile(self, cand, ctx):
-'''Returns true if path matches [keyword] pattern
+'''Returns subset of candidates which are configured for keyword
-and is not a symbolic link.
+expansion are not symbolic links.'''
-Caveat: localrepository._link fails on Windows.'''
+return [f for f in cand if self.match(f) and not 'l' in ctx.flags(f)]
-return self.match(path) and not 'l' in flagfunc(path)
+def overwrite(self, ctx, candidates, lookup, expand, recsubn=None):
-def overwrite(self, ctx, candidates, iswctx, expand, cfiles):
 '''Overwrites selected files expanding/shrinking keywords.'''
-if cfiles is not None:
+if self.restrict or lookup: # exclude kw_copy
-candidates = [f for f in candidates if f in cfiles]
+candidates = self.iskwfile(candidates, ctx)
-candidates = [f for f in candidates if self.iskwfile(f, ctx.flags)]
+if not candidates:
-if candidates:
+return
-restrict = self.restrict
+commit = self.restrict and not lookup
-self.restrict = True        # do not expand when reading
+if self.restrict or expand and lookup:
-rollback = kwtools['hgcmd'] == 'rollback'
 mf = ctx.manifest()
-msg = (expand and _('overwriting %s expanding keywords\n')
+fctx = ctx
-or _('overwriting %s shrinking keywords\n'))
+subn = (self.restrict and self.re_kw.subn or
-for f in candidates:
+recsubn or self.re_kwexp.subn)
-if not self.record and not rollback:
+msg = (expand and _('overwriting %s expanding keywords\n')
-data = self.repo.file(f).read(mf[f])
+or _('overwriting %s shrinking keywords\n'))
-else:
+for f in candidates:
-data = self.repo.wread(f)
+if self.restrict:
-if util.binary(data):
+data = self.repo.file(f).read(mf[f])
-continue
+else:
-if expand:
+data = self.repo.wread(f)
-if iswctx:
+if util.binary(data):
-ctx = self.repo.filectx(f, fileid=mf[f]).changectx()
+continue
-data, found = self.substitute(data, f, ctx,
+if expand:
-self.re_kw.subn)
+if lookup:
-else:
+fctx = self.repo.filectx(f, fileid=mf[f]).changectx()
-found = self.re_kw.search(data)
+data, found = self.substitute(data, f, fctx, subn)
-if found:
+elif self.restrict:
-self.ui.note(msg % f)
+found = self.re_kw.search(data)
-self.repo.wwrite(f, data, mf.flags(f))
+else:
-if iswctx and not rollback:
+data, found = _shrinktext(data, subn)
-self.repo.dirstate.normal(f)
+if found:
-elif self.record:
+self.ui.note(msg % f)
-self.repo.dirstate.normallookup(f)
+self.repo.wwrite(f, data, ctx.flags(f))
-self.restrict = restrict
+if commit:
+self.repo.dirstate.normal(f)
-def shrinktext(self, text):
+elif self.record:
-'''Unconditionally removes all keyword substitutions from text.'''
+self.repo.dirstate.normallookup(f)
-return self.re_kw.sub(r'$\1$', text)
 def shrink(self, fname, text):
 '''Returns text with all keyword substitutions removed.'''
 if self.match(fname) and not util.binary(text):
-return self.shrinktext(text)
+return _shrinktext(text, self.re_kwexp.sub)
 return text
 def shrinklines(self, fname, lines):
 '''Returns lines with keyword substitutions removed.'''
 if self.match(fname):
 text = ''.join(lines)
 if not util.binary(text):
-return self.shrinktext(text).splitlines(True)
+return _shrinktext(text, self.re_kwexp.sub).splitlines(True)
 return lines
 def wread(self, fname, data):
 '''If in restricted mode returns data read from wdir with
 keyword substitutions removed.'''
 self.path = path
 def read(self, node):
 '''Expands keywords when reading filelog.'''
 data = super(kwfilelog, self).read(node)
+if self.renamed(node):
+return data
 return self.kwt.expand(self.path, node, data)
 def add(self, text, meta, tr, link, p1=None, p2=None):
 '''Removes keyword substitutions when adding to filelog.'''
 text = self.kwt.shrink(self.path, text)
 return super(kwfilelog, self).add(text, meta, tr, link, p1, p2)
 def cmp(self, node, text):
 '''Removes keyword substitutions for comparison.'''
 text = self.kwt.shrink(self.path, text)
-if self.renamed(node):
+return super(kwfilelog, self).cmp(node, text)
-t2 = super(kwfilelog, self).read(node)
-return t2 != text
-return revlog.revlog.cmp(self, node, text)
 def _status(ui, repo, kwt, *pats, **opts):
 '''Bails out if [keyword] configuration is not active.
 Returns status of working directory.'''
 if kwt:
 try:
 status = _status(ui, repo, kwt, *pats, **opts)
 modified, added, removed, deleted, unknown, ignored, clean = status
 if modified or added or removed or deleted:
 raise util.Abort(_('outstanding uncommitted changes'))
-kwt.overwrite(wctx, clean, True, expand, None)
+kwt.overwrite(wctx, clean, True, expand)
 finally:
 wlock.release()
 def demo(ui, repo, *args, **opts):
 '''print [keywordmaps] configuration and an expansion example
 modified, added, removed, deleted, unknown, ignored, clean = status
 files = []
 if not opts.get('unknown') or opts.get('all'):
 files = sorted(modified + added + clean)
 wctx = repo[None]
-kwfiles = [f for f in files if kwt.iskwfile(f, wctx.flags)]
+kwfiles = kwt.iskwfile(files, wctx)
-kwunknown = [f for f in unknown if kwt.iskwfile(f, wctx.flags)]
+kwunknown = kwt.iskwfile(unknown, wctx)
 if not opts.get('ignore') or opts.get('all'):
 showfiles = kwfiles, kwunknown
 else:
 showfiles = [], []
 if opts.get('all') or opts.get('ignore'):
 def kwcommitctx(self, ctx, error=False):
 n = super(kwrepo, self).commitctx(ctx, error)
 # no lock needed, only called from repo.commit() which already locks
 if not kwt.record:
+restrict = kwt.restrict
+kwt.restrict = True
 kwt.overwrite(self[n], sorted(ctx.added() + ctx.modified()),
-False, True, None)
+False, True)
+kwt.restrict = restrict
 return n
 def rollback(self, dryrun=False):
 wlock = repo.wlock()
 try:
 if not dryrun:
-cfiles = self['.'].files()
+changed = self['.'].files()
 ret = super(kwrepo, self).rollback(dryrun)
 if not dryrun:
 ctx = self['.']
-modified, added = super(kwrepo, self).status()[:2]
+modified, added = self[None].status()[:2]
-kwt.overwrite(ctx, added, True, False, cfiles)
+modified = [f for f in modified if f in changed]
-kwt.overwrite(ctx, modified, True, True, cfiles)
+added = [f for f in added if f in changed]
+kwt.overwrite(ctx, added, True, False)
+kwt.overwrite(ctx, modified, True, True)
 return ret
 finally:
 wlock.release()
 # monkeypatches
 def kwweb_skip(orig, web, req, tmpl):
 '''Wraps webcommands.x turning off keyword expansion.'''
 kwt.match = util.never
 return orig(web, req, tmpl)
+def kw_copy(orig, ui, repo, pats, opts, rename=False):
+'''Wraps cmdutil.copy so that copy/rename destinations do not
+contain expanded keywords.
+Note that the source may also be a symlink as:
+hg cp sym x                -> x is symlink
+cp sym x; hg cp -A sym x   -> x is file (maybe expanded keywords)
+'''
+orig(ui, repo, pats, opts, rename)
+if opts.get('dry_run'):
+return
+wctx = repo[None]
+candidates = [f for f in repo.dirstate.copies() if
+kwt.match(repo.dirstate.copied(f)) and
+not 'l' in wctx.flags(f)]
+kwt.overwrite(wctx, candidates, False, False)
 def kw_dorecord(orig, ui, repo, commitfunc, *pats, **opts):
 '''Wraps record.dorecord expanding keywords after recording.'''
 wlock = repo.wlock()
 try:
 # record returns 0 even when nothing has changed
 # therefore compare nodes before and after
+kwt.record = True
 ctx = repo['.']
+modified, added = repo[None].status()[:2]
 ret = orig(ui, repo, commitfunc, *pats, **opts)
-recordctx = repo['.']
+recctx = repo['.']
-if ctx != recordctx:
+if ctx != recctx:
-kwt.overwrite(recordctx, recordctx.files(),
+modified = [f for f in modified if f in recctx]
-False, True, recordctx)
+added = [f for f in added if f in recctx]
+kwt.restrict = False
+kwt.overwrite(recctx, modified, False, True, kwt.re_kwexp.subn)
+kwt.overwrite(recctx, added, False, True, kwt.re_kw.subn)
+kwt.restrict = True
 return ret
 finally:
 wlock.release()
 repo.__class__ = kwrepo
 extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init)
 extensions.wrapfunction(patch, 'diff', kw_diff)
+extensions.wrapfunction(cmdutil, 'copy', kw_copy)
 for c in 'annotate changeset rev filediff diff'.split():
 extensions.wrapfunction(webcommands, c, kwweb_skip)
 for name in recordextensions.split():
 try:
 record = extensions.find(name)

branch	stable
changeset 820	67c17a447d99
parent 819	8f2c2cc51789
child 836	53a9228f13de