webcommands.py
836 lines
| 28.5 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 | ||
|
r7873 | from mercurial.node import short, hex | ||
from mercurial.util import binary | ||||
|
r6393 | from common import paritygen, staticfile, get_contact, ErrorResponse | ||
|
r7029 | from common import HTTP_OK, HTTP_FORBIDDEN, HTTP_NOT_FOUND | ||
|
r8390 | from mercurial import graphmod | ||
|
r12666 | from mercurial import help as helpmod | ||
from mercurial.i18n import _ | ||||
|
r5591 | |||
|
r5963 | # __all__ is populated with the allowed commands. Be sure to add to it if | ||
# you're adding a new command, or the new command won't work. | ||||
__all__ = [ | ||||
'log', 'rawfile', 'file', 'changelog', 'shortlog', 'changeset', 'rev', | ||||
|
r13597 | 'manifest', 'tags', 'bookmarks', 'branches', 'summary', 'filediff', 'diff', | ||
'annotate', 'filelog', 'archive', 'static', 'graph', 'help', | ||||
|
r5963 | ] | ||
|
r5600 | def log(web, req, tmpl): | ||
|
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 | |||
|
r5890 | def rawfile(web, req, tmpl): | ||
|
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() | ||||
mt = mimetypes.guess_type(path)[0] | ||||
|
r6981 | if mt is None: | ||
mt = binary(text) and 'application/octet-stream' or 'text/plain' | ||||
|
r11332 | if mt.startswith('text/'): | ||
mt += '; charset="%s"' % encoding.encoding | ||||
|
r5890 | |||
|
r5993 | req.respond(HTTP_OK, mt, path, len(text)) | ||
|
r5964 | return [text] | ||
|
r5890 | |||
|
r6393 | def _filerevision(web, tmpl, fctx): | ||
f = fctx.path() | ||||
text = fctx.data() | ||||
parity = paritygen(web.stripecount) | ||||
if binary(text): | ||||
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(), | ||||
branch=webutil.nodebranchnodefault(fctx), | ||||
|
r7671 | parent=webutil.parents(fctx), | ||
child=webutil.children(fctx), | ||||
|
r6434 | rename=webutil.renamelink(fctx), | ||
|
r6393 | permissions=fctx.manifest().flags(f)) | ||
|
r5600 | def file(web, req, tmpl): | ||
|
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): | ||
query = req.form['rev'][0] | ||||
revcount = web.maxchanges | ||||
if 'revcount' in req.form: | ||||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
|
r13931 | revcount = max(revcount, 1) | ||
|
r10247 | tmpl.defaults['sessionvars']['revcount'] = revcount | ||
lessvars = copy.copy(tmpl.defaults['sessionvars']) | ||||
|
r13931 | lessvars['revcount'] = max(revcount / 2, 1) | ||
|
r10247 | lessvars['rev'] = query | ||
morevars = copy.copy(tmpl.defaults['sessionvars']) | ||||
morevars['revcount'] = revcount * 2 | ||||
morevars['rev'] = query | ||||
|
r6393 | |||
def changelist(**map): | ||||
count = 0 | ||||
qw = query.lower().split() | ||||
def revgen(): | ||||
|
r12059 | for i in xrange(len(web.repo) - 1, 0, -100): | ||
|
r6393 | l = [] | ||
for j in xrange(max(0, i - 100), i + 1): | ||||
|
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: | ||||
if not (q in ctx.user().lower() or | ||||
q in ctx.description().lower() or | ||||
q in " ".join(ctx.files()).lower()): | ||||
miss = 1 | ||||
break | ||||
if miss: | ||||
continue | ||||
|
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(), | ||||
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 | ||
|
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"), | ||
morevars=morevars, lessvars=lessvars) | ||||
|
r6393 | |||
|
r10247 | def changelog(web, req, tmpl, shortlog=False): | ||
|
r5915 | if 'node' in req.form: | ||
|
r6392 | ctx = webutil.changectx(web.repo, req) | ||
|
r5591 | else: | ||
|
r5915 | if 'rev' in req.form: | ||
|
r5591 | hi = req.form['rev'][0] | ||
else: | ||||
|
r6750 | hi = len(web.repo) - 1 | ||
|
r5591 | try: | ||
|
r6747 | ctx = web.repo[hi] | ||
|
r7637 | except error.RepoError: | ||
|
r10247 | return _search(web, req, tmpl) # XXX redirect to 404 page? | ||
|
r6393 | |||
def changelist(limit=0, **map): | ||||
l = [] # build a list in forward order for efficiency | ||||
for i in xrange(start, end): | ||||
|
r6747 | ctx = web.repo[i] | ||
|
r6393 | n = ctx.node() | ||
showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n) | ||||
|
r7311 | files = webutil.listfilediffs(tmpl, ctx.files(), n, web.maxfiles) | ||
|
r6393 | |||
l.insert(0, {"parity": parity.next(), | ||||
"author": ctx.user(), | ||||
|
r7671 | "parent": webutil.parents(ctx, i - 1), | ||
"child": webutil.children(ctx, i + 1), | ||||
|
r6393 | "changelogtag": showtags, | ||
"desc": ctx.description(), | ||||
"date": ctx.date(), | ||||
|
r7311 | "files": files, | ||
|
r6393 | "rev": i, | ||
"node": hex(n), | ||||
"tags": webutil.nodetagsdict(web.repo, n), | ||||
|
r13596 | "bookmarks": webutil.nodebookmarksdict(web.repo, n), | ||
|
r6393 | "inbranch": webutil.nodeinbranch(web.repo, ctx), | ||
"branches": webutil.nodebranchdict(web.repo, ctx) | ||||
}) | ||||
|
r5591 | |||
|
r6393 | if limit > 0: | ||
l = l[:limit] | ||||
for e in l: | ||||
yield e | ||||
|
r10246 | revcount = shortlog and web.maxshortchanges or web.maxchanges | ||
if 'revcount' in req.form: | ||||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
|
r13931 | revcount = max(revcount, 1) | ||
|
r10246 | tmpl.defaults['sessionvars']['revcount'] = revcount | ||
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() | ||
|
r10246 | start = max(0, pos - revcount + 1) | ||
end = min(count, start + revcount) | ||||
|
r6393 | pos = end - 1 | ||
|
r10282 | parity = paritygen(web.stripecount, offset=start - end) | ||
|
r6393 | |||
|
r10246 | changenav = webutil.revnavgen(pos, revcount, count, web.repo.changectx) | ||
|
r6393 | |||
|
r10246 | return tmpl(shortlog and 'shortlog' or 'changelog', changenav=changenav, | ||
|
r14055 | node=ctx.hex(), rev=pos, changesets=count, | ||
|
r6393 | entries=lambda **x: changelist(limit=0,**x), | ||
latestentry=lambda **x: changelist(limit=1,**x), | ||||
|
r10246 | archives=web.archivelist("tip"), revcount=revcount, | ||
morevars=morevars, lessvars=lessvars) | ||||
|
r5591 | |||
|
r5600 | def shortlog(web, req, tmpl): | ||
|
r5964 | return changelog(web, req, tmpl, shortlog = True) | ||
|
r5591 | |||
|
r5600 | def changeset(web, req, tmpl): | ||
|
r6393 | ctx = webutil.changectx(web.repo, req) | ||
|
r7310 | showtags = webutil.showtag(web.repo, tmpl, 'changesettag', ctx.node()) | ||
|
r13596 | showbookmarks = webutil.showbookmark(web.repo, tmpl, 'changesetbookmark', | ||
ctx.node()) | ||||
|
r7410 | showbranch = webutil.nodebranchnodefault(ctx) | ||
|
r6393 | |||
files = [] | ||||
parity = paritygen(web.stripecount) | ||||
for f in ctx.files(): | ||||
|
r7182 | template = f in ctx and 'filenodelink' or 'filenolink' | ||
files.append(tmpl(template, | ||||
|
r7310 | node=ctx.hex(), file=f, | ||
|
r6393 | parity=parity.next())) | ||
|
r9402 | style = web.config('web', 'style', 'paper') | ||
if 'style' in req.form: | ||||
style = req.form['style'][0] | ||||
|
r14490 | parity = paritygen(web.stripecount) | ||
|
r9402 | diffs = webutil.diffs(web.repo, tmpl, ctx, None, parity, style) | ||
|
r14490 | |||
parity = paritygen(web.stripecount) | ||||
diffstat = lambda: webutil.diffstat(tmpl, ctx, parity) | ||||
|
r6393 | return tmpl('changeset', | ||
diff=diffs, | ||||
rev=ctx.rev(), | ||||
|
r7310 | node=ctx.hex(), | ||
|
r7671 | parent=webutil.parents(ctx), | ||
child=webutil.children(ctx), | ||||
|
r6393 | changesettag=showtags, | ||
|
r13596 | changesetbookmark=showbookmarks, | ||
|
r7410 | changesetbranch=showbranch, | ||
|
r6393 | author=ctx.user(), | ||
desc=ctx.description(), | ||||
date=ctx.date(), | ||||
files=files, | ||||
|
r14490 | diffstat=diffstat, | ||
|
r7310 | archives=web.archivelist(ctx.hex()), | ||
tags=webutil.nodetagsdict(web.repo, ctx.node()), | ||||
|
r13596 | bookmarks=webutil.nodebookmarksdict(web.repo, ctx.node()), | ||
|
r6393 | branch=webutil.nodebranchnodefault(ctx), | ||
inbranch=webutil.nodeinbranch(web.repo, ctx), | ||||
branches=webutil.nodebranchdict(web.repo, ctx)) | ||||
|
r5591 | |||
rev = changeset | ||||
|
r5600 | def manifest(web, req, tmpl): | ||
|
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 | ||||
|
r7622 | for f, n in mf.iteritems(): | ||
|
r6393 | if f[:l] != path: | ||
continue | ||||
remain = f[l:] | ||||
|
r7305 | elements = remain.split('/') | ||
if len(elements) == 1: | ||||
files[remain] = f | ||||
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 | |||
|
r5600 | def tags(web, req, tmpl): | ||
|
r6393 | i = web.repo.tagslist() | ||
i.reverse() | ||||
parity = paritygen(web.stripecount) | ||||
|
r9198 | def entries(notip=False, limit=0, **map): | ||
|
r6393 | count = 0 | ||
for k, n in i: | ||||
if notip and k == "tip": | ||||
continue | ||||
if limit > 0 and count >= limit: | ||||
continue | ||||
count = count + 1 | ||||
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()), | ||||
|
r10282 | entries=lambda **x: entries(False, 0, **x), | ||
entriesnotip=lambda **x: entries(True, 0, **x), | ||||
latestentry=lambda **x: entries(True, 1, **x)) | ||||
|
r5591 | |||
|
r13597 | def bookmarks(web, req, tmpl): | ||
i = web.repo._bookmarks.items() | ||||
parity = paritygen(web.stripecount) | ||||
|
r13923 | def entries(limit=0, **map): | ||
|
r13597 | count = 0 | ||
|
r13922 | for k, n in sorted(i): | ||
|
r13597 | if limit > 0 and count >= limit: | ||
continue | ||||
count = count + 1 | ||||
yield {"parity": parity.next(), | ||||
"bookmark": k, | ||||
"date": web.repo[n].date(), | ||||
"node": hex(n)} | ||||
return tmpl("bookmarks", | ||||
node=hex(web.repo.changelog.tip()), | ||||
|
r13923 | entries=lambda **x: entries(0, **x), | ||
latestentry=lambda **x: entries(1, **x)) | ||||
|
r13597 | |||
|
r8352 | def branches(web, req, tmpl): | ||
|
r8354 | tips = (web.repo[n] for t, n in web.repo.branchtags().iteritems()) | ||
|
r8796 | heads = web.repo.heads() | ||
|
r8352 | parity = paritygen(web.stripecount) | ||
|
r8713 | sortkey = lambda ctx: ('close' not in ctx.extra(), ctx.rev()) | ||
|
r8352 | |||
def entries(limit, **map): | ||||
count = 0 | ||||
|
r8713 | for ctx in sorted(tips, key=sortkey, reverse=True): | ||
|
r8352 | if limit > 0 and count >= limit: | ||
return | ||||
count += 1 | ||||
|
r8796 | if ctx.node() not in heads: | ||
status = 'inactive' | ||||
elif not web.repo.branchheads(ctx.branch()): | ||||
status = 'closed' | ||||
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)) | ||||
|
r5600 | def summary(web, req, tmpl): | ||
|
r6393 | i = web.repo.tagslist() | ||
i.reverse() | ||||
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) | ||||
b = web.repo._bookmarks.items() | ||||
for k, n in sorted(b)[:10]: # limit to 10 bookmarks | ||||
yield {'parity': parity.next(), | ||||
'bookmark': k, | ||||
'date': web.repo[n].date(), | ||||
'node': hex(n)} | ||||
|
r6393 | def branches(**map): | ||
parity = paritygen(web.stripecount) | ||||
b = web.repo.branchtags() | ||||
|
r7622 | l = [(-web.repo.changelog.rev(n), n, t) for t, n in b.iteritems()] | ||
|
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 | ||
for i in xrange(start, end): | ||||
|
r6747 | ctx = web.repo[i] | ||
|
r6393 | n = ctx.node() | ||
hn = hex(n) | ||||
l.insert(0, tmpl( | ||||
'shortlogentry', | ||||
parity=parity.next(), | ||||
author=ctx.user(), | ||||
desc=ctx.description(), | ||||
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))) | ||||
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 | |||
|
r5600 | def filediff(web, req, tmpl): | ||
|
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() | ||||
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] | ||||
diffs = webutil.diffs(web.repo, tmpl, fctx or ctx, [path], parity, style) | ||||
|
r7183 | rename = fctx and webutil.renamelink(fctx) or [] | ||
ctx = fctx and fctx or ctx | ||||
|
r6393 | return tmpl("filediff", | ||
file=path, | ||||
node=hex(n), | ||||
|
r7183 | rev=ctx.rev(), | ||
date=ctx.date(), | ||||
desc=ctx.description(), | ||||
author=ctx.user(), | ||||
rename=rename, | ||||
branch=webutil.nodebranchnodefault(ctx), | ||||
|
r7671 | parent=webutil.parents(ctx), | ||
child=webutil.children(ctx), | ||||
|
r6393 | diff=diffs) | ||
|
r5591 | |||
diff = filediff | ||||
|
r5600 | def annotate(web, req, tmpl): | ||
|
r6393 | fctx = webutil.filectx(web.repo, req) | ||
f = fctx.path() | ||||
parity = paritygen(web.stripecount) | ||||
def annotate(**map): | ||||
last = None | ||||
if binary(fctx.data()): | ||||
mt = (mimetypes.guess_type(fctx.path())[0] | ||||
or 'application/octet-stream') | ||||
lines = enumerate([((fctx.filectx(fctx.filerev()), 1), | ||||
'(binary:%s)' % mt)]) | ||||
else: | ||||
lines = enumerate(fctx.annotate(follow=True, linenumber=True)) | ||||
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(), | ||
|
r6393 | "file": f.path(), | ||
"targetline": targetline, | ||||
"line": l, | ||||
"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(), | ||||
|
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 | |||
|
r5600 | def filelog(web, req, tmpl): | ||
|
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: | ||||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
|
r13931 | revcount = max(revcount, 1) | ||
|
r10246 | tmpl.defaults['sessionvars']['revcount'] = revcount | ||
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 | |||
def entries(limit=0, **map): | ||||
l = [] | ||||
|
r7612 | repo = web.repo | ||
|
r6393 | for i in xrange(start, end): | ||
|
r7612 | iterfctx = fctx.filectx(i) | ||
|
r6393 | |||
l.insert(0, {"parity": parity.next(), | ||||
"filerev": i, | ||||
"file": f, | ||||
|
r14055 | "node": iterfctx.hex(), | ||
|
r7612 | "author": iterfctx.user(), | ||
"date": iterfctx.date(), | ||||
"rename": webutil.renamelink(iterfctx), | ||||
|
r7671 | "parent": webutil.parents(iterfctx), | ||
"child": webutil.children(iterfctx), | ||||
|
r7612 | "desc": iterfctx.description(), | ||
"tags": webutil.nodetagsdict(repo, iterfctx.node()), | ||||
|
r13794 | "bookmarks": webutil.nodebookmarksdict( | ||
repo, iterfctx.node()), | ||||
|
r7612 | "branch": webutil.nodebranchnodefault(iterfctx), | ||
"inbranch": webutil.nodeinbranch(repo, iterfctx), | ||||
"branches": webutil.nodebranchdict(repo, iterfctx)}) | ||||
|
r7434 | |||
|
r6393 | if limit > 0: | ||
l = l[:limit] | ||||
for e in l: | ||||
yield e | ||||
nodefunc = lambda x: fctx.filectx(fileid=x) | ||||
|
r10246 | nav = webutil.revnavgen(end - 1, revcount, count, nodefunc) | ||
|
r14055 | return tmpl("filelog", file=f, node=fctx.hex(), nav=nav, | ||
|
r6393 | entries=lambda **x: entries(limit=0, **x), | ||
|
r10246 | latestentry=lambda **x: entries(limit=1, **x), | ||
revcount=revcount, morevars=morevars, lessvars=lessvars) | ||||
|
r5591 | |||
|
r5600 | def archive(web, req, tmpl): | ||
|
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) | ||||
mimetype, artype, extension, encoding = web.archive_specs[type_] | ||||
headers = [ | ||||
('Content-Type', mimetype), | ||||
('Content-Disposition', 'attachment; filename=%s%s' % (name, extension)) | ||||
] | ||||
if encoding: | ||||
headers.append(('Content-Encoding', encoding)) | ||||
req.header(headers) | ||||
req.respond(HTTP_OK) | ||||
archival.archive(web.repo, req, cnode, artype, prefix=name) | ||||
return [] | ||||
|
r5591 | |||
|
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: | ||||
|
r7966 | tp = web.templatepath or templater.templatepath() | ||
|
r7107 | if isinstance(tp, str): | ||
tp = [tp] | ||||
|
r7288 | static = [os.path.join(p, 'static') for p in tp] | ||
|
r5964 | return [staticfile(static, fname, req)] | ||
|
r6691 | |||
def graph(web, req, tmpl): | ||||
|
r10245 | |||
|
r6691 | rev = webutil.changectx(web.repo, req).rev() | ||
bg_height = 39 | ||||
|
r10245 | revcount = web.maxshortchanges | ||
|
r7345 | if 'revcount' in req.form: | ||
revcount = int(req.form.get('revcount', [revcount])[0]) | ||||
|
r13931 | revcount = max(revcount, 1) | ||
|
r7345 | tmpl.defaults['sessionvars']['revcount'] = revcount | ||
lessvars = copy.copy(tmpl.defaults['sessionvars']) | ||||
|
r13931 | lessvars['revcount'] = max(revcount / 2, 1) | ||
|
r7345 | morevars = copy.copy(tmpl.defaults['sessionvars']) | ||
morevars['revcount'] = revcount * 2 | ||||
|
r6750 | max_rev = len(web.repo) - 1 | ||
|
r7345 | revcount = min(max_rev, revcount) | ||
|
r6691 | revnode = web.repo.changelog.node(rev) | ||
revnode_hex = hex(revnode) | ||||
uprev = min(max_rev, rev + revcount) | ||||
downrev = max(0, rev - revcount) | ||||
|
r6750 | count = len(web.repo) | ||
|
r7332 | changenav = webutil.revnavgen(rev, revcount, count, web.repo.changectx) | ||
|
r13905 | startrev = rev | ||
# if starting revision is less than 60 set it to uprev | ||||
if rev < web.maxshortchanges: | ||||
startrev = uprev | ||||
|
r6691 | |||
|
r14043 | dag = graphmod.dagwalker(web.repo, range(startrev, downrev - 1, -1)) | ||
|
r8842 | tree = list(graphmod.colored(dag)) | ||
|
r10394 | canvasheight = (len(tree) + 1) * bg_height - 27 | ||
|
r6691 | data = [] | ||
|
r8842 | for (id, type, ctx, vtx, edges) in tree: | ||
if type != graphmod.CHANGESET: | ||||
continue | ||||
|
r14055 | node = str(ctx) | ||
|
r6691 | age = templatefilters.age(ctx.date()) | ||
desc = templatefilters.firstline(ctx.description()) | ||||
|
r8236 | desc = cgi.escape(templatefilters.nonempty(desc)) | ||
|
r6691 | user = cgi.escape(templatefilters.person(ctx.user())) | ||
|
r6720 | branch = ctx.branch() | ||
branch = branch, web.repo.branchtags().get(branch) == ctx.node() | ||||
|
r13597 | data.append((node, vtx, edges, desc, user, age, branch, ctx.tags(), | ||
ctx.bookmarks())) | ||||
|
r6691 | |||
return tmpl('graph', rev=rev, revcount=revcount, uprev=uprev, | ||||
|
r7345 | lessvars=lessvars, morevars=morevars, downrev=downrev, | ||
canvasheight=canvasheight, jsdata=data, bg_height=bg_height, | ||||
node=revnode_hex, changenav=changenav) | ||||
|
r12666 | |||
def _getdoc(e): | ||||
doc = e[0].__doc__ | ||||
if doc: | ||||
doc = doc.split('\n')[0] | ||||
else: | ||||
doc = _('(no help text available)') | ||||
return doc | ||||
def help(web, req, tmpl): | ||||
from mercurial import commands # avoid cycle | ||||
topicname = req.form.get('node', [None])[0] | ||||
if not topicname: | ||||
def topics(**map): | ||||
for entries, summary, _ in helpmod.helptable: | ||||
entries = sorted(entries, key=len) | ||||
yield {'topic': entries[-1], 'summary': summary} | ||||
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() | ||
|
r12666 | u.pushbuffer() | ||
try: | ||||
commands.help_(u, topicname) | ||||
except error.UnknownCommand: | ||||
raise ErrorResponse(HTTP_NOT_FOUND) | ||||
doc = u.popbuffer() | ||||
return tmpl('help', topic=topicname, doc=doc) | ||||