webutil.py
596 lines
| 18.7 KiB
| text/x-python
|
PythonLexer
|
r6392 | # hgweb/webutil.py - utility library for the web interface. | ||
# | ||||
# 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. | ||
|
r6392 | |||
|
r27046 | from __future__ import absolute_import | ||
import copy | ||||
import difflib | ||||
import os | ||||
|
r26162 | import re | ||
|
r27046 | |||
from ..i18n import _ | ||||
from ..node import hex, nullid, short | ||||
from .common import ( | ||||
ErrorResponse, | ||||
HTTP_NOT_FOUND, | ||||
paritygen, | ||||
) | ||||
from .. import ( | ||||
context, | ||||
error, | ||||
match, | ||||
patch, | ||||
pathutil, | ||||
templatefilters, | ||||
ui as uimod, | ||||
util, | ||||
) | ||||
|
r6392 | |||
|
r6393 | def up(p): | ||
if p[0] != "/": | ||||
p = "/" + p | ||||
if p[-1] == "/": | ||||
p = p[:-1] | ||||
up = os.path.dirname(p) | ||||
if up == "/": | ||||
return "/" | ||||
return up + "/" | ||||
|
r18391 | def _navseq(step, firststep=None): | ||
if firststep: | ||||
yield firststep | ||||
if firststep >= 20 and firststep <= 40: | ||||
|
r18392 | firststep = 50 | ||
yield firststep | ||||
assert step > 0 | ||||
assert firststep > 0 | ||||
while step <= firststep: | ||||
step *= 10 | ||||
|
r18390 | while True: | ||
|
r18391 | yield 1 * step | ||
yield 3 * step | ||||
step *= 10 | ||||
|
r18389 | |||
|
r18403 | class revnav(object): | ||
|
r18320 | |||
|
r18409 | def __init__(self, repo): | ||
|
r18404 | """Navigation generation object | ||
|
r18409 | :repo: repo object we generate nav for | ||
|
r18404 | """ | ||
|
r18409 | # used for hex generation | ||
self._revlog = repo.changelog | ||||
|
r18404 | |||
|
r18406 | def __nonzero__(self): | ||
"""return True if any revision to navigate over""" | ||||
|
r19094 | return self._first() is not None | ||
def _first(self): | ||||
"""return the minimum non-filtered changeset or None""" | ||||
try: | ||||
|
r29216 | return next(iter(self._revlog)) | ||
|
r19094 | except StopIteration: | ||
return None | ||||
|
r18406 | |||
|
r18405 | def hex(self, rev): | ||
|
r18409 | return hex(self._revlog.node(rev)) | ||
|
r18405 | |||
|
r18404 | def gen(self, pos, pagelen, limit): | ||
|
r18403 | """computes label and revision id for navigation link | ||
|
r18320 | |||
|
r18403 | :pos: is the revision relative to which we generate navigation. | ||
:pagelen: the size of each navigation page | ||||
:limit: how far shall we link | ||||
|
r6393 | |||
|
r18403 | The return is: | ||
- a single element tuple | ||||
- containing a dictionary with a `before` and `after` key | ||||
- values are generator functions taking arbitrary number of kwargs | ||||
- yield items are dictionaries with `label` and `node` keys | ||||
""" | ||||
|
r18406 | if not self: | ||
# empty repo | ||||
return ({'before': (), 'after': ()},) | ||||
|
r6393 | |||
|
r18425 | targets = [] | ||
|
r18403 | for f in _navseq(1, pagelen): | ||
if f > limit: | ||||
break | ||||
|
r18425 | targets.append(pos + f) | ||
targets.append(pos - f) | ||||
targets.sort() | ||||
|
r19094 | first = self._first() | ||
navbefore = [("(%i)" % first, self.hex(first))] | ||||
|
r18425 | navafter = [] | ||
for rev in targets: | ||||
|
r18426 | if rev not in self._revlog: | ||
continue | ||||
|
r18425 | if pos < rev < limit: | ||
|
r18503 | navafter.append(("+%d" % abs(rev - pos), self.hex(rev))) | ||
|
r18425 | if 0 < rev < pos: | ||
|
r18503 | navbefore.append(("-%d" % abs(rev - pos), self.hex(rev))) | ||
|
r18425 | |||
|
r10254 | |||
|
r18403 | navafter.append(("tip", "tip")) | ||
data = lambda i: {"label": i[0], "node": i[1]} | ||||
return ({'before': lambda **map: (data(i) for i in navbefore), | ||||
'after': lambda **map: (data(i) for i in navafter)},) | ||||
|
r6393 | |||
|
r18408 | class filerevnav(revnav): | ||
|
r18409 | |||
def __init__(self, repo, path): | ||||
"""Navigation generation object | ||||
:repo: repo object we generate nav for | ||||
:path: path of the file we generate nav for | ||||
""" | ||||
# used for iteration | ||||
self._changelog = repo.unfiltered().changelog | ||||
# used for hex generation | ||||
self._revlog = repo.file(path) | ||||
def hex(self, rev): | ||||
return hex(self._changelog.node(self._revlog.linkrev(rev))) | ||||
r27023 | class _siblings(object): | |||
def __init__(self, siblings=[], hiderev=None): | ||||
self.siblings = [s for s in siblings if s.node() != nullid] | ||||
if len(self.siblings) == 1 and self.siblings[0].rev() == hiderev: | ||||
self.siblings = [] | ||||
|
r18408 | |||
r27023 | def __iter__(self): | |||
for s in self.siblings: | ||||
d = { | ||||
'node': s.hex(), | ||||
'rev': s.rev(), | ||||
'user': s.user(), | ||||
'date': s.date(), | ||||
'description': s.description(), | ||||
'branch': s.branch(), | ||||
} | ||||
if util.safehasattr(s, 'path'): | ||||
d['file'] = s.path() | ||||
yield d | ||||
def __len__(self): | ||||
return len(self.siblings) | ||||
|
r6392 | |||
|
r30081 | def annotate(fctx, ui): | ||
diffopts = patch.difffeatureopts(ui, untrusted=True, | ||||
section='annotate', whitespace=True) | ||||
return fctx.annotate(follow=True, linenumber=True, diffopts=diffopts) | ||||
|
r7671 | def parents(ctx, hide=None): | ||
|
r24136 | if isinstance(ctx, context.basefilectx): | ||
introrev = ctx.introrev() | ||||
if ctx.changectx().rev() != introrev: | ||||
|
r24340 | return _siblings([ctx.repo()[introrev]], hide) | ||
|
r7671 | return _siblings(ctx.parents(), hide) | ||
def children(ctx, hide=None): | ||||
return _siblings(ctx.children(), hide) | ||||
|
r6434 | def renamelink(fctx): | ||
|
r6437 | r = fctx.renamed() | ||
|
r6392 | if r: | ||
|
r20681 | return [{'file': r[0], 'node': hex(r[1])}] | ||
|
r6392 | return [] | ||
def nodetagsdict(repo, node): | ||||
return [{"name": i} for i in repo.nodetags(node)] | ||||
|
r13596 | def nodebookmarksdict(repo, node): | ||
return [{"name": i} for i in repo.nodebookmarks(node)] | ||||
|
r6392 | def nodebranchdict(repo, ctx): | ||
branches = [] | ||||
branch = ctx.branch() | ||||
# If this is an empty repo, ctx.node() == nullid, | ||||
|
r16719 | # ctx.branch() == 'default'. | ||
try: | ||||
branchnode = repo.branchtip(branch) | ||||
except error.RepoLookupError: | ||||
branchnode = None | ||||
if branchnode == ctx.node(): | ||||
|
r6392 | branches.append({"name": branch}) | ||
return branches | ||||
def nodeinbranch(repo, ctx): | ||||
branches = [] | ||||
branch = ctx.branch() | ||||
|
r16719 | try: | ||
branchnode = repo.branchtip(branch) | ||||
except error.RepoLookupError: | ||||
branchnode = None | ||||
if branch != 'default' and branchnode != ctx.node(): | ||||
|
r6392 | branches.append({"name": branch}) | ||
return branches | ||||
def nodebranchnodefault(ctx): | ||||
branches = [] | ||||
branch = ctx.branch() | ||||
if branch != 'default': | ||||
branches.append({"name": branch}) | ||||
return branches | ||||
def showtag(repo, tmpl, t1, node=nullid, **args): | ||||
for t in repo.nodetags(node): | ||||
yield tmpl(t1, tag=t, **args) | ||||
|
r13596 | def showbookmark(repo, tmpl, t1, node=nullid, **args): | ||
for t in repo.nodebookmarks(node): | ||||
yield tmpl(t1, bookmark=t, **args) | ||||
r26129 | def branchentries(repo, stripecount, limit=0): | |||
tips = [] | ||||
heads = repo.heads() | ||||
parity = paritygen(stripecount) | ||||
sortkey = lambda item: (not item[1], item[0].rev()) | ||||
def entries(**map): | ||||
count = 0 | ||||
if not tips: | ||||
for tag, hs, tip, closed in repo.branchmap().iterbranches(): | ||||
tips.append((repo[tip], closed)) | ||||
for ctx, closed in sorted(tips, key=sortkey, reverse=True): | ||||
if limit > 0 and count >= limit: | ||||
return | ||||
count += 1 | ||||
if closed: | ||||
status = 'closed' | ||||
elif ctx.node() not in heads: | ||||
status = 'inactive' | ||||
else: | ||||
status = 'open' | ||||
yield { | ||||
|
r29216 | 'parity': next(parity), | ||
r26129 | 'branch': ctx.branch(), | |||
'status': status, | ||||
'node': ctx.hex(), | ||||
'date': ctx.date() | ||||
} | ||||
return entries | ||||
|
r6392 | def cleanpath(repo, path): | ||
path = path.lstrip('/') | ||||
|
r20033 | return pathutil.canonpath(repo.root, '', path) | ||
|
r6392 | |||
r25999 | def changeidctx(repo, changeid): | |||
|
r6392 | try: | ||
|
r6747 | ctx = repo[changeid] | ||
|
r7637 | except error.RepoError: | ||
|
r30375 | man = repo.manifestlog._revlog | ||
|
r7361 | ctx = repo[man.linkrev(man.rev(man.lookup(changeid)))] | ||
|
r6392 | |||
return ctx | ||||
r25999 | def changectx(repo, req): | |||
|
r17991 | changeid = "tip" | ||
if 'node' in req.form: | ||||
changeid = req.form['node'][0] | ||||
r25999 | ipos = changeid.find(':') | |||
|
r17991 | if ipos != -1: | ||
changeid = changeid[(ipos + 1):] | ||||
elif 'manifest' in req.form: | ||||
changeid = req.form['manifest'][0] | ||||
return changeidctx(repo, changeid) | ||||
def basechangectx(repo, req): | ||||
if 'node' in req.form: | ||||
changeid = req.form['node'][0] | ||||
r25999 | ipos = changeid.find(':') | |||
|
r17991 | if ipos != -1: | ||
changeid = changeid[:ipos] | ||||
return changeidctx(repo, changeid) | ||||
return None | ||||
|
r6392 | def filectx(repo, req): | ||
|
r17289 | if 'file' not in req.form: | ||
raise ErrorResponse(HTTP_NOT_FOUND, 'file not given') | ||||
|
r6392 | path = cleanpath(repo, req.form['file'][0]) | ||
if 'node' in req.form: | ||||
changeid = req.form['node'][0] | ||||
|
r17289 | elif 'filenode' in req.form: | ||
changeid = req.form['filenode'][0] | ||||
|
r6392 | else: | ||
|
r17289 | raise ErrorResponse(HTTP_NOT_FOUND, 'node or filenode not given') | ||
|
r6392 | try: | ||
|
r6747 | fctx = repo[changeid][path] | ||
|
r7637 | except error.RepoError: | ||
|
r6392 | fctx = repo.filectx(path, fileid=changeid) | ||
return fctx | ||||
|
r7310 | |||
r27294 | def commonentry(repo, ctx): | |||
node = ctx.node() | ||||
return { | ||||
'rev': ctx.rev(), | ||||
'node': hex(node), | ||||
'author': ctx.user(), | ||||
'desc': ctx.description(), | ||||
'date': ctx.date(), | ||||
'extra': ctx.extra(), | ||||
'phase': ctx.phasestr(), | ||||
'branch': nodebranchnodefault(ctx), | ||||
'inbranch': nodeinbranch(repo, ctx), | ||||
'branches': nodebranchdict(repo, ctx), | ||||
'tags': nodetagsdict(repo, node), | ||||
'bookmarks': nodebookmarksdict(repo, node), | ||||
'parent': lambda **x: parents(ctx), | ||||
'child': lambda **x: children(ctx), | ||||
} | ||||
|
r23745 | def changelistentry(web, ctx, tmpl): | ||
'''Obtain a dictionary to be used for entries in a changelist. | ||||
This function is called when producing items for the "entries" list passed | ||||
to the "shortlog" and "changelog" templates. | ||||
''' | ||||
repo = web.repo | ||||
rev = ctx.rev() | ||||
n = ctx.node() | ||||
showtags = showtag(repo, tmpl, 'changelogtag', n) | ||||
files = listfilediffs(tmpl, ctx.files(), n, web.maxfiles) | ||||
r27294 | entry = commonentry(repo, ctx) | |||
entry.update( | ||||
r28709 | allparents=lambda **x: parents(ctx), | |||
r27294 | parent=lambda **x: parents(ctx, rev - 1), | |||
child=lambda **x: children(ctx, rev + 1), | ||||
changelogtag=showtags, | ||||
files=files, | ||||
) | ||||
return entry | ||||
|
r23745 | |||
r25602 | def symrevorshortnode(req, ctx): | |||
if 'node' in req.form: | ||||
|
r27008 | return templatefilters.revescape(req.form['node'][0]) | ||
r25602 | else: | |||
return short(ctx.node()) | ||||
|
r24177 | def changesetentry(web, req, tmpl, ctx): | ||
'''Obtain a dictionary to be used to render the "changeset" template.''' | ||||
showtags = showtag(web.repo, tmpl, 'changesettag', ctx.node()) | ||||
showbookmarks = showbookmark(web.repo, tmpl, 'changesetbookmark', | ||||
ctx.node()) | ||||
showbranch = nodebranchnodefault(ctx) | ||||
files = [] | ||||
parity = paritygen(web.stripecount) | ||||
for blockno, f in enumerate(ctx.files()): | ||||
template = f in ctx and 'filenodelink' or 'filenolink' | ||||
files.append(tmpl(template, | ||||
node=ctx.hex(), file=f, blockno=blockno + 1, | ||||
|
r29216 | parity=next(parity))) | ||
|
r24177 | |||
basectx = basechangectx(web.repo, req) | ||||
if basectx is None: | ||||
basectx = ctx.p1() | ||||
style = web.config('web', 'style', 'paper') | ||||
if 'style' in req.form: | ||||
style = req.form['style'][0] | ||||
parity = paritygen(web.stripecount) | ||||
diff = diffs(web.repo, tmpl, ctx, basectx, None, parity, style) | ||||
parity = paritygen(web.stripecount) | ||||
diffstatsgen = diffstatgen(ctx, basectx) | ||||
diffstats = diffstat(tmpl, ctx, diffstatsgen, parity) | ||||
return dict( | ||||
diff=diff, | ||||
r25602 | symrev=symrevorshortnode(req, ctx), | |||
|
r24177 | basenode=basectx.hex(), | ||
changesettag=showtags, | ||||
changesetbookmark=showbookmarks, | ||||
changesetbranch=showbranch, | ||||
files=files, | ||||
diffsummary=lambda **x: diffsummary(diffstatsgen), | ||||
diffstat=diffstats, | ||||
archives=web.archivelist(ctx.hex()), | ||||
r27294 | **commonentry(web.repo, ctx)) | |||
|
r24177 | |||
|
r7311 | def listfilediffs(tmpl, files, node, max): | ||
for f in files[:max]: | ||||
yield tmpl('filedifflink', node=hex(node), file=f) | ||||
if len(files) > max: | ||||
yield tmpl('fileellipses') | ||||
|
r17991 | def diffs(repo, tmpl, ctx, basectx, files, parity, style): | ||
|
r7310 | |||
|
r31276 | def prettyprintlines(lines, blockno): | ||
for lineno, l in enumerate(lines, 1): | ||||
|
r31275 | difflineno = "%d.%d" % (blockno, lineno) | ||
|
r7310 | if l.startswith('+'): | ||
ltype = "difflineplus" | ||||
elif l.startswith('-'): | ||||
ltype = "difflineminus" | ||||
elif l.startswith('@'): | ||||
ltype = "difflineat" | ||||
else: | ||||
ltype = "diffline" | ||||
yield tmpl(ltype, | ||||
line=l, | ||||
|
r31275 | lineno=lineno, | ||
|
r24712 | lineid="l%s" % difflineno, | ||
linenumber="% 8s" % difflineno) | ||||
|
r7310 | |||
if files: | ||||
m = match.exact(repo.root, repo.getcwd(), files) | ||||
else: | ||||
m = match.always(repo.root, repo.getcwd()) | ||||
diffopts = patch.diffopts(repo.ui, untrusted=True) | ||||
|
r31082 | node1 = basectx.node() | ||
|
r7310 | node2 = ctx.node() | ||
|
r31276 | diffhunks = patch.diffhunks(repo, node1, node2, m, opts=diffopts) | ||
for blockno, (header, hunks) in enumerate(diffhunks, 1): | ||||
if style != 'raw': | ||||
header = header[1:] | ||||
lines = [h + '\n' for h in header] | ||||
for hunkrange, hunklines in hunks: | ||||
lines.extend(hunklines) | ||||
if lines: | ||||
|
r29216 | yield tmpl('diffblock', parity=next(parity), blockno=blockno, | ||
|
r31276 | lines=prettyprintlines(lines, blockno)) | ||
|
r7345 | |||
|
r17302 | def compare(tmpl, context, leftlines, rightlines): | ||
|
r17202 | '''Generator function that provides side-by-side comparison data.''' | ||
def compline(type, leftlineno, leftline, rightlineno, rightline): | ||||
lineid = leftlineno and ("l%s" % leftlineno) or '' | ||||
lineid += rightlineno and ("r%s" % rightlineno) or '' | ||||
return tmpl('comparisonline', | ||||
type=type, | ||||
lineid=lineid, | ||||
|
r24712 | leftlineno=leftlineno, | ||
|
r17202 | leftlinenumber="% 6s" % (leftlineno or ''), | ||
leftline=leftline or '', | ||||
|
r24712 | rightlineno=rightlineno, | ||
|
r17202 | rightlinenumber="% 6s" % (rightlineno or ''), | ||
rightline=rightline or '') | ||||
def getblock(opcodes): | ||||
for type, llo, lhi, rlo, rhi in opcodes: | ||||
len1 = lhi - llo | ||||
len2 = rhi - rlo | ||||
count = min(len1, len2) | ||||
for i in xrange(count): | ||||
yield compline(type=type, | ||||
leftlineno=llo + i + 1, | ||||
leftline=leftlines[llo + i], | ||||
rightlineno=rlo + i + 1, | ||||
rightline=rightlines[rlo + i]) | ||||
if len1 > len2: | ||||
for i in xrange(llo + count, lhi): | ||||
yield compline(type=type, | ||||
leftlineno=i + 1, | ||||
leftline=leftlines[i], | ||||
rightlineno=None, | ||||
rightline=None) | ||||
elif len2 > len1: | ||||
for i in xrange(rlo + count, rhi): | ||||
yield compline(type=type, | ||||
leftlineno=None, | ||||
leftline=None, | ||||
rightlineno=i + 1, | ||||
rightline=rightlines[i]) | ||||
s = difflib.SequenceMatcher(None, leftlines, rightlines) | ||||
if context < 0: | ||||
|
r17302 | yield tmpl('comparisonblock', lines=getblock(s.get_opcodes())) | ||
|
r17202 | else: | ||
|
r17302 | for oc in s.get_grouped_opcodes(n=context): | ||
yield tmpl('comparisonblock', lines=getblock(oc)) | ||||
|
r17202 | |||
|
r17991 | def diffstatgen(ctx, basectx): | ||
|
r14570 | '''Generator function that provides the diffstat data.''' | ||
|
r14490 | |||
|
r17991 | stats = patch.diffstatdata(util.iterlines(ctx.diff(basectx))) | ||
|
r14490 | maxname, maxtotal, addtotal, removetotal, binary = patch.diffstatsum(stats) | ||
|
r14570 | while True: | ||
yield stats, maxname, maxtotal, addtotal, removetotal, binary | ||||
def diffsummary(statgen): | ||||
'''Return a short summary of the diff.''' | ||||
|
r29216 | stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen) | ||
|
r14570 | return _(' %d files changed, %d insertions(+), %d deletions(-)\n') % ( | ||
len(stats), addtotal, removetotal) | ||||
def diffstat(tmpl, ctx, statgen, parity): | ||||
'''Return a diffstat template for each file in the diff.''' | ||||
|
r29216 | stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen) | ||
|
r14561 | files = ctx.files() | ||
|
r14490 | |||
|
r14561 | def pct(i): | ||
if maxtotal == 0: | ||||
return 0 | ||||
return (float(i) / maxtotal) * 100 | ||||
|
r14490 | |||
|
r14562 | fileno = 0 | ||
|
r14561 | for filename, adds, removes, isbinary in stats: | ||
template = filename in files and 'diffstatlink' or 'diffstatnolink' | ||||
total = adds + removes | ||||
|
r14562 | fileno += 1 | ||
yield tmpl(template, node=ctx.hex(), file=filename, fileno=fileno, | ||||
|
r14561 | total=total, addpct=pct(adds), removepct=pct(removes), | ||
|
r29216 | parity=next(parity)) | ||
|
r14490 | |||
|
r7345 | class sessionvars(object): | ||
def __init__(self, vars, start='?'): | ||||
self.start = start | ||||
self.vars = vars | ||||
def __getitem__(self, key): | ||||
return self.vars[key] | ||||
def __setitem__(self, key, value): | ||||
self.vars[key] = value | ||||
def __copy__(self): | ||||
return sessionvars(copy.copy(self.vars), self.start) | ||||
def __iter__(self): | ||||
separator = self.start | ||||
|
r18367 | for key, value in sorted(self.vars.iteritems()): | ||
|
r7345 | yield {'name': key, 'value': str(value), 'separator': separator} | ||
separator = '&' | ||||
|
r12691 | |||
|
r27007 | class wsgiui(uimod.ui): | ||
|
r12691 | # default termwidth breaks under mod_wsgi | ||
def termwidth(self): | ||||
return 80 | ||||
|
r26162 | |||
def getwebsubs(repo): | ||||
websubtable = [] | ||||
websubdefs = repo.ui.configitems('websub') | ||||
# we must maintain interhg backwards compatibility | ||||
websubdefs += repo.ui.configitems('interhg') | ||||
for key, pattern in websubdefs: | ||||
# grab the delimiter from the character after the "s" | ||||
unesc = pattern[1] | ||||
delim = re.escape(unesc) | ||||
# identify portions of the pattern, taking care to avoid escaped | ||||
# delimiters. the replace format and flags are optional, but | ||||
# delimiters are required. | ||||
match = re.match( | ||||
r'^s%s(.+)(?:(?<=\\\\)|(?<!\\))%s(.*)%s([ilmsux])*$' | ||||
% (delim, delim, delim), pattern) | ||||
if not match: | ||||
repo.ui.warn(_("websub: invalid pattern for %s: %s\n") | ||||
% (key, pattern)) | ||||
continue | ||||
# we need to unescape the delimiter for regexp and format | ||||
delim_re = re.compile(r'(?<!\\)\\%s' % delim) | ||||
regexp = delim_re.sub(unesc, match.group(1)) | ||||
format = delim_re.sub(unesc, match.group(2)) | ||||
# the pattern allows for 6 regexp flags, so set them if necessary | ||||
flagin = match.group(3) | ||||
flags = 0 | ||||
if flagin: | ||||
for flag in flagin.upper(): | ||||
flags |= re.__dict__[flag] | ||||
try: | ||||
regexp = re.compile(regexp, flags) | ||||
websubtable.append((regexp, format)) | ||||
except re.error: | ||||
repo.ui.warn(_("websub: invalid regexp for %s: %s\n") | ||||
% (key, regexp)) | ||||
return websubtable | ||||