mercurial-scm/hg: mercurial/formatter.py comparison

comparison mercurial/formatter.py @ 43077:687b865b95ad

formatting: byteify all mercurial/ and hgext/ string literals Done with python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py') black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**') # skip-blame mass-reformatting only Differential Revision: https://phab.mercurial-scm.org/D6972

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:48:39 -0400
parents	2372284d9457
children	f1c5358f0d65

comparison

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 '''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'):
+def formatdate(self, date, fmt=b'%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=None, sep=' '):
+def formatdict(self, data, key=b'key', value=b'value', fmt=None, sep=b' '):
 '''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=None, sep=' '):
+def formatlist(self, data, name, fmt=None, sep=b' '):
 '''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 context(self, **ctxs):
 '''insert context objects to be used to render template keywords'''
 ctxs = pycompat.byteskwargs(ctxs)
-assert all(k in {'repo', 'ctx', 'fctx'} for k in ctxs)
+assert all(k in {b'repo', b'ctx', b'fctx'} for k in ctxs)
 if self._converter.storecontext:
 # populate missing resources in fctx -> ctx -> repo order
-if 'fctx' in ctxs and 'ctx' not in ctxs:
+if b'fctx' in ctxs and b'ctx' not in ctxs:
-ctxs['ctx'] = ctxs['fctx'].changectx()
+ctxs[b'ctx'] = ctxs[b'fctx'].changectx()
-if 'ctx' in ctxs and 'repo' not in ctxs:
+if b'ctx' in ctxs and b'repo' not in ctxs:
-ctxs['repo'] = ctxs['ctx'].repo()
+ctxs[b'repo'] = ctxs[b'ctx'].repo()
 self._item.update(ctxs)
 def datahint(self):
 '''set of field names to be referenced'''
 return set()
 def isplain(self):
 '''check for plain formatter usage'''
 return False
-def nested(self, field, tmpl=None, sep=''):
+def nested(self, field, tmpl=None, sep=b''):
 '''sub formatter to store nested data in the specified field'''
 data = []
 self._item[field] = self._converter.wrapnested(data, tmpl, sep)
 return _nestedformatter(self._ui, self._converter, data)
 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)
+baseformatter.__init__(
+self, ui, topic=b'', opts={}, converter=converter
+)
 self._data = data
 def _showitem(self):
 self._data.append(self._item)
 storecontext = False
 @staticmethod
 def wrapnested(data, tmpl, sep):
-raise error.ProgrammingError('plainformatter should never be nested')
+raise error.ProgrammingError(b'plainformatter should never be nested')
 @staticmethod
 def formatdate(date, fmt):
 '''stringify date tuple in the given format'''
 return dateutil.datestr(date, fmt)
 @staticmethod
 def formatdict(data, key, value, fmt, sep):
 '''stringify key-value pairs separated by sep'''
 prefmt = pycompat.identity
 if fmt is None:
-fmt = '%s=%s'
+fmt = b'%s=%s'
 prefmt = pycompat.bytestr
 return sep.join(
 fmt % (prefmt(k), prefmt(v)) for k, v in _iteritems(data)
 )
 @staticmethod
 def formatlist(data, name, fmt, sep):
 '''stringify iterable separated by sep'''
 prefmt = pycompat.identity
 if fmt is None:
-fmt = '%s'
+fmt = b'%s'
 prefmt = pycompat.bytestr
 return sep.join(fmt % prefmt(e) for e in data)
 class plainformatter(baseformatter):
 self._write(text, **opts)
 def isplain(self):
 return True
-def nested(self, field, tmpl=None, sep=''):
+def nested(self, field, tmpl=None, sep=b''):
 # nested data will be directly written to ui
 return self
 def end(self):
 pass
 class debugformatter(baseformatter):
 def __init__(self, ui, out, topic, opts):
 baseformatter.__init__(self, ui, topic, opts, _nullconverter)
 self._out = out
-self._out.write("%s = [\n" % self._topic)
+self._out.write(b"%s = [\n" % self._topic)
 def _showitem(self):
 self._out.write(
-'    %s,\n' % stringutil.pprint(self._item, indent=4, level=1)
+b'    %s,\n' % stringutil.pprint(self._item, indent=4, level=1)
 )
 def end(self):
 baseformatter.end(self)
-self._out.write("]\n")
+self._out.write(b"]\n")
 class pickleformatter(baseformatter):
 def __init__(self, ui, out, topic, opts):
 baseformatter.__init__(self, ui, topic, opts, _nullconverter)
 class jsonformatter(baseformatter):
 def __init__(self, ui, out, topic, opts):
 baseformatter.__init__(self, ui, topic, opts, _nullconverter)
 self._out = out
-self._out.write("[")
+self._out.write(b"[")
 self._first = True
 def _showitem(self):
 if self._first:
 self._first = False
 else:
-self._out.write(",")
+self._out.write(b",")
-self._out.write("\n {\n")
+self._out.write(b"\n {\n")
 first = True
 for k, v in sorted(self._item.items()):
 if first:
 first = False
 else:
-self._out.write(",\n")
+self._out.write(b",\n")
 u = templatefilters.json(v, paranoid=False)
-self._out.write('  "%s": %s' % (k, u))
+self._out.write(b'  "%s": %s' % (k, u))
-self._out.write("\n }")
+self._out.write(b"\n }")
 def end(self):
 baseformatter.end(self)
-self._out.write("\n]\n")
+self._out.write(b"\n]\n")
 class _templateconverter(object):
 '''convert non-primitive data types to be processed by templater'''
 class templateformatter(baseformatter):
 def __init__(self, ui, out, topic, opts):
 baseformatter.__init__(self, ui, topic, opts, _templateconverter)
 self._out = out
-spec = lookuptemplate(ui, topic, opts.get('template', ''))
+spec = lookuptemplate(ui, topic, opts.get(b'template', b''))
 self._tref = spec.ref
 self._t = loadtemplater(
 ui,
 spec,
 defaults=templatekw.keywords,
 resources=templateresources(ui),
 cache=templatekw.defaulttempl,
 )
 self._parts = templatepartsmap(
-spec, self._t, ['docheader', 'docfooter', 'separator']
+spec, self._t, [b'docheader', b'docfooter', b'separator']
 )
 self._counter = itertools.count()
-self._renderitem('docheader', {})
+self._renderitem(b'docheader', {})
 def _showitem(self):
 item = self._item.copy()
-item['index'] = index = next(self._counter)
+item[b'index'] = index = next(self._counter)
 if index > 0:
-self._renderitem('separator', {})
+self._renderitem(b'separator', {})
 self._renderitem(self._tref, item)
 def _renderitem(self, part, item):
 if part not in self._parts:
 return
 '''set of field names to be referenced from the template'''
 return self._symbolsused[0]
 def end(self):
 baseformatter.end(self)
-self._renderitem('docfooter', {})
+self._renderitem(b'docfooter', {})
 @attr.s(frozen=True)
 class templatespec(object):
 ref = attr.ib()
 If no map file selected, all templates in [templates] section will be
 available as well as aliases in [templatealias].
 """
 # looks like a literal template?
-if '{' in tmpl:
+if b'{' in tmpl:
-return templatespec('', tmpl, None)
+return templatespec(b'', tmpl, None)
 # perhaps a stock style?
 if not os.path.split(tmpl)[0]:
 mapname = templater.templatepath(
-'map-cmdline.' + tmpl
+b'map-cmdline.' + tmpl
 ) or templater.templatepath(tmpl)
 if mapname and os.path.isfile(mapname):
 return templatespec(topic, None, mapname)
 # perhaps it's a reference to [templates]
-if ui.config('templates', tmpl):
+if ui.config(b'templates', tmpl):
 return templatespec(tmpl, None, None)
-if tmpl == 'list':
+if tmpl == b'list':
-ui.write(_("available styles: %s\n") % templater.stylelist())
+ui.write(_(b"available styles: %s\n") % templater.stylelist())
-raise error.Abort(_("specify a template"))
+raise error.Abort(_(b"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):
+if (b'/' in tmpl or b'\\' in tmpl) and os.path.isfile(tmpl):
 # is it a mapfile for a style?
-if os.path.basename(tmpl).startswith("map-"):
+if os.path.basename(tmpl).startswith(b"map-"):
 return templatespec(topic, None, os.path.realpath(tmpl))
-with util.posixfile(tmpl, 'rb') as f:
+with util.posixfile(tmpl, b'rb') as f:
 tmpl = f.read()
-return templatespec('', tmpl, None)
+return templatespec(b'', tmpl, None)
 # constant string?
-return templatespec('', tmpl, None)
+return templatespec(b'', tmpl, None)
 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)
 elif spec.ref:
 for part in partnames:
-ref = '%s:%s' % (spec.ref, part)  # select config sub-section
+ref = b'%s:%s' % (spec.ref, part)  # select config sub-section
 if ref in t:
 partsmap[part] = ref
 return partsmap
 )
 def maketemplater(ui, tmpl, defaults=None, resources=None, cache=None):
 """Create a templater from a string template 'tmpl'"""
-aliases = ui.configitems('templatealias')
+aliases = ui.configitems(b'templatealias')
 t = templater.templater(
 defaults=defaults, resources=resources, cache=cache, aliases=aliases
 )
 t.cache.update(
-(k, templater.unquotestring(v)) for k, v in ui.configitems('templates')
+(k, templater.unquotestring(v)) for k, v in ui.configitems(b'templates')
 )
 if tmpl:
-t.cache[''] = tmpl
+t.cache[b''] = tmpl
 return t
 # marker to denote a resource to be loaded on demand based on mapping values
 # (e.g. (ctx, path) -> fctx)
 class templateresources(templater.resourcemapper):
 """Resource mapper designed for the default templatekw and function"""
 def __init__(self, ui, repo=None):
 self._resmap = {
-'cache': {},  # for templatekw/funcs to store reusable data
+b'cache': {},  # for templatekw/funcs to store reusable data
-'repo': repo,
+b'repo': repo,
-'ui': ui,
+b'ui': ui,
 }
 def availablekeys(self, mapping):
 return {
 k for k in self.knownkeys() if self._getsome(mapping, k) is not None
 }
 def knownkeys(self):
-return {'cache', 'ctx', 'fctx', 'repo', 'revcache', 'ui'}
+return {b'cache', b'ctx', b'fctx', b'repo', b'revcache', b'ui'}
 def lookup(self, mapping, key):
 if key not in self.knownkeys():
 return None
 v = self._getsome(mapping, key)
 return v
 def populatemap(self, context, origmapping, newmapping):
 mapping = {}
 if self._hasnodespec(newmapping):
-mapping['revcache'] = {}  # per-ctx cache
+mapping[b'revcache'] = {}  # per-ctx cache
 if self._hasnodespec(origmapping) and self._hasnodespec(newmapping):
-orignode = templateutil.runsymbol(context, origmapping, 'node')
+orignode = templateutil.runsymbol(context, origmapping, b'node')
-mapping['originalnode'] = orignode
+mapping[b'originalnode'] = orignode
 # put marker to override 'ctx'/'fctx' in mapping if any, and flag
 # its existence to be reported by availablekeys()
-if 'ctx' not in newmapping and self._hasliteral(newmapping, 'node'):
+if b'ctx' not in newmapping and self._hasliteral(newmapping, b'node'):
-mapping['ctx'] = _placeholder
+mapping[b'ctx'] = _placeholder
-if 'fctx' not in newmapping and self._hasliteral(newmapping, 'path'):
+if b'fctx' not in newmapping and self._hasliteral(newmapping, b'path'):
-mapping['fctx'] = _placeholder
+mapping[b'fctx'] = _placeholder
 return mapping
 def _getsome(self, mapping, key):
 v = mapping.get(key)
 if v is not None:
 return None
 return v
 def _hasnodespec(self, mapping):
 """Test if context revision is set or unset in the given mapping"""
-return 'node' in mapping or 'ctx' in mapping
+return b'node' in mapping or b'ctx' in mapping
 def _loadctx(self, mapping):
-repo = self._getsome(mapping, 'repo')
+repo = self._getsome(mapping, b'repo')
-node = self._getliteral(mapping, 'node')
+node = self._getliteral(mapping, b'node')
 if repo is None or node is None:
 return
 try:
 return repo[node]
 except error.RepoLookupError:
 return None  # maybe hidden/non-existent node
 def _loadfctx(self, mapping):
-ctx = self._getsome(mapping, 'ctx')
+ctx = self._getsome(mapping, b'ctx')
-path = self._getliteral(mapping, 'path')
+path = self._getliteral(mapping, b'path')
 if ctx is None or path is None:
 return None
 try:
 return ctx[path]
 except error.LookupError:
 return None  # maybe removed file?
 _loadermap = {
-'ctx': _loadctx,
+b'ctx': _loadctx,
-'fctx': _loadfctx,
+b'fctx': _loadfctx,
 }
 def formatter(ui, out, topic, opts):
-template = opts.get("template", "")
+template = opts.get(b"template", b"")
-if template == "cbor":
+if template == b"cbor":
 return cborformatter(ui, out, topic, opts)
-elif template == "json":
+elif template == b"json":
 return jsonformatter(ui, out, topic, opts)
-elif template == "pickle":
+elif template == b"pickle":
 return pickleformatter(ui, out, topic, opts)
-elif template == "debug":
+elif template == b"debug":
 return debugformatter(ui, out, topic, opts)
-elif template != "":
+elif template != b"":
 return templateformatter(ui, out, topic, opts)
 # developer config: ui.formatdebug
-elif ui.configbool('ui', 'formatdebug'):
+elif ui.configbool(b'ui', b'formatdebug'):
 return debugformatter(ui, out, topic, opts)
 # deprecated config: ui.formatjson
-elif ui.configbool('ui', 'formatjson'):
+elif ui.configbool(b'ui', b'formatjson'):
 return jsonformatter(ui, out, topic, opts)
 return plainformatter(ui, out, topic, opts)
 @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.
 """
-with util.posixfile(filename, 'wb') as out:
+with util.posixfile(filename, b'wb') as out:
 with formatter(ui, out, topic, opts) as fm:
 yield fm
 @contextlib.contextmanager

Mercurial > public > mercurial-scm > hg

comparison mercurial/formatter.py @ 43077:687b865b95ad