This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2803

hgweb: stop passing req and tmpl into @webcommand functions (API)
ClosedPublic

Authored by indygreg on Mar 11 2018, 12:24 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG4daa22071d5d: hgweb: stop passing req and tmpl into @webcommand functions (API)
Summary

We have effectively removed all consumers of the old wsgirequest
type. The templater can be accessed on the requestcontext passed
into the @webcommand function.

For the most part, these arguments are unused. They only exist to
provide backwards compatibility. And in the case of wsgirequest,
use of that object could actively interfere with the new request
object.

So let's stop passing these objects to @webcommand functions.

With this commit, wsgirequest is practically dead from the hgweb
WSGI application. There are still some uses in hgwebdir though...

.. api::

@webcommand functions now only receive a single argument. The
request and templater instances can be accessed via the
``req`` and ``templater`` attributes of the first argument.
Note that the request object is different from previous Mercurial
releases and consumers of the previous ``req`` 2nd argument
will need updating to use the new API.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Mar 11 2018, 12:24 AM
durin42 accepted this revision.Mar 12 2018, 5:18 PM
This revision is now accepted and ready to land.Mar 12 2018, 5:18 PM
Closed by commit rHG4daa22071d5d: hgweb: stop passing req and tmpl into @webcommand functions (API) (authored by indygreg). · Explain WhyMar 12 2018, 5:34 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6864

hgext/highlight/__init__.py

ctx = fctx.changectx() ctx = fctx.changectx()
tree = fileset.parse(expr) tree = fileset.parse(expr)
mctx = fileset.matchctx(ctx, subset=[fctx.path()], status=None) mctx = fileset.matchctx(ctx, subset=[fctx.path()], status=None)
if fctx.path() in fileset.getset(mctx, tree): if fctx.path() in fileset.getset(mctx, tree):
highlight.pygmentize(field, fctx, style, tmpl, highlight.pygmentize(field, fctx, style, tmpl,
guessfilenameonly=filenameonly) guessfilenameonly=filenameonly)
def filerevision_highlight(orig, web, req, fctx): def filerevision_highlight(orig, web, fctx):
mt = ''.join(web.tmpl('mimetype', encoding=encoding.encoding)) mt = ''.join(web.tmpl('mimetype', encoding=encoding.encoding))
# only pygmentize for mimetype containing 'html' so we both match # only pygmentize for mimetype containing 'html' so we both match
# 'text/html' and possibly 'application/xhtml+xml' in the future # 'text/html' and possibly 'application/xhtml+xml' in the future
# so that we don't have to touch the extension when the mimetype # so that we don't have to touch the extension when the mimetype
# for a template changes; also hgweb optimizes the case that a # for a template changes; also hgweb optimizes the case that a
# raw file is sent using rawfile() and doesn't call us, so we # raw file is sent using rawfile() and doesn't call us, so we
# can't clash with the file's content-type here in case we # can't clash with the file's content-type here in case we
# pygmentize a html file # pygmentize a html file
if 'html' in mt: if 'html' in mt:
pygmentize(web, 'fileline', fctx, web.tmpl) pygmentize(web, 'fileline', fctx, web.tmpl)
return orig(web, req, fctx) return orig(web, fctx)
def annotate_highlight(orig, web, req, tmpl): def annotate_highlight(orig, web):
mt = ''.join(web.tmpl('mimetype', encoding=encoding.encoding)) mt = ''.join(web.tmpl('mimetype', encoding=encoding.encoding))
if 'html' in mt: if 'html' in mt:
fctx = webutil.filectx(web.repo, web.req) fctx = webutil.filectx(web.repo, web.req)
pygmentize(web, 'annotateline', fctx, web.tmpl) pygmentize(web, 'annotateline', fctx, web.tmpl)
return orig(web, req, web.tmpl) return orig(web)
def generate_css(web, req, tmpl): def generate_css(web):
pg_style = web.config('web', 'pygments_style', 'colorful') pg_style = web.config('web', 'pygments_style', 'colorful')
fmter = highlight.HtmlFormatter(style=pg_style) fmter = highlight.HtmlFormatter(style=pg_style)
web.res.headers['Content-Type'] = 'text/css' web.res.headers['Content-Type'] = 'text/css'
web.res.setbodybytes(''.join([ web.res.setbodybytes(''.join([
'/* pygments_style = %s */\n\n' % pg_style, '/* pygments_style = %s */\n\n' % pg_style,
fmter.get_style_defs(''), fmter.get_style_defs(''),
])) ]))
return web.res.sendresponse() return web.res.sendresponse()
def extsetup(): def extsetup():
# monkeypatch in the new version # monkeypatch in the new version
extensions.wrapfunction(webcommands, '_filerevision', extensions.wrapfunction(webcommands, '_filerevision',
filerevision_highlight) filerevision_highlight)
extensions.wrapfunction(webcommands, 'annotate', annotate_highlight) extensions.wrapfunction(webcommands, 'annotate', annotate_highlight)
webcommands.highlightcss = generate_css webcommands.highlightcss = generate_css
webcommands.__all__.append('highlightcss') webcommands.__all__.append('highlightcss')

hgext/keyword.py

kwt.restrict = True kwt.restrict = True
try: try:
for chunk in orig(repo, *args, **kwargs): for chunk in orig(repo, *args, **kwargs):
yield chunk yield chunk
finally: finally:
if kwt: if kwt:
kwt.restrict = restrict kwt.restrict = restrict
def kwweb_skip(orig, web, req, tmpl): def kwweb_skip(orig, web):
'''Wraps webcommands.x turning off keyword expansion.''' '''Wraps webcommands.x turning off keyword expansion.'''
kwt = getattr(web.repo, '_keywordkwt', None) kwt = getattr(web.repo, '_keywordkwt', None)
if kwt: if kwt:
origmatch = kwt.match origmatch = kwt.match
kwt.match = util.never kwt.match = util.never
try: try:
for chunk in orig(web, req, tmpl): for chunk in orig(web):
yield chunk yield chunk
finally: finally:
if kwt: if kwt:
kwt.match = origmatch kwt.match = origmatch
def kw_amend(orig, ui, repo, old, extra, pats, opts): def kw_amend(orig, ui, repo, old, extra, pats, opts):
'''Wraps cmdutil.amend expanding keywords after amend.''' '''Wraps cmdutil.amend expanding keywords after amend.'''
kwt = getattr(repo, '_keywordkwt', None) kwt = getattr(repo, '_keywordkwt', None)

hgext/largefiles/overrides.py

def overridearchivecmd(orig, ui, repo, dest, **opts): def overridearchivecmd(orig, ui, repo, dest, **opts):
repo.unfiltered().lfstatus = True repo.unfiltered().lfstatus = True
try: try:
return orig(ui, repo.unfiltered(), dest, **opts) return orig(ui, repo.unfiltered(), dest, **opts)
finally: finally:
repo.unfiltered().lfstatus = False repo.unfiltered().lfstatus = False
def hgwebarchive(orig, web, req, tmpl): def hgwebarchive(orig, web):
web.repo.lfstatus = True web.repo.lfstatus = True
try: try:
return orig(web, req, tmpl) return orig(web)
finally: finally:
web.repo.lfstatus = False web.repo.lfstatus = False
def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None, def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None,
prefix='', mtime=None, subrepos=None): prefix='', mtime=None, subrepos=None):
# For some reason setting repo.lfstatus in hgwebarchive only changes the # For some reason setting repo.lfstatus in hgwebarchive only changes the
# unfiltered repo's attr, so check that as well. # unfiltered repo's attr, so check that as well.
if not repo.lfstatus and not repo.unfiltered().lfstatus: if not repo.lfstatus and not repo.unfiltered().lfstatus:

mercurial/hgweb/hgweb_mod.py

if cmd not in webcommands.__all__: if cmd not in webcommands.__all__:
msg = 'no such method: %s' % cmd msg = 'no such method: %s' % cmd
raise ErrorResponse(HTTP_BAD_REQUEST, msg) raise ErrorResponse(HTTP_BAD_REQUEST, msg)
else: else:
# Set some globals appropriate for web handlers. Commands can # Set some globals appropriate for web handlers. Commands can
# override easily enough. # override easily enough.
res.status = '200 Script output follows' res.status = '200 Script output follows'
res.headers['Content-Type'] = ctype res.headers['Content-Type'] = ctype
return getattr(webcommands, cmd)(rctx, wsgireq, rctx.tmpl) return getattr(webcommands, cmd)(rctx)
except (error.LookupError, error.RepoLookupError) as err: except (error.LookupError, error.RepoLookupError) as err:
msg = pycompat.bytestr(err) msg = pycompat.bytestr(err)
if (util.safehasattr(err, 'name') and if (util.safehasattr(err, 'name') and
not isinstance(err, error.ManifestLookupError)): not isinstance(err, error.ManifestLookupError)):
msg = 'revision not found: %s' % err.name msg = 'revision not found: %s' % err.name
res.status = '404 Not Found' res.status = '404 Not Found'

mercurial/hgweb/webcommands.py

The function returns a generator to be consumed by the WSGI application. The function returns a generator to be consumed by the WSGI application.
For most commands, this should be the result from For most commands, this should be the result from
``web.res.sendresponse()``. Many commands will call ``web.sendtemplate()`` ``web.res.sendresponse()``. Many commands will call ``web.sendtemplate()``
to render a template. to render a template.
Usage: Usage:
@webcommand('mycommand') @webcommand('mycommand')
def mycommand(web, req, tmpl): def mycommand(web):
pass pass
""" """
def __init__(self, name): def __init__(self, name):
self.name = name self.name = name
def __call__(self, func): def __call__(self, func):
__all__.append(self.name) __all__.append(self.name)
commands[self.name] = func commands[self.name] = func
return func return func
@webcommand('log') @webcommand('log')
def log(web, req, tmpl): def log(web):
""" """
/log[/{revision}[/{path}]] /log[/{revision}[/{path}]]
-------------------------- --------------------------
Show repository or file history. Show repository or file history.
For URLs of the form ``/log/{revision}``, a list of changesets starting at For URLs of the form ``/log/{revision}``, a list of changesets starting at
the specified changeset identifier is shown. If ``{revision}`` is not the specified changeset identifier is shown. If ``{revision}`` is not
defined, the default is ``tip``. This form is equivalent to the defined, the default is ``tip``. This form is equivalent to the
``changelog`` handler. ``changelog`` handler.
For URLs of the form ``/log/{revision}/{file}``, the history for a specific For URLs of the form ``/log/{revision}/{file}``, the history for a specific
file will be shown. This form is equivalent to the ``filelog`` handler. file will be shown. This form is equivalent to the ``filelog`` handler.
""" """
if web.req.qsparams.get('file'): if web.req.qsparams.get('file'):
return filelog(web, req, None) return filelog(web)
else: else:
return changelog(web, req, None) return changelog(web)
@webcommand('rawfile') @webcommand('rawfile')
def rawfile(web, req, tmpl): def rawfile(web):
guessmime = web.configbool('web', 'guessmime') guessmime = web.configbool('web', 'guessmime')
path = webutil.cleanpath(web.repo, web.req.qsparams.get('file', '')) path = webutil.cleanpath(web.repo, web.req.qsparams.get('file', ''))
if not path: if not path:
return manifest(web, req, None) return manifest(web)
try: try:
fctx = webutil.filectx(web.repo, web.req) fctx = webutil.filectx(web.repo, web.req)
except error.LookupError as inst: except error.LookupError as inst:
try: try:
return manifest(web, req, None) return manifest(web)
except ErrorResponse: except ErrorResponse:
raise inst raise inst
path = fctx.path() path = fctx.path()
text = fctx.data() text = fctx.data()
mt = 'application/binary' mt = 'application/binary'
if guessmime: if guessmime:
mt = mimetypes.guess_type(path)[0] mt = mimetypes.guess_type(path)[0]
if mt is None: if mt is None:
if util.binary(text): if util.binary(text):
mt = 'application/binary' mt = 'application/binary'
else: else:
mt = 'text/plain' mt = 'text/plain'
if mt.startswith('text/'): if mt.startswith('text/'):
mt += '; charset="%s"' % encoding.encoding mt += '; charset="%s"' % encoding.encoding
web.res.headers['Content-Type'] = mt web.res.headers['Content-Type'] = mt
filename = (path.rpartition('/')[-1] filename = (path.rpartition('/')[-1]
.replace('\\', '\\\\').replace('"', '\\"')) .replace('\\', '\\\\').replace('"', '\\"'))
web.res.headers['Content-Disposition'] = 'inline; filename="%s"' % filename web.res.headers['Content-Disposition'] = 'inline; filename="%s"' % filename
web.res.setbodybytes(text) web.res.setbodybytes(text)
return web.res.sendresponse() return web.res.sendresponse()
def _filerevision(web, req, fctx): def _filerevision(web, fctx):
f = fctx.path() f = fctx.path()
text = fctx.data() text = fctx.data()
parity = paritygen(web.stripecount) parity = paritygen(web.stripecount)
ishead = fctx.filerev() in fctx.filelog().headrevs() ishead = fctx.filerev() in fctx.filelog().headrevs()
if util.binary(text): if util.binary(text):
mt = mimetypes.guess_type(f)[0] or 'application/octet-stream' mt = mimetypes.guess_type(f)[0] or 'application/octet-stream'
text = '(binary:%s)' % mt text = '(binary:%s)' % mt
text=lines(), text=lines(),
symrev=webutil.symrevorshortnode(web.req, fctx), symrev=webutil.symrevorshortnode(web.req, fctx),
rename=webutil.renamelink(fctx), rename=webutil.renamelink(fctx),
permissions=fctx.manifest().flags(f), permissions=fctx.manifest().flags(f),
ishead=int(ishead), ishead=int(ishead),
**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))
@webcommand('file') @webcommand('file')
def file(web, req, tmpl): def file(web):
""" """
/file/{revision}[/{path}] /file/{revision}[/{path}]
------------------------- -------------------------
Show information about a directory or file in the repository. Show information about a directory or file in the repository.
Info about the ``path`` given as a URL parameter will be rendered. Info about the ``path`` given as a URL parameter will be rendered.
If ``path`` is a directory, information about the entries in that If ``path`` is a directory, information about the entries in that
directory will be rendered. This form is equivalent to the ``manifest`` directory will be rendered. This form is equivalent to the ``manifest``
handler. handler.
If ``path`` is a file, information about that file will be shown via If ``path`` is a file, information about that file will be shown via
the ``filerevision`` template. the ``filerevision`` template.
If ``path`` is not defined, information about the root directory will If ``path`` is not defined, information about the root directory will
be rendered. be rendered.
""" """
if web.req.qsparams.get('style') == 'raw': if web.req.qsparams.get('style') == 'raw':
return rawfile(web, req, None) return rawfile(web)
path = webutil.cleanpath(web.repo, web.req.qsparams.get('file', '')) path = webutil.cleanpath(web.repo, web.req.qsparams.get('file', ''))
if not path: if not path:
return manifest(web, req, None) return manifest(web)
try: try:
return _filerevision(web, req, webutil.filectx(web.repo, web.req)) return _filerevision(web, webutil.filectx(web.repo, web.req))
except error.LookupError as inst: except error.LookupError as inst:
try: try:
return manifest(web, req, None) return manifest(web)
except ErrorResponse: except ErrorResponse:
raise inst raise inst
def _search(web): def _search(web):
MODE_REVISION = 'rev' MODE_REVISION = 'rev'
MODE_KEYWORD = 'keyword' MODE_KEYWORD = 'keyword'
MODE_REVSET = 'revset' MODE_REVSET = 'revset'
archives=web.archivelist('tip'), archives=web.archivelist('tip'),
morevars=morevars, morevars=morevars,
lessvars=lessvars, lessvars=lessvars,
modedesc=searchfunc[1], modedesc=searchfunc[1],
showforcekw=showforcekw, showforcekw=showforcekw,
showunforcekw=showunforcekw) showunforcekw=showunforcekw)
@webcommand('changelog') @webcommand('changelog')
def changelog(web, req, tmpl, shortlog=False): def changelog(web, shortlog=False):
""" """
/changelog[/{revision}] /changelog[/{revision}]
----------------------- -----------------------
Show information about multiple changesets. Show information about multiple changesets.
If the optional ``revision`` URL argument is absent, information about If the optional ``revision`` URL argument is absent, information about
all changesets starting at ``tip`` will be rendered. If the ``revision`` all changesets starting at ``tip`` will be rendered. If the ``revision``
nextentry=nextentry, nextentry=nextentry,
archives=web.archivelist('tip'), archives=web.archivelist('tip'),
revcount=revcount, revcount=revcount,
morevars=morevars, morevars=morevars,
lessvars=lessvars, lessvars=lessvars,
query=query) query=query)
@webcommand('shortlog') @webcommand('shortlog')
def shortlog(web, req, tmpl): def shortlog(web):
""" """
/shortlog /shortlog
--------- ---------
Show basic information about a set of changesets. Show basic information about a set of changesets.
This accepts the same parameters as the ``changelog`` handler. The only This accepts the same parameters as the ``changelog`` handler. The only
difference is the ``shortlog`` template will be rendered instead of the difference is the ``shortlog`` template will be rendered instead of the
``changelog`` template. ``changelog`` template.
""" """
return changelog(web, req, None, shortlog=True) return changelog(web, shortlog=True)
@webcommand('changeset') @webcommand('changeset')
def changeset(web, req, tmpl): def changeset(web):
""" """
/changeset[/{revision}] /changeset[/{revision}]
----------------------- -----------------------
Show information about a single changeset. Show information about a single changeset.
A URL path argument is the changeset identifier to show. See ``hg help A URL path argument is the changeset identifier to show. See ``hg help
revisions`` for possible values. If not defined, the ``tip`` changeset revisions`` for possible values. If not defined, the ``tip`` changeset
"""Hook for mapping a path in the repository to a path in the """Hook for mapping a path in the repository to a path in the
working copy. working copy.
Extensions (e.g., largefiles) can override this to remap files in Extensions (e.g., largefiles) can override this to remap files in
the virtual file system presented by the manifest command below.""" the virtual file system presented by the manifest command below."""
return path return path
@webcommand('manifest') @webcommand('manifest')
def manifest(web, req, tmpl): def manifest(web):
""" """
/manifest[/{revision}[/{path}]] /manifest[/{revision}[/{path}]]
------------------------------- -------------------------------
Show information about a directory. Show information about a directory.
If the URL path arguments are omitted, information about the root If the URL path arguments are omitted, information about the root
directory for the ``tip`` changeset will be shown. directory for the ``tip`` changeset will be shown.
up=webutil.up(abspath), up=webutil.up(abspath),
upparity=next(parity), upparity=next(parity),
fentries=filelist, fentries=filelist,
dentries=dirlist, dentries=dirlist,
archives=web.archivelist(hex(node)), archives=web.archivelist(hex(node)),
**pycompat.strkwargs(webutil.commonentry(web.repo, ctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))
@webcommand('tags') @webcommand('tags')
def tags(web, req, tmpl): def tags(web):
""" """
/tags /tags
----- -----
Show information about tags. Show information about tags.
No arguments are accepted. No arguments are accepted.
return web.sendtemplate( return web.sendtemplate(
'tags', 'tags',
node=hex(web.repo.changelog.tip()), node=hex(web.repo.changelog.tip()),
entries=lambda **x: entries(False, False, **x), entries=lambda **x: entries(False, False, **x),
entriesnotip=lambda **x: entries(True, False, **x), entriesnotip=lambda **x: entries(True, False, **x),
latestentry=lambda **x: entries(True, True, **x)) latestentry=lambda **x: entries(True, True, **x))
@webcommand('bookmarks') @webcommand('bookmarks')
def bookmarks(web, req, tmpl): def bookmarks(web):
""" """
/bookmarks /bookmarks
---------- ----------
Show information about bookmarks. Show information about bookmarks.
No arguments are accepted. No arguments are accepted.
return web.sendtemplate( return web.sendtemplate(
'bookmarks', 'bookmarks',
node=hex(web.repo.changelog.tip()), node=hex(web.repo.changelog.tip()),
lastchange=[{'date': web.repo[latestrev].date()}], lastchange=[{'date': web.repo[latestrev].date()}],
entries=lambda **x: entries(latestonly=False, **x), entries=lambda **x: entries(latestonly=False, **x),
latestentry=lambda **x: entries(latestonly=True, **x)) latestentry=lambda **x: entries(latestonly=True, **x))
@webcommand('branches') @webcommand('branches')
def branches(web, req, tmpl): def branches(web):
""" """
/branches /branches
--------- ---------
Show information about branches. Show information about branches.
All known branches are contained in the output, even closed branches. All known branches are contained in the output, even closed branches.
No arguments are accepted. No arguments are accepted.
The ``branches`` template is rendered. The ``branches`` template is rendered.
""" """
entries = webutil.branchentries(web.repo, web.stripecount) entries = webutil.branchentries(web.repo, web.stripecount)
latestentry = webutil.branchentries(web.repo, web.stripecount, 1) latestentry = webutil.branchentries(web.repo, web.stripecount, 1)
return web.sendtemplate( return web.sendtemplate(
'branches', 'branches',
node=hex(web.repo.changelog.tip()), node=hex(web.repo.changelog.tip()),
entries=entries, entries=entries,
latestentry=latestentry) latestentry=latestentry)
@webcommand('summary') @webcommand('summary')
def summary(web, req, tmpl): def summary(web):
""" """
/summary /summary
-------- --------
Show a summary of repository state. Show a summary of repository state.
Information about the latest changesets, bookmarks, tags, and branches Information about the latest changesets, bookmarks, tags, and branches
is captured by this handler. is captured by this handler.
branches=webutil.branchentries(web.repo, web.stripecount, 10), branches=webutil.branchentries(web.repo, web.stripecount, 10),
shortlog=changelist, shortlog=changelist,
node=tip.hex(), node=tip.hex(),
symrev='tip', symrev='tip',
archives=web.archivelist('tip'), archives=web.archivelist('tip'),
labels=web.configlist('web', 'labels')) labels=web.configlist('web', 'labels'))
@webcommand('filediff') @webcommand('filediff')
def filediff(web, req, tmpl): def filediff(web):
""" """
/diff/{revision}/{path} /diff/{revision}/{path}
----------------------- -----------------------
Show how a file changed in a particular commit. Show how a file changed in a particular commit.
The ``filediff`` template is rendered. The ``filediff`` template is rendered.
symrev=webutil.symrevorshortnode(web.req, ctx), symrev=webutil.symrevorshortnode(web.req, ctx),
rename=rename, rename=rename,
diff=diffs, diff=diffs,
**pycompat.strkwargs(webutil.commonentry(web.repo, ctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))
diff = webcommand('diff')(filediff) diff = webcommand('diff')(filediff)
@webcommand('comparison') @webcommand('comparison')
def comparison(web, req, tmpl): def comparison(web):
""" """
/comparison/{revision}/{path} /comparison/{revision}/{path}
----------------------------- -----------------------------
Show a comparison between the old and new versions of a file from changes Show a comparison between the old and new versions of a file from changes
made on a particular revision. made on a particular revision.
This is similar to the ``diff`` handler. However, this form features This is similar to the ``diff`` handler. However, this form features
leftrev=leftrev, leftrev=leftrev,
leftnode=hex(leftnode), leftnode=hex(leftnode),
rightrev=rightrev, rightrev=rightrev,
rightnode=hex(rightnode), rightnode=hex(rightnode),
comparison=comparison, comparison=comparison,
**pycompat.strkwargs(webutil.commonentry(web.repo, ctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))
@webcommand('annotate') @webcommand('annotate')
def annotate(web, req, tmpl): def annotate(web):
""" """
/annotate/{revision}/{path} /annotate/{revision}/{path}
--------------------------- ---------------------------
Show changeset information for each line in a file. Show changeset information for each line in a file.
The ``ignorews``, ``ignorewsamount``, ``ignorewseol``, and The ``ignorews``, ``ignorewsamount``, ``ignorewseol``, and
``ignoreblanklines`` query string arguments have the same meaning as ``ignoreblanklines`` query string arguments have the same meaning as
symrev=webutil.symrevorshortnode(web.req, fctx), symrev=webutil.symrevorshortnode(web.req, fctx),
rename=webutil.renamelink(fctx), rename=webutil.renamelink(fctx),
permissions=fctx.manifest().flags(f), permissions=fctx.manifest().flags(f),
ishead=int(ishead), ishead=int(ishead),
diffopts=diffopts, diffopts=diffopts,
**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))
@webcommand('filelog') @webcommand('filelog')
def filelog(web, req, tmpl): def filelog(web):
""" """
/filelog/{revision}/{path} /filelog/{revision}/{path}
-------------------------- --------------------------
Show information about the history of a file in the repository. Show information about the history of a file in the repository.
The ``revcount`` query string argument can be defined to control the The ``revcount`` query string argument can be defined to control the
maximum number of entries to show. maximum number of entries to show.
latestentry=latestentry, latestentry=latestentry,
linerange=linerange, linerange=linerange,
revcount=revcount, revcount=revcount,
morevars=morevars, morevars=morevars,
lessvars=lessvars, lessvars=lessvars,
**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))
@webcommand('archive') @webcommand('archive')
def archive(web, req, tmpl): def archive(web):
""" """
/archive/{revision}.{format}[/{path}] /archive/{revision}.{format}[/{path}]
------------------------------------- -------------------------------------
Obtain an archive of repository content. Obtain an archive of repository content.
The content and type of the archive is defined by a URL path parameter. The content and type of the archive is defined by a URL path parameter.
``format`` is the file extension of the archive type to be generated. e.g. ``format`` is the file extension of the archive type to be generated. e.g.
archival.archive(web.repo, bodyfh, cnode, artype, prefix=name, archival.archive(web.repo, bodyfh, cnode, artype, prefix=name,
matchfn=match, matchfn=match,
subrepos=web.configbool("web", "archivesubrepos")) subrepos=web.configbool("web", "archivesubrepos"))
return [] return []
@webcommand('static') @webcommand('static')
def static(web, req, tmpl): def static(web):
fname = web.req.qsparams['file'] fname = web.req.qsparams['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("web", "static", None, untrusted=False) static = web.config("web", "static", None, untrusted=False)
if not static: if not static:
tp = web.templatepath or templater.templatepaths() tp = web.templatepath or templater.templatepaths()
if isinstance(tp, str): if isinstance(tp, str):
tp = [tp] tp = [tp]
static = [os.path.join(p, 'static') for p in tp] static = [os.path.join(p, 'static') for p in tp]
staticfile(static, fname, web.res) staticfile(static, fname, web.res)
return web.res.sendresponse() return web.res.sendresponse()
@webcommand('graph') @webcommand('graph')
def graph(web, req, tmpl): def graph(web):
""" """
/graph[/{revision}] /graph[/{revision}]
------------------- -------------------
Show information about the graphical topology of the repository. Show information about the graphical topology of the repository.
Information rendered by this handler can be used to create visual Information rendered by this handler can be used to create visual
representations of repository topology. representations of repository topology.
doc = e[0].__doc__ doc = e[0].__doc__
if doc: if doc:
doc = _(doc).partition('\n')[0] doc = _(doc).partition('\n')[0]
else: else:
doc = _('(no help text available)') doc = _('(no help text available)')
return doc return doc
@webcommand('help') @webcommand('help')
def help(web, req, tmpl): def help(web):
""" """
/help[/{topic}] /help[/{topic}]
--------------- ---------------
Render help documentation. Render help documentation.
This web command is roughly equivalent to :hg:`help`. If a ``topic`` This web command is roughly equivalent to :hg:`help`. If a ``topic``
is defined, that help topic will be rendered. If not, an index of is defined, that help topic will be rendered. If not, an index of

tests/hgweberror.py

# A dummy extension that installs an hgweb command that throws an Exception. # A dummy extension that installs an hgweb command that throws an Exception.
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.hgweb import ( from mercurial.hgweb import (
webcommands, webcommands,
) )
def raiseerror(web, req, tmpl): def raiseerror(web):
'''Dummy web command that raises an uncaught Exception.''' '''Dummy web command that raises an uncaught Exception.'''
# Simulate an error after partial response. # Simulate an error after partial response.
if 'partialresponse' in web.req.qsparams: if 'partialresponse' in web.req.qsparams:
web.res.status = b'200 Script output follows' web.res.status = b'200 Script output follows'
web.res.headers[b'Content-Type'] = b'text/plain' web.res.headers[b'Content-Type'] = b'text/plain'
web.res.setbodywillwrite() web.res.setbodywillwrite()
list(web.res.sendresponse()) list(web.res.sendresponse())
web.res.getbodyfile().write(b'partial content\n') web.res.getbodyfile().write(b'partial content\n')
raise AttributeError('I am an uncaught error!') raise AttributeError('I am an uncaught error!')
def extsetup(ui): def extsetup(ui):
setattr(webcommands, 'raiseerror', raiseerror) setattr(webcommands, 'raiseerror', raiseerror)
webcommands.__all__.append('raiseerror') webcommands.__all__.append('raiseerror')