upstream/mercurial-mirror Commit - r7565:5f162f61

hgweb: fix problems with empty repositories

Dirkjan Ochtman -

r7565:5f162f61 default

parent child

tests/test-hgweb-empty

0 created 755 +12 0

@@ -0,0 +1,12 b''
	1	#!/bin/sh
	2	# Some tests for hgweb in an empty repository
	3
	4	hg init test
	5	cd test
	6	hg serve -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
	7	cat hg.pid >> $DAEMON_PIDS
	8
	9	("$TESTDIR/get-with-headers.py" localhost:$HGPORT '/shortlog')
	10	("$TESTDIR/get-with-headers.py" localhost:$HGPORT '/log')
	11	("$TESTDIR/get-with-headers.py" localhost:$HGPORT '/graph')
	12	("$TESTDIR/get-with-headers.py" localhost:$HGPORT '/file')

tests/test-hgweb-empty.out

0 created 644 +348 0

@@ -0,0 +1,348 b''
	1	200 Script output follows
	2
	3	<!-- quirksmode -->
	4	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
	5	<html>
	6	<head>
	7	<link rel="icon" href="/static/hgicon.png" type="image/png">
	8	<meta name="robots" content="index, nofollow" />
	9	<link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
	10
	11	<title>test: log</title>
	12	<link rel="alternate" type="application/atom+xml"
	13	href="/atom-log" title="Atom feed for test">
	14	<link rel="alternate" type="application/rss+xml"
	15	href="/rss-log" title="RSS feed for test">
	16	</head>
	17	<body>
	18
	19	<div class="container">
	20	<div class="menu">
	21	<div class="logo">
	22	<a href="http://www.selenic.com/mercurial/">
	23	<img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
	24	</div>
	25	<ul>
	26	<li class="active">log</li>
	27	<li><a href="/graph/000000000000">graph</a></li>
	28	<li><a href="/tags">tags</a></li>
	29	</ul>
	30	<ul>
	31	<li><a href="/rev/000000000000">changeset</a></li>
	32	<li><a href="/file/000000000000">browse</a></li>
	33	</ul>
	34	<ul>
	35
	36	</ul>
	37	</div>
	38
	39	<div class="main">
	40	<h2><a href="/">test</a></h2>
	41	<h3>log</h3>
	42
	43	<form class="search" action="/log">
	44
	45	<p><input name="rev" id="search1" type="text" size="30"></p>
	46	<span>find changesets by author, revision,
	47	files, or words in the commit message</span>
	48	</form>
	49
	50	<div class="navigate">rev -1: <a href="/shortlog/000000000000">(0)</a> <a href="/shortlog/tip">tip</a> </div>
	51
	52	<table class="bigtable">
	53	<tr>
	54	<th class="age">age</th>
	55	<th class="author">author</th>
	56	<th class="description">description</th>
	57	</tr>
	58
	59	</table>
	60
	61	<div class="navigate">rev -1: <a href="/shortlog/000000000000">(0)</a> <a href="/shortlog/tip">tip</a> </div>
	62	</div>
	63	</div>
	64
	65
	66
	67	</body>
	68	</html>
	69
	70	200 Script output follows
	71
	72	<!-- quirksmode -->
	73	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
	74	<html>
	75	<head>
	76	<link rel="icon" href="/static/hgicon.png" type="image/png">
	77	<meta name="robots" content="index, nofollow" />
	78	<link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
	79
	80	<title>test: log</title>
	81	<link rel="alternate" type="application/atom+xml"
	82	href="/atom-log" title="Atom feed for test">
	83	<link rel="alternate" type="application/rss+xml"
	84	href="/rss-log" title="RSS feed for test">
	85	</head>
	86	<body>
	87
	88	<div class="container">
	89	<div class="menu">
	90	<div class="logo">
	91	<a href="http://www.selenic.com/mercurial/">
	92	<img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
	93	</div>
	94	<ul>
	95	<li class="active">log</li>
	96	<li><a href="/graph/000000000000">graph</a></li>
	97	<li><a href="/tags">tags</a></li>
	98	</ul>
	99	<ul>
	100	<li><a href="/rev/000000000000">changeset</a></li>
	101	<li><a href="/file/000000000000">browse</a></li>
	102	</ul>
	103	<ul>
	104
	105	</ul>
	106	</div>
	107
	108	<div class="main">
	109	<h2><a href="/">test</a></h2>
	110	<h3>log</h3>
	111
	112	<form class="search" action="/log">
	113
	114	<p><input name="rev" id="search1" type="text" size="30"></p>
	115	<span>find changesets by author, revision,
	116	files, or words in the commit message</span>
	117	</form>
	118
	119	<div class="navigate">rev -1: <a href="/shortlog/000000000000">(0)</a> <a href="/shortlog/tip">tip</a> </div>
	120
	121	<table class="bigtable">
	122	<tr>
	123	<th class="age">age</th>
	124	<th class="author">author</th>
	125	<th class="description">description</th>
	126	</tr>
	127
	128	</table>
	129
	130	<div class="navigate">rev -1: <a href="/shortlog/000000000000">(0)</a> <a href="/shortlog/tip">tip</a> </div>
	131	</div>
	132	</div>
	133
	134
	135
	136	</body>
	137	</html>
	138
	139	200 Script output follows
	140
	141	<!-- quirksmode -->
	142	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
	143	<html>
	144	<head>
	145	<link rel="icon" href="/static/hgicon.png" type="image/png">
	146	<meta name="robots" content="index, nofollow" />
	147	<link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
	148
	149	<title>test: revision graph</title>
	150	<link rel="alternate" type="application/atom+xml"
	151	href="/atom-log" title="Atom feed for test: log">
	152	<link rel="alternate" type="application/rss+xml"
	153	href="/rss-log" title="RSS feed for test: log">
	154	<!--[if IE]><script type="text/javascript" src="/static/excanvas.js"></script><![endif]-->
	155	</head>
	156	<body>
	157
	158	<div class="container">
	159	<div class="menu">
	160	<div class="logo">
	161	<a href="http://www.selenic.com/mercurial/">
	162	<img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
	163	</div>
	164	<ul>
	165	<li><a href="/shortlog/000000000000">log</a></li>
	166	<li class="active">graph</li>
	167	<li><a href="/tags">tags</a></li>
	168	</ul>
	169	<ul>
	170	<li><a href="/rev/000000000000">changeset</a></li>
	171	<li><a href="/file/000000000000">browse</a></li>
	172	</ul>
	173	</div>
	174
	175	<div class="main">
	176	<h2><a href="/">test</a></h2>
	177	<h3>graph</h3>
	178
	179	<form class="search" action="/log">
	180
	181	<p><input name="rev" id="search1" type="text" size="30"></p>
	182	<span>find changesets by author, revision,
	183	files, or words in the commit message</span>
	184	</form>
	185
	186	<div class="navigate">
	187	<a href="/graph/-1?revcount=12">less</a>
	188	<a href="/graph/-1?revcount=50">more</a>
	189	\| rev -1: <a href="/graph/000000000000">(0)</a> <a href="/graph/tip">tip</a>
	190	</div>
	191
	192	<noscript>The revision graph only works with JavaScript-enabled browsers.</noscript>
	193
	194	<div id="wrapper">
	195	<ul id="nodebgs"></ul>
	196	<canvas id="graph" width="224" height="12"></canvas>
	197	<ul id="graphnodes"></ul>
	198	</div>
	199
	200	<script type="text/javascript" src="/static/graph.js"></script>
	201	<script type="text/javascript">
	202	<!-- hide script content
	203
	204	var data = [];
	205	var graph = new Graph();
	206	graph.scale(39);
	207
	208	graph.edge = function(x0, y0, x1, y1, color) {
	209
	210	this.setColor(color, 0.0, 0.65);
	211	this.ctx.beginPath();
	212	this.ctx.moveTo(x0, y0);
	213	this.ctx.lineTo(x1, y1);
	214	this.ctx.stroke();
	215
	216	}
	217
	218	var revlink = '<li style="_STYLE"><span class="desc">';
	219	revlink += '<a href="/rev/_NODEID" title="_NODEID">_DESC</a>';
	220	revlink += '</span>_TAGS<span class="info">_DATE ago, by _USER</span></li>';
	221
	222	graph.vertex = function(x, y, color, parity, cur) {
	223
	224	this.ctx.beginPath();
	225	color = this.setColor(color, 0.25, 0.75);
	226	this.ctx.arc(x, y, radius, 0, Math.PI * 2, true);
	227	this.ctx.fill();
	228
	229	var bg = '<li class="bg parity' + parity + '"></li>';
	230	var left = (this.columns + 1) * this.bg_height;
	231	var nstyle = 'padding-left: ' + left + 'px;';
	232	var item = revlink.replace(/_STYLE/, nstyle);
	233	item = item.replace(/_PARITY/, 'parity' + parity);
	234	item = item.replace(/_NODEID/, cur[0]);
	235	item = item.replace(/_NODEID/, cur[0]);
	236	item = item.replace(/_DESC/, cur[3]);
	237	item = item.replace(/_USER/, cur[4]);
	238	item = item.replace(/_DATE/, cur[5]);
	239
	240	var tagspan = '';
	241	if (cur[7].length \|\| (cur[6][0] != 'default' \|\| cur[6][1])) {
	242	tagspan = '<span class="logtags">';
	243	if (cur[6][1]) {
	244	tagspan += '<span class="branchhead" title="' + cur[6][0] + '">';
	245	tagspan += cur[6][0] + '</span> ';
	246	} else if (!cur[6][1] && cur[6][0] != 'default') {
	247	tagspan += '<span class="branchname" title="' + cur[6][0] + '">';
	248	tagspan += cur[6][0] + '</span> ';
	249	}
	250	if (cur[7].length) {
	251	for (var t in cur[7]) {
	252	var tag = cur[7][t];
	253	tagspan += '<span class="tag">' + tag + '</span> ';
	254	}
	255	}
	256	tagspan += '</span>';
	257	}
	258
	259	item = item.replace(/_TAGS/, tagspan);
	260	return [bg, item];
	261
	262	}
	263
	264	graph.render(data);
	265
	266	// stop hiding script -->
	267	</script>
	268
	269	<div class="navigate">
	270	<a href="/graph/-1?revcount=12">less</a>
	271	<a href="/graph/-1?revcount=50">more</a>
	272	\| rev -1: <a href="/graph/000000000000">(0)</a> <a href="/graph/tip">tip</a>
	273	</div>
	274
	275	</div>
	276	</div>
	277
	278
	279
	280	</body>
	281	</html>
	282
	283	200 Script output follows
	284
	285	<!-- quirksmode -->
	286	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
	287	<html>
	288	<head>
	289	<link rel="icon" href="/static/hgicon.png" type="image/png">
	290	<meta name="robots" content="index, nofollow" />
	291	<link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
	292
	293	<title>test: 000000000000 /</title>
	294	</head>
	295	<body>
	296
	297	<div class="container">
	298	<div class="menu">
	299	<div class="logo">
	300	<a href="http://www.selenic.com/mercurial/">
	301	<img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
	302	</div>
	303	<ul>
	304	<li><a href="/shortlog/000000000000">log</a></li>
	305	<li><a href="/graph/000000000000">graph</a></li>
	306	<li><a href="/tags">tags</a></li>
	307	</ul>
	308	<ul>
	309	<li><a href="/rev/000000000000">changeset</a></li>
	310	<li class="active">browse</li>
	311	</ul>
	312	<ul>
	313
	314	</ul>
	315	</div>
	316
	317	<div class="main">
	318	<h2><a href="/">test</a></h2>
	319	<h3>directory / @ -1:000000000000 <span class="tag">tip</span> </h3>
	320
	321	<form class="search" action="/log">
	322
	323	<p><input name="rev" id="search1" type="text" size="30"></p>
	324	<span>find changesets by author, revision,
	325	files, or words in the commit message</span>
	326	</form>
	327
	328	<table class="bigtable">
	329	<tr>
	330	<th class="name">name</th>
	331	<th class="size">size</th>
	332	<th class="permissions">permissions</th>
	333	</tr>
	334	<tr class="fileline parity0">
	335	<td class="name"><a href="/file/000000000000/">[up]</a></td>
	336	<td class="size"></td>
	337	<td class="permissions">drwxr-xr-x</td>
	338	</tr>
	339
	340
	341	</table>
	342	</div>
	343	</div>
	344
	345
	346	</body>
	347	</html>
	348

mercurial/graphmod.py

0 +3 0

             # Revision graph generator for Mercurial
             #
             # Copyright 2008 Dirkjan Ochtman <dirkjan@ochtman.nl>
             # Copyright 2007 Joel Rosdahl <joel@rosdahl.net>
             #
             # This software may be used and distributed according to the terms of
             # the GNU General Public License, incorporated herein by reference.
             from node import nullrev, short
             import ui, hg, util, templatefilters
             def graph(repo, start_rev, stop_rev):
                 """incremental revision grapher
                 This generator function walks through the revision history from
                 revision start_rev to revision stop_rev (which must be less than
                 or equal to start_rev) and for each revision emits tuples with the
                 following elements:
                   - Current node
                   - Column and color for the current node
                   - Edges; a list of (col, next_col, color) indicating the edges between
                     the current node and its parents.
                   - First line of the changeset description
                   - The changeset author
                   - The changeset date/time
                 """
+                if start_rev == nullrev and not stop_rev:
+                    return
                 assert start_rev >= stop_rev
                 assert stop_rev >= 0
                 curr_rev = start_rev
                 revs = []
                 cl = repo.changelog
                 colors = {}
                 new_color = 1
                 while curr_rev >= stop_rev:
                     # Compute revs and next_revs
                     if curr_rev not in revs:
                         revs.append(curr_rev) # new head
                         colors[curr_rev] = new_color
                         new_color += 1
                     idx = revs.index(curr_rev)
                     color = colors.pop(curr_rev)
                     next = revs[:]
                     # Add parents to next_revs
                     parents = [x for x in cl.parentrevs(curr_rev) if x != nullrev]
                     addparents = [p for p in parents if p not in next]
                     next[idx:idx + 1] = addparents
                     # Set colors for the parents
                     for i, p in enumerate(addparents):
                         if not i:
                             colors[p] = color
                         else:
                             colors[p] = new_color
                             new_color += 1
                     # Add edges to the graph
                     edges = []
                     for col, r in enumerate(revs):
                         if r in next:
                             edges.append((col, next.index(r), colors[r]))
                         elif r == curr_rev:
                             for p in parents:
                                 edges.append((col, next.index(p), colors[p]))
                     # Yield and move on
                     yield (repo[curr_rev], (idx, color), edges)
                     revs = next
                     curr_rev -= 1

mercurial/hgweb/webcommands.py

0 +1 -1

             #
             # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
             # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
             #
             # This software may be used and distributed according to the terms
             # of the GNU General Public License, incorporated herein by reference.
             import os, mimetypes, re, cgi, copy
             import webutil
             from mercurial import revlog, archival, templatefilters
             from mercurial.node import short, hex, nullid
             from mercurial.util import binary, datestr
             from mercurial.repo import RepoError
             from common import paritygen, staticfile, get_contact, ErrorResponse
             from common import HTTP_OK, HTTP_FORBIDDEN, HTTP_NOT_FOUND
             from mercurial import graphmod, util
             # __all__ is populated with the allowed commands. Be sure to add to it if
             # you're adding a new command, or the new command won't work.
             __all__ = [
                'log', 'rawfile', 'file', 'changelog', 'shortlog', 'changeset', 'rev',
                'manifest', 'tags', 'summary', 'filediff', 'diff', 'annotate', 'filelog',
                'archive', 'static', 'graph',
             ]
             def log(web, req, tmpl):
                 if 'file' in req.form and req.form['file'][0]:
                     return filelog(web, req, tmpl)
                 else:
                     return changelog(web, req, tmpl)
             def rawfile(web, req, tmpl):
                 path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
                 if not path:
                     content = manifest(web, req, tmpl)
                     req.respond(HTTP_OK, web.ctype)
                     return content
                 try:
                     fctx = webutil.filectx(web.repo, req)
                 except revlog.LookupError, inst:
                     try:
                         content = manifest(web, req, tmpl)
                         req.respond(HTTP_OK, web.ctype)
                         return content
                     except ErrorResponse:
                         raise inst
                 path = fctx.path()
                 text = fctx.data()
                 mt = mimetypes.guess_type(path)[0]
                 if mt is None:
                     mt = binary(text) and 'application/octet-stream' or 'text/plain'
                 req.respond(HTTP_OK, mt, path, len(text))
                 return [text]
             def _filerevision(web, tmpl, fctx):
                 f = fctx.path()
                 text = fctx.data()
                 parity = paritygen(web.stripecount)
                 if binary(text):
                     mt = mimetypes.guess_type(f)[0] or 'application/octet-stream'
                     text = '(binary:%s)' % mt
                 def lines():
                     for lineno, t in enumerate(text.splitlines(1)):
                         yield {"line": t,
                                "lineid": "l%d" % (lineno + 1),
                                "linenumber": "% 6d" % (lineno + 1),
                                "parity": parity.next()}
                 return tmpl("filerevision",
                             file=f,
                             path=webutil.up(f),
                             text=lines(),
                             rev=fctx.rev(),
                             node=hex(fctx.node()),
                             author=fctx.user(),
                             date=fctx.date(),
                             desc=fctx.description(),
                             branch=webutil.nodebranchnodefault(fctx),
                             parent=webutil.siblings(fctx.parents()),
                             child=webutil.siblings(fctx.children()),
                             rename=webutil.renamelink(fctx),
                             permissions=fctx.manifest().flags(f))
             def file(web, req, tmpl):
                 path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
                 if not path:
                     return manifest(web, req, tmpl)
                 try:
                     return _filerevision(web, tmpl, webutil.filectx(web.repo, req))
                 except revlog.LookupError, inst:
                     try:
                         return manifest(web, req, tmpl)
                     except ErrorResponse:
                         raise inst
             def _search(web, tmpl, query):
                 def changelist(**map):
                     cl = web.repo.changelog
                     count = 0
                     qw = query.lower().split()
                     def revgen():
                         for i in xrange(len(cl) - 1, 0, -100):
                             l = []
                             for j in xrange(max(0, i - 100), i + 1):
                                 ctx = web.repo[j]
                                 l.append(ctx)
                             l.reverse()
                             for e in l:
                                 yield e
                     for ctx in revgen():
                         miss = 0
                         for q in qw:
                             if not (q in ctx.user().lower() or
                                     q in ctx.description().lower() or
                                     q in " ".join(ctx.files()).lower()):
                                 miss = 1
                                 break
                         if miss:
                             continue
                         count += 1
                         n = ctx.node()
                         showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n)
                         files = webutil.listfilediffs(tmpl, ctx.files(), n, web.maxfiles)
                         yield tmpl('searchentry',
                                    parity=parity.next(),
                                    author=ctx.user(),
                                    parent=webutil.siblings(ctx.parents()),
                                    child=webutil.siblings(ctx.children()),
                                    changelogtag=showtags,
                                    desc=ctx.description(),
                                    date=ctx.date(),
                                    files=files,
                                    rev=ctx.rev(),
                                    node=hex(n),
                                    tags=webutil.nodetagsdict(web.repo, n),
                                    inbranch=webutil.nodeinbranch(web.repo, ctx),
                                    branches=webutil.nodebranchdict(web.repo, ctx))
                         if count >= web.maxchanges:
                             break
                 cl = web.repo.changelog
                 parity = paritygen(web.stripecount)
                 return tmpl('search',
                             query=query,
                             node=hex(cl.tip()),
                             entries=changelist,
                             archives=web.archivelist("tip"))
             def changelog(web, req, tmpl, shortlog = False):
                 if 'node' in req.form:
                     ctx = webutil.changectx(web.repo, req)
                 else:
                     if 'rev' in req.form:
                         hi = req.form['rev'][0]
                     else:
                         hi = len(web.repo) - 1
                     try:
                         ctx = web.repo[hi]
                     except RepoError:
                         return _search(web, tmpl, hi) # XXX redirect to 404 page?
                 def changelist(limit=0, **map):
                     cl = web.repo.changelog
                     l = [] # build a list in forward order for efficiency
                     for i in xrange(start, end):
                         ctx = web.repo[i]
                         n = ctx.node()
                         showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n)
                         files = webutil.listfilediffs(tmpl, ctx.files(), n, web.maxfiles)
                         l.insert(0, {"parity": parity.next(),
                                      "author": ctx.user(),
                                      "parent": webutil.siblings(ctx.parents(), i - 1),
                                      "child": webutil.siblings(ctx.children(), i + 1),
                                      "changelogtag": showtags,
                                      "desc": ctx.description(),
                                      "date": ctx.date(),
                                      "files": files,
                                      "rev": i,
                                      "node": hex(n),
                                      "tags": webutil.nodetagsdict(web.repo, n),
                                      "inbranch": webutil.nodeinbranch(web.repo, ctx),
                                      "branches": webutil.nodebranchdict(web.repo, ctx)
                                     })
                     if limit > 0:
                         l = l[:limit]
                     for e in l:
                         yield e
                 maxchanges = shortlog and web.maxshortchanges or web.maxchanges
                 cl = web.repo.changelog
                 count = len(cl)
                 pos = ctx.rev()
                 start = max(0, pos - maxchanges + 1)
                 end = min(count, start + maxchanges)
                 pos = end - 1
                 parity = paritygen(web.stripecount, offset=start-end)
                 changenav = webutil.revnavgen(pos, maxchanges, count, web.repo.changectx)
                 return tmpl(shortlog and 'shortlog' or 'changelog',
                             changenav=changenav,
                             node=hex(ctx.node()),
                             rev=pos, changesets=count,
                             entries=lambda **x: changelist(limit=0,**x),
                             latestentry=lambda **x: changelist(limit=1,**x),
                             archives=web.archivelist("tip"))
             def shortlog(web, req, tmpl):
                 return changelog(web, req, tmpl, shortlog = True)
             def changeset(web, req, tmpl):
                 ctx = webutil.changectx(web.repo, req)
                 showtags = webutil.showtag(web.repo, tmpl, 'changesettag', ctx.node())
                 showbranch = webutil.nodebranchnodefault(ctx)
                 parents = ctx.parents()
                 files = []
                 parity = paritygen(web.stripecount)
                 for f in ctx.files():
                     template = f in ctx and 'filenodelink' or 'filenolink'
                     files.append(tmpl(template,
                                       node=ctx.hex(), file=f,
                                       parity=parity.next()))
                 parity = paritygen(web.stripecount)
                 diffs = webutil.diffs(web.repo, tmpl, ctx, None, parity)
                 return tmpl('changeset',
                             diff=diffs,
                             rev=ctx.rev(),
                             node=ctx.hex(),
                             parent=webutil.siblings(parents),
                             child=webutil.siblings(ctx.children()),
                             changesettag=showtags,
                             changesetbranch=showbranch,
                             author=ctx.user(),
                             desc=ctx.description(),
                             date=ctx.date(),
                             files=files,
                             archives=web.archivelist(ctx.hex()),
                             tags=webutil.nodetagsdict(web.repo, ctx.node()),
                             branch=webutil.nodebranchnodefault(ctx),
                             inbranch=webutil.nodeinbranch(web.repo, ctx),
                             branches=webutil.nodebranchdict(web.repo, ctx))
             rev = changeset
             def manifest(web, req, tmpl):
                 ctx = webutil.changectx(web.repo, req)
                 path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
                 mf = ctx.manifest()
                 node = ctx.node()
                 files = {}
                 dirs = {}
                 parity = paritygen(web.stripecount)
                 if path and path[-1] != "/":
                     path += "/"
                 l = len(path)
                 abspath = "/" + path
                 for f, n in mf.items():
                     if f[:l] != path:
                         continue
                     remain = f[l:]
                     elements = remain.split('/')
                     if len(elements) == 1:
                         files[remain] = f
                     else:
                         h = dirs # need to retain ref to dirs (root)
                         for elem in elements[0:-1]:
                             if elem not in h:
                                 h[elem] = {}
                             h = h[elem]
                             if len(h) > 1:
                                 break
                         h[None] = None # denotes files present
-                if not files and not dirs:
+                if mf and not files and not dirs:
                     raise ErrorResponse(HTTP_NOT_FOUND, 'path not found: ' + path)
                 def filelist(**map):
                     for f in util.sort(files):
                         full = files[f]
                         fctx = ctx.filectx(full)
                         yield {"file": full,
                                "parity": parity.next(),
                                "basename": f,
                                "date": fctx.date(),
                                "size": fctx.size(),
                                "permissions": mf.flags(full)}
                 def dirlist(**map):
                     for d in util.sort(dirs):
                         emptydirs = []
                         h = dirs[d]
                         while isinstance(h, dict) and len(h) == 1:
                             k,v = h.items()[0]
                             if v:
                                 emptydirs.append(k)
                             h = v
                         path = "%s%s" % (abspath, d)
                         yield {"parity": parity.next(),
                                "path": path,
                                "emptydirs": "/".join(emptydirs),
                                "basename": d}
                 return tmpl("manifest",
                             rev=ctx.rev(),
                             node=hex(node),
                             path=abspath,
                             up=webutil.up(abspath),
                             upparity=parity.next(),
                             fentries=filelist,
                             dentries=dirlist,
                             archives=web.archivelist(hex(node)),
                             tags=webutil.nodetagsdict(web.repo, node),
                             inbranch=webutil.nodeinbranch(web.repo, ctx),
                             branches=webutil.nodebranchdict(web.repo, ctx))
             def tags(web, req, tmpl):
                 i = web.repo.tagslist()
                 i.reverse()
                 parity = paritygen(web.stripecount)
                 def entries(notip=False,limit=0, **map):
                     count = 0
                     for k, n in i:
                         if notip and k == "tip":
                             continue
                         if limit > 0 and count >= limit:
                             continue
                         count = count + 1
                         yield {"parity": parity.next(),
                                "tag": k,
                                "date": web.repo[n].date(),
                                "node": hex(n)}
                 return tmpl("tags",
                             node=hex(web.repo.changelog.tip()),
                             entries=lambda **x: entries(False,0, **x),
                             entriesnotip=lambda **x: entries(True,0, **x),
                             latestentry=lambda **x: entries(True,1, **x))
             def summary(web, req, tmpl):
                 i = web.repo.tagslist()
                 i.reverse()
                 def tagentries(**map):
                     parity = paritygen(web.stripecount)
                     count = 0
                     for k, n in i:
                         if k == "tip": # skip tip
                             continue
                         count += 1
                         if count > 10: # limit to 10 tags
                             break
                         yield tmpl("tagentry",
                                    parity=parity.next(),
                                    tag=k,
                                    node=hex(n),
                                    date=web.repo[n].date())
                 def branches(**map):
                     parity = paritygen(web.stripecount)
                     b = web.repo.branchtags()
                     l = [(-web.repo.changelog.rev(n), n, t) for t, n in b.items()]
                     for r,n,t in util.sort(l):
                         yield {'parity': parity.next(),
                                'branch': t,
                                'node': hex(n),
                                'date': web.repo[n].date()}
                 def changelist(**map):
                     parity = paritygen(web.stripecount, offset=start-end)
                     l = [] # build a list in forward order for efficiency
                     for i in xrange(start, end):
                         ctx = web.repo[i]
                         n = ctx.node()
                         hn = hex(n)
                         l.insert(0, tmpl(
                            'shortlogentry',
                             parity=parity.next(),
                             author=ctx.user(),
                             desc=ctx.description(),
                             date=ctx.date(),
                             rev=i,
                             node=hn,
                             tags=webutil.nodetagsdict(web.repo, n),
                             inbranch=webutil.nodeinbranch(web.repo, ctx),
                             branches=webutil.nodebranchdict(web.repo, ctx)))
                     yield l
                 cl = web.repo.changelog
                 count = len(cl)
                 start = max(0, count - web.maxchanges)
                 end = min(count, start + web.maxchanges)
                 return tmpl("summary",
                             desc=web.config("web", "description", "unknown"),
                             owner=get_contact(web.config) or "unknown",
                             lastchange=cl.read(cl.tip())[2],
                             tags=tagentries,
                             branches=branches,
                             shortlog=changelist,
                             node=hex(cl.tip()),
                             archives=web.archivelist("tip"))
             def filediff(web, req, tmpl):
                 fctx, ctx = None, None
                 try:
                     fctx = webutil.filectx(web.repo, req)
                 except LookupError:
                     ctx = webutil.changectx(web.repo, req)
                     path = webutil.cleanpath(web.repo, req.form['file'][0])
                     if path not in ctx.files():
                         raise
                 if fctx is not None:
                     n = fctx.node()
                     path = fctx.path()
                     parents = fctx.parents()
                     p1 = parents and parents[0].node() or nullid
                 else:
                     n = ctx.node()
                     # path already defined in except clause
                     parents = ctx.parents()
                 parity = paritygen(web.stripecount)
                 diffs = webutil.diffs(web.repo, tmpl, fctx or ctx, [path], parity)
                 rename = fctx and webutil.renamelink(fctx) or []
                 ctx = fctx and fctx or ctx
                 return tmpl("filediff",
                             file=path,
                             node=hex(n),
                             rev=ctx.rev(),
                             date=ctx.date(),
                             desc=ctx.description(),
                             author=ctx.user(),
                             rename=rename,
                             branch=webutil.nodebranchnodefault(ctx),
                             parent=webutil.siblings(parents),
                             child=webutil.siblings(ctx.children()),
                             diff=diffs)
             diff = filediff
             def annotate(web, req, tmpl):
                 fctx = webutil.filectx(web.repo, req)
                 f = fctx.path()
                 parity = paritygen(web.stripecount)
                 def annotate(**map):
                     last = None
                     if binary(fctx.data()):
                         mt = (mimetypes.guess_type(fctx.path())[0]
                               or 'application/octet-stream')
                         lines = enumerate([((fctx.filectx(fctx.filerev()), 1),
                                             '(binary:%s)' % mt)])
                     else:
                         lines = enumerate(fctx.annotate(follow=True, linenumber=True))
                     for lineno, ((f, targetline), l) in lines:
                         fnode = f.filenode()
                         if last != fnode:
                             last = fnode
                         yield {"parity": parity.next(),
                                "node": hex(f.node()),
                                "rev": f.rev(),
                                "author": f.user(),
                                "desc": f.description(),
                                "file": f.path(),
                                "targetline": targetline,
                                "line": l,
                                "lineid": "l%d" % (lineno + 1),
                                "linenumber": "% 6d" % (lineno + 1)}
                 return tmpl("fileannotate",
                             file=f,
                             annotate=annotate,
                             path=webutil.up(f),
                             rev=fctx.rev(),
                             node=hex(fctx.node()),
                             author=fctx.user(),
                             date=fctx.date(),
                             desc=fctx.description(),
                             rename=webutil.renamelink(fctx),
                             branch=webutil.nodebranchnodefault(fctx),
                             parent=webutil.siblings(fctx.parents()),
                             child=webutil.siblings(fctx.children()),
                             permissions=fctx.manifest().flags(f))
             def filelog(web, req, tmpl):
                 try:
                     fctx = webutil.filectx(web.repo, req)
                     f = fctx.path()
                     fl = fctx.filelog()
                 except revlog.LookupError:
                     f = webutil.cleanpath(web.repo, req.form['file'][0])
                     fl = web.repo.file(f)
                     numrevs = len(fl)
                     if not numrevs: # file doesn't exist at all
                         raise
                     rev = webutil.changectx(web.repo, req).rev()
                     first = fl.linkrev(0)
                     if rev < first: # current rev is from before file existed
                         raise
                     frev = numrevs - 1
                     while fl.linkrev(frev) > rev:
                         frev -= 1
                     fctx = web.repo.filectx(f, fl.linkrev(frev))
                 count = fctx.filerev() + 1
                 pagelen = web.maxshortchanges
                 start = max(0, fctx.filerev() - pagelen + 1) # first rev on this page
                 end = min(count, start + pagelen) # last rev on this page
                 parity = paritygen(web.stripecount, offset=start-end)
                 def entries(limit=0, **map):
                     l = []
                     for i in xrange(start, end):
                         ctx = fctx.filectx(i)
                         l.insert(0, {"parity": parity.next(),
                                      "filerev": i,
                                      "file": f,
                                      "node": hex(ctx.node()),
                                      "author": ctx.user(),
                                      "date": ctx.date(),
                                      "rename": webutil.renamelink(fctx),
                                      "parent": webutil.siblings(fctx.parents()),
                                      "child": webutil.siblings(fctx.children()),
                                      "desc": ctx.description(),
                                      "tags": webutil.nodetagsdict(web.repo, ctx.node()),
                                      "branch": webutil.nodebranchnodefault(ctx),
                                      "inbranch": webutil.nodeinbranch(web.repo, ctx),
                                      "branches": webutil.nodebranchdict(web.repo, ctx)})
                     if limit > 0:
                         l = l[:limit]
                     for e in l:
                         yield e
                 nodefunc = lambda x: fctx.filectx(fileid=x)
                 nav = webutil.revnavgen(end - 1, pagelen, count, nodefunc)
                 return tmpl("filelog", file=f, node=hex(fctx.node()), nav=nav,
                             entries=lambda **x: entries(limit=0, **x),
                             latestentry=lambda **x: entries(limit=1, **x))
             def archive(web, req, tmpl):
                 type_ = req.form.get('type', [None])[0]
                 allowed = web.configlist("web", "allow_archive")
                 key = req.form['node'][0]
                 if type_ not in web.archives:
                     msg = 'Unsupported archive type: %s' % type_
                     raise ErrorResponse(HTTP_NOT_FOUND, msg)
                 if not ((type_ in allowed or
                     web.configbool("web", "allow" + type_, False))):
                     msg = 'Archive type not allowed: %s' % type_
                     raise ErrorResponse(HTTP_FORBIDDEN, msg)
                 reponame = re.sub(r"\W+", "-", os.path.basename(web.reponame))
                 cnode = web.repo.lookup(key)
                 arch_version = key
                 if cnode == key or key == 'tip':
                     arch_version = short(cnode)
                 name = "%s-%s" % (reponame, arch_version)
                 mimetype, artype, extension, encoding = web.archive_specs[type_]
                 headers = [
                     ('Content-Type', mimetype),
                     ('Content-Disposition', 'attachment; filename=%s%s' % (name, extension))
                 ]
                 if encoding:
                     headers.append(('Content-Encoding', encoding))
                 req.header(headers)
                 req.respond(HTTP_OK)
                 archival.archive(web.repo, req, cnode, artype, prefix=name)
                 return []
             def static(web, req, tmpl):
                 fname = req.form['file'][0]
                 # a repo owner may set web.static in .hg/hgrc to get any file
                 # readable by the user running the CGI script
                 static = web.config("web", "static", None, untrusted=False)
                 if not static:
                     tp = web.templatepath
                     if isinstance(tp, str):
                         tp = [tp]
                     static = [os.path.join(p, 'static') for p in tp]
                 return [staticfile(static, fname, req)]
             def graph(web, req, tmpl):
                 rev = webutil.changectx(web.repo, req).rev()
                 bg_height = 39
                 revcount = 25
                 if 'revcount' in req.form:
                     revcount = int(req.form.get('revcount', [revcount])[0])
                     tmpl.defaults['sessionvars']['revcount'] = revcount
                 lessvars = copy.copy(tmpl.defaults['sessionvars'])
                 lessvars['revcount'] = revcount / 2
                 morevars = copy.copy(tmpl.defaults['sessionvars'])
                 morevars['revcount'] = revcount * 2
                 max_rev = len(web.repo) - 1
                 revcount = min(max_rev, revcount)
                 revnode = web.repo.changelog.node(rev)
                 revnode_hex = hex(revnode)
                 uprev = min(max_rev, rev + revcount)
                 downrev = max(0, rev - revcount)
                 count = len(web.repo)
                 changenav = webutil.revnavgen(rev, revcount, count, web.repo.changectx)
                 tree = list(graphmod.graph(web.repo, rev, downrev))
                 canvasheight = (len(tree) + 1) * bg_height - 27;
                 data = []
                 for i, (ctx, vtx, edges) in enumerate(tree):
                     node = short(ctx.node())
                     age = templatefilters.age(ctx.date())
                     desc = templatefilters.firstline(ctx.description())
                     desc = cgi.escape(desc)
                     user = cgi.escape(templatefilters.person(ctx.user()))
                     branch = ctx.branch()
                     branch = branch, web.repo.branchtags().get(branch) == ctx.node()
                     data.append((node, vtx, edges, desc, user, age, branch, ctx.tags()))
                 return tmpl('graph', rev=rev, revcount=revcount, uprev=uprev,
                             lessvars=lessvars, morevars=morevars, downrev=downrev,
                             canvasheight=canvasheight, jsdata=data, bg_height=bg_height,
                             node=revnode_hex, changenav=changenav)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages