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