mercurial-scm/hg: comparison mercurial/hgweb/webcommands.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 smartset,
 templater,
 templateutil,
 )
-from ..utils import (
+from ..utils import stringutil
-stringutil,
-)
+from . import webutil
-from . import (
-webutil,
-)
 __all__ = []
 commands = {}
 class webcommand(object):
 """Decorator used to register a web command handler.
 The decorator takes as its positional arguments the name/path the
 def __call__(self, func):
 __all__.append(self.name)
 commands[self.name] = func
 return func
 @webcommand('log')
 def log(web):
 """
 /log[/{revision}[/{path}]]
 --------------------------
 if web.req.qsparams.get('file'):
 return filelog(web)
 else:
 return changelog(web)
 @webcommand('rawfile')
 def rawfile(web):
 guessmime = web.configbool('web', 'guessmime')
 if mt.startswith('text/'):
 mt += '; charset="%s"' % encoding.encoding
 web.res.headers['Content-Type'] = mt
-filename = (path.rpartition('/')[-1]
+filename = (
-.replace('\\', '\\\\').replace('"', '\\"'))
+path.rpartition('/')[-1].replace('\\', '\\\\').replace('"', '\\"')
+)
 web.res.headers['Content-Disposition'] = 'inline; filename="%s"' % filename
 web.res.setbodybytes(text)
 return web.res.sendresponse()
 def _filerevision(web, fctx):
 f = fctx.path()
 text = fctx.data()
 parity = paritygen(web.stripecount)
 ishead = fctx.filenode() in fctx.filelog().heads()
 if stringutil.binary(text):
 mt = pycompat.sysbytes(
 mimetypes.guess_type(pycompat.fsdecode(f))[0]
-or r'application/octet-stream')
+or r'application/octet-stream'
+)
 text = '(binary:%s)' % mt
 def lines(context):
 for lineno, t in enumerate(text.splitlines(True)):
-yield {"line": t,
+yield {
-"lineid": "l%d" % (lineno + 1),
+"line": t,
-"linenumber": "% 6d" % (lineno + 1),
+"lineid": "l%d" % (lineno + 1),
-"parity": next(parity)}
+"linenumber": "% 6d" % (lineno + 1),
+"parity": next(parity),
+}
 return web.sendtemplate(
 'filerevision',
 file=f,
 path=webutil.up(f),
 text=templateutil.mappinggenerator(lines),
 symrev=webutil.symrevorshortnode(web.req, fctx),
 rename=webutil.renamelink(fctx),
 permissions=fctx.manifest().flags(f),
 ishead=int(ishead),
-**pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))
+**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
+)
 @webcommand('file')
 def file(web):
 """
 /file/{revision}[/{path}]
 try:
 return manifest(web)
 except ErrorResponse:
 raise inst
 def _search(web):
 MODE_REVISION = 'rev'
 MODE_KEYWORD = 'keyword'
 MODE_REVSET = 'revset'
 yield e
 for ctx in revgen():
 miss = 0
 for q in qw:
-if not (q in lower(ctx.user()) or
+if not (
-q in lower(ctx.description()) or
+q in lower(ctx.user())
-q in lower(" ".join(ctx.files()))):
+or q in lower(ctx.description())
+or q in lower(" ".join(ctx.files()))
+):
 miss = 1
 break
 if miss:
 continue
 if revsetlang.depth(tree) <= 2:
 # no revset syntax used
 return MODE_KEYWORD, query
-if any((token, (value or '')[:3]) == ('string', 're:')
+if any(
-for token, value, pos in revsetlang.tokenize(revdef)):
+(token, (value or '')[:3]) == ('string', 're:')
+for token, value, pos in revsetlang.tokenize(revdef)
+):
 return MODE_KEYWORD, query
 funcsused = revsetlang.funcsused(tree)
 if not funcsused.issubset(revset.safesymbols):
 return MODE_KEYWORD, query
 try:
-mfunc = revset.match(web.repo.ui, revdef,
+mfunc = revset.match(
-lookup=revset.lookupfn(web.repo))
+web.repo.ui, revdef, lookup=revset.lookupfn(web.repo)
+)
 revs = mfunc(web.repo)
 return MODE_REVSET, revs
 # ParseError: wrongly placed tokens, wrongs arguments, etc
 # RepoLookupError: no such revision, e.g. in 'revision:'
 # Abort: bookmark/tag not exists
 # LookupError: ambiguous identifier, e.g. in '(bc)' on a large repo
-except (error.ParseError, error.RepoLookupError, error.Abort,
+except (
-LookupError):
+error.ParseError,
+error.RepoLookupError,
+error.Abort,
+LookupError,
+):
 return MODE_KEYWORD, query
 def changelist(context):
 count = 0
 n = scmutil.binnode(ctx)
 showtags = webutil.showtag(web.repo, 'changelogtag', n)
 files = webutil.listfilediffs(ctx.files(), n, web.maxfiles)
 lm = webutil.commonentry(web.repo, ctx)
-lm.update({
+lm.update(
-'parity': next(parity),
+{
-'changelogtag': showtags,
+'parity': next(parity),
-'files': files,
+'changelogtag': showtags,
-})
+'files': files,
+}
+)
 yield lm
 if count >= revcount:
 break
 archives=web.archivelist('tip'),
 morevars=morevars,
 lessvars=lessvars,
 modedesc=searchfunc[1],
 showforcekw=showforcekw,
-showunforcekw=showunforcekw)
+showunforcekw=showunforcekw,
+)
 @webcommand('changelog')
 def changelog(web, shortlog=False):
 """
 /changelog[/{revision}]
 nextentry=templateutil.mappinglist(nextentry),
 archives=web.archivelist('tip'),
 revcount=revcount,
 morevars=morevars,
 lessvars=lessvars,
-query=query)
+query=query,
+)
 @webcommand('shortlog')
 def shortlog(web):
 """
 /shortlog
 difference is the ``shortlog`` template will be rendered instead of the
 ``changelog`` template.
 """
 return changelog(web, shortlog=True)
 @webcommand('changeset')
 def changeset(web):
 """
 /changeset[/{revision}]
 -----------------------
 ``changesetbookmark``, ``filenodelink``, ``filenolink``, and the many
 templates related to diffs may all be used to produce the output.
 """
 ctx = webutil.changectx(web.repo, web.req)
-return web.sendtemplate(
+return web.sendtemplate('changeset', **webutil.changesetentry(web, ctx))
-'changeset',
-**webutil.changesetentry(web, ctx))
 rev = webcommand('rev')(changeset)
 def decodepath(path):
 """Hook for mapping a path in the repository to a path in the
 working copy.
 Extensions (e.g., largefiles) can override this to remap files in
 the virtual file system presented by the manifest command below."""
 return path
 @webcommand('manifest')
 def manifest(web):
 """
 /manifest[/{revision}[/{path}]]
 remain = f[l:]
 elements = remain.split('/')
 if len(elements) == 1:
 files[remain] = full
 else:
-h = dirs # need to retain ref to dirs (root)
+h = dirs  # need to retain ref to dirs (root)
 for elem in elements[0:-1]:
 if elem not in h:
 h[elem] = {}
 h = h[elem]
 if len(h) > 1:
 break
-h[None] = None # denotes files present
+h[None] = None  # denotes files present
 if mf and not files and not dirs:
 raise ErrorResponse(HTTP_NOT_FOUND, 'path not found: ' + path)
 def filelist(context):
 for f in sorted(files):
 full = files[f]
 fctx = ctx.filectx(full)
-yield {"file": full,
+yield {
-"parity": next(parity),
+"file": full,
-"basename": f,
+"parity": next(parity),
-"date": fctx.date(),
+"basename": f,
-"size": fctx.size(),
+"date": fctx.date(),
-"permissions": mf.flags(full)}
+"size": fctx.size(),
+"permissions": mf.flags(full),
+}
 def dirlist(context):
 for d in sorted(dirs):
 emptydirs = []
 if v:
 emptydirs.append(k)
 h = v
 path = "%s%s" % (abspath, d)
-yield {"parity": next(parity),
+yield {
-"path": path,
+"parity": next(parity),
-"emptydirs": "/".join(emptydirs),
+"path": path,
-"basename": d}
+"emptydirs": "/".join(emptydirs),
+"basename": d,
+}
 return web.sendtemplate(
 'manifest',
 symrev=symrev,
 path=abspath,
 up=webutil.up(abspath),
 upparity=next(parity),
 fentries=templateutil.mappinggenerator(filelist),
 dentries=templateutil.mappinggenerator(dirlist),
 archives=web.archivelist(hex(node)),
-**pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))
+**pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
+)
 @webcommand('tags')
 def tags(web):
 """
 /tags
 if notip:
 t = [(k, n) for k, n in i if k != "tip"]
 if latestonly:
 t = t[:1]
 for k, n in t:
-yield {"parity": next(parity),
+yield {
-"tag": k,
+"parity": next(parity),
-"date": web.repo[n].date(),
+"tag": k,
-"node": hex(n)}
+"date": web.repo[n].date(),
+"node": hex(n),
+}
 return web.sendtemplate(
 'tags',
 node=hex(web.repo.changelog.tip()),
 entries=templateutil.mappinggenerator(entries, args=(False, False)),
-entriesnotip=templateutil.mappinggenerator(entries,
+entriesnotip=templateutil.mappinggenerator(entries, args=(True, False)),
-args=(True, False)),
+latestentry=templateutil.mappinggenerator(entries, args=(True, True)),
-latestentry=templateutil.mappinggenerator(entries, args=(True, True)))
+)
 @webcommand('bookmarks')
 def bookmarks(web):
 """
 /bookmarks
 def entries(context, latestonly):
 t = i
 if latestonly:
 t = i[:1]
 for k, n in t:
-yield {"parity": next(parity),
+yield {
-"bookmark": k,
+"parity": next(parity),
-"date": web.repo[n].date(),
+"bookmark": k,
-"node": hex(n)}
+"date": web.repo[n].date(),
+"node": hex(n),
+}
 if i:
 latestrev = i[0][1]
 else:
 latestrev = -1
 return web.sendtemplate(
 'bookmarks',
 node=hex(web.repo.changelog.tip()),
 lastchange=templateutil.mappinglist([{'date': lastdate}]),
 entries=templateutil.mappinggenerator(entries, args=(False,)),
-latestentry=templateutil.mappinggenerator(entries, args=(True,)))
+latestentry=templateutil.mappinggenerator(entries, args=(True,)),
+)
 @webcommand('branches')
 def branches(web):
 """
 /branches
 return web.sendtemplate(
 'branches',
 node=hex(web.repo.changelog.tip()),
 entries=entries,
-latestentry=latestentry)
+latestentry=latestentry,
+)
 @webcommand('summary')
 def summary(web):
 """
 /summary
 def tagentries(context):
 parity = paritygen(web.stripecount)
 count = 0
 for k, n in i:
-if k == "tip": # skip tip
+if k == "tip":  # skip tip
 continue
 count += 1
-if count > 10: # limit to 10 tags
+if count > 10:  # limit to 10 tags
 break
 yield {
 'parity': next(parity),
 'tag': k,
 parity = paritygen(web.stripecount)
 marks = [b for b in web.repo._bookmarks.items() if b[1] in web.repo]
 sortkey = lambda b: (web.repo[b[1]].rev(), b[0])
 marks = sorted(marks, key=sortkey, reverse=True)
 for k, n in marks[:10]:  # limit to 10 bookmarks
-yield {'parity': next(parity),
+yield {
-'bookmark': k,
+'parity': next(parity),
-'date': web.repo[n].date(),
+'bookmark': k,
-'node': hex(n)}
+'date': web.repo[n].date(),
+'node': hex(n),
+}
 def changelist(context):
 parity = paritygen(web.stripecount, offset=start - end)
-l = [] # build a list in forward order for efficiency
+l = []  # build a list in forward order for efficiency
 revs = []
 if start < end:
 revs = web.repo.changelog.revs(start, end - 1)
 for i in revs:
 ctx = web.repo[i]
 owner=get_contact(web.config) or 'unknown',
 lastchange=tip.date(),
 tags=templateutil.mappinggenerator(tagentries, name='tagentry'),
 bookmarks=templateutil.mappinggenerator(bookmarks),
 branches=webutil.branchentries(web.repo, web.stripecount, 10),
-shortlog=templateutil.mappinggenerator(changelist,
+shortlog=templateutil.mappinggenerator(
-name='shortlogentry'),
+changelist, name='shortlogentry'
+),
 node=tip.hex(),
 symrev='tip',
 archives=web.archivelist('tip'),
-labels=templateutil.hybridlist(labels, name='label'))
+labels=templateutil.hybridlist(labels, name='label'),
+)
 @webcommand('filediff')
 def filediff(web):
 """
 /diff/{revision}/{path}
 'filediff',
 file=path,
 symrev=webutil.symrevorshortnode(web.req, ctx),
 rename=rename,
 diff=diffs,
-**pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))
+**pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
+)
 diff = webcommand('diff')(filediff)
 @webcommand('comparison')
 def comparison(web):
 """
 /comparison/{revision}/{path}
 def filelines(f):
 if f.isbinary():
 mt = pycompat.sysbytes(
 mimetypes.guess_type(pycompat.fsdecode(f.path()))[0]
-or r'application/octet-stream')
+or r'application/octet-stream'
+)
 return [_('(binary file %s, hash: %s)') % (mt, hex(f.filenode()))]
 return f.data().splitlines()
 fctx = None
 parent = ctx.p1()
 leftrev=leftrev,
 leftnode=hex(leftnode),
 rightrev=rightrev,
 rightnode=hex(rightnode),
 comparison=comparison,
-**pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))
+**pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
+)
 @webcommand('annotate')
 def annotate(web):
 """
 /annotate/{revision}/{path}
 # parents() is called once per line and several lines likely belong to
 # same revision. So it is worth caching.
 # TODO there are still redundant operations within basefilectx.parents()
 # and from the fctx.annotate() call itself that could be cached.
 parentscache = {}
 def parents(context, f):
 rev = f.rev()
 if rev not in parentscache:
 parentscache[rev] = []
 for p in f.parents():
 def annotate(context):
 if fctx.isbinary():
 mt = pycompat.sysbytes(
 mimetypes.guess_type(pycompat.fsdecode(fctx.path()))[0]
-or r'application/octet-stream')
+or r'application/octet-stream'
-lines = [dagop.annotateline(fctx=fctx.filectx(fctx.filerev()),
+)
-lineno=1, text='(binary:%s)' % mt)]
+lines = [
+dagop.annotateline(
+fctx=fctx.filectx(fctx.filerev()),
+lineno=1,
+text='(binary:%s)' % mt,
+)
+]
 else:
 lines = webutil.annotate(web.req, fctx, web.repo.ui)
 previousrev = None
 blockparitygen = paritygen(1)
 blockhead = True
 blockparity = next(blockparitygen)
 else:
 blockhead = None
 previousrev = rev
-yield {"parity": next(parity),
+yield {
-"node": f.hex(),
+"parity": next(parity),
-"rev": rev,
+"node": f.hex(),
-"author": f.user(),
+"rev": rev,
-"parents": templateutil.mappinggenerator(parents, args=(f,)),
+"author": f.user(),
-"desc": f.description(),
+"parents": templateutil.mappinggenerator(parents, args=(f,)),
-"extra": f.extra(),
+"desc": f.description(),
-"file": f.path(),
+"extra": f.extra(),
-"blockhead": blockhead,
+"file": f.path(),
-"blockparity": blockparity,
+"blockhead": blockhead,
-"targetline": aline.lineno,
+"blockparity": blockparity,
-"line": aline.text,
+"targetline": aline.lineno,
-"lineno": lineno + 1,
+"line": aline.text,
-"lineid": "l%d" % (lineno + 1),
+"lineno": lineno + 1,
-"linenumber": "% 6d" % (lineno + 1),
+"lineid": "l%d" % (lineno + 1),
-"revdate": f.date()}
+"linenumber": "% 6d" % (lineno + 1),
+"revdate": f.date(),
+}
 diffopts = webutil.difffeatureopts(web.req, web.repo.ui, 'annotate')
 diffopts = {k: getattr(diffopts, k) for k in diffopts.defaults}
 return web.sendtemplate(
 symrev=webutil.symrevorshortnode(web.req, fctx),
 rename=webutil.renamelink(fctx),
 permissions=fctx.manifest().flags(f),
 ishead=int(ishead),
 diffopts=templateutil.hybriddict(diffopts),
-**pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))
+**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
+)
 @webcommand('filelog')
 def filelog(web):
 """
 /filelog/{revision}/{path}
 fl = fctx.filelog()
 except error.LookupError:
 f = webutil.cleanpath(web.repo, web.req.qsparams['file'])
 fl = web.repo.file(f)
 numrevs = len(fl)
-if not numrevs: # file doesn't exist at all
+if not numrevs:  # file doesn't exist at all
 raise
 rev = webutil.changectx(web.repo, web.req).rev()
 first = fl.linkrev(0)
-if rev < first: # current rev is from before file existed
+if rev < first:  # current rev is from before file existed
 raise
 frev = numrevs - 1
 while fl.linkrev(frev) > rev:
 frev -= 1
 fctx = web.repo.filectx(f, fl.linkrev(frev))
 descend = 'descend' in web.req.qsparams
 if descend:
 lessvars['descend'] = morevars['descend'] = web.req.qsparams['descend']
 count = fctx.filerev() + 1
-start = max(0, count - revcount) # first rev on this page
+start = max(0, count - revcount)  # first rev on this page
-end = min(count, start + revcount) # last rev on this page
+end = min(count, start + revcount)  # last rev on this page
 parity = paritygen(web.stripecount, offset=start - end)
 repo = web.repo
 filelog = fctx.filelog()
-revs = [filerev for filerev in filelog.revs(start, end - 1)
+revs = [
-if filelog.linkrev(filerev) in repo]
+filerev
+for filerev in filelog.revs(start, end - 1)
+if filelog.linkrev(filerev) in repo
+]
 entries = []
 diffstyle = web.config('web', 'style')
 if 'style' in web.req.qsparams:
 diffstyle = web.req.qsparams['style']
 def diff(fctx, linerange=None):
 ctx = fctx.changectx()
 basectx = ctx.p1()
 path = fctx.path()
-return webutil.diffs(web, ctx, basectx, [path], diffstyle,
+return webutil.diffs(
-linerange=linerange,
+web,
-lineidprefix='%s-' % ctx.hex()[:12])
+ctx,
+basectx,
+[path],
+diffstyle,
+linerange=linerange,
+lineidprefix='%s-' % ctx.hex()[:12],
+)
 linerange = None
 if lrange is not None:
 linerange = webutil.formatlinerange(*lrange)
 # deactivate numeric nav links when linerange is specified as this
 if patch:
 diffs = diff(c, linerange=lr)
 # follow renames accross filtered (not in range) revisions
 path = c.path()
 lm = webutil.commonentry(repo, c)
-lm.update({
+lm.update(
-'parity': next(parity),
+{
-'filerev': c.rev(),
+'parity': next(parity),
-'file': path,
+'filerev': c.rev(),
-'diff': diffs,
+'file': path,
-'linerange': webutil.formatlinerange(*lr),
+'diff': diffs,
-'rename': templateutil.mappinglist([]),
+'linerange': webutil.formatlinerange(*lr),
-})
+'rename': templateutil.mappinglist([]),
+}
+)
 entries.append(lm)
 if i == revcount:
 break
 lessvars['linerange'] = webutil.formatlinerange(*lrange)
 morevars['linerange'] = lessvars['linerange']
 iterfctx = fctx.filectx(i)
 diffs = None
 if patch:
 diffs = diff(iterfctx)
 lm = webutil.commonentry(repo, iterfctx)
-lm.update({
+lm.update(
-'parity': next(parity),
+{
-'filerev': i,
+'parity': next(parity),
-'file': f,
+'filerev': i,
-'diff': diffs,
+'file': f,
-'rename': webutil.renamelink(iterfctx),
+'diff': diffs,
-})
+'rename': webutil.renamelink(iterfctx),
+}
+)
 entries.append(lm)
 entries.reverse()
 revnav = webutil.filerevnav(web.repo, fctx.path())
 nav = revnav.gen(end - 1, revcount, count)
 latestentry=templateutil.mappinglist(latestentry),
 linerange=linerange,
 revcount=revcount,
 morevars=morevars,
 lessvars=lessvars,
-**pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))
+**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
+)
 @webcommand('archive')
 def archive(web):
 """
 /archive/{revision}.{format}[/{path}]
 if type_ not in webutil.archivespecs:
 msg = 'Unsupported archive type: %s' % stringutil.pprint(type_)
 raise ErrorResponse(HTTP_NOT_FOUND, msg)
-if not ((type_ in allowed or
+if not ((type_ in allowed or web.configbool("web", "allow" + type_))):
-web.configbool("web", "allow" + type_))):
 msg = 'Archive type not allowed: %s' % type_
 raise ErrorResponse(HTTP_FORBIDDEN, msg)
 reponame = re.sub(br"\W+", "-", os.path.basename(web.reponame))
 cnode = web.repo.lookup(key)
 pats = ['path:' + file]
 match = scmutil.match(ctx, pats, default='path')
 if pats:
 files = [f for f in ctx.manifest().keys() if match(f)]
 if not files:
-raise ErrorResponse(HTTP_NOT_FOUND,
+raise ErrorResponse(
-'file(s) not found: %s' % file)
+HTTP_NOT_FOUND, 'file(s) not found: %s' % file
+)
 mimetype, artype, extension, encoding = webutil.archivespecs[type_]
 web.res.headers['Content-Type'] = mimetype
 web.res.headers['Content-Disposition'] = 'attachment; filename=%s%s' % (
-name, extension)
+name,
+extension,
+)
 if encoding:
 web.res.headers['Content-Encoding'] = encoding
 web.res.setbodywillwrite()
 if list(web.res.sendresponse()):
-raise error.ProgrammingError('sendresponse() should not emit data '
+raise error.ProgrammingError(
-'if writing later')
+'sendresponse() should not emit data ' 'if writing later'
+)
 bodyfh = web.res.getbodyfile()
-archival.archive(web.repo, bodyfh, cnode, artype, prefix=name, match=match,
+archival.archive(
-subrepos=web.configbool("web", "archivesubrepos"))
+web.repo,
+bodyfh,
+cnode,
+artype,
+prefix=name,
+match=match,
+subrepos=web.configbool("web", "archivesubrepos"),
+)
 return []
 @webcommand('static')
 def static(web):
 fname = web.req.qsparams['file']
 # a repo owner may set web.static in .hg/hgrc to get any file
 static = [os.path.join(p, 'static') for p in tp]
 staticfile(static, fname, web.res)
 return web.res.sendresponse()
 @webcommand('graph')
 def graph(web):
 """
 /graph[/{revision}]
 -------------------
 # We have to feed a baseset to dagwalker as it is expecting smartset
 # object. This does not have a big impact on hgweb performance itself
 # since hgweb graphing code is not itself lazy yet.
 dag = graphmod.dagwalker(web.repo, smartset.baseset(revs))
 # As we said one line above... not lazy.
-tree = list(item for item in graphmod.colored(dag, web.repo)
+tree = list(
-if item[1] == graphmod.CHANGESET)
+item
+for item in graphmod.colored(dag, web.repo)
+if item[1] == graphmod.CHANGESET
+)
 def fulltree():
 pos = web.repo[graphtop].rev()
 tree = []
 if pos != -1:
 revs = web.repo.changelog.revs(pos, lastrev)
 dag = graphmod.dagwalker(web.repo, smartset.baseset(revs))
-tree = list(item for item in graphmod.colored(dag, web.repo)
+tree = list(
-if item[1] == graphmod.CHANGESET)
+item
+for item in graphmod.colored(dag, web.repo)
+if item[1] == graphmod.CHANGESET
+)
 return tree
 def jsdata(context):
 for (id, type, ctx, vtx, edges) in fulltree():
-yield {'node': pycompat.bytestr(ctx),
+yield {
-'graphnode': webutil.getgraphnode(web.repo, ctx),
+'node': pycompat.bytestr(ctx),
-'vertex': vtx,
+'graphnode': webutil.getgraphnode(web.repo, ctx),
-'edges': edges}
+'vertex': vtx,
+'edges': edges,
+}
 def nodes(context):
 parity = paritygen(web.stripecount)
 for row, (id, type, ctx, vtx, edges) in enumerate(tree):
 entry = webutil.commonentry(web.repo, ctx)
-edgedata = [{'col': edge[0],
+edgedata = [
-'nextcol': edge[1],
+{
-'color': (edge[2] - 1) % 6 + 1,
+'col': edge[0],
-'width': edge[3],
+'nextcol': edge[1],
-'bcolor': edge[4]}
+'color': (edge[2] - 1) % 6 + 1,
-for edge in edges]
+'width': edge[3],
+'bcolor': edge[4],
-entry.update({'col': vtx[0],
+}
-'color': (vtx[1] - 1) % 6 + 1,
+for edge in edges
-'parity': next(parity),
+]
-'edges': templateutil.mappinglist(edgedata),
-'row': row,
+entry.update(
-'nextrow': row + 1})
+{
+'col': vtx[0],
+'color': (vtx[1] - 1) % 6 + 1,
+'parity': next(parity),
+'edges': templateutil.mappinglist(edgedata),
+'row': row,
+'nextrow': row + 1,
+}
+)
 yield entry
 rows = len(tree)
 nextentry=templateutil.mappinglist(nextentry),
 jsdata=templateutil.mappinggenerator(jsdata),
 nodes=templateutil.mappinggenerator(nodes),
 node=ctx.hex(),
 archives=web.archivelist('tip'),
-changenav=changenav)
+changenav=changenav,
+)
 def _getdoc(e):
 doc = e[0].__doc__
 if doc:
 doc = _(doc).partition('\n')[0]
 else:
 doc = _('(no help text available)')
 return doc
 @webcommand('help')
 def help(web):
 """
 /help[/{topic}]
 ---------------
 """
 from .. import commands, help as helpmod  # avoid cycle
 topicname = web.req.qsparams.get('node')
 if not topicname:
 def topics(context):
 for h in helpmod.helptable:
 entries, summary, _doc = h[0:3]
 yield {'topic': entries[0], 'summary': summary}
 return web.sendtemplate(
 'helptopics',
 topics=templateutil.mappinggenerator(topics),
 earlycommands=templateutil.mappinggenerator(earlycommands),
 othercommands=templateutil.mappinggenerator(othercommands),
-title='Index')
+title='Index',
+)
 # Render an index of sub-topics.
 if topicname in helpmod.subtopics:
 topics = []
 for entries, summary, _doc in helpmod.subtopics[topicname]:
-topics.append({
+topics.append(
-'topic': '%s.%s' % (topicname, entries[0]),
+{
-'basename': entries[0],
+'topic': '%s.%s' % (topicname, entries[0]),
-'summary': summary,
+'basename': entries[0],
-})
+'summary': summary,
+}
+)
 return web.sendtemplate(
 'helptopics',
 topics=templateutil.mappinglist(topics),
 title=topicname,
-subindex=True)
+subindex=True,
+)
 u = webutil.wsgiui.load()
 u.verbose = True
 # Render a page from a sub-topic.
 try:
 doc = helpmod.help_(u, commands, topic, subtopic=subtopic)
 except error.Abort:
 raise ErrorResponse(HTTP_NOT_FOUND)
-return web.sendtemplate(
+return web.sendtemplate('help', topic=topicname, doc=doc)
-'help',
-topic=topicname,
-doc=doc)
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = commands.values()

changeset 43076	2372284d9457
parent 41397	0bd56c291359
child 43077	687b865b95ad