formatter.py
870 lines
| 26.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / formatter.py
|
r16134 | # formatter.py - generic output formatting for mercurial | ||
# | ||||
|
r47575 | # Copyright 2012 Olivia Mackall <olivia@selenic.com> | ||
|
r16134 | # | ||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
|
r30560 | """Generic output formatting for Mercurial | ||
The formatter provides API to show data in various ways. The following | ||||
functions should be used in place of ui.write(): | ||||
- fm.write() for unconditional output | ||||
- fm.condwrite() to show some extra data conditionally in plain output | ||||
|
r31172 | - fm.context() to provide changectx to template output | ||
|
r30560 | - fm.data() to provide extra data to JSON or template output | ||
- fm.plain() to show raw text that isn't provided to JSON or template output | ||||
To show structured data (e.g. date tuples, dicts, lists), apply fm.format*() | ||||
beforehand so the data is converted to the appropriate data type. Use | ||||
fm.isplain() if you need to convert or format data conditionally which isn't | ||||
supported by the formatter API. | ||||
To build nested structure (i.e. a list of dicts), use fm.nested(). | ||||
See also https://www.mercurial-scm.org/wiki/GenericTemplatingPlan | ||||
fm.condwrite() vs 'if cond:': | ||||
In most cases, use fm.condwrite() so users can selectively show the data | ||||
in template output. If it's costly to build data, use plain 'if cond:' with | ||||
fm.write(). | ||||
fm.nested() vs fm.formatdict() (or fm.formatlist()): | ||||
fm.nested() should be used to form a tree structure (a list of dicts of | ||||
lists of dicts...) which can be accessed through template keywords, e.g. | ||||
"{foo % "{bar % {...}} {baz % {...}}"}". On the other hand, fm.formatdict() | ||||
exports a dict-type object to template, which can be accessed by e.g. | ||||
"{get(foo, key)}" function. | ||||
Doctest helper: | ||||
>>> def show(fn, verbose=False, **opts): | ||||
... import sys | ||||
... from . import ui as uimod | ||||
... ui = uimod.ui() | ||||
... ui.verbose = verbose | ||||
|
r34256 | ... ui.pushbuffer() | ||
... try: | ||||
|
r34257 | ... return fn(ui, ui.formatter(pycompat.sysbytes(fn.__name__), | ||
... pycompat.byteskwargs(opts))) | ||||
|
r34256 | ... finally: | ||
... print(pycompat.sysstr(ui.popbuffer()), end='') | ||||
|
r30560 | |||
Basic example: | ||||
>>> def files(ui, fm): | ||||
|
r34133 | ... files = [(b'foo', 123, (0, 0)), (b'bar', 456, (1, 0))] | ||
|
r30560 | ... for f in files: | ||
... fm.startitem() | ||||
|
r34133 | ... fm.write(b'path', b'%s', f[0]) | ||
... fm.condwrite(ui.verbose, b'date', b' %s', | ||||
... fm.formatdate(f[2], b'%Y-%m-%d %H:%M:%S')) | ||||
|
r30560 | ... fm.data(size=f[1]) | ||
|
r34133 | ... fm.plain(b'\\n') | ||
|
r30560 | ... fm.end() | ||
>>> show(files) | ||||
foo | ||||
bar | ||||
>>> show(files, verbose=True) | ||||
foo 1970-01-01 00:00:00 | ||||
bar 1970-01-01 00:00:01 | ||||
|
r34133 | >>> show(files, template=b'json') | ||
|
r30560 | [ | ||
{ | ||||
"date": [0, 0], | ||||
"path": "foo", | ||||
"size": 123 | ||||
}, | ||||
{ | ||||
"date": [1, 0], | ||||
"path": "bar", | ||||
"size": 456 | ||||
} | ||||
] | ||||
|
r34133 | >>> show(files, template=b'path: {path}\\ndate: {date|rfc3339date}\\n') | ||
|
r30560 | path: foo | ||
date: 1970-01-01T00:00:00+00:00 | ||||
path: bar | ||||
date: 1970-01-01T00:00:01+00:00 | ||||
Nested example: | ||||
>>> def subrepos(ui, fm): | ||||
... fm.startitem() | ||||
|
r35486 | ... fm.write(b'reponame', b'[%s]\\n', b'baz') | ||
|
r37518 | ... files(ui, fm.nested(b'files', tmpl=b'{reponame}')) | ||
|
r30560 | ... fm.end() | ||
>>> show(subrepos) | ||||
[baz] | ||||
foo | ||||
bar | ||||
|
r35486 | >>> show(subrepos, template=b'{reponame}: {join(files % "{path}", ", ")}\\n') | ||
|
r30560 | baz: foo, bar | ||
""" | ||||
|
r25950 | |||
|
r32574 | import contextlib | ||
|
r31807 | import itertools | ||
|
r25511 | import os | ||
|
r49725 | import pickle | ||
|
r22428 | |||
|
r25950 | from .i18n import _ | ||
from .node import ( | ||||
hex, | ||||
short, | ||||
) | ||||
|
r43346 | from .thirdparty import attr | ||
|
r25950 | |||
from . import ( | ||||
|
r26587 | error, | ||
|
r32159 | pycompat, | ||
|
r31782 | templatefilters, | ||
|
r29676 | templatekw, | ||
|
r25950 | templater, | ||
|
r36938 | templateutil, | ||
|
r29324 | util, | ||
|
r25950 | ) | ||
|
r40310 | from .utils import ( | ||
|
r42163 | cborutil, | ||
|
r40310 | dateutil, | ||
stringutil, | ||||
) | ||||
|
r25950 | |||
|
r43346 | |||
|
r43643 | def isprintable(obj): | ||
"""Check if the given object can be directly passed in to formatter's | ||||
write() and data() functions | ||||
Returns False if the object is unsupported or must be pre-processed by | ||||
formatdate(), formatdict(), or formatlist(). | ||||
""" | ||||
|
r49787 | return isinstance(obj, (type(None), bool, int, int, float, bytes)) | ||
|
r43643 | |||
|
r29836 | class _nullconverter(object): | ||
'''convert non-primitive data types to be processed by formatter''' | ||||
|
r33090 | |||
# set to True if context object should be stored as item | ||||
storecontext = False | ||||
|
r29836 | @staticmethod | ||
|
r37518 | def wrapnested(data, tmpl, sep): | ||
'''wrap nested data by appropriate type''' | ||||
return data | ||||
|
r43346 | |||
|
r37518 | @staticmethod | ||
|
r29836 | def formatdate(date, fmt): | ||
'''convert date tuple to appropriate format''' | ||||
|
r37788 | # timestamp can be float, but the canonical form should be int | ||
ts, tz = date | ||||
return (int(ts), tz) | ||||
|
r43346 | |||
|
r29836 | @staticmethod | ||
def formatdict(data, key, value, fmt, sep): | ||||
'''convert dict or key-value pairs to appropriate dict format''' | ||||
# use plain dict instead of util.sortdict so that data can be | ||||
# serialized as a builtin dict in pickle output | ||||
return dict(data) | ||||
|
r43346 | |||
|
r29836 | @staticmethod | ||
def formatlist(data, name, fmt, sep): | ||||
'''convert iterable to appropriate list format''' | ||||
return list(data) | ||||
|
r43346 | |||
|
r16134 | class baseformatter(object): | ||
r47503 | ||||
# set to True if the formater output a strict format that does not support | ||||
# arbitrary output in the stream. | ||||
strict_format = False | ||||
|
r29836 | def __init__(self, ui, topic, opts, converter): | ||
|
r16134 | self._ui = ui | ||
self._topic = topic | ||||
|
r37615 | self._opts = opts | ||
|
r29836 | self._converter = converter | ||
|
r16134 | self._item = None | ||
|
r22701 | # function to convert node to string suitable for this output | ||
self.hexfunc = hex | ||||
|
r43346 | |||
|
r29882 | def __enter__(self): | ||
return self | ||||
|
r43346 | |||
|
r29882 | def __exit__(self, exctype, excvalue, traceback): | ||
if exctype is None: | ||||
self.end() | ||||
|
r43346 | |||
|
r16134 | def _showitem(self): | ||
'''show a formatted item once all data is collected''' | ||||
|
r43346 | |||
|
r16134 | def startitem(self): | ||
'''begin an item in the format list''' | ||||
if self._item is not None: | ||||
self._showitem() | ||||
self._item = {} | ||||
|
r43346 | |||
|
r43347 | def formatdate(self, date, fmt=b'%a %b %d %H:%M:%S %Y %1%2'): | ||
|
r29678 | '''convert date tuple to appropriate format''' | ||
|
r29836 | return self._converter.formatdate(date, fmt) | ||
|
r43346 | |||
|
r43347 | def formatdict(self, data, key=b'key', value=b'value', fmt=None, sep=b' '): | ||
|
r29794 | '''convert dict or key-value pairs to appropriate dict format''' | ||
|
r29836 | return self._converter.formatdict(data, key, value, fmt, sep) | ||
|
r43346 | |||
|
r43347 | def formatlist(self, data, name, fmt=None, sep=b' '): | ||
|
r29676 | '''convert iterable to appropriate list format''' | ||
|
r29836 | # name is mandatory argument for now, but it could be optional if | ||
# we have default template keyword, e.g. {item} | ||||
return self._converter.formatlist(data, name, fmt, sep) | ||||
|
r43346 | |||
|
r31172 | def context(self, **ctxs): | ||
'''insert context objects to be used to render template keywords''' | ||||
|
r33090 | ctxs = pycompat.byteskwargs(ctxs) | ||
|
r43347 | assert all(k in {b'repo', b'ctx', b'fctx'} for k in ctxs) | ||
|
r33090 | if self._converter.storecontext: | ||
|
r39619 | # populate missing resources in fctx -> ctx -> repo order | ||
|
r43347 | if b'fctx' in ctxs and b'ctx' not in ctxs: | ||
ctxs[b'ctx'] = ctxs[b'fctx'].changectx() | ||||
if b'ctx' in ctxs and b'repo' not in ctxs: | ||||
ctxs[b'repo'] = ctxs[b'ctx'].repo() | ||||
|
r33090 | self._item.update(ctxs) | ||
|
r43346 | |||
|
r38375 | def datahint(self): | ||
'''set of field names to be referenced''' | ||||
return set() | ||||
|
r43346 | |||
|
r16134 | def data(self, **data): | ||
'''insert data into item that's not shown in default output''' | ||||
|
r32159 | data = pycompat.byteskwargs(data) | ||
|
r17630 | self._item.update(data) | ||
|
r43346 | |||
|
r16134 | def write(self, fields, deftext, *fielddata, **opts): | ||
'''do default text output while assigning data to item''' | ||||
|
r26372 | fieldkeys = fields.split() | ||
|
r40175 | assert len(fieldkeys) == len(fielddata), (fieldkeys, fielddata) | ||
|
r26373 | self._item.update(zip(fieldkeys, fielddata)) | ||
|
r43346 | |||
|
r17909 | def condwrite(self, cond, fields, deftext, *fielddata, **opts): | ||
'''do conditional write (primarily for plain formatter)''' | ||||
|
r26372 | fieldkeys = fields.split() | ||
assert len(fieldkeys) == len(fielddata) | ||||
|
r26373 | self._item.update(zip(fieldkeys, fielddata)) | ||
|
r43346 | |||
|
r16134 | def plain(self, text, **opts): | ||
'''show raw text for non-templated mode''' | ||||
|
r43346 | |||
|
r29949 | def isplain(self): | ||
'''check for plain formatter usage''' | ||||
return False | ||||
|
r43346 | |||
|
r43347 | def nested(self, field, tmpl=None, sep=b''): | ||
|
r29837 | '''sub formatter to store nested data in the specified field''' | ||
|
r37518 | data = [] | ||
self._item[field] = self._converter.wrapnested(data, tmpl, sep) | ||||
|
r29837 | return _nestedformatter(self._ui, self._converter, data) | ||
|
r43346 | |||
|
r16134 | def end(self): | ||
'''end output for the formatter''' | ||||
if self._item is not None: | ||||
self._showitem() | ||||
|
r43346 | |||
|
r37615 | def nullformatter(ui, topic, opts): | ||
|
r32575 | '''formatter that prints nothing''' | ||
|
r37615 | return baseformatter(ui, topic, opts, converter=_nullconverter) | ||
|
r32575 | |||
|
r43346 | |||
|
r29837 | class _nestedformatter(baseformatter): | ||
'''build sub items and store them in the parent formatter''' | ||||
|
r43346 | |||
|
r29837 | def __init__(self, ui, converter, data): | ||
|
r43347 | baseformatter.__init__( | ||
self, ui, topic=b'', opts={}, converter=converter | ||||
) | ||||
|
r29837 | self._data = data | ||
|
r43346 | |||
|
r29837 | def _showitem(self): | ||
self._data.append(self._item) | ||||
|
r43346 | |||
|
r29794 | def _iteritems(data): | ||
'''iterate key-value pairs in stable order''' | ||||
if isinstance(data, dict): | ||||
|
r49768 | return sorted(data.items()) | ||
|
r29794 | return data | ||
|
r43346 | |||
|
r29836 | class _plainconverter(object): | ||
'''convert non-primitive data types to text''' | ||||
|
r33090 | |||
storecontext = False | ||||
|
r29836 | @staticmethod | ||
|
r37518 | def wrapnested(data, tmpl, sep): | ||
|
r43347 | raise error.ProgrammingError(b'plainformatter should never be nested') | ||
|
r43346 | |||
|
r37518 | @staticmethod | ||
|
r29836 | def formatdate(date, fmt): | ||
'''stringify date tuple in the given format''' | ||||
|
r36625 | return dateutil.datestr(date, fmt) | ||
|
r43346 | |||
|
r29836 | @staticmethod | ||
def formatdict(data, key, value, fmt, sep): | ||||
'''stringify key-value pairs separated by sep''' | ||||
|
r36652 | prefmt = pycompat.identity | ||
|
r36651 | if fmt is None: | ||
|
r43347 | fmt = b'%s=%s' | ||
|
r36652 | prefmt = pycompat.bytestr | ||
|
r43346 | return sep.join( | ||
fmt % (prefmt(k), prefmt(v)) for k, v in _iteritems(data) | ||||
) | ||||
|
r29836 | @staticmethod | ||
def formatlist(data, name, fmt, sep): | ||||
'''stringify iterable separated by sep''' | ||||
|
r36652 | prefmt = pycompat.identity | ||
|
r36651 | if fmt is None: | ||
|
r43347 | fmt = b'%s' | ||
|
r36652 | prefmt = pycompat.bytestr | ||
return sep.join(fmt % prefmt(e) for e in data) | ||||
|
r29836 | |||
|
r43346 | |||
|
r16134 | class plainformatter(baseformatter): | ||
'''the default text output scheme''' | ||||
|
r43346 | |||
|
r32573 | def __init__(self, ui, out, topic, opts): | ||
|
r29836 | baseformatter.__init__(self, ui, topic, opts, _plainconverter) | ||
|
r22701 | if ui.debugflag: | ||
self.hexfunc = hex | ||||
else: | ||||
self.hexfunc = short | ||||
|
r32573 | if ui is out: | ||
self._write = ui.write | ||||
else: | ||||
self._write = lambda s, **opts: out.write(s) | ||||
|
r43346 | |||
|
r16134 | def startitem(self): | ||
pass | ||||
|
r43346 | |||
|
r16134 | def data(self, **data): | ||
pass | ||||
|
r43346 | |||
|
r16134 | def write(self, fields, deftext, *fielddata, **opts): | ||
|
r32573 | self._write(deftext % fielddata, **opts) | ||
|
r43346 | |||
|
r17909 | def condwrite(self, cond, fields, deftext, *fielddata, **opts): | ||
'''do conditional write''' | ||||
if cond: | ||||
|
r32573 | self._write(deftext % fielddata, **opts) | ||
|
r43346 | |||
|
r16134 | def plain(self, text, **opts): | ||
|
r32573 | self._write(text, **opts) | ||
|
r43346 | |||
|
r29949 | def isplain(self): | ||
return True | ||||
|
r43346 | |||
|
r43347 | def nested(self, field, tmpl=None, sep=b''): | ||
|
r29837 | # nested data will be directly written to ui | ||
return self | ||||
|
r43346 | |||
|
r16134 | def end(self): | ||
pass | ||||
|
r43346 | |||
|
r16134 | class debugformatter(baseformatter): | ||
|
r31182 | def __init__(self, ui, out, topic, opts): | ||
|
r29836 | baseformatter.__init__(self, ui, topic, opts, _nullconverter) | ||
|
r31182 | self._out = out | ||
|
r43347 | self._out.write(b"%s = [\n" % self._topic) | ||
|
r43346 | |||
|
r16134 | def _showitem(self): | ||
|
r43346 | self._out.write( | ||
|
r43347 | b' %s,\n' % stringutil.pprint(self._item, indent=4, level=1) | ||
|
r43346 | ) | ||
|
r16134 | def end(self): | ||
baseformatter.end(self) | ||||
|
r43347 | self._out.write(b"]\n") | ||
|
r16134 | |||
|
r43346 | |||
|
r22430 | class pickleformatter(baseformatter): | ||
|
r31182 | def __init__(self, ui, out, topic, opts): | ||
|
r29836 | baseformatter.__init__(self, ui, topic, opts, _nullconverter) | ||
|
r31182 | self._out = out | ||
|
r22430 | self._data = [] | ||
|
r43346 | |||
|
r22430 | def _showitem(self): | ||
self._data.append(self._item) | ||||
|
r43346 | |||
|
r22430 | def end(self): | ||
baseformatter.end(self) | ||||
|
r31182 | self._out.write(pickle.dumps(self._data)) | ||
|
r22430 | |||
|
r43346 | |||
|
r42163 | class cborformatter(baseformatter): | ||
'''serialize items as an indefinite-length CBOR array''' | ||||
|
r43346 | |||
|
r42163 | def __init__(self, ui, out, topic, opts): | ||
baseformatter.__init__(self, ui, topic, opts, _nullconverter) | ||||
self._out = out | ||||
self._out.write(cborutil.BEGIN_INDEFINITE_ARRAY) | ||||
|
r43346 | |||
|
r42163 | def _showitem(self): | ||
self._out.write(b''.join(cborutil.streamencode(self._item))) | ||||
|
r43346 | |||
|
r42163 | def end(self): | ||
baseformatter.end(self) | ||||
self._out.write(cborutil.BREAK) | ||||
|
r43346 | |||
|
r22428 | class jsonformatter(baseformatter): | ||
r47503 | ||||
strict_format = True | ||||
|
r31182 | def __init__(self, ui, out, topic, opts): | ||
|
r29836 | baseformatter.__init__(self, ui, topic, opts, _nullconverter) | ||
|
r31182 | self._out = out | ||
|
r43347 | self._out.write(b"[") | ||
|
r31298 | self._first = True | ||
|
r43346 | |||
|
r22428 | def _showitem(self): | ||
|
r31298 | if self._first: | ||
self._first = False | ||||
|
r22428 | else: | ||
|
r43347 | self._out.write(b",") | ||
|
r22428 | |||
|
r43347 | self._out.write(b"\n {\n") | ||
|
r22428 | first = True | ||
for k, v in sorted(self._item.items()): | ||||
if first: | ||||
first = False | ||||
else: | ||||
|
r43347 | self._out.write(b",\n") | ||
|
r31782 | u = templatefilters.json(v, paranoid=False) | ||
|
r43347 | self._out.write(b' "%s": %s' % (k, u)) | ||
self._out.write(b"\n }") | ||||
|
r43346 | |||
|
r22428 | def end(self): | ||
baseformatter.end(self) | ||||
|
r43347 | self._out.write(b"\n]\n") | ||
|
r22428 | |||
|
r43346 | |||
|
r29836 | class _templateconverter(object): | ||
'''convert non-primitive data types to be processed by templater''' | ||||
|
r33090 | |||
storecontext = True | ||||
|
r29836 | @staticmethod | ||
|
r37518 | def wrapnested(data, tmpl, sep): | ||
'''wrap nested data by templatable type''' | ||||
return templateutil.mappinglist(data, tmpl=tmpl, sep=sep) | ||||
|
r43346 | |||
|
r37518 | @staticmethod | ||
|
r29836 | def formatdate(date, fmt): | ||
'''return date tuple''' | ||||
|
r38304 | return templateutil.date(date) | ||
|
r43346 | |||
|
r29836 | @staticmethod | ||
def formatdict(data, key, value, fmt, sep): | ||||
'''build object that can be evaluated as either plain string or dict''' | ||||
data = util.sortdict(_iteritems(data)) | ||||
|
r43346 | |||
|
r29836 | def f(): | ||
yield _plainconverter.formatdict(data, key, value, fmt, sep) | ||||
|
r43346 | |||
return templateutil.hybriddict( | ||||
data, key=key, value=value, fmt=fmt, gen=f | ||||
) | ||||
|
r29836 | @staticmethod | ||
def formatlist(data, name, fmt, sep): | ||||
'''build object that can be evaluated as either plain string or list''' | ||||
data = list(data) | ||||
|
r43346 | |||
|
r29836 | def f(): | ||
yield _plainconverter.formatlist(data, name, fmt, sep) | ||||
|
r43346 | |||
|
r36939 | return templateutil.hybridlist(data, name=name, fmt=fmt, gen=f) | ||
|
r29836 | |||
|
r43346 | |||
|
r25513 | class templateformatter(baseformatter): | ||
|
r43371 | def __init__(self, ui, out, topic, opts, spec, overridetemplates=None): | ||
|
r29836 | baseformatter.__init__(self, ui, topic, opts, _templateconverter) | ||
|
r31182 | self._out = out | ||
|
r32841 | self._tref = spec.ref | ||
|
r43346 | self._t = loadtemplater( | ||
ui, | ||||
spec, | ||||
defaults=templatekw.keywords, | ||||
resources=templateresources(ui), | ||||
cache=templatekw.defaulttempl, | ||||
) | ||||
|
r43371 | if overridetemplates: | ||
self._t.cache.update(overridetemplates) | ||||
|
r43346 | self._parts = templatepartsmap( | ||
|
r43347 | spec, self._t, [b'docheader', b'docfooter', b'separator'] | ||
|
r43346 | ) | ||
|
r31807 | self._counter = itertools.count() | ||
|
r43347 | self._renderitem(b'docheader', {}) | ||
|
r32949 | |||
|
r25513 | def _showitem(self): | ||
|
r32948 | item = self._item.copy() | ||
|
r43347 | item[b'index'] = index = next(self._counter) | ||
|
r32950 | if index > 0: | ||
|
r43347 | self._renderitem(b'separator', {}) | ||
|
r32948 | self._renderitem(self._tref, item) | ||
|
r32949 | def _renderitem(self, part, item): | ||
if part not in self._parts: | ||||
return | ||||
ref = self._parts[part] | ||||
|
r43645 | # None can't be put in the mapping dict since it means <unset> | ||
for k, v in item.items(): | ||||
if v is None: | ||||
item[k] = templateutil.wrappedvalue(v) | ||||
|
r37121 | self._out.write(self._t.render(ref, item)) | ||
|
r25513 | |||
|
r38375 | @util.propertycache | ||
def _symbolsused(self): | ||||
|
r38465 | return self._t.symbolsused(self._tref) | ||
|
r38375 | |||
def datahint(self): | ||||
'''set of field names to be referenced from the template''' | ||||
return self._symbolsused[0] | ||||
|
r32949 | def end(self): | ||
baseformatter.end(self) | ||||
|
r43347 | self._renderitem(b'docfooter', {}) | ||
|
r32949 | |||
|
r43346 | |||
|
r37860 | @attr.s(frozen=True) | ||
class templatespec(object): | ||||
ref = attr.ib() | ||||
tmpl = attr.ib() | ||||
mapfile = attr.ib() | ||||
|
r43371 | refargs = attr.ib(default=None) | ||
|
r45870 | fp = attr.ib(default=None) | ||
|
r32838 | |||
|
r43346 | |||
|
r45824 | def empty_templatespec(): | ||
return templatespec(None, None, None) | ||||
def reference_templatespec(ref, refargs=None): | ||||
return templatespec(ref, None, None, refargs) | ||||
def literal_templatespec(tmpl): | ||||
|
r49743 | assert not isinstance(tmpl, str), b'tmpl must not be a str' | ||
|
r45824 | return templatespec(b'', tmpl, None) | ||
|
r45870 | def mapfile_templatespec(topic, mapfile, fp=None): | ||
return templatespec(topic, None, mapfile, fp=fp) | ||||
|
r45824 | |||
|
r25511 | def lookuptemplate(ui, topic, tmpl): | ||
|
r32834 | """Find the template matching the given -T/--template spec 'tmpl' | ||
'tmpl' can be any of the following: | ||||
- a literal template (e.g. '{rev}') | ||||
|
r43370 | - a reference to built-in template (i.e. formatter) | ||
|
r32834 | - a map-file name or path (e.g. 'changelog') | ||
- a reference to [templates] in config file | ||||
- a path to raw template file | ||||
A map file defines a stand-alone template environment. If a map file | ||||
selected, all templates defined in the file will be loaded, and the | ||||
|
r34716 | template matching the given topic will be rendered. Aliases won't be | ||
loaded from user config, but from the map file. | ||||
|
r32875 | |||
If no map file selected, all templates in [templates] section will be | ||||
available as well as aliases in [templatealias]. | ||||
|
r32834 | """ | ||
|
r43370 | if not tmpl: | ||
|
r45824 | return empty_templatespec() | ||
|
r43370 | |||
|
r25511 | # looks like a literal template? | ||
|
r43347 | if b'{' in tmpl: | ||
|
r45824 | return literal_templatespec(tmpl) | ||
|
r25511 | |||
|
r43370 | # a reference to built-in (formatter) template | ||
if tmpl in {b'cbor', b'json', b'pickle', b'debug'}: | ||||
|
r45824 | return reference_templatespec(tmpl) | ||
|
r43370 | |||
|
r43371 | # a function-style reference to built-in template | ||
func, fsep, ftail = tmpl.partition(b'(') | ||||
if func in {b'cbor', b'json'} and fsep and ftail.endswith(b')'): | ||||
templater.parseexpr(tmpl) # make sure syntax errors are confined | ||||
|
r45824 | return reference_templatespec(func, refargs=ftail[:-1]) | ||
|
r43371 | |||
|
r25511 | # perhaps a stock style? | ||
if not os.path.split(tmpl)[0]: | ||||
|
r45880 | (mapname, fp) = templater.try_open_template( | ||
|
r43347 | b'map-cmdline.' + tmpl | ||
|
r45880 | ) or templater.try_open_template(tmpl) | ||
|
r45820 | if mapname: | ||
|
r45870 | return mapfile_templatespec(topic, mapname, fp) | ||
|
r25511 | |||
# perhaps it's a reference to [templates] | ||||
|
r43347 | if ui.config(b'templates', tmpl): | ||
|
r45824 | return reference_templatespec(tmpl) | ||
|
r25511 | |||
|
r43347 | if tmpl == b'list': | ||
ui.write(_(b"available styles: %s\n") % templater.stylelist()) | ||||
raise error.Abort(_(b"specify a template")) | ||||
|
r25511 | |||
# perhaps it's a path to a map or a template | ||||
|
r43347 | if (b'/' in tmpl or b'\\' in tmpl) and os.path.isfile(tmpl): | ||
|
r25511 | # is it a mapfile for a style? | ||
|
r43347 | if os.path.basename(tmpl).startswith(b"map-"): | ||
|
r45824 | return mapfile_templatespec(topic, os.path.realpath(tmpl)) | ||
|
r43347 | with util.posixfile(tmpl, b'rb') as f: | ||
|
r32827 | tmpl = f.read() | ||
|
r45824 | return literal_templatespec(tmpl) | ||
|
r25511 | |||
# constant string? | ||||
|
r45824 | return literal_templatespec(tmpl) | ||
|
r25511 | |||
|
r43346 | |||
|
r32949 | def templatepartsmap(spec, t, partnames): | ||
"""Create a mapping of {part: ref}""" | ||||
partsmap = {spec.ref: spec.ref} # initial ref must exist in t | ||||
if spec.mapfile: | ||||
partsmap.update((p, p) for p in partnames if p in t) | ||||
|
r32952 | elif spec.ref: | ||
for part in partnames: | ||||
|
r43347 | ref = b'%s:%s' % (spec.ref, part) # select config sub-section | ||
|
r32952 | if ref in t: | ||
partsmap[part] = ref | ||||
|
r32949 | return partsmap | ||
|
r43346 | |||
|
r35499 | def loadtemplater(ui, spec, defaults=None, resources=None, cache=None): | ||
|
r32831 | """Create a templater from either a literal template or loading from | ||
a map file""" | ||||
|
r32838 | assert not (spec.tmpl and spec.mapfile) | ||
if spec.mapfile: | ||||
|
r45822 | return templater.templater.frommapfile( | ||
|
r45870 | spec.mapfile, | ||
spec.fp, | ||||
defaults=defaults, | ||||
resources=resources, | ||||
cache=cache, | ||||
|
r43346 | ) | ||
return maketemplater( | ||||
ui, spec.tmpl, defaults=defaults, resources=resources, cache=cache | ||||
) | ||||
|
r28955 | |||
|
r35499 | def maketemplater(ui, tmpl, defaults=None, resources=None, cache=None): | ||
|
r28955 | """Create a templater from a string template 'tmpl'""" | ||
|
r43347 | aliases = ui.configitems(b'templatealias') | ||
|
r43346 | t = templater.templater( | ||
defaults=defaults, resources=resources, cache=cache, aliases=aliases | ||||
) | ||||
t.cache.update( | ||||
|
r43347 | (k, templater.unquotestring(v)) for k, v in ui.configitems(b'templates') | ||
|
r43346 | ) | ||
|
r25512 | if tmpl: | ||
|
r43347 | t.cache[b''] = tmpl | ||
|
r25512 | return t | ||
|
r43346 | |||
|
r39622 | # marker to denote a resource to be loaded on demand based on mapping values | ||
# (e.g. (ctx, path) -> fctx) | ||||
_placeholder = object() | ||||
|
r43346 | |||
|
r37091 | class templateresources(templater.resourcemapper): | ||
"""Resource mapper designed for the default templatekw and function""" | ||||
def __init__(self, ui, repo=None): | ||||
self._resmap = { | ||||
|
r43347 | b'cache': {}, # for templatekw/funcs to store reusable data | ||
b'repo': repo, | ||||
b'ui': ui, | ||||
|
r37091 | } | ||
|
r35485 | |||
|
r39618 | def availablekeys(self, mapping): | ||
|
r43346 | return { | ||
k for k in self.knownkeys() if self._getsome(mapping, k) is not None | ||||
} | ||||
|
r37093 | |||
|
r37091 | def knownkeys(self): | ||
|
r43347 | return {b'cache', b'ctx', b'fctx', b'repo', b'revcache', b'ui'} | ||
|
r37091 | |||
|
r39618 | def lookup(self, mapping, key): | ||
|
r39620 | if key not in self.knownkeys(): | ||
|
r37091 | return None | ||
|
r39622 | v = self._getsome(mapping, key) | ||
if v is _placeholder: | ||||
v = mapping[key] = self._loadermap[key](self, mapping) | ||||
return v | ||||
|
r37091 | |||
|
r37120 | def populatemap(self, context, origmapping, newmapping): | ||
|
r37121 | mapping = {} | ||
|
r39621 | if self._hasnodespec(newmapping): | ||
|
r43347 | mapping[b'revcache'] = {} # per-ctx cache | ||
|
r39621 | if self._hasnodespec(origmapping) and self._hasnodespec(newmapping): | ||
|
r43347 | orignode = templateutil.runsymbol(context, origmapping, b'node') | ||
mapping[b'originalnode'] = orignode | ||||
|
r39659 | # put marker to override 'ctx'/'fctx' in mapping if any, and flag | ||
|
r39622 | # its existence to be reported by availablekeys() | ||
|
r43347 | if b'ctx' not in newmapping and self._hasliteral(newmapping, b'node'): | ||
mapping[b'ctx'] = _placeholder | ||||
if b'fctx' not in newmapping and self._hasliteral(newmapping, b'path'): | ||||
mapping[b'fctx'] = _placeholder | ||||
|
r37121 | return mapping | ||
|
r37120 | |||
|
r39618 | def _getsome(self, mapping, key): | ||
|
r36998 | v = mapping.get(key) | ||
if v is not None: | ||||
return v | ||||
|
r37091 | return self._resmap.get(key) | ||
|
r36997 | |||
|
r39622 | def _hasliteral(self, mapping, key): | ||
"""Test if a literal value is set or unset in the given mapping""" | ||||
return key in mapping and not callable(mapping[key]) | ||||
def _getliteral(self, mapping, key): | ||||
"""Return value of the given name if it is a literal""" | ||||
v = mapping.get(key) | ||||
if callable(v): | ||||
return None | ||||
return v | ||||
|
r39621 | def _hasnodespec(self, mapping): | ||
"""Test if context revision is set or unset in the given mapping""" | ||||
|
r43347 | return b'node' in mapping or b'ctx' in mapping | ||
|
r36999 | |||
|
r39659 | def _loadctx(self, mapping): | ||
|
r43347 | repo = self._getsome(mapping, b'repo') | ||
node = self._getliteral(mapping, b'node') | ||||
|
r39659 | if repo is None or node is None: | ||
return | ||||
try: | ||||
return repo[node] | ||||
except error.RepoLookupError: | ||||
|
r43346 | return None # maybe hidden/non-existent node | ||
|
r39659 | |||
|
r39622 | def _loadfctx(self, mapping): | ||
|
r43347 | ctx = self._getsome(mapping, b'ctx') | ||
path = self._getliteral(mapping, b'path') | ||||
|
r39622 | if ctx is None or path is None: | ||
return None | ||||
try: | ||||
return ctx[path] | ||||
except error.LookupError: | ||||
|
r43346 | return None # maybe removed file? | ||
|
r39622 | |||
_loadermap = { | ||||
|
r43347 | b'ctx': _loadctx, | ||
b'fctx': _loadfctx, | ||||
|
r39622 | } | ||
|
r43346 | |||
|
r43371 | def _internaltemplateformatter( | ||
ui, | ||||
out, | ||||
topic, | ||||
opts, | ||||
spec, | ||||
tmpl, | ||||
docheader=b'', | ||||
docfooter=b'', | ||||
separator=b'', | ||||
): | ||||
"""Build template formatter that handles customizable built-in templates | ||||
such as -Tjson(...)""" | ||||
templates = {spec.ref: tmpl} | ||||
if docheader: | ||||
templates[b'%s:docheader' % spec.ref] = docheader | ||||
if docfooter: | ||||
templates[b'%s:docfooter' % spec.ref] = docfooter | ||||
if separator: | ||||
templates[b'%s:separator' % spec.ref] = separator | ||||
return templateformatter( | ||||
ui, out, topic, opts, spec, overridetemplates=templates | ||||
) | ||||
|
r32573 | def formatter(ui, out, topic, opts): | ||
|
r43370 | spec = lookuptemplate(ui, topic, opts.get(b'template', b'')) | ||
|
r43371 | if spec.ref == b"cbor" and spec.refargs is not None: | ||
return _internaltemplateformatter( | ||||
ui, | ||||
out, | ||||
topic, | ||||
opts, | ||||
spec, | ||||
tmpl=b'{dict(%s)|cbor}' % spec.refargs, | ||||
docheader=cborutil.BEGIN_INDEFINITE_ARRAY, | ||||
docfooter=cborutil.BREAK, | ||||
) | ||||
elif spec.ref == b"cbor": | ||||
|
r42163 | return cborformatter(ui, out, topic, opts) | ||
|
r43371 | elif spec.ref == b"json" and spec.refargs is not None: | ||
return _internaltemplateformatter( | ||||
ui, | ||||
out, | ||||
topic, | ||||
opts, | ||||
spec, | ||||
tmpl=b'{dict(%s)|json}' % spec.refargs, | ||||
docheader=b'[\n ', | ||||
docfooter=b'\n]\n', | ||||
separator=b',\n ', | ||||
) | ||||
|
r43370 | elif spec.ref == b"json": | ||
|
r32573 | return jsonformatter(ui, out, topic, opts) | ||
|
r43370 | elif spec.ref == b"pickle": | ||
|
r43371 | assert spec.refargs is None, r'function-style not supported' | ||
|
r32573 | return pickleformatter(ui, out, topic, opts) | ||
|
r43370 | elif spec.ref == b"debug": | ||
|
r43371 | assert spec.refargs is None, r'function-style not supported' | ||
|
r32573 | return debugformatter(ui, out, topic, opts) | ||
|
r43370 | elif spec.ref or spec.tmpl or spec.mapfile: | ||
|
r43371 | assert spec.refargs is None, r'function-style not supported' | ||
|
r43369 | return templateformatter(ui, out, topic, opts, spec) | ||
|
r25838 | # developer config: ui.formatdebug | ||
|
r43347 | elif ui.configbool(b'ui', b'formatdebug'): | ||
|
r32573 | return debugformatter(ui, out, topic, opts) | ||
|
r25838 | # deprecated config: ui.formatjson | ||
|
r43347 | elif ui.configbool(b'ui', b'formatjson'): | ||
|
r32573 | return jsonformatter(ui, out, topic, opts) | ||
return plainformatter(ui, out, topic, opts) | ||||
|
r32574 | |||
|
r43346 | |||
|
r32574 | @contextlib.contextmanager | ||
def openformatter(ui, filename, topic, opts): | ||||
"""Create a formatter that writes outputs to the specified file | ||||
Must be invoked using the 'with' statement. | ||||
""" | ||||
|
r43347 | with util.posixfile(filename, b'wb') as out: | ||
|
r32574 | with formatter(ui, out, topic, opts) as fm: | ||
yield fm | ||||
|
r43346 | |||
|
r32574 | @contextlib.contextmanager | ||
def _neverending(fm): | ||||
yield fm | ||||
|
r43346 | |||
|
r37615 | def maybereopen(fm, filename): | ||
|
r32574 | """Create a formatter backed by file if filename specified, else return | ||
the given formatter | ||||
Must be invoked using the 'with' statement. This will never call fm.end() | ||||
of the given formatter. | ||||
""" | ||||
if filename: | ||||
|
r37615 | return openformatter(fm._ui, filename, fm._topic, fm._opts) | ||
|
r32574 | else: | ||
return _neverending(fm) | ||||