test: comparison hgkw/keyword.py

equal deleted inserted replaced

-:13043607c6ae
+:e089672ef9b4
 '''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 }
+kwtools = {'templater': None, 'hgcmd': None}
 # monkeypatches and backwards compatibility hacks
 try:
 # cmdutil.parse moves to dispatch._parse in 18a9fbb5cd78
 _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
+kwtools['hgcmd'] = cmd
 return cmd, func, args, options, cmdoptions
 try:
 setattr(dispatch, '_parse', _kwdispatch_parse)
 except (NameError, ImportError):
 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)
+self.lines = kwtools['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
+kwtools['templater'].matcher = util.never
 elif node1 is not None and node1 != repo.changectx().node():
-kwx['templater'].restrict = True
+kwtools['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']:
+if kwtools['templater']:
-kwx['templater'].matcher = util.never
+kwtools['templater'].matcher = util.never
 return web.changeset(tmpl, web.changectx(req))
 def _kwweb_filediff(web, req, tmpl):
 '''Wraps webcommands.filediff turning off keyword expansion.'''
-if kwx['templater']:
+if kwtools['templater']:
-kwx['templater'].matcher = util.never
+kwtools['templater'].matcher = util.never
 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']:
+if kwtools['templater']:
-kwx['templater'].matcher = util.never
+kwtools['templater'].matcher = util.never
 req.write(self.changeset(self.changectx(req)))
 def _kwweb_do_filediff(self, req):
-if kwx['templater']:
+if kwtools['templater']:
-kwx['templater'].matcher = util.never
+kwtools['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
 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()
+self.restrict = kwtools['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]
 except TypeError:
 return cmdutil.changeset_templater(self.ui, self.repo,
 False, None, '', False)
 def getnode(self, path, fnode):
-'''Derives changenode from file context.'''
+'''Derives changenode from file path and filenode.'''
+# used by kwfilelog.read and kwexpand
 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.'''
 Subclass of filelog to hook into its read, add, cmp methods.
 Keywords are "stored" unexpanded, and processed on reading.
 '''
 def __init__(self, opener, path):
 super(kwfilelog, self).__init__(opener, path)
-self.kwt = kwx['templater']
+self.kwt = kwtools['templater']
 self.path = path
 def read(self, node):
 '''Expands keywords when reading filelog.'''
 data = super(kwfilelog, self).read(node)
 raise util.Abort(_('[keyword] patterns cannot match'))
 raise util.Abort(_('no [keyword] patterns configured'))
 def _kwfwrite(ui, repo, expand, *pats, **opts):
 '''Selects files and passes them to kwtemplater.overwrite.'''
-kwt = kwx['templater']
+kwt = kwtools['templater']
 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 in given files'))
 wlock = lock = None
 Crosscheck which files in working directory are potential targets for
 keyword expansion.
 That is, files matched by [keyword] config patterns but not symlinks.
 '''
-kwt = kwx['templater']
+kwt = kwtools['templater']
 status = _status(ui, repo, kwt, *pats, **opts)
 modified, added, removed, deleted, unknown, ignored, clean = status
 files = modified + added + clean
 if opts.get('untracked'):
 files += unknown
 keyword substitutions.
 This is done for local repos only, and only if there are
 files configured at all for keyword substitution.'''
 try:
-if (not repo.local() or kwx['hgcmd'] in nokwcommands.split()
+if (not repo.local() or kwtools['hgcmd'] in nokwcommands.split()
 or '.hg' in repo.root.split(os.sep)
 or repo._url.startswith('bundle:')):
 return
 except AttributeError:
 pass
 else:
 exc.append(pat)
 if not inc:
 return
-kwx['templater'] = kwt = kwtemplater(ui, repo, inc, exc)
+kwtools['templater'] = kwt = kwtemplater(ui, repo, inc, exc)
 class kwrepo(repo.__class__):
 def file(self, f):
 if f[0] == '/':
 f = f[1:]

branch	0.9.2compat
changeset 417	e089672ef9b4
parent 414	13043607c6ae
child 420	25f2d4cedd4c