This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8893

templater: pass opened file-like object to templatespec
ClosedPublic

Authored by martinvonz on Aug 5 2020, 12:26 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGf3481e4fcc3a: templater: pass opened file-like object to templatespec
Summary

I think I said earlier that I planned to create a special templatespec
variant for built-in templates. That was true (I planned that), but I
ended up (in this patch) just adding a file-like object to the
mapfile_templatespec() variant instead.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

PathPackages
Mmercurial/formatter.py (13 lines)
Mmercurial/logcmdutil.py (3 lines)
Mmercurial/templater.py (4 lines)

Diff 22291

mercurial/formatter.py

@attr.s(frozen=True) @attr.s(frozen=True)
class templatespec(object): class templatespec(object):
ref = attr.ib() ref = attr.ib()
tmpl = attr.ib() tmpl = attr.ib()
mapfile = attr.ib() mapfile = attr.ib()
refargs = attr.ib(default=None) refargs = attr.ib(default=None)
fp = attr.ib(default=None)
def empty_templatespec(): def empty_templatespec():
return templatespec(None, None, None) return templatespec(None, None, None)
def reference_templatespec(ref, refargs=None): def reference_templatespec(ref, refargs=None):
return templatespec(ref, None, None, refargs) return templatespec(ref, None, None, refargs)
def literal_templatespec(tmpl): def literal_templatespec(tmpl):
if pycompat.ispy3: if pycompat.ispy3:
assert not isinstance(tmpl, str), b'tmpl must not be a str' assert not isinstance(tmpl, str), b'tmpl must not be a str'
return templatespec(b'', tmpl, None) return templatespec(b'', tmpl, None)
def mapfile_templatespec(topic, mapfile): def mapfile_templatespec(topic, mapfile, fp=None):
return templatespec(topic, None, mapfile) return templatespec(topic, None, mapfile, fp=fp)
def lookuptemplate(ui, topic, tmpl): def lookuptemplate(ui, topic, tmpl):
"""Find the template matching the given -T/--template spec 'tmpl' """Find the template matching the given -T/--template spec 'tmpl'
'tmpl' can be any of the following: 'tmpl' can be any of the following:
- a literal template (e.g. '{rev}') - a literal template (e.g. '{rev}')
return reference_templatespec(func, refargs=ftail[:-1]) return reference_templatespec(func, refargs=ftail[:-1])
# perhaps a stock style? # perhaps a stock style?
if not os.path.split(tmpl)[0]: if not os.path.split(tmpl)[0]:
(mapname, fp) = templater.open_template( (mapname, fp) = templater.open_template(
b'map-cmdline.' + tmpl b'map-cmdline.' + tmpl
) or templater.open_template(tmpl) ) or templater.open_template(tmpl)
if mapname: if mapname:
return mapfile_templatespec(topic, mapname) return mapfile_templatespec(topic, mapname, fp)
# perhaps it's a reference to [templates] # perhaps it's a reference to [templates]
if ui.config(b'templates', tmpl): if ui.config(b'templates', tmpl):
return reference_templatespec(tmpl) return reference_templatespec(tmpl)
if tmpl == b'list': if tmpl == b'list':
ui.write(_(b"available styles: %s\n") % templater.stylelist()) ui.write(_(b"available styles: %s\n") % templater.stylelist())
raise error.Abort(_(b"specify a template")) raise error.Abort(_(b"specify a template"))
def loadtemplater(ui, spec, defaults=None, resources=None, cache=None): def loadtemplater(ui, spec, defaults=None, resources=None, cache=None):
"""Create a templater from either a literal template or loading from """Create a templater from either a literal template or loading from
a map file""" a map file"""
assert not (spec.tmpl and spec.mapfile) assert not (spec.tmpl and spec.mapfile)
if spec.mapfile: if spec.mapfile:
return templater.templater.frommapfile( return templater.templater.frommapfile(
spec.mapfile, defaults=defaults, resources=resources, cache=cache spec.mapfile,
spec.fp,
defaults=defaults,
resources=resources,
cache=cache,
) )
return maketemplater( return maketemplater(
ui, spec.tmpl, defaults=defaults, resources=resources, cache=cache ui, spec.tmpl, defaults=defaults, resources=resources, cache=cache
) )
def maketemplater(ui, tmpl, defaults=None, resources=None, cache=None): def maketemplater(ui, tmpl, defaults=None, resources=None, cache=None):
"""Create a templater from a string template 'tmpl'""" """Create a templater from a string template 'tmpl'"""

mercurial/logcmdutil.py

tmpl = ui.config(b'ui', b'logtemplate') tmpl = ui.config(b'ui', b'logtemplate')
if tmpl: if tmpl:
return formatter.literal_templatespec(templater.unquotestring(tmpl)) return formatter.literal_templatespec(templater.unquotestring(tmpl))
else: else:
style = util.expandpath(ui.config(b'ui', b'style')) style = util.expandpath(ui.config(b'ui', b'style'))
if not tmpl and style: if not tmpl and style:
mapfile = style mapfile = style
fp = None
if not os.path.split(mapfile)[0]: if not os.path.split(mapfile)[0]:
(mapname, fp) = templater.open_template( (mapname, fp) = templater.open_template(
b'map-cmdline.' + mapfile b'map-cmdline.' + mapfile
) or templater.open_template(mapfile) ) or templater.open_template(mapfile)
if mapname: if mapname:
mapfile = mapname mapfile = mapname
return formatter.mapfile_templatespec(b'changeset', mapfile) return formatter.mapfile_templatespec(b'changeset', mapfile, fp)
return formatter.lookuptemplate(ui, b'changeset', tmpl) return formatter.lookuptemplate(ui, b'changeset', tmpl)
def maketemplater(ui, repo, tmpl, buffered=False): def maketemplater(ui, repo, tmpl, buffered=False):
"""Create a changesettemplater from a literal template 'tmpl' """Create a changesettemplater from a literal template 'tmpl'
byte-string.""" byte-string."""
spec = formatter.literal_templatespec(tmpl) spec = formatter.literal_templatespec(tmpl)

mercurial/templater.py

self._loader = loader(cache, aliases) self._loader = loader(cache, aliases)
self._proc = engine(self._loader.load, allfilters, defaults, resources) self._proc = engine(self._loader.load, allfilters, defaults, resources)
self._minchunk, self._maxchunk = minchunk, maxchunk self._minchunk, self._maxchunk = minchunk, maxchunk
@classmethod @classmethod
def frommapfile( def frommapfile(
cls, cls,
mapfile, mapfile,
fp=None,
filters=None, filters=None,
defaults=None, defaults=None,
resources=None, resources=None,
cache=None, cache=None,
minchunk=1024, minchunk=1024,
maxchunk=65536, maxchunk=65536,
): ):
"""Create templater from the specified map file""" """Create templater from the specified map file"""
t = cls(filters, defaults, resources, cache, [], minchunk, maxchunk) t = cls(filters, defaults, resources, cache, [], minchunk, maxchunk)
if not fp:
fp = _open_mapfile(mapfile) fp = _open_mapfile(mapfile)
cache, tmap, aliases = _readmapfile(fp, mapfile) cache, tmap, aliases = _readmapfile(fp, mapfile)
t._loader.cache.update(cache) t._loader.cache.update(cache)
t._loader._map = tmap t._loader._map = tmap
t._loader._aliasmap = _aliasrules.buildmap(aliases) t._loader._aliasmap = _aliasrules.buildmap(aliases)
return t return t
def __contains__(self, key): def __contains__(self, key):
return key in self._loader return key in self._loader