webcommands.py
1323 lines
| 42.1 KiB
| text/x-python
|
PythonLexer
|
r5591 | # | ||
# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | ||||
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r5591 | |||
|
r7345 | import os, mimetypes, re, cgi, copy | ||
|
r6392 | import webutil | ||
|
r11332 | from mercurial import error, encoding, archival, templater, templatefilters | ||
|
r21123 | from mercurial.node import short, hex | ||
|
r19657 | from mercurial import util | ||
|
r6393 | from common import paritygen, staticfile, get_contact, ErrorResponse | ||
|
r7029 | from common import HTTP_OK, HTTP_FORBIDDEN, HTTP_NOT_FOUND | ||
|
r15528 | from mercurial import graphmod, patch | ||
|
r17933 | from mercurial import scmutil | ||
|
r12666 | from mercurial.i18n import _ | ||
|
r19722 | from mercurial.error import ParseError, RepoLookupError, Abort | ||
from mercurial import revset | ||||
|
r5591 | |||
|
r24076 | __all__ = [] | ||
|
r24077 | commands = {} | ||
|
r24076 | |||
class webcommand(object): | ||||
"""Decorator used to register a web command handler. | ||||
The decorator takes as its positional arguments the name/path the | ||||
command should be accessible under. | ||||
Usage: | ||||
|
r5963 | |||
|
r24076 | @webcommand('mycommand') | ||
def mycommand(web, req, tmpl): | ||||
pass | ||||
""" | ||||
|
r5963 | |||
|
r24076 | def __init__(self, name): | ||
self.name = name | ||||
def __call__(self, func): | ||||
__all__.append(self.name) | ||||
|
r24077 | commands[self.name] = func | ||
|
r24076 | return func | ||
@webcommand('log') | ||||
|
r5600 | def log(web, req, tmpl): | ||
|
r24087 | """ | ||
/log[/{revision}[/{path}]] | ||||
-------------------------- | ||||
Show repository or file history. | ||||
For URLs of the form ``/log/{revision}``, a list of changesets starting at | ||||
the specified changeset identifier is shown. If ``{revision}`` is not | ||||
defined, the default is ``tip``. This form is equivalent to the | ||||
``changelog`` handler. | ||||
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. | ||||
""" | ||||
|
r5915 | if 'file' in req.form and req.form['file'][0]: | ||
|
r5964 | return filelog(web, req, tmpl) | ||
|
r5591 | else: | ||
|
r5964 | return changelog(web, req, tmpl) | ||
|
r5591 | |||
|
r24076 | @webcommand('rawfile') | ||
|
r5890 | def rawfile(web, req, tmpl): | ||
|
r15004 | guessmime = web.configbool('web', 'guessmime', False) | ||
|
r6392 | path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0]) | ||
|
r5890 | if not path: | ||
|
r6393 | content = manifest(web, req, tmpl) | ||
|
r5993 | req.respond(HTTP_OK, web.ctype) | ||
return content | ||||
|
r5890 | |||
try: | ||||
|
r6392 | fctx = webutil.filectx(web.repo, req) | ||
|
r7633 | except error.LookupError, inst: | ||
|
r6368 | try: | ||
|
r6393 | content = manifest(web, req, tmpl) | ||
|
r6368 | req.respond(HTTP_OK, web.ctype) | ||
return content | ||||
except ErrorResponse: | ||||
raise inst | ||||
|
r5890 | |||
path = fctx.path() | ||||
text = fctx.data() | ||||
|
r15004 | mt = 'application/binary' | ||
if guessmime: | ||||
mt = mimetypes.guess_type(path)[0] | ||||
if mt is None: | ||||
|
r24306 | if util.binary(text): | ||
mt = 'application/binary' | ||||
else: | ||||
mt = 'text/plain' | ||||
|
r11332 | if mt.startswith('text/'): | ||
mt += '; charset="%s"' % encoding.encoding | ||||
|
r5890 | |||
|
r18352 | req.respond(HTTP_OK, mt, path, body=text) | ||
return [] | ||||
|
r5890 | |||
|
r6393 | def _filerevision(web, tmpl, fctx): | ||
f = fctx.path() | ||||
text = fctx.data() | ||||
parity = paritygen(web.stripecount) | ||||
|
r19657 | if util.binary(text): | ||
|
r6393 | mt = mimetypes.guess_type(f)[0] or 'application/octet-stream' | ||
text = '(binary:%s)' % mt | ||||
def lines(): | ||||
|
r9136 | for lineno, t in enumerate(text.splitlines(True)): | ||
|
r6393 | yield {"line": t, | ||
"lineid": "l%d" % (lineno + 1), | ||||
"linenumber": "% 6d" % (lineno + 1), | ||||
"parity": parity.next()} | ||||
return tmpl("filerevision", | ||||
file=f, | ||||
path=webutil.up(f), | ||||
text=lines(), | ||||
rev=fctx.rev(), | ||||
|
r14055 | node=fctx.hex(), | ||
|
r6393 | author=fctx.user(), | ||
date=fctx.date(), | ||||
desc=fctx.description(), | ||||
|
r18581 | extra=fctx.extra(), | ||
|
r6393 | branch=webutil.nodebranchnodefault(fctx), | ||
|
r7671 | parent=webutil.parents(fctx), | ||
child=webutil.children(fctx), | ||||
|
r6434 | rename=webutil.renamelink(fctx), | ||
|
r6393 | permissions=fctx.manifest().flags(f)) | ||
|
r24076 | @webcommand('file') | ||
|
r5600 | def file(web, req, tmpl): | ||
|
r24088 | """ | ||
/file/{revision}[/{path}] | ||||
------------------------- | ||||
Show information about a directory or file in the repository. | ||||
Info about the ``path`` given as a URL parameter will be rendered. | ||||
If ``path`` is a directory, information about the entries in that | ||||
directory will be rendered. This form is equivalent to the ``manifest`` | ||||
handler. | ||||
If ``path`` is a file, information about that file will be shown via | ||||
the ``filerevision`` template. | ||||
If ``path`` is not defined, information about the root directory will | ||||
be rendered. | ||||
""" | ||||
|
r6392 | path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0]) | ||
|
r6853 | if not path: | ||
|
r6857 | return manifest(web, req, tmpl) | ||
|
r6853 | try: | ||
|
r6857 | return _filerevision(web, tmpl, webutil.filectx(web.repo, req)) | ||
|
r7633 | except error.LookupError, inst: | ||
|
r5591 | try: | ||
|
r6857 | return manifest(web, req, tmpl) | ||
|
r6853 | except ErrorResponse: | ||
raise inst | ||||
|
r5591 | |||
|
r10247 | def _search(web, req, tmpl): | ||
|
r19656 | MODE_REVISION = 'rev' | ||
MODE_KEYWORD = 'keyword' | ||||
|
r19722 | MODE_REVSET = 'revset' | ||
|
r10247 | |||
|
r19633 | def revsearch(ctx): | ||
yield ctx | ||||
|
r19632 | def keywordsearch(query): | ||
|
r15727 | lower = encoding.lower | ||
qw = lower(query).split() | ||||
|
r6393 | |||
def revgen(): | ||||
|
r18497 | cl = web.repo.changelog | ||
|
r12059 | for i in xrange(len(web.repo) - 1, 0, -100): | ||
|
r6393 | l = [] | ||
|
r19491 | for j in cl.revs(max(0, i - 99), i): | ||
|
r6747 | ctx = web.repo[j] | ||
|
r6393 | l.append(ctx) | ||
l.reverse() | ||||
for e in l: | ||||
yield e | ||||
for ctx in revgen(): | ||||
miss = 0 | ||||
for q in qw: | ||||
|
r15727 | if not (q in lower(ctx.user()) or | ||
q in lower(ctx.description()) or | ||||
q in lower(" ".join(ctx.files()))): | ||||
|
r6393 | miss = 1 | ||
break | ||||
if miss: | ||||
continue | ||||
|
r19533 | yield ctx | ||
|
r19722 | def revsetsearch(revs): | ||
for r in revs: | ||||
yield web.repo[r] | ||||
|
r19631 | searchfuncs = { | ||
|
r20004 | MODE_REVISION: (revsearch, 'exact revision search'), | ||
MODE_KEYWORD: (keywordsearch, 'literal keyword search'), | ||||
MODE_REVSET: (revsetsearch, 'revset expression search'), | ||||
|
r19631 | } | ||
|
r19632 | def getsearchmode(query): | ||
|
r19633 | try: | ||
ctx = web.repo[query] | ||||
except (error.RepoError, error.LookupError): | ||||
|
r19722 | # query is not an exact revision pointer, need to | ||
|
r19951 | # decide if it's a revset expression or keywords | ||
|
r19722 | pass | ||
|
r19633 | else: | ||
|
r19656 | return MODE_REVISION, ctx | ||
|
r19631 | |||
|
r19722 | revdef = 'reverse(%s)' % query | ||
try: | ||||
tree, pos = revset.parse(revdef) | ||||
except ParseError: | ||||
# can't parse to a revset tree | ||||
return MODE_KEYWORD, query | ||||
if revset.depth(tree) <= 2: | ||||
# no revset syntax used | ||||
return MODE_KEYWORD, query | ||||
if util.any((token, (value or '')[:3]) == ('string', 're:') | ||||
for token, value, pos in revset.tokenize(revdef)): | ||||
return MODE_KEYWORD, query | ||||
funcsused = revset.funcsused(tree) | ||||
if not funcsused.issubset(revset.safesymbols): | ||||
return MODE_KEYWORD, query | ||||
mfunc = revset.match(web.repo.ui, revdef) | ||||
try: | ||||
|
r24114 | revs = mfunc(web.repo) | ||
|
r19722 | 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 (ParseError, RepoLookupError, Abort, LookupError): | ||||
return MODE_KEYWORD, query | ||||
|
r19533 | def changelist(**map): | ||
count = 0 | ||||
|
r19765 | for ctx in searchfunc[0](funcarg): | ||
|
r6659 | count += 1 | ||
|
r6393 | n = ctx.node() | ||
showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n) | ||||
|
r7311 | files = webutil.listfilediffs(tmpl, ctx.files(), n, web.maxfiles) | ||
|
r6393 | |||
yield tmpl('searchentry', | ||||
parity=parity.next(), | ||||
author=ctx.user(), | ||||
|
r7671 | parent=webutil.parents(ctx), | ||
child=webutil.children(ctx), | ||||
|
r6393 | changelogtag=showtags, | ||
desc=ctx.description(), | ||||
|
r18581 | extra=ctx.extra(), | ||
|
r6393 | date=ctx.date(), | ||
|
r7311 | files=files, | ||
|
r6393 | rev=ctx.rev(), | ||
node=hex(n), | ||||
tags=webutil.nodetagsdict(web.repo, n), | ||||
|
r13794 | bookmarks=webutil.nodebookmarksdict(web.repo, n), | ||
|
r6393 | inbranch=webutil.nodeinbranch(web.repo, ctx), | ||
branches=webutil.nodebranchdict(web.repo, ctx)) | ||||
|
r10247 | if count >= revcount: | ||
|
r6393 | break | ||
|
r19418 | query = req.form['rev'][0] | ||
revcount = web.maxchanges | ||||
if 'revcount' in req.form: | ||||
|
r20092 | try: | ||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
revcount = max(revcount, 1) | ||||
tmpl.defaults['sessionvars']['revcount'] = revcount | ||||
except ValueError: | ||||
pass | ||||
|
r19418 | |||
lessvars = copy.copy(tmpl.defaults['sessionvars']) | ||||
lessvars['revcount'] = max(revcount / 2, 1) | ||||
lessvars['rev'] = query | ||||
morevars = copy.copy(tmpl.defaults['sessionvars']) | ||||
morevars['revcount'] = revcount * 2 | ||||
morevars['rev'] = query | ||||
|
r19632 | mode, funcarg = getsearchmode(query) | ||
|
r19768 | |||
if 'forcekw' in req.form: | ||||
showforcekw = '' | ||||
showunforcekw = searchfuncs[mode][1] | ||||
mode = MODE_KEYWORD | ||||
funcarg = query | ||||
else: | ||||
if mode != MODE_KEYWORD: | ||||
showforcekw = searchfuncs[MODE_KEYWORD][1] | ||||
else: | ||||
showforcekw = '' | ||||
showunforcekw = '' | ||||
|
r19631 | searchfunc = searchfuncs[mode] | ||
|
r12059 | tip = web.repo['tip'] | ||
|
r6393 | parity = paritygen(web.stripecount) | ||
|
r12059 | return tmpl('search', query=query, node=tip.hex(), | ||
|
r10247 | entries=changelist, archives=web.archivelist("tip"), | ||
|
r19765 | morevars=morevars, lessvars=lessvars, | ||
|
r19768 | modedesc=searchfunc[1], | ||
showforcekw=showforcekw, showunforcekw=showunforcekw) | ||||
|
r6393 | |||
|
r24076 | @webcommand('changelog') | ||
|
r10247 | def changelog(web, req, tmpl, shortlog=False): | ||
|
r24089 | """ | ||
/changelog[/{revision}] | ||||
----------------------- | ||||
Show information about multiple changesets. | ||||
If the optional ``revision`` URL argument is absent, information about | ||||
all changesets starting at ``tip`` will be rendered. If the ``revision`` | ||||
argument is present, changesets will be shown starting from the specified | ||||
revision. | ||||
If ``revision`` is absent, the ``rev`` query string argument may be | ||||
defined. This will perform a search for changesets. | ||||
The argument for ``rev`` can be a single revision, a revision set, | ||||
or a literal keyword to search for in changeset data (equivalent to | ||||
:hg:`log -k`. | ||||
The ``revcount`` query string argument defines the maximum numbers of | ||||
changesets to render. | ||||
For non-searches, the ``changelog`` template will be rendered. | ||||
""" | ||||
|
r10247 | |||
|
r19396 | query = '' | ||
|
r5915 | if 'node' in req.form: | ||
|
r6392 | ctx = webutil.changectx(web.repo, req) | ||
|
r19534 | elif 'rev' in req.form: | ||
|
r19634 | return _search(web, req, tmpl) | ||
|
r5591 | else: | ||
|
r19534 | ctx = web.repo['tip'] | ||
|
r6393 | |||
|
r19737 | def changelist(): | ||
|
r18427 | revs = [] | ||
|
r19486 | if pos != -1: | ||
revs = web.repo.changelog.revs(pos, 0) | ||||
curcount = 0 | ||||
|
r23745 | for rev in revs: | ||
|
r19486 | curcount += 1 | ||
|
r19738 | if curcount > revcount + 1: | ||
|
r19486 | break | ||
|
r23745 | |||
entry = webutil.changelistentry(web, web.repo[rev], tmpl) | ||||
entry['parity'] = parity.next() | ||||
yield entry | ||||
|
r6393 | |||
|
r24306 | if shortlog: | ||
revcount = web.maxshortchanges | ||||
else: | ||||
revcount = web.maxchanges | ||||
|
r10246 | if 'revcount' in req.form: | ||
|
r20092 | try: | ||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
revcount = max(revcount, 1) | ||||
tmpl.defaults['sessionvars']['revcount'] = revcount | ||||
except ValueError: | ||||
pass | ||||
|
r10246 | |||
lessvars = copy.copy(tmpl.defaults['sessionvars']) | ||||
|
r13931 | lessvars['revcount'] = max(revcount / 2, 1) | ||
|
r10246 | morevars = copy.copy(tmpl.defaults['sessionvars']) | ||
morevars['revcount'] = revcount * 2 | ||||
|
r12059 | count = len(web.repo) | ||
|
r6393 | pos = ctx.rev() | ||
|
r19486 | parity = paritygen(web.stripecount) | ||
|
r6393 | |||
|
r18409 | changenav = webutil.revnav(web.repo).gen(pos, revcount, count) | ||
|
r6393 | |||
|
r19737 | entries = list(changelist()) | ||
latestentry = entries[:1] | ||||
|
r19738 | if len(entries) > revcount: | ||
nextentry = entries[-1:] | ||||
entries = entries[:-1] | ||||
else: | ||||
nextentry = [] | ||||
|
r19737 | |||
|
r10246 | return tmpl(shortlog and 'shortlog' or 'changelog', changenav=changenav, | ||
|
r14055 | node=ctx.hex(), rev=pos, changesets=count, | ||
|
r19737 | entries=entries, | ||
|
r19738 | latestentry=latestentry, nextentry=nextentry, | ||
|
r10246 | archives=web.archivelist("tip"), revcount=revcount, | ||
|
r19396 | morevars=morevars, lessvars=lessvars, query=query) | ||
|
r5591 | |||
|
r24076 | @webcommand('shortlog') | ||
|
r5600 | def shortlog(web, req, tmpl): | ||
|
r24086 | """ | ||
/shortlog | ||||
--------- | ||||
Show basic information about a set of changesets. | ||||
This accepts the same parameters as the ``changelog`` handler. The only | ||||
difference is the ``shortlog`` template will be rendered instead of the | ||||
``changelog`` template. | ||||
""" | ||||
|
r19872 | return changelog(web, req, tmpl, shortlog=True) | ||
|
r5591 | |||
|
r24076 | @webcommand('changeset') | ||
|
r5600 | def changeset(web, req, tmpl): | ||
|
r24085 | """ | ||
/changeset[/{revision}] | ||||
----------------------- | ||||
Show information about a single changeset. | ||||
A URL path argument is the changeset identifier to show. See ``hg help | ||||
revisions`` for possible values. If not defined, the ``tip`` changeset | ||||
will be shown. | ||||
The ``changeset`` template is rendered. Contents of the ``changesettag``, | ||||
``changesetbookmark``, ``filenodelink``, ``filenolink``, and the many | ||||
templates related to diffs may all be used to produce the output. | ||||
""" | ||||
|
r6393 | ctx = webutil.changectx(web.repo, req) | ||
|
r24177 | return tmpl('changeset', **webutil.changesetentry(web, req, tmpl, ctx)) | ||
|
r5591 | |||
|
r24076 | rev = webcommand('rev')(changeset) | ||
|
r5591 | |||
|
r16448 | 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 | ||||
|
r24076 | @webcommand('manifest') | ||
|
r5600 | def manifest(web, req, tmpl): | ||
|
r24090 | """ | ||
/manifest[/{revision}[/{path}]] | ||||
------------------------------- | ||||
Show information about a directory. | ||||
If the URL path arguments are defined, information about the root | ||||
directory for the ``tip`` changeset will be shown. | ||||
Because this handler can only show information for directories, it | ||||
is recommended to use the ``file`` handler instead, as it can handle both | ||||
directories and files. | ||||
The ``manifest`` template will be rendered for this handler. | ||||
""" | ||||
|
r6393 | ctx = webutil.changectx(web.repo, req) | ||
path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0]) | ||||
mf = ctx.manifest() | ||||
node = ctx.node() | ||||
files = {} | ||||
|
r7305 | dirs = {} | ||
|
r6393 | parity = paritygen(web.stripecount) | ||
if path and path[-1] != "/": | ||||
path += "/" | ||||
l = len(path) | ||||
abspath = "/" + path | ||||
|
r16448 | for full, n in mf.iteritems(): | ||
# the virtual path (working copy path) used for the full | ||||
# (repository) path | ||||
f = decodepath(full) | ||||
|
r6393 | if f[:l] != path: | ||
continue | ||||
remain = f[l:] | ||||
|
r7305 | elements = remain.split('/') | ||
if len(elements) == 1: | ||||
|
r16448 | files[remain] = full | ||
|
r7305 | else: | ||
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 | ||||
|
r6393 | |||
|
r7565 | if mf and not files and not dirs: | ||
|
r6393 | raise ErrorResponse(HTTP_NOT_FOUND, 'path not found: ' + path) | ||
def filelist(**map): | ||||
|
r8209 | for f in sorted(files): | ||
|
r7305 | full = files[f] | ||
|
r6393 | |||
fctx = ctx.filectx(full) | ||||
yield {"file": full, | ||||
"parity": parity.next(), | ||||
"basename": f, | ||||
|
r6747 | "date": fctx.date(), | ||
|
r6393 | "size": fctx.size(), | ||
"permissions": mf.flags(full)} | ||||
def dirlist(**map): | ||||
|
r8209 | for d in sorted(dirs): | ||
|
r6393 | |||
|
r7305 | emptydirs = [] | ||
h = dirs[d] | ||||
while isinstance(h, dict) and len(h) == 1: | ||||
|
r10282 | k, v = h.items()[0] | ||
|
r7305 | if v: | ||
emptydirs.append(k) | ||||
h = v | ||||
path = "%s%s" % (abspath, d) | ||||
|
r6393 | yield {"parity": parity.next(), | ||
|
r7305 | "path": path, | ||
"emptydirs": "/".join(emptydirs), | ||||
"basename": d} | ||||
|
r6393 | |||
return tmpl("manifest", | ||||
rev=ctx.rev(), | ||||
node=hex(node), | ||||
path=abspath, | ||||
up=webutil.up(abspath), | ||||
upparity=parity.next(), | ||||
fentries=filelist, | ||||
dentries=dirlist, | ||||
archives=web.archivelist(hex(node)), | ||||
tags=webutil.nodetagsdict(web.repo, node), | ||||
|
r13794 | bookmarks=webutil.nodebookmarksdict(web.repo, node), | ||
|
r6393 | inbranch=webutil.nodeinbranch(web.repo, ctx), | ||
branches=webutil.nodebranchdict(web.repo, ctx)) | ||||
|
r5591 | |||
|
r24076 | @webcommand('tags') | ||
|
r5600 | def tags(web, req, tmpl): | ||
|
r24084 | """ | ||
/tags | ||||
----- | ||||
Show information about tags. | ||||
No arguments are accepted. | ||||
The ``tags`` template is rendered. | ||||
""" | ||||
|
r18029 | i = list(reversed(web.repo.tagslist())) | ||
|
r6393 | parity = paritygen(web.stripecount) | ||
|
r18402 | def entries(notip, latestonly, **map): | ||
t = i | ||||
if notip: | ||||
t = [(k, n) for k, n in i if k != "tip"] | ||||
if latestonly: | ||||
t = t[:1] | ||||
for k, n in t: | ||||
|
r6393 | yield {"parity": parity.next(), | ||
"tag": k, | ||||
|
r6747 | "date": web.repo[n].date(), | ||
|
r6393 | "node": hex(n)} | ||
return tmpl("tags", | ||||
node=hex(web.repo.changelog.tip()), | ||||
|
r18402 | entries=lambda **x: entries(False, False, **x), | ||
entriesnotip=lambda **x: entries(True, False, **x), | ||||
latestentry=lambda **x: entries(True, True, **x)) | ||||
|
r5591 | |||
|
r24076 | @webcommand('bookmarks') | ||
|
r13597 | def bookmarks(web, req, tmpl): | ||
|
r24083 | """ | ||
/bookmarks | ||||
---------- | ||||
Show information about bookmarks. | ||||
No arguments are accepted. | ||||
The ``bookmarks`` template is rendered. | ||||
""" | ||||
|
r18478 | i = [b for b in web.repo._bookmarks.items() if b[1] in web.repo] | ||
|
r13597 | parity = paritygen(web.stripecount) | ||
|
r18402 | def entries(latestonly, **map): | ||
if latestonly: | ||||
t = [min(i)] | ||||
else: | ||||
t = sorted(i) | ||||
for k, n in t: | ||||
|
r13597 | yield {"parity": parity.next(), | ||
"bookmark": k, | ||||
"date": web.repo[n].date(), | ||||
"node": hex(n)} | ||||
return tmpl("bookmarks", | ||||
node=hex(web.repo.changelog.tip()), | ||||
|
r18402 | entries=lambda **x: entries(latestonly=False, **x), | ||
latestentry=lambda **x: entries(latestonly=True, **x)) | ||||
|
r13597 | |||
|
r24076 | @webcommand('branches') | ||
|
r8352 | def branches(web, req, tmpl): | ||
|
r24082 | """ | ||
/branches | ||||
--------- | ||||
Show information about branches. | ||||
All known branches are contained in the output, even closed branches. | ||||
No arguments are accepted. | ||||
The ``branches`` template is rendered. | ||||
""" | ||||
|
r18030 | tips = [] | ||
|
r8796 | heads = web.repo.heads() | ||
|
r8352 | parity = paritygen(web.stripecount) | ||
|
r20194 | sortkey = lambda item: (not item[1], item[0].rev()) | ||
|
r8352 | |||
def entries(limit, **map): | ||||
count = 0 | ||||
|
r18030 | if not tips: | ||
|
r20194 | for tag, hs, tip, closed in web.repo.branchmap().iterbranches(): | ||
tips.append((web.repo[tip], closed)) | ||||
for ctx, closed in sorted(tips, key=sortkey, reverse=True): | ||||
|
r8352 | if limit > 0 and count >= limit: | ||
return | ||||
count += 1 | ||||
|
r20194 | if closed: | ||
|
r14771 | status = 'closed' | ||
elif ctx.node() not in heads: | ||||
|
r8796 | status = 'inactive' | ||
else: | ||||
status = 'open' | ||||
|
r8352 | yield {'parity': parity.next(), | ||
|
r8354 | 'branch': ctx.branch(), | ||
|
r8713 | 'status': status, | ||
|
r8354 | 'node': ctx.hex(), | ||
'date': ctx.date()} | ||||
|
r8352 | |||
return tmpl('branches', node=hex(web.repo.changelog.tip()), | ||||
entries=lambda **x: entries(0, **x), | ||||
latestentry=lambda **x: entries(1, **x)) | ||||
|
r24076 | @webcommand('summary') | ||
|
r5600 | def summary(web, req, tmpl): | ||
|
r24091 | """ | ||
/summary | ||||
-------- | ||||
Show a summary of repository state. | ||||
Information about the latest changesets, bookmarks, tags, and branches | ||||
is captured by this handler. | ||||
The ``summary`` template is rendered. | ||||
""" | ||||
|
r17261 | i = reversed(web.repo.tagslist()) | ||
|
r6393 | |||
def tagentries(**map): | ||||
parity = paritygen(web.stripecount) | ||||
count = 0 | ||||
for k, n in i: | ||||
if k == "tip": # skip tip | ||||
continue | ||||
|
r6659 | count += 1 | ||
|
r6393 | if count > 10: # limit to 10 tags | ||
break | ||||
yield tmpl("tagentry", | ||||
parity=parity.next(), | ||||
tag=k, | ||||
node=hex(n), | ||||
|
r6747 | date=web.repo[n].date()) | ||
|
r6393 | |||
|
r13924 | def bookmarks(**map): | ||
parity = paritygen(web.stripecount) | ||||
|
r18563 | marks = [b for b in web.repo._bookmarks.items() if b[1] in web.repo] | ||
for k, n in sorted(marks)[:10]: # limit to 10 bookmarks | ||||
|
r13924 | yield {'parity': parity.next(), | ||
'bookmark': k, | ||||
'date': web.repo[n].date(), | ||||
'node': hex(n)} | ||||
|
r6393 | def branches(**map): | ||
parity = paritygen(web.stripecount) | ||||
|
r20193 | b = web.repo.branchmap() | ||
l = [(-web.repo.changelog.rev(tip), tip, tag) | ||||
for tag, heads, tip, closed in b.iterbranches()] | ||||
|
r10282 | for r, n, t in sorted(l): | ||
|
r6393 | yield {'parity': parity.next(), | ||
'branch': t, | ||||
'node': hex(n), | ||||
|
r6747 | 'date': web.repo[n].date()} | ||
|
r6393 | |||
def changelist(**map): | ||||
|
r10282 | parity = paritygen(web.stripecount, offset=start - end) | ||
|
r6393 | l = [] # build a list in forward order for efficiency | ||
|
r18563 | revs = [] | ||
if start < end: | ||||
revs = web.repo.changelog.revs(start, end - 1) | ||||
for i in revs: | ||||
|
r6747 | ctx = web.repo[i] | ||
|
r6393 | n = ctx.node() | ||
hn = hex(n) | ||||
|
r18319 | l.append(tmpl( | ||
|
r6393 | 'shortlogentry', | ||
parity=parity.next(), | ||||
author=ctx.user(), | ||||
desc=ctx.description(), | ||||
|
r18581 | extra=ctx.extra(), | ||
|
r6393 | date=ctx.date(), | ||
rev=i, | ||||
node=hn, | ||||
tags=webutil.nodetagsdict(web.repo, n), | ||||
|
r13794 | bookmarks=webutil.nodebookmarksdict(web.repo, n), | ||
|
r6393 | inbranch=webutil.nodeinbranch(web.repo, ctx), | ||
branches=webutil.nodebranchdict(web.repo, ctx))) | ||||
|
r18319 | l.reverse() | ||
|
r6393 | yield l | ||
|
r12059 | tip = web.repo['tip'] | ||
count = len(web.repo) | ||||
|
r6393 | start = max(0, count - web.maxchanges) | ||
end = min(count, start + web.maxchanges) | ||||
return tmpl("summary", | ||||
desc=web.config("web", "description", "unknown"), | ||||
owner=get_contact(web.config) or "unknown", | ||||
|
r12059 | lastchange=tip.date(), | ||
|
r6393 | tags=tagentries, | ||
|
r13924 | bookmarks=bookmarks, | ||
|
r6393 | branches=branches, | ||
shortlog=changelist, | ||||
|
r12059 | node=tip.hex(), | ||
|
r6393 | archives=web.archivelist("tip")) | ||
|
r5591 | |||
|
r24076 | @webcommand('filediff') | ||
|
r5600 | def filediff(web, req, tmpl): | ||
|
r24092 | """ | ||
/diff/{revision}/{path} | ||||
----------------------- | ||||
Show how a file changed in a particular commit. | ||||
The ``filediff`` template is rendered. | ||||
This hander is registered under both the ``/diff`` and ``/filediff`` | ||||
paths. ``/diff`` is used in modern code. | ||||
""" | ||||
|
r7183 | fctx, ctx = None, None | ||
try: | ||||
fctx = webutil.filectx(web.repo, req) | ||||
|
r7280 | except LookupError: | ||
|
r7183 | ctx = webutil.changectx(web.repo, req) | ||
path = webutil.cleanpath(web.repo, req.form['file'][0]) | ||||
if path not in ctx.files(): | ||||
raise | ||||
if fctx is not None: | ||||
n = fctx.node() | ||||
path = fctx.path() | ||||
|
r16722 | ctx = fctx.changectx() | ||
|
r7183 | else: | ||
n = ctx.node() | ||||
# path already defined in except clause | ||||
|
r6393 | |||
|
r7310 | parity = paritygen(web.stripecount) | ||
|
r9402 | style = web.config('web', 'style', 'paper') | ||
if 'style' in req.form: | ||||
style = req.form['style'][0] | ||||
|
r17991 | diffs = webutil.diffs(web.repo, tmpl, ctx, None, [path], parity, style) | ||
|
r24306 | if fctx: | ||
rename = webutil.renamelink(fctx) | ||||
ctx = fctx | ||||
else: | ||||
rename = [] | ||||
ctx = ctx | ||||
|
r6393 | return tmpl("filediff", | ||
file=path, | ||||
node=hex(n), | ||||
|
r7183 | rev=ctx.rev(), | ||
date=ctx.date(), | ||||
desc=ctx.description(), | ||||
|
r18581 | extra=ctx.extra(), | ||
|
r7183 | author=ctx.user(), | ||
rename=rename, | ||||
branch=webutil.nodebranchnodefault(ctx), | ||||
|
r7671 | parent=webutil.parents(ctx), | ||
child=webutil.children(ctx), | ||||
|
r6393 | diff=diffs) | ||
|
r5591 | |||
|
r24076 | diff = webcommand('diff')(filediff) | ||
|
r5591 | |||
|
r24076 | @webcommand('comparison') | ||
|
r17202 | def comparison(web, req, tmpl): | ||
|
r24093 | """ | ||
/comparison/{revision}/{path} | ||||
----------------------------- | ||||
Show a comparison between the old and new versions of a file from changes | ||||
made on a particular revision. | ||||
This is similar to the ``diff`` handler. However, this form features | ||||
a split or side-by-side diff rather than a unified diff. | ||||
The ``context`` query string argument can be used to control the lines of | ||||
context in the diff. | ||||
The ``filecomparison`` template is rendered. | ||||
""" | ||||
|
r17202 | ctx = webutil.changectx(web.repo, req) | ||
|
r17289 | if 'file' not in req.form: | ||
raise ErrorResponse(HTTP_NOT_FOUND, 'file not given') | ||||
|
r17202 | path = webutil.cleanpath(web.repo, req.form['file'][0]) | ||
rename = path in ctx and webutil.renamelink(ctx[path]) or [] | ||||
parsecontext = lambda v: v == 'full' and -1 or int(v) | ||||
if 'context' in req.form: | ||||
context = parsecontext(req.form['context'][0]) | ||||
else: | ||||
context = parsecontext(web.config('web', 'comparisoncontext', '5')) | ||||
|
r17302 | def filelines(f): | ||
|
r19657 | if util.binary(f.data()): | ||
|
r17302 | mt = mimetypes.guess_type(f.path())[0] | ||
if not mt: | ||||
mt = 'application/octet-stream' | ||||
return [_('(binary file %s, hash: %s)') % (mt, hex(f.filenode()))] | ||||
return f.data().splitlines() | ||||
|
r21123 | parent = ctx.p1() | ||
leftrev = parent.rev() | ||||
leftnode = parent.node() | ||||
rightrev = ctx.rev() | ||||
rightnode = ctx.node() | ||||
|
r17302 | if path in ctx: | ||
fctx = ctx[path] | ||||
rightlines = filelines(fctx) | ||||
|
r21121 | if path not in parent: | ||
|
r17302 | leftlines = () | ||
else: | ||||
|
r21121 | pfctx = parent[path] | ||
|
r17302 | leftlines = filelines(pfctx) | ||
else: | ||||
rightlines = () | ||||
fctx = ctx.parents()[0][path] | ||||
leftlines = filelines(fctx) | ||||
comparison = webutil.compare(tmpl, context, leftlines, rightlines) | ||||
|
r17202 | return tmpl('filecomparison', | ||
file=path, | ||||
node=hex(ctx.node()), | ||||
rev=ctx.rev(), | ||||
date=ctx.date(), | ||||
desc=ctx.description(), | ||||
|
r18581 | extra=ctx.extra(), | ||
|
r17202 | author=ctx.user(), | ||
rename=rename, | ||||
branch=webutil.nodebranchnodefault(ctx), | ||||
|
r17303 | parent=webutil.parents(fctx), | ||
child=webutil.children(fctx), | ||||
|
r17302 | leftrev=leftrev, | ||
leftnode=hex(leftnode), | ||||
rightrev=rightrev, | ||||
rightnode=hex(rightnode), | ||||
|
r17202 | comparison=comparison) | ||
|
r24076 | @webcommand('annotate') | ||
|
r5600 | def annotate(web, req, tmpl): | ||
|
r24094 | """ | ||
/annotate/{revision}/{path} | ||||
--------------------------- | ||||
Show changeset information for each line in a file. | ||||
The ``fileannotate`` template is rendered. | ||||
""" | ||||
|
r6393 | fctx = webutil.filectx(web.repo, req) | ||
f = fctx.path() | ||||
parity = paritygen(web.stripecount) | ||||
|
r23689 | diffopts = patch.difffeatureopts(web.repo.ui, untrusted=True, | ||
section='annotate', whitespace=True) | ||||
|
r6393 | |||
def annotate(**map): | ||||
last = None | ||||
|
r19657 | if util.binary(fctx.data()): | ||
|
r6393 | mt = (mimetypes.guess_type(fctx.path())[0] | ||
or 'application/octet-stream') | ||||
lines = enumerate([((fctx.filectx(fctx.filerev()), 1), | ||||
'(binary:%s)' % mt)]) | ||||
else: | ||||
|
r15528 | lines = enumerate(fctx.annotate(follow=True, linenumber=True, | ||
diffopts=diffopts)) | ||||
|
r6393 | for lineno, ((f, targetline), l) in lines: | ||
fnode = f.filenode() | ||||
if last != fnode: | ||||
last = fnode | ||||
yield {"parity": parity.next(), | ||||
|
r14055 | "node": f.hex(), | ||
|
r6393 | "rev": f.rev(), | ||
|
r6564 | "author": f.user(), | ||
|
r6657 | "desc": f.description(), | ||
|
r18581 | "extra": f.extra(), | ||
|
r6393 | "file": f.path(), | ||
"targetline": targetline, | ||||
"line": l, | ||||
|
r24712 | "lineno": lineno + 1, | ||
|
r6393 | "lineid": "l%d" % (lineno + 1), | ||
|
r13199 | "linenumber": "% 6d" % (lineno + 1), | ||
"revdate": f.date()} | ||||
|
r6393 | |||
return tmpl("fileannotate", | ||||
file=f, | ||||
annotate=annotate, | ||||
path=webutil.up(f), | ||||
rev=fctx.rev(), | ||||
|
r14055 | node=fctx.hex(), | ||
|
r6393 | author=fctx.user(), | ||
date=fctx.date(), | ||||
desc=fctx.description(), | ||||
|
r18581 | extra=fctx.extra(), | ||
|
r6434 | rename=webutil.renamelink(fctx), | ||
|
r6393 | branch=webutil.nodebranchnodefault(fctx), | ||
|
r7671 | parent=webutil.parents(fctx), | ||
child=webutil.children(fctx), | ||||
|
r6393 | permissions=fctx.manifest().flags(f)) | ||
|
r5591 | |||
|
r24076 | @webcommand('filelog') | ||
|
r5600 | def filelog(web, req, tmpl): | ||
|
r24095 | """ | ||
/filelog/{revision}/{path} | ||||
-------------------------- | ||||
Show information about the history of a file in the repository. | ||||
The ``revcount`` query string argument can be defined to control the | ||||
maximum number of entries to show. | ||||
The ``filelog`` template will be rendered. | ||||
""" | ||||
|
r7300 | |||
try: | ||||
fctx = webutil.filectx(web.repo, req) | ||||
f = fctx.path() | ||||
fl = fctx.filelog() | ||||
|
r7633 | except error.LookupError: | ||
|
r7300 | f = webutil.cleanpath(web.repo, req.form['file'][0]) | ||
fl = web.repo.file(f) | ||||
numrevs = len(fl) | ||||
if not numrevs: # file doesn't exist at all | ||||
raise | ||||
rev = webutil.changectx(web.repo, req).rev() | ||||
|
r7361 | first = fl.linkrev(0) | ||
|
r7300 | if rev < first: # current rev is from before file existed | ||
raise | ||||
frev = numrevs - 1 | ||||
|
r7361 | while fl.linkrev(frev) > rev: | ||
|
r7300 | frev -= 1 | ||
|
r7361 | fctx = web.repo.filectx(f, fl.linkrev(frev)) | ||
|
r7300 | |||
|
r10246 | revcount = web.maxshortchanges | ||
if 'revcount' in req.form: | ||||
|
r20092 | try: | ||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
revcount = max(revcount, 1) | ||||
tmpl.defaults['sessionvars']['revcount'] = revcount | ||||
except ValueError: | ||||
pass | ||||
|
r10246 | |||
lessvars = copy.copy(tmpl.defaults['sessionvars']) | ||||
|
r13931 | lessvars['revcount'] = max(revcount / 2, 1) | ||
|
r10246 | morevars = copy.copy(tmpl.defaults['sessionvars']) | ||
morevars['revcount'] = revcount * 2 | ||||
|
r7300 | count = fctx.filerev() + 1 | ||
|
r10246 | start = max(0, fctx.filerev() - revcount + 1) # first rev on this page | ||
end = min(count, start + revcount) # last rev on this page | ||||
|
r10282 | parity = paritygen(web.stripecount, offset=start - end) | ||
|
r6393 | |||
|
r20022 | def entries(): | ||
|
r6393 | l = [] | ||
|
r7612 | repo = web.repo | ||
|
r20023 | revs = fctx.filelog().revs(start, end - 1) | ||
|
r18402 | for i in revs: | ||
|
r7612 | iterfctx = fctx.filectx(i) | ||
|
r6393 | |||
|
r18319 | l.append({"parity": parity.next(), | ||
"filerev": i, | ||||
"file": f, | ||||
"node": iterfctx.hex(), | ||||
"author": iterfctx.user(), | ||||
"date": iterfctx.date(), | ||||
"rename": webutil.renamelink(iterfctx), | ||||
"parent": webutil.parents(iterfctx), | ||||
"child": webutil.children(iterfctx), | ||||
"desc": iterfctx.description(), | ||||
|
r18581 | "extra": iterfctx.extra(), | ||
|
r18319 | "tags": webutil.nodetagsdict(repo, iterfctx.node()), | ||
"bookmarks": webutil.nodebookmarksdict( | ||||
repo, iterfctx.node()), | ||||
"branch": webutil.nodebranchnodefault(iterfctx), | ||||
"inbranch": webutil.nodeinbranch(repo, iterfctx), | ||||
"branches": webutil.nodebranchdict(repo, iterfctx)}) | ||||
for e in reversed(l): | ||||
|
r6393 | yield e | ||
|
r20022 | entries = list(entries()) | ||
latestentry = entries[:1] | ||||
|
r18409 | revnav = webutil.filerevnav(web.repo, fctx.path()) | ||
nav = revnav.gen(end - 1, revcount, count) | ||||
|
r14055 | return tmpl("filelog", file=f, node=fctx.hex(), nav=nav, | ||
|
r20022 | entries=entries, | ||
latestentry=latestentry, | ||||
|
r10246 | revcount=revcount, morevars=morevars, lessvars=lessvars) | ||
|
r5591 | |||
|
r24076 | @webcommand('archive') | ||
|
r5600 | def archive(web, req, tmpl): | ||
|
r24096 | """ | ||
/archive/{revision}.{format}[/{path}] | ||||
------------------------------------- | ||||
Obtain an archive of repository content. | ||||
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. | ||||
``zip`` or ``tar.bz2``. Not all archive types may be allowed by your | ||||
server configuration. | ||||
The optional ``path`` URL parameter controls content to include in the | ||||
archive. If omitted, every file in the specified revision is present in the | ||||
archive. If included, only the specified file or contents of the specified | ||||
directory will be included in the archive. | ||||
No template is used for this handler. Raw, binary content is generated. | ||||
""" | ||||
|
r6669 | type_ = req.form.get('type', [None])[0] | ||
|
r5591 | allowed = web.configlist("web", "allow_archive") | ||
|
r6393 | key = req.form['node'][0] | ||
|
r7029 | if type_ not in web.archives: | ||
|
r6393 | msg = 'Unsupported archive type: %s' % type_ | ||
raise ErrorResponse(HTTP_NOT_FOUND, msg) | ||||
|
r7029 | if not ((type_ in allowed or | ||
web.configbool("web", "allow" + type_, False))): | ||||
msg = 'Archive type not allowed: %s' % type_ | ||||
raise ErrorResponse(HTTP_FORBIDDEN, msg) | ||||
|
r6393 | reponame = re.sub(r"\W+", "-", os.path.basename(web.reponame)) | ||
cnode = web.repo.lookup(key) | ||||
arch_version = key | ||||
if cnode == key or key == 'tip': | ||||
arch_version = short(cnode) | ||||
name = "%s-%s" % (reponame, arch_version) | ||||
|
r18771 | |||
ctx = webutil.changectx(web.repo, req) | ||||
pats = [] | ||||
|
r23232 | matchfn = scmutil.match(ctx, []) | ||
|
r18771 | file = req.form.get('file', None) | ||
if file: | ||||
|
r18968 | pats = ['path:' + file[0]] | ||
matchfn = scmutil.match(ctx, pats, default='path') | ||||
if pats: | ||||
files = [f for f in ctx.manifest().keys() if matchfn(f)] | ||||
if not files: | ||||
raise ErrorResponse(HTTP_NOT_FOUND, | ||||
'file(s) not found: %s' % file[0]) | ||||
|
r18771 | |||
|
r6393 | mimetype, artype, extension, encoding = web.archive_specs[type_] | ||
headers = [ | ||||
('Content-Disposition', 'attachment; filename=%s%s' % (name, extension)) | ||||
|
r18347 | ] | ||
|
r6393 | if encoding: | ||
headers.append(('Content-Encoding', encoding)) | ||||
|
r18348 | req.headers.extend(headers) | ||
|
r18347 | req.respond(HTTP_OK, mimetype) | ||
|
r17933 | |||
archival.archive(web.repo, req, cnode, artype, prefix=name, | ||||
|
r18771 | matchfn=matchfn, | ||
|
r17933 | subrepos=web.configbool("web", "archivesubrepos")) | ||
|
r6393 | return [] | ||
|
r5591 | |||
|
r24076 | @webcommand('static') | ||
|
r5600 | def static(web, req, tmpl): | ||
|
r5591 | fname = req.form['file'][0] | ||
# a repo owner may set web.static in .hg/hgrc to get any file | ||||
# readable by the user running the CGI script | ||||
|
r7107 | static = web.config("web", "static", None, untrusted=False) | ||
if not static: | ||||
|
r22634 | tp = web.templatepath or templater.templatepaths() | ||
|
r7107 | if isinstance(tp, str): | ||
tp = [tp] | ||||
|
r7288 | static = [os.path.join(p, 'static') for p in tp] | ||
|
r18645 | staticfile(static, fname, req) | ||
return [] | ||||
|
r6691 | |||
|
r24076 | @webcommand('graph') | ||
|
r6691 | def graph(web, req, tmpl): | ||
|
r24097 | """ | ||
/graph[/{revision}] | ||||
------------------- | ||||
Show information about the graphical topology of the repository. | ||||
Information rendered by this handler can be used to create visual | ||||
representations of repository topology. | ||||
The ``revision`` URL parameter controls the starting changeset. | ||||
The ``revcount`` query string argument can define the number of changesets | ||||
to show information for. | ||||
This handler will render the ``graph`` template. | ||||
""" | ||||
|
r10245 | |||
|
r17318 | ctx = webutil.changectx(web.repo, req) | ||
rev = ctx.rev() | ||||
|
r6691 | bg_height = 39 | ||
|
r10245 | revcount = web.maxshortchanges | ||
|
r7345 | if 'revcount' in req.form: | ||
|
r20092 | try: | ||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
revcount = max(revcount, 1) | ||||
tmpl.defaults['sessionvars']['revcount'] = revcount | ||||
except ValueError: | ||||
pass | ||||
|
r7345 | |||
lessvars = copy.copy(tmpl.defaults['sessionvars']) | ||||
|
r13931 | lessvars['revcount'] = max(revcount / 2, 1) | ||
|
r7345 | morevars = copy.copy(tmpl.defaults['sessionvars']) | ||
morevars['revcount'] = revcount * 2 | ||||
|
r17318 | count = len(web.repo) | ||
pos = rev | ||||
uprev = min(max(0, count - 1), rev + revcount) | ||||
|
r6691 | downrev = max(0, rev - revcount) | ||
|
r18409 | changenav = webutil.revnav(web.repo).gen(pos, revcount, count) | ||
|
r6691 | |||
|
r18428 | tree = [] | ||
|
r19487 | if pos != -1: | ||
allrevs = web.repo.changelog.revs(pos, 0) | ||||
revs = [] | ||||
for i in allrevs: | ||||
revs.append(i) | ||||
if len(revs) >= revcount: | ||||
break | ||||
|
r20761 | # 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, revset.baseset(revs)) | ||||
# As we said one line above... not lazy. | ||||
|
r18428 | tree = list(graphmod.colored(dag, web.repo)) | ||
|
r16773 | |||
def getcolumns(tree): | ||||
cols = 0 | ||||
for (id, type, ctx, vtx, edges) in tree: | ||||
if type != graphmod.CHANGESET: | ||||
continue | ||||
cols = max(cols, max([edge[0] for edge in edges] or [0]), | ||||
max([edge[1] for edge in edges] or [0])) | ||||
return cols | ||||
def graphdata(usetuples, **map): | ||||
data = [] | ||||
row = 0 | ||||
for (id, type, ctx, vtx, edges) in tree: | ||||
if type != graphmod.CHANGESET: | ||||
continue | ||||
node = str(ctx) | ||||
age = templatefilters.age(ctx.date()) | ||||
desc = templatefilters.firstline(ctx.description()) | ||||
desc = cgi.escape(templatefilters.nonempty(desc)) | ||||
user = cgi.escape(templatefilters.person(ctx.user())) | ||||
|
r19879 | branch = cgi.escape(ctx.branch()) | ||
|
r16773 | try: | ||
branchnode = web.repo.branchtip(branch) | ||||
except error.RepoLookupError: | ||||
branchnode = None | ||||
branch = branch, branchnode == ctx.node() | ||||
if usetuples: | ||||
data.append((node, vtx, edges, desc, user, age, branch, | ||||
|
r19883 | [cgi.escape(x) for x in ctx.tags()], | ||
[cgi.escape(x) for x in ctx.bookmarks()])) | ||||
|
r16773 | else: | ||
|
r20678 | edgedata = [{'col': edge[0], 'nextcol': edge[1], | ||
'color': (edge[2] - 1) % 6 + 1, | ||||
'width': edge[3], 'bcolor': edge[4]} | ||||
|
r16773 | for edge in edges] | ||
data.append( | ||||
|
r20678 | {'node': node, | ||
'col': vtx[0], | ||||
'color': (vtx[1] - 1) % 6 + 1, | ||||
'edges': edgedata, | ||||
'row': row, | ||||
'nextrow': row + 1, | ||||
'desc': desc, | ||||
'user': user, | ||||
'age': age, | ||||
'bookmarks': webutil.nodebookmarksdict( | ||||
web.repo, ctx.node()), | ||||
'branches': webutil.nodebranchdict(web.repo, ctx), | ||||
'inbranch': webutil.nodeinbranch(web.repo, ctx), | ||||
'tags': webutil.nodetagsdict(web.repo, ctx.node())}) | ||||
|
r16773 | |||
row += 1 | ||||
return data | ||||
cols = getcolumns(tree) | ||||
rows = len(tree) | ||||
canvasheight = (rows + 1) * bg_height - 27 | ||||
|
r6691 | |||
return tmpl('graph', rev=rev, revcount=revcount, uprev=uprev, | ||||
|
r7345 | lessvars=lessvars, morevars=morevars, downrev=downrev, | ||
|
r16773 | cols=cols, rows=rows, | ||
canvaswidth=(cols + 1) * bg_height, | ||||
truecanvasheight=rows * bg_height, | ||||
canvasheight=canvasheight, bg_height=bg_height, | ||||
jsdata=lambda **x: graphdata(True, **x), | ||||
nodes=lambda **x: graphdata(False, **x), | ||||
|
r17318 | node=ctx.hex(), changenav=changenav) | ||
|
r12666 | |||
def _getdoc(e): | ||||
doc = e[0].__doc__ | ||||
if doc: | ||||
|
r16469 | doc = _(doc).split('\n')[0] | ||
|
r12666 | else: | ||
doc = _('(no help text available)') | ||||
return doc | ||||
|
r24076 | @webcommand('help') | ||
|
r12666 | def help(web, req, tmpl): | ||
|
r24081 | """ | ||
/help[/{topic}] | ||||
--------------- | ||||
Render help documentation. | ||||
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 | ||||
available help topics will be rendered. | ||||
The ``help`` template will be rendered when requesting help for a topic. | ||||
``helptopics`` will be rendered for the index of help topics. | ||||
""" | ||||
|
r12666 | from mercurial import commands # avoid cycle | ||
|
r24078 | from mercurial import help as helpmod # avoid cycle | ||
|
r12666 | |||
topicname = req.form.get('node', [None])[0] | ||||
if not topicname: | ||||
def topics(**map): | ||||
|
r22199 | for entries, summary, _doc in helpmod.helptable: | ||
|
r17322 | yield {'topic': entries[0], 'summary': summary} | ||
|
r12666 | |||
early, other = [], [] | ||||
primary = lambda s: s.split('|')[0] | ||||
for c, e in commands.table.iteritems(): | ||||
doc = _getdoc(e) | ||||
if 'DEPRECATED' in doc or c.startswith('debug'): | ||||
continue | ||||
cmd = primary(c) | ||||
if cmd.startswith('^'): | ||||
early.append((cmd[1:], doc)) | ||||
else: | ||||
other.append((cmd, doc)) | ||||
early.sort() | ||||
other.sort() | ||||
def earlycommands(**map): | ||||
for c, doc in early: | ||||
yield {'topic': c, 'summary': doc} | ||||
def othercommands(**map): | ||||
for c, doc in other: | ||||
yield {'topic': c, 'summary': doc} | ||||
return tmpl('helptopics', topics=topics, earlycommands=earlycommands, | ||||
othercommands=othercommands, title='Index') | ||||
|
r12696 | u = webutil.wsgiui() | ||
|
r17146 | u.verbose = True | ||
|
r12666 | try: | ||
|
r18747 | doc = helpmod.help_(u, topicname) | ||
|
r12666 | except error.UnknownCommand: | ||
raise ErrorResponse(HTTP_NOT_FOUND) | ||||
return tmpl('help', topic=topicname, doc=doc) | ||||
|
r24859 | |||
# tell hggettext to extract docstrings from these functions: | ||||
i18nfunctions = commands.values() | ||||