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