author | mpm@selenic.com |
Mon, 23 May 2005 20:57:48 -0800 | |
changeset 142 | 529bf610092e |
parent 138 | c77a679e9cfa |
child 153 | e8a360cd5a9f |
child 155 | 083c38bdfa64 |
permissions | -rw-r--r-- |
131 | 1 |
#!/usr/bin/env python |
2 |
# |
|
132 | 3 |
# hgweb.py - 0.2 - 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> |
131 | 4 |
# - web interface to a mercurial repository |
5 |
# |
|
6 |
# This software may be used and distributed according to the terms |
|
7 |
# of the GNU General Public License, incorporated herein by reference. |
|
8 |
||
9 |
# useful for debugging |
|
10 |
import cgitb |
|
11 |
cgitb.enable() |
|
12 |
||
13 |
import os, cgi, time, re, difflib, sys, zlib |
|
138 | 14 |
from mercurial.hg import * |
15 |
||
16 |
def age(t): |
|
17 |
def plural(t, c): |
|
18 |
if c == 1: return t |
|
19 |
return t + "s" |
|
20 |
def fmt(t, c): |
|
21 |
return "%d %s" % (c, plural(t, c)) |
|
22 |
||
23 |
now = time.time() |
|
24 |
delta = max(1, int(now - t)) |
|
25 |
||
26 |
scales = [["second", 1], |
|
27 |
["minute", 60], |
|
28 |
["hour", 3600], |
|
29 |
["day", 3600 * 24], |
|
30 |
["week", 3600 * 24 * 7], |
|
31 |
["month", 3600 * 24 * 30], |
|
32 |
["year", 3600 * 24 * 365]] |
|
33 |
||
34 |
scales.reverse() |
|
35 |
||
36 |
for t, s in scales: |
|
37 |
n = delta / s |
|
38 |
if n >= 1: return fmt(t, n) |
|
131 | 39 |
|
40 |
def nl2br(text): |
|
138 | 41 |
return text.replace('\n', '<br/>') |
131 | 42 |
|
43 |
def obfuscate(text): |
|
138 | 44 |
return ''.join([ '&#%d' % ord(c) for c in text ]) |
45 |
||
46 |
def up(p): |
|
47 |
if p[0] != "/": p = "/" + p |
|
48 |
if p[-1] == "/": p = p[:-1] |
|
49 |
up = os.path.dirname(p) |
|
50 |
if up == "/": |
|
51 |
return "/" |
|
52 |
return up + "/" |
|
131 | 53 |
|
54 |
def httphdr(type): |
|
55 |
print 'Content-type: %s\n' % type |
|
56 |
||
135 | 57 |
def write(*things): |
58 |
for thing in things: |
|
59 |
if hasattr(thing, "__iter__"): |
|
60 |
for part in thing: |
|
61 |
write(part) |
|
62 |
else: |
|
63 |
sys.stdout.write(str(thing)) |
|
64 |
||
138 | 65 |
def template(tmpl, **map): |
66 |
while tmpl: |
|
67 |
m = re.search(r"#([a-zA-Z0-9]+)#", tmpl) |
|
68 |
if m: |
|
69 |
yield tmpl[:m.start(0)] |
|
70 |
v = map.get(m.group(1), "") |
|
71 |
yield callable(v) and v() or v |
|
72 |
tmpl = tmpl[m.end(0):] |
|
73 |
else: |
|
74 |
yield tmpl |
|
75 |
return |
|
76 |
||
77 |
class templater: |
|
78 |
def __init__(self, mapfile): |
|
79 |
self.cache = {} |
|
80 |
self.map = {} |
|
81 |
self.base = os.path.dirname(mapfile) |
|
82 |
||
83 |
for l in file(mapfile): |
|
84 |
m = re.match(r'(\S+)\s*=\s*"(.*)"$', l) |
|
133
fb84d3e71042
added template support for some hgweb output, also, template files for
jake@edge2.net
parents:
132
diff
changeset
|
85 |
if m: |
138 | 86 |
self.cache[m.group(1)] = m.group(2) |
87 |
else: |
|
88 |
m = re.match(r'(\S+)\s*=\s*(\S+)', l) |
|
89 |
if m: |
|
90 |
self.map[m.group(1)] = os.path.join(self.base, m.group(2)) |
|
133
fb84d3e71042
added template support for some hgweb output, also, template files for
jake@edge2.net
parents:
132
diff
changeset
|
91 |
else: |
138 | 92 |
raise "unknown map entry '%s'" % l |
133
fb84d3e71042
added template support for some hgweb output, also, template files for
jake@edge2.net
parents:
132
diff
changeset
|
93 |
|
138 | 94 |
def __call__(self, t, **map): |
95 |
try: |
|
96 |
tmpl = self.cache[t] |
|
97 |
except KeyError: |
|
98 |
tmpl = self.cache[t] = file(self.map[t]).read() |
|
99 |
return template(tmpl, **map) |
|
100 |
||
101 |
class hgweb: |
|
102 |
maxchanges = 20 |
|
103 |
maxfiles = 10 |
|
133
fb84d3e71042
added template support for some hgweb output, also, template files for
jake@edge2.net
parents:
132
diff
changeset
|
104 |
|
138 | 105 |
def __init__(self, path, name, templatemap): |
106 |
self.reponame = name |
|
107 |
self.repo = repository(ui(), path) |
|
108 |
self.t = templater(templatemap) |
|
131 | 109 |
|
138 | 110 |
def date(self, cs): |
111 |
return time.asctime(time.gmtime(float(cs[2].split(' ')[0]))) |
|
112 |
||
113 |
def listfiles(self, files, mf): |
|
114 |
for f in files[:self.maxfiles]: |
|
115 |
yield self.t("filenodelink", node = hex(mf[f]), file = f) |
|
116 |
if len(files) > self.maxfiles: |
|
117 |
yield self.t("fileellipses") |
|
118 |
||
119 |
def listfilediffs(self, files, changeset): |
|
120 |
for f in files[:self.maxfiles]: |
|
121 |
yield self.t("filedifflink", node = hex(changeset), file = f) |
|
122 |
if len(files) > self.maxfiles: |
|
123 |
yield self.t("fileellipses") |
|
124 |
||
142 | 125 |
def parent(self, t1, node, rev): |
126 |
if node != hex(nullid): |
|
127 |
yield self.t(t1, node = node, rev = rev) |
|
128 |
||
138 | 129 |
def diff(self, node1, node2, files): |
130 |
def filterfiles(list, files): |
|
131 |
l = [ x for x in list if x in files ] |
|
132 |
||
133 |
for f in files: |
|
134 |
if f[-1] != os.sep: f += os.sep |
|
135 |
l += [ x for x in list if x.startswith(f) ] |
|
136 |
return l |
|
131 | 137 |
|
138 | 138 |
def prettyprint(diff): |
139 |
for l in diff.splitlines(1): |
|
140 |
line = cgi.escape(l) |
|
141 |
if line.startswith('+'): |
|
142 |
yield self.t("difflineplus", line = line) |
|
143 |
elif line.startswith('-'): |
|
144 |
yield self.t("difflineminus", line = line) |
|
145 |
elif line.startswith('@'): |
|
146 |
yield self.t("difflineat", line = line) |
|
147 |
else: |
|
148 |
yield self.t("diffline", line = line) |
|
131 | 149 |
|
138 | 150 |
r = self.repo |
151 |
cl = r.changelog |
|
152 |
mf = r.manifest |
|
153 |
change1 = cl.read(node1) |
|
154 |
change2 = cl.read(node2) |
|
155 |
mmap1 = mf.read(change1[0]) |
|
156 |
mmap2 = mf.read(change2[0]) |
|
157 |
date1 = self.date(change1) |
|
158 |
date2 = self.date(change2) |
|
131 | 159 |
|
138 | 160 |
c, a, d = r.diffrevs(node1, node2) |
161 |
c, a, d = map(lambda x: filterfiles(x, files), (c, a, d)) |
|
131 | 162 |
|
138 | 163 |
for f in c: |
164 |
to = r.file(f).read(mmap1[f]) |
|
165 |
tn = r.file(f).read(mmap2[f]) |
|
166 |
yield prettyprint(mdiff.unidiff(to, date1, tn, date2, f)) |
|
167 |
for f in a: |
|
168 |
to = "" |
|
169 |
tn = r.file(f).read(mmap2[f]) |
|
170 |
yield prettyprint(mdiff.unidiff(to, date1, tn, date2, f)) |
|
171 |
for f in d: |
|
172 |
to = r.file(f).read(mmap1[f]) |
|
173 |
tn = "" |
|
174 |
yield prettyprint(mdiff.unidiff(to, date1, tn, date2, f)) |
|
131 | 175 |
|
142 | 176 |
def header(self): |
177 |
yield self.t("header", repo = self.reponame) |
|
178 |
||
179 |
def footer(self): |
|
180 |
yield self.t("footer", repo = self.reponame) |
|
181 |
||
138 | 182 |
def changelog(self, pos=None): |
183 |
def changenav(): |
|
184 |
def seq(factor = 1): |
|
185 |
yield 1 * factor |
|
186 |
yield 2 * factor |
|
187 |
yield 5 * factor |
|
188 |
for f in seq(factor * 10): |
|
189 |
yield f |
|
190 |
||
191 |
linear = range(0, count - 2, self.maxchanges)[0:8] |
|
192 |
||
193 |
for i in linear: |
|
194 |
yield self.t("naventry", rev = max(i, 1)) |
|
131 | 195 |
|
138 | 196 |
for s in seq(): |
197 |
if s > count - 2: break |
|
198 |
if s > linear[-1]: |
|
199 |
yield self.t("naventry", rev = s) |
|
200 |
||
201 |
yield self.t("naventry", rev = count - 1) |
|
131 | 202 |
|
138 | 203 |
def changelist(): |
142 | 204 |
parity = (start - end) & 1 |
138 | 205 |
cl = self.repo.changelog |
206 |
l = [] # build a list in forward order for efficiency |
|
207 |
for i in range(start, end + 1): |
|
208 |
n = cl.node(i) |
|
209 |
changes = cl.read(n) |
|
210 |
hn = hex(n) |
|
211 |
p1, p2 = cl.parents(n) |
|
212 |
t = float(changes[2].split(' ')[0]) |
|
131 | 213 |
|
138 | 214 |
l.insert(0, self.t( |
215 |
'changelogentry', |
|
142 | 216 |
parity = parity, |
138 | 217 |
author = obfuscate(changes[1]), |
218 |
shortdesc = cgi.escape(changes[4].splitlines()[0]), |
|
219 |
age = age(t), |
|
142 | 220 |
parent1 = self.parent("changelogparent", |
221 |
hex(p1), cl.rev(p1)), |
|
222 |
parent2 = self.parent("changelogparent", |
|
223 |
hex(p2), cl.rev(p2)), |
|
138 | 224 |
p1 = hex(p1), p2 = hex(p2), |
225 |
p1rev = cl.rev(p1), p2rev = cl.rev(p2), |
|
226 |
manifest = hex(changes[0]), |
|
227 |
desc = nl2br(cgi.escape(changes[4])), |
|
228 |
date = time.asctime(time.gmtime(t)), |
|
229 |
files = self.listfilediffs(changes[3], n), |
|
230 |
rev = i, |
|
231 |
node = hn)) |
|
142 | 232 |
parity = 1 - parity |
138 | 233 |
|
234 |
yield l |
|
131 | 235 |
|
138 | 236 |
count = self.repo.changelog.count() |
237 |
pos = pos or count - 1 |
|
238 |
end = min(pos, count - 1) |
|
239 |
start = max(0, pos - self.maxchanges) |
|
240 |
end = min(count - 1, start + self.maxchanges) |
|
241 |
||
142 | 242 |
yield self.t('changelog', |
243 |
header = self.header(), |
|
244 |
footer = self.footer(), |
|
245 |
repo = self.reponame, |
|
246 |
changenav = changenav, |
|
247 |
rev = pos, changesets = count, entries = changelist) |
|
131 | 248 |
|
138 | 249 |
def changeset(self, nodeid): |
250 |
n = bin(nodeid) |
|
251 |
cl = self.repo.changelog |
|
252 |
changes = cl.read(n) |
|
253 |
p1, p2 = cl.parents(n) |
|
254 |
p1rev, p2rev = cl.rev(p1), cl.rev(p2) |
|
255 |
t = float(changes[2].split(' ')[0]) |
|
256 |
||
133
fb84d3e71042
added template support for some hgweb output, also, template files for
jake@edge2.net
parents:
132
diff
changeset
|
257 |
files = [] |
138 | 258 |
mf = self.repo.manifest.read(changes[0]) |
131 | 259 |
for f in changes[3]: |
138 | 260 |
files.append(self.t("filenodelink", |
261 |
filenode = hex(mf[f]), file = f)) |
|
262 |
||
263 |
def diff(): |
|
264 |
yield self.diff(p1, n, changes[3]) |
|
131 | 265 |
|
138 | 266 |
yield self.t('changeset', |
142 | 267 |
header = self.header(), |
268 |
footer = self.footer(), |
|
269 |
repo = self.reponame, |
|
138 | 270 |
diff = diff, |
271 |
rev = cl.rev(n), |
|
272 |
node = nodeid, |
|
273 |
shortdesc = cgi.escape(changes[4].splitlines()[0]), |
|
142 | 274 |
parent1 = self.parent("changesetparent", |
275 |
hex(p1), cl.rev(p1)), |
|
276 |
parent2 = self.parent("changesetparent", |
|
277 |
hex(p2), cl.rev(p2)), |
|
138 | 278 |
p1 = hex(p1), p2 = hex(p2), |
279 |
p1rev = cl.rev(p1), p2rev = cl.rev(p2), |
|
280 |
manifest = hex(changes[0]), |
|
281 |
author = obfuscate(changes[1]), |
|
282 |
desc = nl2br(cgi.escape(changes[4])), |
|
283 |
date = time.asctime(time.gmtime(t)), |
|
284 |
files = files) |
|
131 | 285 |
|
138 | 286 |
def filelog(self, f, filenode): |
287 |
cl = self.repo.changelog |
|
288 |
fl = self.repo.file(f) |
|
289 |
count = fl.count() |
|
290 |
||
291 |
def entries(): |
|
292 |
l = [] |
|
142 | 293 |
parity = (count - 1) & 1 |
294 |
||
138 | 295 |
for i in range(count): |
296 |
||
297 |
n = fl.node(i) |
|
298 |
lr = fl.linkrev(n) |
|
299 |
cn = cl.node(lr) |
|
300 |
cs = cl.read(cl.node(lr)) |
|
301 |
p1, p2 = fl.parents(n) |
|
302 |
t = float(cs[2].split(' ')[0]) |
|
133
fb84d3e71042
added template support for some hgweb output, also, template files for
jake@edge2.net
parents:
132
diff
changeset
|
303 |
|
138 | 304 |
l.insert(0, self.t("filelogentry", |
142 | 305 |
parity = parity, |
138 | 306 |
filenode = hex(n), |
307 |
filerev = i, |
|
308 |
file = f, |
|
309 |
node = hex(cn), |
|
310 |
author = obfuscate(cs[1]), |
|
311 |
age = age(t), |
|
312 |
date = time.asctime(time.gmtime(t)), |
|
313 |
shortdesc = cgi.escape(cs[4].splitlines()[0]), |
|
314 |
p1 = hex(p1), p2 = hex(p2), |
|
315 |
p1rev = fl.rev(p1), p2rev = fl.rev(p2))) |
|
142 | 316 |
parity = 1 - parity |
138 | 317 |
|
318 |
yield l |
|
319 |
||
320 |
yield self.t("filelog", |
|
142 | 321 |
header = self.header(), |
322 |
footer = self.footer(), |
|
323 |
repo = self.reponame, |
|
138 | 324 |
file = f, |
325 |
filenode = filenode, |
|
326 |
entries = entries) |
|
131 | 327 |
|
138 | 328 |
def filerevision(self, f, node): |
329 |
fl = self.repo.file(f) |
|
330 |
n = bin(node) |
|
331 |
text = cgi.escape(fl.read(n)) |
|
332 |
changerev = fl.linkrev(n) |
|
333 |
cl = self.repo.changelog |
|
334 |
cn = cl.node(changerev) |
|
335 |
cs = cl.read(cn) |
|
336 |
p1, p2 = fl.parents(n) |
|
337 |
t = float(cs[2].split(' ')[0]) |
|
338 |
mfn = cs[0] |
|
142 | 339 |
|
340 |
def lines(): |
|
341 |
for l, t in enumerate(text.splitlines(1)): |
|
342 |
yield self.t("fileline", |
|
343 |
line = t, |
|
344 |
linenumber = "% 6d" % (l + 1), |
|
345 |
parity = l & 1) |
|
138 | 346 |
|
347 |
yield self.t("filerevision", file = f, |
|
142 | 348 |
header = self.header(), |
349 |
footer = self.footer(), |
|
350 |
repo = self.reponame, |
|
138 | 351 |
filenode = node, |
352 |
path = up(f), |
|
142 | 353 |
text = lines(), |
138 | 354 |
rev = changerev, |
355 |
node = hex(cn), |
|
356 |
manifest = hex(mfn), |
|
357 |
author = obfuscate(cs[1]), |
|
358 |
age = age(t), |
|
359 |
date = time.asctime(time.gmtime(t)), |
|
360 |
shortdesc = cgi.escape(cs[4].splitlines()[0]), |
|
142 | 361 |
parent1 = self.parent("filerevparent", |
362 |
hex(p1), fl.rev(p1)), |
|
363 |
parent2 = self.parent("filerevparent", |
|
364 |
hex(p2), fl.rev(p2)), |
|
138 | 365 |
p1 = hex(p1), p2 = hex(p2), |
366 |
p1rev = fl.rev(p1), p2rev = fl.rev(p2)) |
|
367 |
||
131 | 368 |
|
138 | 369 |
def fileannotate(self, f, node): |
370 |
bcache = {} |
|
371 |
ncache = {} |
|
372 |
fl = self.repo.file(f) |
|
373 |
n = bin(node) |
|
374 |
changerev = fl.linkrev(n) |
|
375 |
||
376 |
cl = self.repo.changelog |
|
377 |
cn = cl.node(changerev) |
|
378 |
cs = cl.read(cn) |
|
379 |
p1, p2 = fl.parents(n) |
|
380 |
t = float(cs[2].split(' ')[0]) |
|
381 |
mfn = cs[0] |
|
131 | 382 |
|
138 | 383 |
def annotate(): |
142 | 384 |
parity = 1 |
385 |
last = None |
|
138 | 386 |
for r, l in fl.annotate(n): |
387 |
try: |
|
388 |
cnode = ncache[r] |
|
389 |
except KeyError: |
|
390 |
cnode = ncache[r] = self.repo.changelog.node(r) |
|
391 |
||
392 |
try: |
|
393 |
name = bcache[r] |
|
394 |
except KeyError: |
|
395 |
cl = self.repo.changelog.read(cnode) |
|
396 |
name = cl[1] |
|
397 |
f = name.find('@') |
|
398 |
if f >= 0: |
|
399 |
name = name[:f] |
|
400 |
bcache[r] = name |
|
131 | 401 |
|
142 | 402 |
if last != cnode: |
403 |
parity = 1 - parity |
|
404 |
last = cnode |
|
405 |
||
138 | 406 |
yield self.t("annotateline", |
142 | 407 |
parity = parity, |
138 | 408 |
node = hex(cnode), |
409 |
rev = r, |
|
410 |
author = name, |
|
411 |
file = f, |
|
412 |
line = cgi.escape(l)) |
|
413 |
||
414 |
yield self.t("fileannotate", |
|
142 | 415 |
header = self.header(), |
416 |
footer = self.footer(), |
|
417 |
repo = self.reponame, |
|
138 | 418 |
file = f, |
419 |
filenode = node, |
|
420 |
annotate = annotate, |
|
421 |
path = up(f), |
|
422 |
rev = changerev, |
|
423 |
node = hex(cn), |
|
424 |
manifest = hex(mfn), |
|
425 |
author = obfuscate(cs[1]), |
|
426 |
age = age(t), |
|
427 |
date = time.asctime(time.gmtime(t)), |
|
428 |
shortdesc = cgi.escape(cs[4].splitlines()[0]), |
|
142 | 429 |
parent1 = self.parent("filerevparent", |
430 |
hex(p1), fl.rev(p1)), |
|
431 |
parent2 = self.parent("filerevparent", |
|
432 |
hex(p2), fl.rev(p2)), |
|
138 | 433 |
p1 = hex(p1), p2 = hex(p2), |
434 |
p1rev = fl.rev(p1), p2rev = fl.rev(p2)) |
|
136 | 435 |
|
138 | 436 |
def manifest(self, mnode, path): |
437 |
mf = self.repo.manifest.read(bin(mnode)) |
|
438 |
rev = self.repo.manifest.rev(bin(mnode)) |
|
439 |
node = self.repo.changelog.node(rev) |
|
440 |
||
441 |
files = {} |
|
142 | 442 |
|
138 | 443 |
p = path[1:] |
444 |
l = len(p) |
|
131 | 445 |
|
138 | 446 |
for f,n in mf.items(): |
447 |
if f[:l] != p: |
|
448 |
continue |
|
449 |
remain = f[l:] |
|
450 |
if "/" in remain: |
|
451 |
short = remain[:remain.find("/") + 1] # bleah |
|
142 | 452 |
files[short] = (f, None) |
138 | 453 |
else: |
454 |
short = os.path.basename(remain) |
|
455 |
files[short] = (f, n) |
|
131 | 456 |
|
138 | 457 |
def filelist(): |
142 | 458 |
parity = 0 |
138 | 459 |
fl = files.keys() |
460 |
fl.sort() |
|
461 |
for f in fl: |
|
462 |
full, fnode = files[f] |
|
142 | 463 |
if fnode: |
464 |
yield self.t("manifestfileentry", |
|
465 |
file = full, |
|
466 |
manifest = mnode, |
|
467 |
filenode = hex(fnode), |
|
468 |
parity = parity, |
|
469 |
basename = f) |
|
470 |
else: |
|
471 |
yield self.t("manifestdirentry", |
|
472 |
parity = parity, |
|
473 |
path = os.path.join(path, f), |
|
474 |
manifest = mnode, basename = f[:-1]) |
|
475 |
parity = 1 - parity |
|
138 | 476 |
|
477 |
yield self.t("manifest", |
|
142 | 478 |
header = self.header(), |
479 |
footer = self.footer(), |
|
480 |
repo = self.reponame, |
|
138 | 481 |
manifest = mnode, |
482 |
rev = rev, |
|
483 |
node = hex(node), |
|
484 |
path = path, |
|
485 |
up = up(path), |
|
142 | 486 |
entries = filelist) |
131 | 487 |
|
138 | 488 |
def filediff(self, file, changeset): |
489 |
n = bin(changeset) |
|
490 |
cl = self.repo.changelog |
|
491 |
p1 = cl.parents(n)[0] |
|
492 |
cs = cl.read(n) |
|
493 |
mf = self.repo.manifest.read(cs[0]) |
|
494 |
||
495 |
def diff(): |
|
496 |
yield self.diff(p1, n, file) |
|
131 | 497 |
|
138 | 498 |
yield self.t("filediff", |
142 | 499 |
header = self.header(), |
500 |
footer = self.footer(), |
|
501 |
repo = self.reponame, |
|
138 | 502 |
file = file, |
503 |
filenode = hex(mf[file]), |
|
504 |
node = changeset, |
|
505 |
rev = self.repo.changelog.rev(n), |
|
506 |
p1 = hex(p1), |
|
507 |
p1rev = self.repo.changelog.rev(p1), |
|
508 |
diff = diff) |
|
509 |
||
510 |
# add tags to things |
|
511 |
# tags -> list of changesets corresponding to tags |
|
512 |
# find tag, changeset, file |
|
131 | 513 |
|
132 | 514 |
def run(self): |
515 |
args = cgi.parse() |
|
516 |
||
138 | 517 |
if not args.has_key('cmd') or args['cmd'][0] == 'changelog': |
518 |
hi = self.repo.changelog.count() |
|
519 |
if args.has_key('pos'): |
|
520 |
hi = int(args['pos'][0]) |
|
131 | 521 |
|
138 | 522 |
write(self.changelog(hi)) |
132 | 523 |
|
138 | 524 |
elif args['cmd'][0] == 'changeset': |
525 |
write(self.changeset(args['node'][0])) |
|
526 |
||
527 |
elif args['cmd'][0] == 'manifest': |
|
528 |
write(self.manifest(args['manifest'][0], args['path'][0])) |
|
529 |
||
530 |
elif args['cmd'][0] == 'filediff': |
|
531 |
write(self.filediff(args['file'][0], args['node'][0])) |
|
131 | 532 |
|
132 | 533 |
elif args['cmd'][0] == 'file': |
138 | 534 |
write(self.filerevision(args['file'][0], args['filenode'][0])) |
131 | 535 |
|
138 | 536 |
elif args['cmd'][0] == 'annotate': |
537 |
write(self.fileannotate(args['file'][0], args['filenode'][0])) |
|
131 | 538 |
|
138 | 539 |
elif args['cmd'][0] == 'filelog': |
540 |
write(self.filelog(args['file'][0], args['filenode'][0])) |
|
136 | 541 |
|
132 | 542 |
elif args['cmd'][0] == 'branches': |
543 |
httphdr("text/plain") |
|
544 |
nodes = [] |
|
545 |
if args.has_key('nodes'): |
|
138 | 546 |
nodes = map(bin, args['nodes'][0].split(" ")) |
547 |
for b in self.repo.branches(nodes): |
|
548 |
sys.stdout.write(" ".join(map(hex, b)) + "\n") |
|
131 | 549 |
|
132 | 550 |
elif args['cmd'][0] == 'between': |
551 |
httphdr("text/plain") |
|
552 |
nodes = [] |
|
553 |
if args.has_key('pairs'): |
|
138 | 554 |
pairs = [ map(bin, p.split("-")) |
132 | 555 |
for p in args['pairs'][0].split(" ") ] |
138 | 556 |
for b in self.repo.between(pairs): |
557 |
sys.stdout.write(" ".join(map(hex, b)) + "\n") |
|
132 | 558 |
|
559 |
elif args['cmd'][0] == 'changegroup': |
|
560 |
httphdr("application/hg-changegroup") |
|
561 |
nodes = [] |
|
562 |
if args.has_key('roots'): |
|
138 | 563 |
nodes = map(bin, args['roots'][0].split(" ")) |
131 | 564 |
|
132 | 565 |
z = zlib.compressobj() |
138 | 566 |
for chunk in self.repo.changegroup(nodes): |
132 | 567 |
sys.stdout.write(z.compress(chunk)) |
568 |
||
569 |
sys.stdout.write(z.flush()) |
|
131 | 570 |
|
132 | 571 |
else: |
138 | 572 |
write(self.t("error")) |
131 | 573 |
|
132 | 574 |
if __name__ == "__main__": |
575 |
hgweb().run() |