Mercurial > hg
view mercurial/formatter.py @ 30198:145482f505a5
tests: add more test coverage of phase changes when pushing
Prepare for test coverage of phase updates with future push --readonly option,
both with and without actually pushing changesets.
author | Mads Kiilerich <madski@unity3d.com> |
---|---|
date | Sun, 21 Aug 2016 01:12:00 +0200 |
parents | e7cacb45c4be |
children | 783016005122 |
line wrap: on
line source
# formatter.py - generic output formatting for mercurial # # Copyright 2012 Matt Mackall <mpm@selenic.com> # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. from __future__ import absolute_import import os from .i18n import _ from .node import ( hex, short, ) from . import ( encoding, error, templatekw, templater, util, ) pickle = util.pickle class _nullconverter(object): '''convert non-primitive data types to be processed by formatter''' @staticmethod def formatdate(date, fmt): '''convert date tuple to appropriate format''' return date @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) @staticmethod def formatlist(data, name, fmt, sep): '''convert iterable to appropriate list format''' return list(data) class baseformatter(object): def __init__(self, ui, topic, opts, converter): self._ui = ui self._topic = topic self._style = opts.get("style") self._template = opts.get("template") self._converter = converter self._item = None # function to convert node to string suitable for this output self.hexfunc = hex def __enter__(self): return self def __exit__(self, exctype, excvalue, traceback): if exctype is None: self.end() def _showitem(self): '''show a formatted item once all data is collected''' pass def startitem(self): '''begin an item in the format list''' if self._item is not None: self._showitem() self._item = {} def formatdate(self, date, fmt='%a %b %d %H:%M:%S %Y %1%2'): '''convert date tuple to appropriate format''' return self._converter.formatdate(date, fmt) def formatdict(self, data, key='key', value='value', fmt='%s=%s', sep=' '): '''convert dict or key-value pairs to appropriate dict format''' return self._converter.formatdict(data, key, value, fmt, sep) def formatlist(self, data, name, fmt='%s', sep=' '): '''convert iterable to appropriate list format''' # 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) def data(self, **data): '''insert data into item that's not shown in default output''' self._item.update(data) def write(self, fields, deftext, *fielddata, **opts): '''do default text output while assigning data to item''' fieldkeys = fields.split() assert len(fieldkeys) == len(fielddata) self._item.update(zip(fieldkeys, fielddata)) def condwrite(self, cond, fields, deftext, *fielddata, **opts): '''do conditional write (primarily for plain formatter)''' fieldkeys = fields.split() assert len(fieldkeys) == len(fielddata) self._item.update(zip(fieldkeys, fielddata)) def plain(self, text, **opts): '''show raw text for non-templated mode''' pass def isplain(self): '''check for plain formatter usage''' return False def nested(self, field): '''sub formatter to store nested data in the specified field''' self._item[field] = data = [] return _nestedformatter(self._ui, self._converter, data) def end(self): '''end output for the formatter''' if self._item is not None: self._showitem() class _nestedformatter(baseformatter): '''build sub items and store them in the parent formatter''' def __init__(self, ui, converter, data): baseformatter.__init__(self, ui, topic='', opts={}, converter=converter) self._data = data def _showitem(self): self._data.append(self._item) def _iteritems(data): '''iterate key-value pairs in stable order''' if isinstance(data, dict): return sorted(data.iteritems()) return data class _plainconverter(object): '''convert non-primitive data types to text''' @staticmethod def formatdate(date, fmt): '''stringify date tuple in the given format''' return util.datestr(date, fmt) @staticmethod def formatdict(data, key, value, fmt, sep): '''stringify key-value pairs separated by sep''' return sep.join(fmt % (k, v) for k, v in _iteritems(data)) @staticmethod def formatlist(data, name, fmt, sep): '''stringify iterable separated by sep''' return sep.join(fmt % e for e in data) class plainformatter(baseformatter): '''the default text output scheme''' def __init__(self, ui, topic, opts): baseformatter.__init__(self, ui, topic, opts, _plainconverter) if ui.debugflag: self.hexfunc = hex else: self.hexfunc = short def startitem(self): pass def data(self, **data): pass def write(self, fields, deftext, *fielddata, **opts): self._ui.write(deftext % fielddata, **opts) def condwrite(self, cond, fields, deftext, *fielddata, **opts): '''do conditional write''' if cond: self._ui.write(deftext % fielddata, **opts) def plain(self, text, **opts): self._ui.write(text, **opts) def isplain(self): return True def nested(self, field): # nested data will be directly written to ui return self def end(self): pass class debugformatter(baseformatter): def __init__(self, ui, topic, opts): baseformatter.__init__(self, ui, topic, opts, _nullconverter) self._ui.write("%s = [\n" % self._topic) def _showitem(self): self._ui.write(" " + repr(self._item) + ",\n") def end(self): baseformatter.end(self) self._ui.write("]\n") class pickleformatter(baseformatter): def __init__(self, ui, topic, opts): baseformatter.__init__(self, ui, topic, opts, _nullconverter) self._data = [] def _showitem(self): self._data.append(self._item) def end(self): baseformatter.end(self) self._ui.write(pickle.dumps(self._data)) def _jsonifyobj(v): if isinstance(v, dict): xs = ['"%s": %s' % (encoding.jsonescape(k), _jsonifyobj(u)) for k, u in sorted(v.iteritems())] return '{' + ', '.join(xs) + '}' elif isinstance(v, (list, tuple)): return '[' + ', '.join(_jsonifyobj(e) for e in v) + ']' elif v is None: return 'null' elif v is True: return 'true' elif v is False: return 'false' elif isinstance(v, (int, float)): return str(v) else: return '"%s"' % encoding.jsonescape(v) class jsonformatter(baseformatter): def __init__(self, ui, topic, opts): baseformatter.__init__(self, ui, topic, opts, _nullconverter) self._ui.write("[") self._ui._first = True def _showitem(self): if self._ui._first: self._ui._first = False else: self._ui.write(",") self._ui.write("\n {\n") first = True for k, v in sorted(self._item.items()): if first: first = False else: self._ui.write(",\n") self._ui.write(' "%s": %s' % (k, _jsonifyobj(v))) self._ui.write("\n }") def end(self): baseformatter.end(self) self._ui.write("\n]\n") class _templateconverter(object): '''convert non-primitive data types to be processed by templater''' @staticmethod def formatdate(date, fmt): '''return date tuple''' return date @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)) def f(): yield _plainconverter.formatdict(data, key, value, fmt, sep) return templatekw._hybrid(f(), data, lambda k: {key: k, value: data[k]}, lambda d: fmt % (d[key], d[value])) @staticmethod def formatlist(data, name, fmt, sep): '''build object that can be evaluated as either plain string or list''' data = list(data) def f(): yield _plainconverter.formatlist(data, name, fmt, sep) return templatekw._hybrid(f(), data, lambda x: {name: x}, lambda d: fmt % d[name]) class templateformatter(baseformatter): def __init__(self, ui, topic, opts): baseformatter.__init__(self, ui, topic, opts, _templateconverter) self._topic = topic self._t = gettemplater(ui, topic, opts.get('template', '')) def _showitem(self): g = self._t(self._topic, ui=self._ui, **self._item) self._ui.write(templater.stringify(g)) def lookuptemplate(ui, topic, tmpl): # looks like a literal template? if '{' in tmpl: return tmpl, None # perhaps a stock style? if not os.path.split(tmpl)[0]: mapname = (templater.templatepath('map-cmdline.' + tmpl) or templater.templatepath(tmpl)) if mapname and os.path.isfile(mapname): return None, mapname # perhaps it's a reference to [templates] t = ui.config('templates', tmpl) if t: return templater.unquotestring(t), None if tmpl == 'list': ui.write(_("available styles: %s\n") % templater.stylelist()) raise error.Abort(_("specify a template")) # perhaps it's a path to a map or a template if ('/' in tmpl or '\\' in tmpl) and os.path.isfile(tmpl): # is it a mapfile for a style? if os.path.basename(tmpl).startswith("map-"): return None, os.path.realpath(tmpl) tmpl = open(tmpl).read() return tmpl, None # constant string? return tmpl, None def gettemplater(ui, topic, spec): tmpl, mapfile = lookuptemplate(ui, topic, spec) assert not (tmpl and mapfile) if mapfile: return templater.templater.frommapfile(mapfile) return maketemplater(ui, topic, tmpl) def maketemplater(ui, topic, tmpl, filters=None, cache=None): """Create a templater from a string template 'tmpl'""" aliases = ui.configitems('templatealias') t = templater.templater(filters=filters, cache=cache, aliases=aliases) if tmpl: t.cache[topic] = tmpl return t def formatter(ui, topic, opts): template = opts.get("template", "") if template == "json": return jsonformatter(ui, topic, opts) elif template == "pickle": return pickleformatter(ui, topic, opts) elif template == "debug": return debugformatter(ui, topic, opts) elif template != "": return templateformatter(ui, topic, opts) # developer config: ui.formatdebug elif ui.configbool('ui', 'formatdebug'): return debugformatter(ui, topic, opts) # deprecated config: ui.formatjson elif ui.configbool('ui', 'formatjson'): return jsonformatter(ui, topic, opts) return plainformatter(ui, topic, opts)