This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8786

templater: make templatepaths() return a single path, or None
ClosedPublic

Authored by martinvonz on Jul 22 2020, 1:24 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG91aa9bba3dc9: templater: make templatepaths() return a single path, or None
Summary

The function returns either a singleton list or an empty list, so it
makes more sense to return a value or None. The plural in the name
also doesn't make sense, but templatepath() is already taken, so I
renamed it to templatedir() instead.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 22034

mercurial/debugcommands.py

) )
re2 = b'missing' re2 = b'missing'
if util._re2: if util._re2:
re2 = b'available' re2 = b'available'
fm.plain(_(b'checking "re2" regexp engine (%s)\n') % re2) fm.plain(_(b'checking "re2" regexp engine (%s)\n') % re2)
fm.data(re2=bool(util._re2)) fm.data(re2=bool(util._re2))
# templates # templates
p = templater.templatepaths() p = templater.templatedir()
fm.write(b'templatedirs', b'checking templates (%s)...\n', b' '.join(p)) fm.write(b'templatedirs', b'checking templates (%s)...\n', p)
fm.condwrite(not p, b'', _(b" no template directories found\n")) fm.condwrite(not p, b'', _(b" no template directories found\n"))
if p: if p:
m = templater.templatepath(b"map-cmdline.default") m = templater.templatepath(b"map-cmdline.default")
if m: if m:
# template found, check if it is working # template found, check if it is working
err = None err = None
try: try:
templater.templater.frommapfile(m) templater.templater.frommapfile(m)

mercurial/hgweb/hgwebdir_mod.py

# a static file # a static file
if virtual.startswith(b'static/') or b'static' in req.qsparams: if virtual.startswith(b'static/') or b'static' in req.qsparams:
if virtual.startswith(b'static/'): if virtual.startswith(b'static/'):
fname = virtual[7:] fname = virtual[7:]
else: else:
fname = req.qsparams[b'static'] fname = req.qsparams[b'static']
static = self.ui.config(b"web", b"static", untrusted=False) static = self.ui.config(b"web", b"static", untrusted=False)
if not static: if not static:
tp = self.templatepath or templater.templatepaths() tp = self.templatepath or templater.templatedir()
if isinstance(tp, bytes): if isinstance(tp, bytes):
tp = [tp] tp = [tp]
static = [os.path.join(p, b'static') for p in tp] static = [os.path.join(p, b'static') for p in tp]
staticfile(static, fname, res) staticfile(static, fname, res)
return res.sendresponse() return res.sendresponse()
# top-level index # top-level index

mercurial/hgweb/webcommands.py

@webcommand(b'static') @webcommand(b'static')
def static(web): def static(web):
fname = web.req.qsparams[b'file'] fname = web.req.qsparams[b'file']
# a repo owner may set web.static in .hg/hgrc to get any file # a repo owner may set web.static in .hg/hgrc to get any file
# readable by the user running the CGI script # readable by the user running the CGI script
static = web.config(b"web", b"static", untrusted=False) static = web.config(b"web", b"static", untrusted=False)
if not static: if not static:
tp = web.templatepath or templater.templatepaths() tp = web.templatepath or templater.templatedir()
if isinstance(tp, bytes): if isinstance(tp, bytes):
tp = [tp] tp = [tp]
static = [os.path.join(p, b'static') for p in tp] static = [os.path.join(p, b'static') for p in tp]
staticfile(static, fname, web.res) staticfile(static, fname, web.res)
return web.res.sendresponse() return web.res.sendresponse()

mercurial/templater.py

extramapping = self._resources.populatemap(self, {}, mapping) extramapping = self._resources.populatemap(self, {}, mapping)
if extramapping: if extramapping:
extramapping.update(mapping) extramapping.update(mapping)
mapping = extramapping mapping = extramapping
return templateutil.flatten(self, mapping, func(self, mapping, data)) return templateutil.flatten(self, mapping, func(self, mapping, data))
def stylelist(): def stylelist():
paths = templatepaths() path = templatedir()
if not paths: if not path:
return _(b'no templates found, try `hg debuginstall` for more info') return _(b'no templates found, try `hg debuginstall` for more info')
dirlist = os.listdir(paths[0]) dirlist = os.listdir(path)
stylelist = [] stylelist = []
for file in dirlist: for file in dirlist:
split = file.split(b".") split = file.split(b".")
if split[-1] in (b'orig', b'rej'): if split[-1] in (b'orig', b'rej'):
continue continue
if split[0] == b"map-cmdline": if split[0] == b"map-cmdline":
stylelist.append(split[1]) stylelist.append(split[1])
return b", ".join(sorted(stylelist)) return b", ".join(sorted(stylelist))
def _readmapfile(mapfile): def _readmapfile(mapfile):
"""Load template elements from the given map file""" """Load template elements from the given map file"""
if not os.path.exists(mapfile): if not os.path.exists(mapfile):
raise error.Abort( raise error.Abort(
_(b"style '%s' not found") % mapfile, _(b"style '%s' not found") % mapfile,
hint=_(b"available styles: %s") % stylelist(), hint=_(b"available styles: %s") % stylelist(),
) )
base = os.path.dirname(mapfile) base = os.path.dirname(mapfile)
conf = config.config(includepaths=templatepaths()) conf = config.config(includepaths=[templatedir()])
conf.read(mapfile, remap={b'': b'templates'}) conf.read(mapfile, remap={b'': b'templates'})
cache = {} cache = {}
tmap = {} tmap = {}
aliases = [] aliases = []
val = conf.get(b'templates', b'__base__') val = conf.get(b'templates', b'__base__')
if val and val[0] not in b"'\"": if val and val[0] not in b"'\"":
# treat as a pointer to a base class for this style # treat as a pointer to a base class for this style
path = util.normpath(os.path.join(base, val)) path = util.normpath(os.path.join(base, val))
# fallback check in template paths # fallback check in template paths
if not os.path.exists(path): if not os.path.exists(path):
for p in templatepaths(): p2 = util.normpath(os.path.join(templatedir(), val))
p2 = util.normpath(os.path.join(p, val))
if os.path.isfile(p2): if os.path.isfile(p2):
path = p2 path = p2
break else:
p3 = util.normpath(os.path.join(p2, b"map")) p3 = util.normpath(os.path.join(p2, b"map"))
if os.path.isfile(p3): if os.path.isfile(p3):
path = p3 path = p3
break
cache, tmap, aliases = _readmapfile(path) cache, tmap, aliases = _readmapfile(path)
for key, val in conf[b'templates'].items(): for key, val in conf[b'templates'].items():
if not val: if not val:
raise error.ParseError( raise error.ParseError(
_(b'missing value'), conf.source(b'templates', key) _(b'missing value'), conf.source(b'templates', key)
) )
stream = self._proc.process(t, mapping) stream = self._proc.process(t, mapping)
if self._minchunk: if self._minchunk:
stream = util.increasingchunks( stream = util.increasingchunks(
stream, min=self._minchunk, max=self._maxchunk stream, min=self._minchunk, max=self._maxchunk
) )
return stream return stream
def templatepaths(): def templatedir():
'''return locations used for template files.''' '''return the directory used for template files, or None.'''
path = os.path.normpath(os.path.join(resourceutil.datapath, b'templates')) path = os.path.normpath(os.path.join(resourceutil.datapath, b'templates'))
return [path] if os.path.isdir(path) else [] return path if os.path.isdir(path) else None
def templatepath(name): def templatepath(name):
'''return location of template file. returns None if not found.''' '''return location of template file. returns None if not found.'''
for p in templatepaths(): f = os.path.join(templatedir(), name)
f = os.path.join(p, name) if f and os.path.exists(f):
if os.path.exists(f):
return f return f
return None return None
def stylemap(styles, paths=None): def stylemap(styles, paths=None):
"""Return path to mapfile for a given style. """Return path to mapfile for a given style.
Searches mapfile in the following locations: Searches mapfile in the following locations:
1. templatepath/style/map 1. templatepath/style/map
2. templatepath/map-style 2. templatepath/map-style
3. templatepath/map 3. templatepath/map
""" """
if paths is None: if paths is None:
paths = templatepaths() paths = [templatedir()]
elif isinstance(paths, bytes): elif isinstance(paths, bytes):
paths = [paths] paths = [paths]
if isinstance(styles, bytes): if isinstance(styles, bytes):
styles = [styles] styles = [styles]
for style in styles: for style in styles:
# only plain name is allowed to honor template paths # only plain name is allowed to honor template paths