upstream/mercurial-mirror Commit - r6876:077f1e63

Merge with stable...

Matt Mackall -

r6876:077f1e63 default

parent child

Expand all files

The requested changes are too big and content was truncated. Show full diff

contrib/dumprevlog

0 created 644 +25 0

			@@ -0,0 +1,25
		1	#!/usr/bin/env python
		2	# Dump revlogs as raw data stream
		3	# $ find .hg/store/ -name "*.i" \| xargs dumprevlog > repo.dump
		4
		5	import sys
		6	from mercurial import revlog, node, util
		7
		8	for fp in (sys.stdin, sys.stdout, sys.stderr):
		9	util.set_binary(fp)
		10
		11	for f in sys.argv[1:]:
		12	binopen = lambda fn: open(fn, 'rb')
		13	r = revlog.revlog(binopen, f)
		14	print "file:", f
		15	for i in r:
		16	n = r.node(i)
		17	p = r.parents(n)
		18	d = r.revision(n)
		19	print "node:", node.hex(n)
		20	print "linkrev:", r.linkrev(n)
		21	print "parents:", node.hex(p[0]), node.hex(p[1])
		22	print "length:", len(d)
		23	print "-start-"
		24	print d
		25	print "-end-"

contrib/undumprevlog

0 created 644 +37 0

			@@ -0,0 +1,37
		1	#!/usr/bin/env python
		2	# Undump a dump from dumprevlog
		3	# $ hg init
		4	# $ undumprevlog < repo.dump
		5
		6	import sys
		7	from mercurial import revlog, node, util, transaction
		8
		9	for fp in (sys.stdin, sys.stdout, sys.stderr):
		10	util.set_binary(fp)
		11
		12	opener = util.opener('.', False)
		13	tr = transaction.transaction(sys.stderr.write, opener, "undump.journal")
		14	while 1:
		15	l = sys.stdin.readline()
		16	if not l:
		17	break
		18	if l.startswith("file:"):
		19	f = l[6:-1]
		20	r = revlog.revlog(opener, f)
		21	print f
		22	elif l.startswith("node:"):
		23	n = node.bin(l[6:-1])
		24	elif l.startswith("linkrev:"):
		25	lr = int(l[9:-1])
		26	elif l.startswith("parents:"):
		27	p = l[9:-1].split()
		28	p1 = node.bin(p[0])
		29	p2 = node.bin(p[1])
		30	elif l.startswith("length:"):
		31	length = int(l[8:-1])
		32	sys.stdin.readline() # start marker
		33	d = sys.stdin.read(length)
		34	sys.stdin.readline() # end marker
		35	r.addrevision(d, tr, lr, p1, p2)
		36
		37	tr.close()

contrib/win32/hg.bat

0 created 644 +12 0

			@@ -0,0 +1,12
		1	@echo off
		2	rem Windows Driver script for Mercurial
		3
		4	setlocal
		5	set HG=%~f0
		6
		7	rem Use a full path to Python (relative to this script) as the standard Python
		8	rem install does not put python.exe on the PATH...
		9	rem %~dp0 is the directory of this script
		10
		11	%~dp0..\python "%~dp0hg" %*
		12	endlocal

hgext/convert/cvsps

0 created 644 +154 0

			@@ -0,0 +1,154
		1	#!/usr/bin/env python
		2	#
		3	# Commandline front-end for cvsps.py
		4	#
		5	# Copyright 2008, Frank Kingswood <frank@kingswood-consulting.co.uk>
		6	#
		7	# This software may be used and distributed according to the terms
		8	# of the GNU General Public License, incorporated herein by reference.
		9
		10	import sys
		11	from mercurial import util
		12	from mercurial.i18n import _
		13	from optparse import OptionParser, SUPPRESS_HELP
		14	from hgext.convert.cvsps import createlog, createchangeset, logerror
		15
		16	def main():
		17	'''Main program to mimic cvsps.'''
		18
		19	op = OptionParser(usage='%prog [-bpruvxz] path',
		20	description='Read CVS rlog for current directory or named '
		21	'path in repository, and convert the log to changesets '
		22	'based on matching commit log entries and dates.')
		23
		24	# Options that are ignored for compatibility with cvsps-2.1
		25	op.add_option('-A', dest='Ignore', action='store_true', help=SUPPRESS_HELP)
		26	op.add_option('--cvs-direct', dest='Ignore', action='store_true', help=SUPPRESS_HELP)
		27	op.add_option('-q', dest='Ignore', action='store_true', help=SUPPRESS_HELP)
		28
		29	# Main options shared with cvsps-2.1
		30	op.add_option('-b', dest='Branches', action='append', default=[],
		31	help='Only return changes on specified branches')
		32	op.add_option('-p', dest='Prefix', action='store', default='',
		33	help='Prefix to remove from file names')
		34	op.add_option('-r', dest='Revisions', action='append', default=[],
		35	help='Only return changes after or between specified tags')
		36	op.add_option('-u', dest='Cache', action='store_const', const='update',
		37	help="Update cvs log cache")
		38	op.add_option('-v', dest='Verbose', action='count', default=0,
		39	help='Be verbose')
		40	op.add_option('-x', dest='Cache', action='store_const', const='write',
		41	help="Create new cvs log cache")
		42	op.add_option('-z', dest='Fuzz', action='store', type='int', default=60,
		43	help='Set commit time fuzz', metavar='seconds')
		44	op.add_option('--root', dest='Root', action='store', default='',
		45	help='Specify cvsroot', metavar='cvsroot')
		46
		47	# Options specific to this version
		48	op.add_option('--parents', dest='Parents', action='store_true',
		49	help='Show parent changesets')
		50	op.add_option('--ancestors', dest='Ancestors', action='store_true',
		51	help='Show current changeset in ancestor branches')
		52
		53	options, args = op.parse_args()
		54
		55	# Create a ui object for printing progress messages
		56	class UI:
		57	def __init__(self, verbose):
		58	if verbose:
		59	self.status = self.message
		60	if verbose>1:
		61	self.note = self.message
		62	if verbose>2:
		63	self.debug = self.message
		64	def message(self, msg):
		65	sys.stderr.write(msg)
		66	def nomessage(self, msg):
		67	pass
		68	status = nomessage
		69	note = nomessage
		70	debug = nomessage
		71	ui = UI(options.Verbose)
		72
		73	try:
		74	if args:
		75	log = []
		76	for d in args:
		77	log += createlog(ui, d, root=options.Root, cache=options.Cache)
		78	else:
		79	log = createlog(ui, root=options.Root, cache=options.Cache)
		80	except logerror, e:
		81	print e
		82	return
		83
		84	changesets = createchangeset(ui, log, options.Fuzz)
		85	del log
		86
		87	# Print changesets (optionally filtered)
		88
		89	off = len(options.Revisions)
		90	branches = {} # latest version number in each branch
		91	ancestors = {} # parent branch
		92	for cs in changesets:
		93
		94	if options.Ancestors:
		95	if cs.branch not in branches and cs.parents and cs.parents[0].id:
		96	ancestors[cs.branch] = changesets[cs.parents[0].id-1].branch, cs.parents[0].id
		97	branches[cs.branch] = cs.id
		98
		99	# limit by branches
		100	if options.Branches and (cs.branch or 'HEAD') not in options.Branches:
		101	continue
		102
		103	if not off:
		104	# Note: trailing spaces on several lines here are needed to have
		105	# bug-for-bug compatibility with cvsps.
		106	print '---------------------'
		107	print 'PatchSet %d ' % cs.id
		108	print 'Date: %s' % util.datestr(cs.date, '%Y/%m/%d %H:%M:%S %1%2')
		109	print 'Author: %s' % cs.author
		110	print 'Branch: %s' % (cs.branch or 'HEAD')
		111	print 'Tag%s: %s ' % (['', 's'][len(cs.tags)>1],
		112	','.join(cs.tags) or '(none)')
		113	if options.Parents and cs.parents:
		114	if len(cs.parents)>1:
		115	print 'Parents: %s' % (','.join([str(p.id) for p in cs.parents]))
		116	else:
		117	print 'Parent: %d' % cs.parents[0].id
		118
		119	if options.Ancestors:
		120	b = cs.branch
		121	r = []
		122	while b:
		123	b, c = ancestors[b]
		124	r.append('%s:%d:%d' % (b or "HEAD", c, branches[b]))
		125	if r:
		126	print 'Ancestors: %s' % (','.join(r))
		127
		128	print 'Log:'
		129	print cs.comment
		130	print
		131	print 'Members: '
		132	for f in cs.entries:
		133	fn = f.file
		134	if fn.startswith(options.Prefix):
		135	fn = fn[len(options.Prefix):]
		136	print '\t%s:%s->%s%s ' % (fn, '.'.join([str(x) for x in f.parent]) or 'INITIAL',
		137	'.'.join([str(x) for x in f.revision]), ['', '(DEAD)'][f.dead])
		138	print
		139
		140	# have we seen the start tag?
		141	if options.Revisions and off:
		142	if options.Revisions[0] == str(cs.id) or \
		143	options.Revisions[0] in cs.tags:
		144	off = False
		145
		146	# see if we reached the end tag
		147	if len(options.Revisions)>1 and not off:
		148	if options.Revisions[1] == str(cs.id) or \
		149	options.Revisions[1] in cs.tags:
		150	break
		151
		152
		153	if __name__ == '__main__':
		154	main()

hgext/convert/cvsps.py

0 created 644 +548 0

This diff has been collapsed as it changes many lines, (548 lines changed) Show them Hide them
		@@ -0,0 +1,548
	1	#
	2	# Mercurial built-in replacement for cvsps.
	3	#
	4	# Copyright 2008, Frank Kingswood <frank@kingswood-consulting.co.uk>
	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	import os
	10	import re
	11	import sys
	12	import cPickle as pickle
	13	from mercurial import util
	14	from mercurial.i18n import _
	15
	16	def listsort(list, key):
	17	"helper to sort by key in Python 2.3"
	18	try:
	19	list.sort(key=key)
	20	except TypeError:
	21	list.sort(lambda l, r: cmp(key(l), key(r)))
	22
	23	class logentry(object):
	24	'''Class logentry has the following attributes:
	25	.author - author name as CVS knows it
	26	.branch - name of branch this revision is on
	27	.branches - revision tuple of branches starting at this revision
	28	.comment - commit message
	29	.date - the commit date as a (time, tz) tuple
	30	.dead - true if file revision is dead
	31	.file - Name of file
	32	.lines - a tuple (+lines, -lines) or None
	33	.parent - Previous revision of this entry
	34	.rcs - name of file as returned from CVS
	35	.revision - revision number as tuple
	36	.tags - list of tags on the file
	37	'''
	38	def __init__(self, **entries):
	39	self.__dict__.update(entries)
	40
	41	class logerror(Exception):
	42	pass
	43
	44	def createlog(ui, directory=None, root="", rlog=True, cache=None):
	45	'''Collect the CVS rlog'''
	46
	47	# Because we store many duplicate commit log messages, reusing strings
	48	# saves a lot of memory and pickle storage space.
	49	_scache = {}
	50	def scache(s):
	51	"return a shared version of a string"
	52	return _scache.setdefault(s, s)
	53
	54	ui.status(_('collecting CVS rlog\n'))
	55
	56	log = [] # list of logentry objects containing the CVS state
	57
	58	# patterns to match in CVS (r)log output, by state of use
	59	re_00 = re.compile('RCS file: (.+)$')
	60	re_01 = re.compile('cvs \\[r?log aborted\\]: (.+)$')
	61	re_02 = re.compile('cvs (r?log\|server): (.+)\n$')
	62	re_03 = re.compile("(Cannot access.+CVSROOT)\|(can't create temporary directory.+)$")
	63	re_10 = re.compile('Working file: (.+)$')
	64	re_20 = re.compile('symbolic names:')
	65	re_30 = re.compile('\t(.+): ([\\d.]+)$')
	66	re_31 = re.compile('----------------------------$')
	67	re_32 = re.compile('=============================================================================$')
	68	re_50 = re.compile('revision ([\\d.]+)(\s+locked by:\s+.+;)?$')
	69	re_60 = re.compile(r'date:\s+(.+);\s+author:\s+(.+);\s+state:\s+(.+?);(\s+lines:\s+(\+\d+)?\s+(-\d+)?;)?')
	70	re_70 = re.compile('branches: (.+);$')
	71
	72	prefix = '' # leading path to strip of what we get from CVS
	73
	74	if directory is None:
	75	# Current working directory
	76
	77	# Get the real directory in the repository
	78	try:
	79	prefix = file(os.path.join('CVS','Repository')).read().strip()
	80	if prefix == ".":
	81	prefix = ""
	82	directory = prefix
	83	except IOError:
	84	raise logerror('Not a CVS sandbox')
	85
	86	if prefix and not prefix.endswith('/'):
	87	prefix += '/'
	88
	89	# Use the Root file in the sandbox, if it exists
	90	try:
	91	root = file(os.path.join('CVS','Root')).read().strip()
	92	except IOError:
	93	pass
	94
	95	if not root:
	96	root = os.environ.get('CVSROOT', '')
	97
	98	# read log cache if one exists
	99	oldlog = []
	100	date = None
	101
	102	if cache:
	103	cachedir = os.path.expanduser('~/.hg.cvsps')
	104	if not os.path.exists(cachedir):
	105	os.mkdir(cachedir)
	106
	107	# The cvsps cache pickle needs a uniquified name, based on the
	108	# repository location. The address may have all sort of nasties
	109	# in it, slashes, colons and such. So here we take just the
	110	# alphanumerics, concatenated in a way that does not mix up the
	111	# various components, so that
	112	# :pserver:user@server:/path
	113	# and
	114	# /pserver/user/server/path
	115	# are mapped to different cache file names.
	116	cachefile = root.split(":") + [directory, "cache"]
	117	cachefile = ['-'.join(re.findall(r'\w+', s)) for s in cachefile if s]
	118	cachefile = os.path.join(cachedir,
	119	'.'.join([s for s in cachefile if s]))
	120
	121	if cache == 'update':
	122	try:
	123	ui.note(_('reading cvs log cache %s\n') % cachefile)
	124	oldlog = pickle.load(file(cachefile))
	125	ui.note(_('cache has %d log entries\n') % len(oldlog))
	126	except Exception, e:
	127	ui.note(_('error reading cache: %r\n') % e)
	128
	129	if oldlog:
	130	date = oldlog[-1].date # last commit date as a (time,tz) tuple
	131	date = util.datestr(date, '%Y/%m/%d %H:%M:%S %1%2')
	132
	133	# build the CVS commandline
	134	cmd = ['cvs', '-q']
	135	if root:
	136	cmd.append('-d%s' % root)
	137	p = root.split(':')[-1]
	138	if not p.endswith('/'):
	139	p += '/'
	140	prefix = p + prefix
	141	cmd.append(['log', 'rlog'][rlog])
	142	if date:
	143	# no space between option and date string
	144	cmd.append('-d>%s' % date)
	145	cmd.append(directory)
	146
	147	# state machine begins here
	148	tags = {} # dictionary of revisions on current file with their tags
	149	state = 0
	150	store = False # set when a new record can be appended
	151
	152	cmd = [util.shellquote(arg) for arg in cmd]
	153	ui.note("running %s\n" % (' '.join(cmd)))
	154	ui.debug("prefix=%r directory=%r root=%r\n" % (prefix, directory, root))
	155
	156	for line in util.popen(' '.join(cmd)):
	157	if line.endswith('\n'):
	158	line = line[:-1]
	159	#ui.debug('state=%d line=%r\n' % (state, line))
	160
	161	if state == 0:
	162	# initial state, consume input until we see 'RCS file'
	163	match = re_00.match(line)
	164	if match:
	165	rcs = match.group(1)
	166	tags = {}
	167	if rlog:
	168	filename = rcs[:-2]
	169	if filename.startswith(prefix):
	170	filename = filename[len(prefix):]
	171	if filename.startswith('/'):
	172	filename = filename[1:]
	173	if filename.startswith('Attic/'):
	174	filename = filename[6:]
	175	else:
	176	filename = filename.replace('/Attic/', '/')
	177	state = 2
	178	continue
	179	state = 1
	180	continue
	181	match = re_01.match(line)
	182	if match:
	183	raise Exception(match.group(1))
	184	match = re_02.match(line)
	185	if match:
	186	raise Exception(match.group(2))
	187	if re_03.match(line):
	188	raise Exception(line)
	189
	190	elif state == 1:
	191	# expect 'Working file' (only when using log instead of rlog)
	192	match = re_10.match(line)
	193	assert match, _('RCS file must be followed by working file')
	194	filename = match.group(1)
	195	state = 2
	196
	197	elif state == 2:
	198	# expect 'symbolic names'
	199	if re_20.match(line):
	200	state = 3
	201
	202	elif state == 3:
	203	# read the symbolic names and store as tags
	204	match = re_30.match(line)
	205	if match:
	206	rev = [int(x) for x in match.group(2).split('.')]
	207
	208	# Convert magic branch number to an odd-numbered one
	209	revn = len(rev)
	210	if revn > 3 and (revn % 2) == 0 and rev[-2] == 0:
	211	rev = rev[:-2] + rev[-1:]
	212	rev = tuple(rev)
	213
	214	if rev not in tags:
	215	tags[rev] = []
	216	tags[rev].append(match.group(1))
	217
	218	elif re_31.match(line):
	219	state = 5
	220	elif re_32.match(line):
	221	state = 0
	222
	223	elif state == 4:
	224	# expecting '------' separator before first revision
	225	if re_31.match(line):
	226	state = 5
	227	else:
	228	assert not re_32.match(line), _('Must have at least some revisions')
	229
	230	elif state == 5:
	231	# expecting revision number and possibly (ignored) lock indication
	232	# we create the logentry here from values stored in states 0 to 4,
	233	# as this state is re-entered for subsequent revisions of a file.
	234	match = re_50.match(line)
	235	assert match, _('expected revision number')
	236	e = logentry(rcs=scache(rcs), file=scache(filename),
	237	revision=tuple([int(x) for x in match.group(1).split('.')]),
	238	branches=[], parent=None)
	239	state = 6
	240
	241	elif state == 6:
	242	# expecting date, author, state, lines changed
	243	match = re_60.match(line)
	244	assert match, _('revision must be followed by date line')
	245	d = match.group(1)
	246	if d[2] == '/':
	247	# Y2K
	248	d = '19' + d
	249
	250	if len(d.split()) != 3:
	251	# cvs log dates always in GMT
	252	d = d + ' UTC'
	253	e.date = util.parsedate(d, ['%y/%m/%d %H:%M:%S', '%Y/%m/%d %H:%M:%S', '%Y-%m-%d %H:%M:%S'])
	254	e.author = scache(match.group(2))
	255	e.dead = match.group(3).lower() == 'dead'
	256
	257	if match.group(5):
	258	if match.group(6):
	259	e.lines = (int(match.group(5)), int(match.group(6)))
	260	else:
	261	e.lines = (int(match.group(5)), 0)
	262	elif match.group(6):
	263	e.lines = (0, int(match.group(6)))
	264	else:
	265	e.lines = None
	266	e.comment = []
	267	state = 7
	268
	269	elif state == 7:
	270	# read the revision numbers of branches that start at this revision
	271	# or store the commit log message otherwise
	272	m = re_70.match(line)
	273	if m:
	274	e.branches = [tuple([int(y) for y in x.strip().split('.')])
	275	for x in m.group(1).split(';')]
	276	state = 8
	277	elif re_31.match(line):
	278	state = 5
	279	store = True
	280	elif re_32.match(line):
	281	state = 0
	282	store = True
	283	else:
	284	e.comment.append(line)
	285
	286	elif state == 8:
	287	# store commit log message
	288	if re_31.match(line):
	289	state = 5
	290	store = True
	291	elif re_32.match(line):
	292	state = 0
	293	store = True
	294	else:
	295	e.comment.append(line)
	296
	297	if store:
	298	# clean up the results and save in the log.
	299	store = False
	300	e.tags = util.sort([scache(x) for x in tags.get(e.revision, [])])
	301	e.comment = scache('\n'.join(e.comment))
	302
	303	revn = len(e.revision)
	304	if revn > 3 and (revn % 2) == 0:
	305	e.branch = tags.get(e.revision[:-1], [None])[0]
	306	else:
	307	e.branch = None
	308
	309	log.append(e)
	310
	311	if len(log) % 100 == 0:
	312	ui.status(util.ellipsis('%d %s' % (len(log), e.file), 80)+'\n')
	313
	314	listsort(log, key=lambda x:(x.rcs, x.revision))
	315
	316	# find parent revisions of individual files
	317	versions = {}
	318	for e in log:
	319	branch = e.revision[:-1]
	320	p = versions.get((e.rcs, branch), None)
	321	if p is None:
	322	p = e.revision[:-2]
	323	e.parent = p
	324	versions[(e.rcs, branch)] = e.revision
	325
	326	# update the log cache
	327	if cache:
	328	if log:
	329	# join up the old and new logs
	330	listsort(log, key=lambda x:x.date)
	331
	332	if oldlog and oldlog[-1].date >= log[0].date:
	333	raise logerror('Log cache overlaps with new log entries,'
	334	' re-run without cache.')
	335
	336	log = oldlog + log
	337
	338	# write the new cachefile
	339	ui.note(_('writing cvs log cache %s\n') % cachefile)
	340	pickle.dump(log, file(cachefile, 'w'))
	341	else:
	342	log = oldlog
	343
	344	ui.status(_('%d log entries\n') % len(log))
	345
	346	return log
	347
	348
	349	class changeset(object):
	350	'''Class changeset has the following attributes:
	351	.author - author name as CVS knows it
	352	.branch - name of branch this changeset is on, or None
	353	.comment - commit message
	354	.date - the commit date as a (time,tz) tuple
	355	.entries - list of logentry objects in this changeset
	356	.parents - list of one or two parent changesets
	357	.tags - list of tags on this changeset
	358	'''
	359	def __init__(self, **entries):
	360	self.__dict__.update(entries)
	361
	362	def createchangeset(ui, log, fuzz=60, mergefrom=None, mergeto=None):
	363	'''Convert log into changesets.'''
	364
	365	ui.status(_('creating changesets\n'))
	366
	367	# Merge changesets
	368
	369	listsort(log, key=lambda x:(x.comment, x.author, x.branch, x.date))
	370
	371	changesets = []
	372	files = {}
	373	c = None
	374	for i, e in enumerate(log):
	375
	376	# Check if log entry belongs to the current changeset or not.
	377	if not (c and
	378	e.comment == c.comment and
	379	e.author == c.author and
	380	e.branch == c.branch and
	381	((c.date[0] + c.date[1]) <=
	382	(e.date[0] + e.date[1]) <=
	383	(c.date[0] + c.date[1]) + fuzz) and
	384	e.file not in files):
	385	c = changeset(comment=e.comment, author=e.author,
	386	branch=e.branch, date=e.date, entries=[])
	387	changesets.append(c)
	388	files = {}
	389	if len(changesets) % 100 == 0:
	390	t = '%d %s' % (len(changesets), repr(e.comment)[1:-1])
	391	ui.status(util.ellipsis(t, 80) + '\n')
	392
	393	c.entries.append(e)
	394	files[e.file] = True
	395	c.date = e.date # changeset date is date of latest commit in it
	396
	397	# Sort files in each changeset
	398
	399	for c in changesets:
	400	def pathcompare(l, r):
	401	'Mimic cvsps sorting order'
	402	l = l.split('/')
	403	r = r.split('/')
	404	nl = len(l)
	405	nr = len(r)
	406	n = min(nl, nr)
	407	for i in range(n):
	408	if i + 1 == nl and nl < nr:
	409	return -1
	410	elif i + 1 == nr and nl > nr:
	411	return +1
	412	elif l[i] < r[i]:
	413	return -1
	414	elif l[i] > r[i]:
	415	return +1
	416	return 0
	417	def entitycompare(l, r):
	418	return pathcompare(l.file, r.file)
	419
	420	c.entries.sort(entitycompare)
	421
	422	# Sort changesets by date
	423
	424	def cscmp(l, r):
	425	d = sum(l.date) - sum(r.date)
	426	if d:
	427	return d
	428
	429	# detect vendor branches and initial commits on a branch
	430	le = {}
	431	for e in l.entries:
	432	le[e.rcs] = e.revision
	433	re = {}
	434	for e in r.entries:
	435	re[e.rcs] = e.revision
	436
	437	d = 0
	438	for e in l.entries:
	439	if re.get(e.rcs, None) == e.parent:
	440	assert not d
	441	d = 1
	442	break
	443
	444	for e in r.entries:
	445	if le.get(e.rcs, None) == e.parent:
	446	assert not d
	447	d = -1
	448	break
	449
	450	return d
	451
	452	changesets.sort(cscmp)
	453
	454	# Collect tags
	455
	456	globaltags = {}
	457	for c in changesets:
	458	tags = {}
	459	for e in c.entries:
	460	for tag in e.tags:
	461	# remember which is the latest changeset to have this tag
	462	globaltags[tag] = c
	463
	464	for c in changesets:
	465	tags = {}
	466	for e in c.entries:
	467	for tag in e.tags:
	468	tags[tag] = True
	469	# remember tags only if this is the latest changeset to have it
	470	c.tags = util.sort([tag for tag in tags if globaltags[tag] is c])
	471
	472	# Find parent changesets, handle {{mergetobranch BRANCHNAME}}
	473	# by inserting dummy changesets with two parents, and handle
	474	# {{mergefrombranch BRANCHNAME}} by setting two parents.
	475
	476	if mergeto is None:
	477	mergeto = r'{{mergetobranch ([-\w]+)}}'
	478	if mergeto:
	479	mergeto = re.compile(mergeto)
	480
	481	if mergefrom is None:
	482	mergefrom = r'{{mergefrombranch ([-\w]+)}}'
	483	if mergefrom:
	484	mergefrom = re.compile(mergefrom)
	485
	486	versions = {} # changeset index where we saw any particular file version
	487	branches = {} # changeset index where we saw a branch
	488	n = len(changesets)
	489	i = 0
	490	while i<n:
	491	c = changesets[i]
	492
	493	for f in c.entries:
	494	versions[(f.rcs, f.revision)] = i
	495
	496	p = None
	497	if c.branch in branches:
	498	p = branches[c.branch]
	499	else:
	500	for f in c.entries:
	501	p = max(p, versions.get((f.rcs, f.parent), None))
	502
	503	c.parents = []
	504	if p is not None:
	505	c.parents.append(changesets[p])
	506
	507	if mergefrom:
	508	m = mergefrom.search(c.comment)
	509	if m:
	510	m = m.group(1)
	511	if m == 'HEAD':
	512	m = None
	513	if m in branches and c.branch != m:
	514	c.parents.append(changesets[branches[m]])
	515
	516	if mergeto:
	517	m = mergeto.search(c.comment)
	518	if m:
	519	try:
	520	m = m.group(1)
	521	if m == 'HEAD':
	522	m = None
	523	except:
	524	m = None # if no group found then merge to HEAD
	525	if m in branches and c.branch != m:
	526	# insert empty changeset for merge
	527	cc = changeset(author=c.author, branch=m, date=c.date,
	528	comment='convert-repo: CVS merge from branch %s' % c.branch,
	529	entries=[], tags=[], parents=[changesets[branches[m]], c])
	530	changesets.insert(i + 1, cc)
	531	branches[m] = i + 1
	532
	533	# adjust our loop counters now we have inserted a new entry
	534	n += 1
	535	i += 2
	536	continue
	537
	538	branches[c.branch] = i
	539	i += 1
	540
	541	# Number changesets
	542
	543	for i, c in enumerate(changesets):
	544	c.id = i + 1
	545
	546	ui.status(_('%d changeset entries\n') % len(changesets))
	547
	548	return changesets

mercurial/graphmod.py

0 created 644 +74 0

			@@ -0,0 +1,74
		1	# Revision graph generator for Mercurial
		2	#
		3	# Copyright 2008 Dirkjan Ochtman <dirkjan@ochtman.nl>
		4	# Copyright 2007 Joel Rosdahl <joel@rosdahl.net>
		5	#
		6	# This software may be used and distributed according to the terms of
		7	# the GNU General Public License, incorporated herein by reference.
		8
		9	from node import nullrev, short
		10	import ui, hg, util, templatefilters
		11
		12	def graph(repo, start_rev, stop_rev):
		13	"""incremental revision grapher
		14
		15	This generator function walks through the revision history from
		16	revision start_rev to revision stop_rev (which must be less than
		17	or equal to start_rev) and for each revision emits tuples with the
		18	following elements:
		19
		20	- Current node
		21	- Column and color for the current node
		22	- Edges; a list of (col, next_col, color) indicating the edges between
		23	the current node and its parents.
		24	- First line of the changeset description
		25	- The changeset author
		26	- The changeset date/time
		27	"""
		28
		29	assert start_rev >= stop_rev
		30	curr_rev = start_rev
		31	revs = []
		32	cl = repo.changelog
		33	colors = {}
		34	new_color = 1
		35
		36	while curr_rev >= stop_rev:
		37	node = cl.node(curr_rev)
		38
		39	# Compute revs and next_revs
		40	if curr_rev not in revs:
		41	revs.append(curr_rev) # new head
		42	colors[curr_rev] = new_color
		43	new_color += 1
		44
		45	idx = revs.index(curr_rev)
		46	color = colors.pop(curr_rev)
		47	next = revs[:]
		48
		49	# Add parents to next_revs
		50	parents = [x for x in cl.parentrevs(curr_rev) if x != nullrev]
		51	addparents = [p for p in parents if p not in next]
		52	next[idx:idx + 1] = addparents
		53
		54	# Set colors for the parents
		55	for i, p in enumerate(addparents):
		56	if not i:
		57	colors[p] = color
		58	else:
		59	colors[p] = new_color
		60	new_color += 1
		61
		62	# Add edges to the graph
		63	edges = []
		64	for col, r in enumerate(revs):
		65	if r in next:
		66	edges.append((col, next.index(r), colors[r]))
		67	elif r == curr_rev:
		68	for p in parents:
		69	edges.append((col, next.index(p), colors[p]))
		70
		71	# Yield and move on
		72	yield (repo[curr_rev], (idx, color), edges)
		73	revs = next
		74	curr_rev -= 1

mercurial/hgweb/webutil.py

0 created 644 +140 0

			@@ -0,0 +1,140
		1	# hgweb/webutil.py - utility library for the web interface.
		2	#
		3	# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
		4	# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
		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	import os
		10	from mercurial.node import hex, nullid
		11	from mercurial.repo import RepoError
		12	from mercurial import util
		13
		14	def up(p):
		15	if p[0] != "/":
		16	p = "/" + p
		17	if p[-1] == "/":
		18	p = p[:-1]
		19	up = os.path.dirname(p)
		20	if up == "/":
		21	return "/"
		22	return up + "/"
		23
		24	def revnavgen(pos, pagelen, limit, nodefunc):
		25	def seq(factor, limit=None):
		26	if limit:
		27	yield limit
		28	if limit >= 20 and limit <= 40:
		29	yield 50
		30	else:
		31	yield 1 * factor
		32	yield 3 * factor
		33	for f in seq(factor * 10):
		34	yield f
		35
		36	def nav(**map):
		37	l = []
		38	last = 0
		39	for f in seq(1, pagelen):
		40	if f < pagelen or f <= last:
		41	continue
		42	if f > limit:
		43	break
		44	last = f
		45	if pos + f < limit:
		46	l.append(("+%d" % f, hex(nodefunc(pos + f).node())))
		47	if pos - f >= 0:
		48	l.insert(0, ("-%d" % f, hex(nodefunc(pos - f).node())))
		49
		50	try:
		51	yield {"label": "(0)", "node": hex(nodefunc('0').node())}
		52
		53	for label, node in l:
		54	yield {"label": label, "node": node}
		55
		56	yield {"label": "tip", "node": "tip"}
		57	except RepoError:
		58	pass
		59
		60	return nav
		61
		62	def siblings(siblings=[], hiderev=None, **args):
		63	siblings = [s for s in siblings if s.node() != nullid]
		64	if len(siblings) == 1 and siblings[0].rev() == hiderev:
		65	return
		66	for s in siblings:
		67	d = {'node': hex(s.node()), 'rev': s.rev()}
		68	if hasattr(s, 'path'):
		69	d['file'] = s.path()
		70	d.update(args)
		71	yield d
		72
		73	def renamelink(fctx):
		74	r = fctx.renamed()
		75	if r:
		76	return [dict(file=r[0], node=hex(r[1]))]
		77	return []
		78
		79	def nodetagsdict(repo, node):
		80	return [{"name": i} for i in repo.nodetags(node)]
		81
		82	def nodebranchdict(repo, ctx):
		83	branches = []
		84	branch = ctx.branch()
		85	# If this is an empty repo, ctx.node() == nullid,
		86	# ctx.branch() == 'default', but branchtags() is
		87	# an empty dict. Using dict.get avoids a traceback.
		88	if repo.branchtags().get(branch) == ctx.node():
		89	branches.append({"name": branch})
		90	return branches
		91
		92	def nodeinbranch(repo, ctx):
		93	branches = []
		94	branch = ctx.branch()
		95	if branch != 'default' and repo.branchtags().get(branch) != ctx.node():
		96	branches.append({"name": branch})
		97	return branches
		98
		99	def nodebranchnodefault(ctx):
		100	branches = []
		101	branch = ctx.branch()
		102	if branch != 'default':
		103	branches.append({"name": branch})
		104	return branches
		105
		106	def showtag(repo, tmpl, t1, node=nullid, **args):
		107	for t in repo.nodetags(node):
		108	yield tmpl(t1, tag=t, **args)
		109
		110	def cleanpath(repo, path):
		111	path = path.lstrip('/')
		112	return util.canonpath(repo.root, '', path)
		113
		114	def changectx(repo, req):
		115	changeid = "tip"
		116	if 'node' in req.form:
		117	changeid = req.form['node'][0]
		118	elif 'manifest' in req.form:
		119	changeid = req.form['manifest'][0]
		120
		121	try:
		122	ctx = repo[changeid]
		123	except RepoError:
		124	man = repo.manifest
		125	ctx = repo[man.linkrev(man.lookup(changeid))]
		126
		127	return ctx
		128
		129	def filectx(repo, req):
		130	path = cleanpath(repo, req.form['file'][0])
		131	if 'node' in req.form:
		132	changeid = req.form['node'][0]
		133	else:
		134	changeid = req.form['filenode'][0]
		135	try:
		136	fctx = repo[changeid][path]
		137	except RepoError:
		138	fctx = repo.filectx(path, fileid=changeid)
		139
		140	return fctx

mercurial/match.py

0 created 644 +47 0

			@@ -0,0 +1,47
		1	import util
		2
		3	class _match(object):
		4	def __init__(self, root, cwd, files, mf, ap):
		5	self._root = root
		6	self._cwd = cwd
		7	self._files = files
		8	self._fmap = dict.fromkeys(files)
		9	self.matchfn = mf
		10	self._anypats = ap
		11	def __call__(self, fn):
		12	return self.matchfn(fn)
		13	def __iter__(self):
		14	for f in self._files:
		15	yield f
		16	def bad(self, f, msg):
		17	return True
		18	def dir(self, f):
		19	pass
		20	def missing(self, f):
		21	pass
		22	def exact(self, f):
		23	return f in self._fmap
		24	def rel(self, f):
		25	return util.pathto(self._root, self._cwd, f)
		26	def files(self):
		27	return self._files
		28	def anypats(self):
		29	return self._anypats
		30
		31	class always(_match):
		32	def __init__(self, root, cwd):
		33	_match.__init__(self, root, cwd, [], lambda f: True, False)
		34
		35	class never(_match):
		36	def __init__(self, root, cwd):
		37	_match.__init__(self, root, cwd, [], lambda f: False, False)
		38
		39	class exact(_match):
		40	def __init__(self, root, cwd, files):
		41	_match.__init__(self, root, cwd, files, lambda f: f in files, False)
		42
		43	class match(_match):
		44	def __init__(self, root, cwd, patterns, include, exclude, default):
		45	f, mf, ap = util.matcher(root, cwd, patterns, include, exclude,
		46	None, default)
		47	_match.__init__(self, root, cwd, f, mf, ap)

mercurial/parsers.c

0 created 644 +169 0

			@@ -0,0 +1,169
		1	/*
		2	parsers.c - efficient content parsing
		3
		4	Copyright 2008 Matt Mackall <mpm@selenic.com> and others
		5
		6	This software may be used and distributed according to the terms of
		7	the GNU General Public License, incorporated herein by reference.
		8	*/
		9
		10	#include <Python.h>
		11	#include <ctype.h>
		12	#include <string.h>
		13
		14	static int hexdigit(char c)
		15	{
		16	if (c >= '0' && c <= '9')
		17	return c - '0';
		18
		19	if (c >= 'A' && c <= 'F')
		20	return c - 'A' + 10;
		21
		22	if (c >= 'a' && c <= 'f')
		23	return c - 'a' + 10;
		24
		25	return -1;
		26	}
		27
		28	/*
		29	* Turn a hex-encoded string into binary.
		30	*/
		31	static PyObject unhexlify(const char str, int len)
		32	{
		33	PyObject *ret = NULL;
		34	const char *c;
		35	char *d;
		36
		37	if (len % 2) {
		38	PyErr_SetString(PyExc_ValueError,
		39	"input is not even in length");
		40	goto bail;
		41	}
		42
		43	ret = PyString_FromStringAndSize(NULL, len / 2);
		44	if (!ret)
		45	goto bail;
		46
		47	d = PyString_AsString(ret);
		48	if (!d)
		49	goto bail;
		50
		51	for (c = str; c < str + len;) {
		52	int hi = hexdigit(*c++);
		53	int lo = hexdigit(*c++);
		54
		55	if (hi == -1 \|\| lo == -1) {
		56	PyErr_SetString(PyExc_ValueError,
		57	"input contains non-hex character");
		58	goto bail;
		59	}
		60
		61	*d++ = (hi << 4) \| lo;
		62	}
		63
		64	goto done;
		65
		66	bail:
		67	Py_XDECREF(ret);
		68	ret = NULL;
		69	done:
		70	return ret;
		71	}
		72
		73	/*
		74	* This code assumes that a manifest is stitched together with newline
		75	* ('\n') characters.
		76	*/
		77	static PyObject parse_manifest(PyObject self, PyObject *args)
		78	{
		79	PyObject mfdict, fdict;
		80	char str, cur, start, zero;
		81	int len;
		82
		83	if (!PyArg_ParseTuple(args, "O!O!s#:parse_manifest",
		84	&PyDict_Type, &mfdict,
		85	&PyDict_Type, &fdict,
		86	&str, &len))
		87	goto quit;
		88
		89	for (start = cur = str, zero = NULL; cur < str + len; cur++) {
		90	PyObject file = NULL, node = NULL;
		91	PyObject *flags = NULL;
		92	int nlen;
		93
		94	if (!*cur) {
		95	zero = cur;
		96	continue;
		97	}
		98	else if (*cur != '\n')
		99	continue;
		100
		101	if (!zero) {
		102	PyErr_SetString(PyExc_ValueError,
		103	"manifest entry has no separator");
		104	goto quit;
		105	}
		106
		107	file = PyString_FromStringAndSize(start, zero - start);
		108	if (!file)
		109	goto bail;
		110
		111	nlen = cur - zero - 1;
		112
		113	node = unhexlify(zero + 1, nlen > 40 ? 40 : nlen);
		114	if (!node)
		115	goto bail;
		116
		117	if (nlen > 40) {
		118	PyObject *flags;
		119
		120	flags = PyString_FromStringAndSize(zero + 41,
		121	nlen - 40);
		122	if (!flags)
		123	goto bail;
		124
		125	if (PyDict_SetItem(fdict, file, flags) == -1)
		126	goto bail;
		127	}
		128
		129	if (PyDict_SetItem(mfdict, file, node) == -1)
		130	goto bail;
		131
		132	start = cur + 1;
		133	zero = NULL;
		134
		135	Py_XDECREF(flags);
		136	Py_XDECREF(node);
		137	Py_XDECREF(file);
		138	continue;
		139	bail:
		140	Py_XDECREF(flags);
		141	Py_XDECREF(node);
		142	Py_XDECREF(file);
		143	goto quit;
		144	}
		145
		146	if (len > 0 && *(cur - 1) != '\n') {
		147	PyErr_SetString(PyExc_ValueError,
		148	"manifest contains trailing garbage");
		149	goto quit;
		150	}
		151
		152	Py_INCREF(Py_None);
		153	return Py_None;
		154
		155	quit:
		156	return NULL;
		157	}
		158
		159	static char parsers_doc[] = "Efficient content parsing.";
		160
		161	static PyMethodDef methods[] = {
		162	{"parse_manifest", parse_manifest, METH_VARARGS, "parse a manifest\n"},
		163	{NULL, NULL}
		164	};
		165
		166	PyMODINIT_FUNC initparsers(void)
		167	{
		168	Py_InitModule3("parsers", methods, parsers_doc);
		169	}

mercurial/store.py

0 created 644 +125 0

			@@ -0,0 +1,125
		1	# store.py - repository store handling for Mercurial
		2	#
		3	# Copyright 2008 Matt Mackall <mpm@selenic.com>
		4	#
		5	# This software may be used and distributed according to the terms
		6	# of the GNU General Public License, incorporated herein by reference.
		7
		8	import os, stat, osutil, util
		9
		10	def _buildencodefun():
		11	e = '_'
		12	win_reserved = [ord(x) for x in '\\:*?"<>\|']
		13	cmap = dict([ (chr(x), chr(x)) for x in xrange(127) ])
		14	for x in (range(32) + range(126, 256) + win_reserved):
		15	cmap[chr(x)] = "~%02x" % x
		16	for x in range(ord("A"), ord("Z")+1) + [ord(e)]:
		17	cmap[chr(x)] = e + chr(x).lower()
		18	dmap = {}
		19	for k, v in cmap.iteritems():
		20	dmap[v] = k
		21	def decode(s):
		22	i = 0
		23	while i < len(s):
		24	for l in xrange(1, 4):
		25	try:
		26	yield dmap[s[i:i+l]]
		27	i += l
		28	break
		29	except KeyError:
		30	pass
		31	else:
		32	raise KeyError
		33	return (lambda s: "".join([cmap[c] for c in s]),
		34	lambda s: "".join(list(decode(s))))
		35
		36	encodefilename, decodefilename = _buildencodefun()
		37
		38	def _dirwalk(path, recurse):
		39	'''yields (filename, size)'''
		40	for e, kind, st in osutil.listdir(path, stat=True):
		41	pe = os.path.join(path, e)
		42	if kind == stat.S_IFDIR:
		43	if recurse:
		44	for x in _dirwalk(pe, True):
		45	yield x
		46	elif kind == stat.S_IFREG:
		47	yield pe, st.st_size
		48
		49	class _store:
		50	'''base class for local repository stores'''
		51	def __init__(self, path):
		52	self.path = path
		53	try:
		54	# files in .hg/ will be created using this mode
		55	mode = os.stat(self.path).st_mode
		56	# avoid some useless chmods
		57	if (0777 & ~util._umask) == (0777 & mode):
		58	mode = None
		59	except OSError:
		60	mode = None
		61	self.createmode = mode
		62
		63	def join(self, f):
		64	return os.path.join(self.path, f)
		65
		66	def _revlogfiles(self, relpath='', recurse=False):
		67	'''yields (filename, size)'''
		68	if relpath:
		69	path = os.path.join(self.path, relpath)
		70	else:
		71	path = self.path
		72	striplen = len(self.path) + len(os.sep)
		73	filetypes = ('.d', '.i')
		74	for f, size in _dirwalk(path, recurse):
		75	if (len(f) > 2) and f[-2:] in filetypes:
		76	yield util.pconvert(f[striplen:]), size
		77
		78	def _datafiles(self):
		79	for x in self._revlogfiles('data', True):
		80	yield x
		81
		82	def walk(self):
		83	'''yields (direncoded filename, size)'''
		84	# yield data files first
		85	for x in self._datafiles():
		86	yield x
		87	# yield manifest before changelog
		88	meta = util.sort(self._revlogfiles())
		89	meta.reverse()
		90	for x in meta:
		91	yield x
		92
		93	class directstore(_store):
		94	def __init__(self, path):
		95	_store.__init__(self, path)
		96	self.encodefn = lambda x: x
		97	self.opener = util.opener(self.path)
		98	self.opener.createmode = self.createmode
		99
		100	class encodedstore(_store):
		101	def __init__(self, path):
		102	_store.__init__(self, os.path.join(path, 'store'))
		103	self.encodefn = encodefilename
		104	op = util.opener(self.path)
		105	op.createmode = self.createmode
		106	self.opener = lambda f, args, kw: op(self.encodefn(f), args, **kw)
		107
		108	def _datafiles(self):
		109	for f, size in self._revlogfiles('data', True):
		110	yield decodefilename(f), size
		111
		112	def join(self, f):
		113	return os.path.join(self.path, self.encodefn(f))
		114
		115	def encodefn(requirements):
		116	if 'store' not in requirements:
		117	return lambda x: x
		118	else:
		119	return encodefilename
		120
		121	def store(requirements, path):
		122	if 'store' not in requirements:
		123	return directstore(path)
		124	else:
		125	return encodedstore(path)

templates/coal/changeset.tmpl

0 created 644 +72 0

			@@ -0,0 +1,72
		1	{header}
		2	<title>{repo\|escape}: {node\|short}</title>
		3	</head>
		4	<body>
		5	<div class="container">
		6	<div class="menu">
		7	<div class="logo">
		8	<a href="http://www.selenic.com/mercurial/">
		9	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		10	</div>
		11	<ul>
		12	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		13	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		14	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		15	</ul>
		16	<ul>
		17	<li class="active">changeset</li>
		18	<li><a href="{url}file/{node\|short}{sessionvars%urlparameter}">browse</a></li>
		19	</ul>
		20	<ul>
		21	{archives%archiveentry}</ul>
		22	</ul>
		23	</div>
		24
		25	<div class="main">
		26
		27	<h2>{repo\|escape}</h2>
		28	<h3>changeset {rev}:{node\|short} {changesettag}</h3>
		29
		30	<form class="search" action="{url}log">
		31	{sessionvars%hiddenformentry}
		32	<p><input name="rev" id="search1" type="text" size="30"></p>
		33	</form>
		34
		35	<div class="description">{desc\|strip\|escape\|addbreaks}</div>
		36
		37	<table id="changesetEntry">
		38	<tr>
		39	<th class="author">author</th>
		40	<td class="author">{author\|obfuscate}</td>
		41	</tr>
		42	<tr>
		43	<th class="date">date</th>
		44	<td class="date">{date\|date} ({date\|age} ago)</td></tr>
		45	<tr>
		46	<th class="author">parents</th>
		47	<td class="author">{parent%changesetparent}</td>
		48	</tr>
		49	<tr>
		50	<th class="author">children</th>
		51	<td class="author">{child%changesetchild}</td>
		52	</tr>
		53	<tr>
		54	<th class="files">files</th>
		55	<td class="files">{files}</td></tr>
		56	</tr>
		57	</table>
		58	<tr>
		59
		60	<div class="overflow">
		61	<table class="bigtable">
		62	<tr>
		63	<th class="lineno">line</th>
		64	<th class="source">diff</th>
		65	</tr>
		66	</table>
		67	{diff}
		68	</div>
		69	</div>
		70	{footer}
		71
		72

templates/coal/error.tmpl

0 created 644 +40 0

			@@ -0,0 +1,40
		1	{header}
		2	<title>{repo\|escape}: error</title>
		3	</head>
		4	<body>
		5
		6	<div class="content">
		7	<div class="menu">
		8	<div class="logo">
		9	<a href="http://www.selenic.com/mercurial/">
		10	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		11	</div>
		12	<ul>
		13	<li><a href="{url}log{sessionvars%urlparameter}">log</a></li>
		14	<li><a href="{url}graph{sessionvars%urlparameter}">graph</a></li>
		15	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		16	</ul>
		17	</div>
		18
		19	<div class="main">
		20
		21	<h2>{repo\|escape}</h2>
		22	<h3>error</h3>
		23
		24	<form class="search" action="{url}log">
		25	{sessionvars%hiddenformentry}
		26	<p><input name="rev" id="search1" type="text" size="30"></p>
		27	</form>
		28
		29	<div class="description">
		30	<p>
		31	An error occurred while processing your request:
		32	</p>
		33	<p>
		34	{error\|escape}
		35	</p>
		36	</div>
		37	</div>
		38	</div>
		39
		40	{footer}

templates/coal/fileannotate.tmpl

0 created 644 +77 0

			@@ -0,0 +1,77
		1	{header}
		2	<title>{repo\|escape}: {file\|escape} annotate</title>
		3	</head>
		4	<body>
		5
		6	<div class="container">
		7	<div class="menu">
		8	<div class="logo">
		9	<a href="http://www.selenic.com/mercurial/">
		10	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		11	</div>
		12	<ul>
		13	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		14	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		15	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		16	</ul>
		17
		18	<ul>
		19	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		20	<li><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}">browse</a></li>
		21	</ul>
		22	<ul>
		23	<li><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">file</a></li>
		24	<li><a href="{url}diff/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">diff</a></li>
		25	<li class="active">annotate</li>
		26	<li><a href="{url}log/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">file log</a></li>
		27	<li><a href="{url}raw-annotate/{node\|short}/{file\|urlescape}">raw</a></li>
		28	</ul>
		29	</div>
		30
		31	<div class="main">
		32	<h2>{repo\|escape}</h2>
		33	<h3>annotate {file\|escape} @ {rev}:{node\|short}</h2>
		34
		35	<form class="search" action="{url}log">
		36	{sessionvars%hiddenformentry}
		37	<p><input name="rev" id="search1" type="text" size="30"></p>
		38	</form>
		39
		40	<div class="description">{desc\|strip\|escape\|addbreaks}</div>
		41
		42	<table id="changesetEntry">
		43	<tr>
		44	<th class="author">author</th>
		45	<td class="author">{author\|obfuscate}</td>
		46	</tr>
		47	<tr>
		48	<th class="date">date</th>
		49	<td class="date">{date\|date} ({date\|age} ago)</td>
		50	</tr>
		51	<tr>
		52	<th class="author">parents</th>
		53	<td class="author">{parent%filerevparent}</td>
		54	</tr>
		55	<tr>
		56	<th class="author">children</th>
		57	<td class="author">{child%filerevchild}</td>
		58	</tr>
		59	{changesettag}
		60	</table>
		61
		62	<br/>
		63
		64	<div class="overflow">
		65	<table class="bigtable">
		66	<tr>
		67	<th class="annotate">rev</th>
		68	<th class="lineno">line</th>
		69	<th class="line">source</th>
		70	</tr>
		71	{annotate%annotateline}
		72	</table>
		73	</div>
		74	</div>
		75	</div>
		76
		77	{footer}

templates/coal/filediff.tmpl

0 created 644 +75 0

			@@ -0,0 +1,75
		1	{header}
		2	<title>{repo\|escape}: {file\|escape} diff</title>
		3	</head>
		4	<body>
		5
		6	<div class="container">
		7	<div class="menu">
		8	<div class="logo">
		9	<a href="http://www.selenic.com/mercurial/">
		10	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		11	</div>
		12	<ul>
		13	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		14	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		15	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		16	</ul>
		17	<ul>
		18	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		19	<li><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}">browse</a></li>
		20	</ul>
		21	<ul>
		22	<li><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">file</a></li>
		23	<li class="active">diff</li>
		24	<li><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">annotate</a></li>
		25	<li><a href="{url}log/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">file log</a></li>
		26	<li><a href="{url}raw-file/{node\|short}/{file\|urlescape}">raw</a></li>
		27	</ul>
		28	</div>
		29
		30	<div class="main">
		31	<h2>{repo\|escape}</h2>
		32	<h3>diff {file\|escape} @ {rev}:{node\|short}</h3>
		33
		34	<form class="search" action="{url}log">
		35	{sessionvars%hiddenformentry}
		36	<p><input name="rev" id="search1" type="text" size="30"></p>
		37	</form>
		38
		39	<div class="description">{desc\|strip\|escape\|addbreaks}</div>
		40
		41	<table id="changesetEntry">
		42	<tr>
		43	<th>author</th>
		44	<td>{author\|obfuscate}</td>
		45	</tr>
		46	<tr>
		47	<th>date</th>
		48	<td>{date\|date} ({date\|age} ago)</td>
		49	</tr>
		50	<tr>
		51	<th>parents</th>
		52	<td>{parent%filerevparent}</td>
		53	</tr>
		54	<tr>
		55	<th>children</th>
		56	<td>{child%filerevchild}</td>
		57	</tr>
		58	{changesettag}
		59	</table>
		60
		61	<div class="overflow">
		62	<table class="bigtable">
		63	<tr>
		64	<th class="lineno">line</th>
		65	<th class="source">diff</th>
		66	</tr>
		67	<table>
		68	{diff}
		69	</div>
		70	</div>
		71	</div>
		72
		73	{footer}
		74
		75

templates/coal/filelog.tmpl

0 created 644 +59 0

			@@ -0,0 +1,59
		1	{header}
		2	<title>{repo\|escape}: {file\|escape} history</title>
		3	<link rel="alternate" type="application/atom+xml"
		4	href="{url}atom-log/tip/{file\|urlescape}" title="Atom feed for {repo\|escape}:{file}">
		5	<link rel="alternate" type="application/rss+xml"
		6	href="{url}rss-log/tip/{file\|urlescape}" title="RSS feed for {repo\|escape}:{file}">
		7	</head>
		8	</head>
		9	<body>
		10
		11	<div class="container">
		12	<div class="menu">
		13	<div class="logo">
		14	<a href="http://www.selenic.com/mercurial/">
		15	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		16	</div>
		17	<ul>
		18	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		19	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		20	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		21	</ul>
		22	<ul>
		23	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		24	<li><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}">browse</a></li>
		25	</ul>
		26	<ul>
		27	<li><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">file</a></li>
		28	<li><a href="{url}diff/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">diff</a></li>
		29	<li><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">annotate</a></li>
		30	<li class="active">file log</li>
		31	<li><a href="{url}raw-file/{node\|short}/{file\|urlescape}">raw</a></li>
		32	</ul>
		33	</div>
		34
		35	<div class="main">
		36
		37	<h2>{repo\|escape}</h2>
		38	<h3>log {file\|escape}</h3>
		39
		40	<form class="search" action="{url}log">
		41	{sessionvars%hiddenformentry}
		42	<p><input name="rev" id="search1" type="text" size="30"></p>
		43	</form>
		44
		45	<div class="navigate">{nav%filenaventry}</div>
		46
		47	<table class="bigtable">
		48	<tr>
		49	<th class="age">age</td>
		50	<th class="author">author</td>
		51	<th class="description">description</td>
		52	</tr>
		53	{entries%filelogentry}
		54	</table>
		55
		56	</div>
		57	</div>
		58
		59	{footer}

templates/coal/filelogentry.tmpl

0 created 644 +5 0

			@@ -0,0 +1,5
		1	<tr class="parity{parity}">
		2	<td class="age">{date\|age}</td>
		3	<td class="author">{author\|person}</td>
		4	<td class="description"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{desc\|strip\|firstline\|escape}</a></td>
		5	</tr>

templates/coal/filerevision.tmpl

0 created 644 +74 0

			@@ -0,0 +1,74
		1	{header}
		2	<title>{repo\|escape}: {node\|short} {file\|escape}</title>
		3	</head>
		4	<body>
		5
		6	<div class="container">
		7	<div class="menu">
		8	<div class="logo">
		9	<a href="http://www.selenic.com/mercurial/">
		10	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		11	</div>
		12	<ul>
		13	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		14	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		15	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		16	</ul>
		17	<ul>
		18	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		19	<li><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}">browse</a></li>
		20	</ul>
		21	<ul>
		22	<li class="active">file</li>
		23	<li><a href="{url}diff/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">diff</a></li>
		24	<li><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">annotate</a></li>
		25	<li><a href="{url}log/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">file log</a></li>
		26	<li><a href="{url}raw-file/{node\|short}/{file\|urlescape}">raw</a></li>
		27	</ul>
		28	</div>
		29
		30	<div class="main">
		31
		32	<h2>{repo\|escape}</h2>
		33	<h3>view {file\|escape} @ {rev}:{node\|short}</h3>
		34
		35	<form class="search" action="{url}log">
		36	{sessionvars%hiddenformentry}
		37	<p><input name="rev" id="search1" type="text" size="30"></p>
		38	</form>
		39
		40	<div class="description">{desc\|strip\|escape\|addbreaks}</div>
		41
		42	<table id="changesetEntry">
		43	<tr>
		44	<th class="author">author</th>
		45	<td class="author">{author\|obfuscate}</td>
		46	</tr>
		47	<tr>
		48	<th class="date">date</th>
		49	<td class="date">{date\|date} ({date\|age} ago)</td>
		50	</tr>
		51	<tr>
		52	<th class="author">parents</th>
		53	<td class="author">{parent%filerevparent}</td>
		54	</tr>
		55	<tr>
		56	<th class="author">children</th>
		57	<td class="author">{child%filerevchild}</td>
		58	</tr>
		59	{changesettag}
		60	</table>
		61
		62	<div class="overflow">
		63	<table class="bigtable">
		64	<tr>
		65	<th class="lineno">line</th>
		66	<th class="source">source</th>
		67	</tr>
		68	{text%fileline}
		69	</table>
		70	</div>
		71	</div>
		72	</div>
		73
		74	{footer}

templates/coal/footer.tmpl

0 created 644 +4 0

			@@ -0,0 +1,4
		1	{motd}
		2
		3	</body>
		4	</html>

templates/coal/graph.tmpl

0 created 644 +113 0

			@@ -0,0 +1,113
		1	{header}
		2	<title>{repo\|escape}: revision graph</title>
		3	<link rel="alternate" type="application/atom+xml"
		4	href="{url}atom-log" title="Atom feed for {repo\|escape}: log">
		5	<link rel="alternate" type="application/rss+xml"
		6	href="{url}rss-log" title="RSS feed for {repo\|escape}: log">
		7	<!--[if IE]><script type="text/javascript" src="{staticurl}excanvas.js"></script><![endif]-->
		8	</head>
		9	<body>
		10
		11	<div class="container">
		12	<div class="menu">
		13	<div class="logo">
		14	<a href="http://www.selenic.com/mercurial/">
		15	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		16	</div>
		17	<ul>
		18	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		19	<li class="active">graph</li>
		20	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		21	</ul>
		22	<ul>
		23	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		24	<li><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}">browse</a></li>
		25	</ul>
		26	</div>
		27
		28	<div class="main">
		29	<h2>{repo\|escape}</h2>
		30	<h3>graph</h3>
		31
		32	<form class="search" action="{url}log">
		33	{sessionvars%hiddenformentry}
		34	<p><input name="rev" id="search1" type="text" size="30"></p>
		35	</form>
		36
		37	<div class="navigate">
		38	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountless}">less</a>
		39	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountmore}">more</a>
		40	\| {changenav%navgraphentry}
		41	</div>
		42
		43	<div id="noscript">The revision graph only works with JavaScript-enabled browsers.</div>
		44
		45	<div id="wrapper">
		46	<ul id="nodebgs"></ul>
		47	<canvas id="graph" width="224" height="{canvasheight}"></canvas>
		48	<ul id="graphnodes"></ul>
		49	</div>
		50
		51	<script type="text/javascript" src="{staticurl}graph.js"></script>
		52	<script>
		53	<!-- hide script content
		54
		55	document.getElementById('noscript').style.display = 'none';
		56
		57	var data = {jsdata\|json};
		58	var graph = new Graph();
		59	graph.scale({bg_height});
		60
		61	graph.edge = function(x0, y0, x1, y1, color) {
		62
		63	this.setColor(color, 0.0, 0.65);
		64	this.ctx.beginPath();
		65	this.ctx.moveTo(x0, y0);
		66	this.ctx.lineTo(x1, y1);
		67	this.ctx.stroke();
		68
		69	}
		70
		71	var revlink = '<li style="_STYLE"><span class="desc">';
		72	revlink += '<a href="{url}rev/_NODEID{sessionvars%urlparameter}" title="_NODEID">_DESC</a>';
		73	revlink += '</span><span class="tag">_TAGS</span>';
		74	revlink += '<span class="info">_DATE ago, by _USER</span></li>';
		75
		76	graph.vertex = function(x, y, color, parity, cur) {
		77
		78	this.ctx.beginPath();
		79	color = this.setColor(color, 0.25, 0.75);
		80	this.ctx.arc(x, y, radius, 0, Math.PI * 2, true);
		81	this.ctx.fill();
		82
		83	var bg = '<li class="bg parity' + parity + '"></li>';
		84	var left = (this.columns + 1) * this.bg_height;
		85	var nstyle = 'padding-left: ' + left + 'px;';
		86	var item = revlink.replace(/_STYLE/, nstyle);
		87	item = item.replace(/_PARITY/, 'parity' + parity);
		88	item = item.replace(/_NODEID/, cur[0]);
		89	item = item.replace(/_NODEID/, cur[0]);
		90	item = item.replace(/_DESC/, cur[3]);
		91	item = item.replace(/_USER/, cur[4]);
		92	item = item.replace(/_DATE/, cur[5]);
		93	item = item.replace(/_TAGS/, cur[7].join('  '));
		94
		95	return [bg, item];
		96
		97	}
		98
		99	graph.render(data);
		100
		101	// stop hiding script -->
		102	</script>
		103
		104	<div class="navigate">
		105	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountless}">less</a>
		106	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountmore}">more</a>
		107	\| {changenav%navgraphentry}
		108	</div>
		109
		110	</div>
		111	</div>
		112
		113	{footer}

templates/coal/header.tmpl

0 created 644 +7 0

			@@ -0,0 +1,7
		1	<!-- quirksmode -->
		2	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
		3	<html>
		4	<head>
		5	<link rel="icon" href="{staticurl}hgicon.png" type="image/png">
		6	<meta name="robots" content="index, nofollow" />
		7	<link rel="stylesheet" href="{staticurl}style-coal.css" type="text/css" />

templates/coal/index.tmpl

0 created 644 +26 0

			@@ -0,0 +1,26
		1	{header}
		2	<title>Mercurial repositories index</title>
		3	</head>
		4	<body>
		5
		6	<div class="container">
		7	<div class="menu">
		8	<a href="http://www.selenic.com/mercurial/">
		9	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		10	</div>
		11	<div class="main">
		12	<h2>Mercurial Repositories</h2>
		13
		14	<table class="bigtable">
		15	<tr>
		16	<th><a href="?sort={sort_name}">Name</a></th>
		17	<th><a href="?sort={sort_description}">Description</a></th>
		18	<th><a href="?sort={sort_contact}">Contact</a></th>
		19	<th><a href="?sort={sort_lastchange}">Last change</a></th>
		20	<th> </th>
		21	<tr>
		22	{entries%indexentry}
		23	</table>
		24	</div>
		25	</div>
		26	{footer}

templates/coal/manifest.tmpl

0 created 644 +52 0

			@@ -0,0 +1,52
		1	{header}
		2	<title>{repo\|escape}: {node\|short} {path\|escape}</title>
		3	</head>
		4	<body>
		5
		6	<div class="container">
		7	<div class="menu">
		8	<div class="logo">
		9	<a href="http://www.selenic.com/mercurial/">
		10	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		11	</div>
		12	<ul>
		13	<li><a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">log</a></li>
		14	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		15	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		16	</ul>
		17	<ul>
		18	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		19	<li class="active">browse</li>
		20	</ul>
		21	<ul>
		22	{archives%archiveentry}
		23	</ul>
		24	</div>
		25
		26	<div class="main">
		27
		28	<h2>{repo\|escape}</h2>
		29	<h3>directory {path\|escape} @ {rev}:{node\|short} {tags%changelogtag}</h3>
		30
		31	<form class="search" action="{url}log">
		32	{sessionvars%hiddenformentry}
		33	<p><input name="rev" id="search1" type="text" size="30"></p>
		34	</form>
		35
		36	<table class="bigtable">
		37	<tr>
		38	<th class="name">name</th>
		39	<th class="size">size</th>
		40	<th class="permissions">permissions</th>
		41	</tr>
		42	<tr class="fileline parity{upparity}">
		43	<td class="name"><a href="{url}file/{node\|short}{up\|urlescape}{sessionvars%urlparameter}">[up]</a></td>
		44	<td class="size"></td>
		45	<td class="permissions">drwxr-xr-x</td>
		46	</tr>
		47	{dentries%direntry}
		48	{fentries%fileentry}
		49	</table>
		50	</div>
		51	</div>
		52	{footer}

templates/coal/map

0 created 644 +71 0

			@@ -0,0 +1,71
		1	default = 'shortlog'
		2
		3	mimetype = 'text/html; charset={encoding}'
		4	header = header.tmpl
		5	footer = footer.tmpl
		6	search = search.tmpl
		7
		8	changelog = shortlog.tmpl
		9	shortlog = shortlog.tmpl
		10	shortlogentry = shortlogentry.tmpl
		11	graph = graph.tmpl
		12
		13	naventry = '<a href="{url}log/{node\|short}{sessionvars%urlparameter}">{label\|escape}</a> '
		14	navshortentry = '<a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">{label\|escape}</a> '
		15	navgraphentry = '<a href="{url}graph/{node\|short}{sessionvars%urlparameter}">{label\|escape}</a> '
		16	filenaventry = '<a href="{url}log/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{label\|escape}</a> '
		17	filedifflink = '<a href="{url}diff/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{file\|escape}</a> '
		18	filenodelink = '<a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{file\|escape}</a> '
		19	fileellipses = '...'
		20	changelogentry = shortlogentry.tmpl
		21	searchentry = shortlogentry.tmpl
		22	changeset = changeset.tmpl
		23	manifest = manifest.tmpl
		24
		25	direntry = '<tr class="fileline parity{parity}"><td class="name"><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}"><img src="{staticurl}coal-folder.png"> {basename\|escape}/</a><td class="size"></td><td class="permissions">drwxr-xr-x</td></tr>'
		26	fileentry = '<tr class="fileline parity{parity}"><td class="filename"><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}#l1"><img src="{staticurl}coal-file.png"> {basename\|escape}</a></td><td class="size">{size}</td><td class="permissions">{permissions\|permissions}</td></tr>'
		27
		28	filerevision = filerevision.tmpl
		29	fileannotate = fileannotate.tmpl
		30	filediff = filediff.tmpl
		31	filelog = filelog.tmpl
		32	fileline = '<tr class="parity{parity}"><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source">{line\|escape}</td></tr>'
		33	filelogentry = filelogentry.tmpl
		34
		35	annotateline = '<tr class="parity{parity}"><td class="annotate"><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}#{targetline}" title="{node\|short}: {desc\|escape\|firstline}">{author\|user}@{rev}</a></td><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source">{line\|escape}</td></tr>'
		36
		37	diffblock = '<table class="bigtable parity{parity}">{lines}</table>'
		38	difflineplus = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source plusline">{line\|escape}</td></tr>'
		39	difflineminus = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source minusline">{line\|escape}</td></tr>'
		40	difflineat = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source atline">{line\|escape}</td></tr>'
		41	diffline = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source">{line\|escape}</td></tr>'
		42
		43	changelogparent = '<tr><th class="parent">parent {rev}:</th><td class="parent"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		44
		45	changesetparent = '<a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a> '
		46
		47	filerevparent = '<a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{rename%filerename}{node\|short}</a> '
		48	filerevchild = '<a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a> '
		49
		50	filerename = '{file\|escape}@'
		51	filelogrename = '<tr><th>base:</th><td><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{file\|escape}@{node\|short}</a></td></tr>'
		52	fileannotateparent = '<tr><td class="metatag">parent:</td><td><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{rename%filerename}{node\|short}</a></td></tr>'
		53	changesetchild = '<a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a>'
		54	changelogchild = '<tr><th class="child">child</th><td class="child"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		55	fileannotatechild = '<tr><td class="metatag">child:</td><td><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		56	tags = tags.tmpl
		57	tagentry = '<tr class="tagEntry parity{parity}"><td><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{tag\|escape}</a></td><td class="node">{node\|short}</td></tr>'
		58	changelogtag = '<span class="tag">{name\|escape}</span> '
		59	changesettag = '<span class="tag">{tag\|escape}</span> '
		60	filediffparent = '<tr><th class="parent">parent {rev}:</th><td class="parent"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		61	filelogparent = '<tr><th>parent {rev}:</th><td><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		62	filediffchild = '<tr><th class="child">child {rev}:</th><td class="child"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		63	filelogchild = '<tr><th>child {rev}:</th><td><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		64	indexentry = '<tr class="parity{parity}"><td><a href="{url}{sessionvars%urlparameter}">{name\|escape}</a></td><td>{description}</td><td>{contact\|obfuscate}</td><td class="age">{lastchange\|age} ago</td><td class="indexlinks">{archives%indexarchiveentry}</td></tr>\n'
		65	indexarchiveentry = '<a href="{url}archive/{node\|short}{extension\|urlescape}"> ↓{type\|escape}</a>'
		66	index = index.tmpl
		67	archiveentry = '<li><a href="{url}archive/{node\|short}{extension\|urlescape}">{type\|escape}</a></li>'
		68	notfound = notfound.tmpl
		69	error = error.tmpl
		70	urlparameter = '{separator}{name}={value\|urlescape}'
		71	hiddenformentry = '<input type="hidden" name="{name}" value="{value\|escape}" />'

templates/coal/notfound.tmpl

0 created 644 +12 0

			@@ -0,0 +1,12
		1	{header}
		2	<title>Mercurial repository not found</title>
		3	</head>
		4	<body>
		5
		6	<h2>Mercurial repository not found</h2>
		7
		8	The specified repository "{repo\|escape}" is unknown, sorry.
		9
		10	Please go back to the main repository list page.
		11
		12	{footer}

templates/coal/search.tmpl

0 created 644 +41 0

			@@ -0,0 +1,41
		1	{header}
		2	<title>{repo\|escape}: searching for {query\|escape}</title>
		3	</head>
		4	<body>
		5
		6	<div class="container">
		7	<div class="menu">
		8	<div class="logo">
		9	<a href="http://www.selenic.com/mercurial/">
		10	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		11	</div>
		12	<ul>
		13	<li><a href="{url}shortlog{sessionvars%urlparameter}">log</a></li>
		14	<li><a href="{url}graph{sessionvars%urlparameter}">graph</a></li>
		15	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		16	</ul>
		17	</div>
		18
		19	<div class="main">
		20
		21	<h2>{repo\|escape}</h2>
		22	<h3>searching for '{query\|escape}'</h3>
		23
		24	<form class="search" action="{url}log">
		25	{sessionvars%hiddenformentry}
		26	<p><input name="rev" id="search1" type="text" size="30"></p>
		27	</form>
		28
		29	<table class="bigtable">
		30	<tr>
		31	<th class="age">age</td>
		32	<th class="author">author</td>
		33	<th class="description">description</td>
		34	</tr>
		35	{entries}
		36	</table>
		37
		38	</div>
		39	</div>
		40
		41	{footer}

templates/coal/shortlog.tmpl

0 created 644 +55 0

			@@ -0,0 +1,55
		1	{header}
		2	<title>{repo\|escape}: log</title>
		3	<link rel="alternate" type="application/atom+xml"
		4	href="{url}atom-log" title="Atom feed for {repo\|escape}">
		5	<link rel="alternate" type="application/rss+xml"
		6	href="{url}rss-log" title="RSS feed for {repo\|escape}">
		7	</head>
		8	<body>
		9
		10	<div class="container">
		11	<div class="menu">
		12	<div class="logo">
		13	<a href="http://www.selenic.com/mercurial/">
		14	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		15	</div>
		16	<ul>
		17	<li class="active">log</li>
		18	<li><a href="{url}graph/{node\|short}{sessionvars%urlparameter}">graph</a></li>
		19	<li><a href="{url}tags{sessionvars%urlparameter}">tags</a></li>
		20	</ul>
		21	<ul>
		22	<li><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">changeset</a></li>
		23	<li><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}">browse</a></li>
		24	</ul>
		25	<ul>
		26	{archives%archiveentry}
		27	</ul>
		28	</div>
		29
		30	<div class="main">
		31
		32	<h2>{repo\|escape}</h2>
		33	<h3>log</h3>
		34
		35	<form class="search" action="{url}log">
		36	{sessionvars%hiddenformentry}
		37	<p><input name="rev" id="search1" type="text" size="30"></p>
		38	</form>
		39
		40	<div class="navigate">rev {rev}: {changenav%navshortentry}</div>
		41
		42	<table class="bigtable">
		43	<tr>
		44	<th class="age">age</td>
		45	<th class="author">author</td>
		46	<th class="description">description</td>
		47	</tr>
		48	{entries%shortlogentry}
		49	</table>
		50
		51	<div class="navigate">rev {rev}: {changenav%navshortentry}</div>
		52	</div>
		53	</div>
		54
		55	{footer}

templates/coal/shortlogentry.tmpl

0 created 644 +5 0

			@@ -0,0 +1,5
		1	<tr class="parity{parity}">
		2	<td class="age">{date\|age}</td>
		3	<td class="author">{author\|person}</td>
		4	<td class="description"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{desc\|strip\|firstline\|escape}</a>{tags%changelogtag}</td>
		5	</tr>

templates/coal/tags.tmpl

0 created 644 +42 0

			@@ -0,0 +1,42
		1	{header}
		2	<title>{repo\|escape}: tags</title>
		3	<link rel="alternate" type="application/atom+xml"
		4	href="{url}atom-tags" title="Atom feed for {repo\|escape}: tags">
		5	<link rel="alternate" type="application/rss+xml"
		6	href="{url}rss-tags" title="RSS feed for {repo\|escape}: tags">
		7	</head>
		8	<body>
		9
		10	<div class="container">
		11	<div class="menu">
		12	<div class="logo">
		13	<a href="http://www.selenic.com/mercurial/">
		14	<img src="{staticurl}hglogo.png" width=75 height=90 border=0 alt="mercurial"></a>
		15	</div>
		16	<ul>
		17	<li><a href="{url}shortlog{sessionvars%urlparameter}">log</a></li>
		18	<li><a href="{url}graph{sessionvars%urlparameter}">graph</a></li>
		19	<li class="active">tags</li>
		20	</ul>
		21	</div>
		22
		23	<div class="main">
		24	<h2>{repo\|escape}</h2>
		25	<h3>tags</h3>
		26
		27	<form class="search" action="{url}log">
		28	{sessionvars%hiddenformentry}
		29	<p><input name="rev" id="search1" type="text" size="30"></p>
		30	</form>
		31
		32	<table class="bigtable">
		33	<tr>
		34	<th>tag</th>
		35	<th>node</th>
		36	</tr>
		37	{entries%tagentry}
		38	</table>
		39	</div>
		40	</div>
		41
		42	{footer}

templates/gitweb/graph.tmpl

0 created 644 +121 0

			@@ -0,0 +1,121
		1	#header#
		2	<title>#repo\|escape#: Graph</title>
		3	<link rel="alternate" type="application/atom+xml"
		4	href="{url}atom-log" title="Atom feed for #repo\|escape#"/>
		5	<link rel="alternate" type="application/rss+xml"
		6	href="{url}rss-log" title="RSS feed for #repo\|escape#"/>
		7	</head>
		8	<body>
		9
		10	<div class="page_header">
		11	<a href="http://www.selenic.com/mercurial/" title="Mercurial" style="float: right;">Mercurial</a><a href="{url}summary{sessionvars%urlparameter}">#repo\|escape#</a> / graph
		12	</div>
		13
		14	<form action="{url}log">
		15	{sessionvars%hiddenformentry}
		16	<div class="search">
		17	<input type="text" name="rev" />
		18	</div>
		19	</form>
		20	<div class="page_nav">
		21	<a href="{url}summary{sessionvars%urlparameter}">summary</a> \|
		22	<a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> \|
		23	<a href="{url}log/#rev#{sessionvars%urlparameter}">changelog</a> \|
		24	graph \|
		25	<a href="{url}tags{sessionvars%urlparameter}">tags</a> \|
		26	<a href="{url}file/#node\|short#{sessionvars%urlparameter}">files</a>
		27	<br/>
		28	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountless}">less</a>
		29	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountmore}">more</a>
		30	\| #changenav%navgraphentry#<br/>
		31	</div>
		32
		33	<div class="title"> </div>
		34
		35	<div id="noscript">The revision graph only works with JavaScript-enabled browsers.</div>
		36
		37	<div id="wrapper">
		38	<ul id="nodebgs"></ul>
		39	<canvas id="graph" width="224" height="#canvasheight#"></canvas>
		40	<ul id="graphnodes"></ul>
		41	</div>
		42
		43	<script type="text/javascript" src="#staticurl#graph.js"></script>
		44	<script>
		45	<!-- hide script content
		46
		47	document.getElementById('noscript').style.display = 'none';
		48
		49	var data = {jsdata\|json};
		50	var graph = new Graph();
		51	graph.scale({bg_height});
		52
		53	graph.edge = function(x0, y0, x1, y1, color) {
		54
		55	this.setColor(color, 0.0, 0.65);
		56	this.ctx.beginPath();
		57	this.ctx.moveTo(x0, y0);
		58	this.ctx.lineTo(x1, y1);
		59	this.ctx.stroke();
		60
		61	}
		62
		63	var revlink = '<li style="_STYLE"><span class="desc">';
		64	revlink += '<a class="list" href="{url}rev/_NODEID{sessionvars%urlparameter}" title="_NODEID"><b>_DESC</b></a>';
		65	revlink += '</span> _TAGS';
		66	revlink += '<span class="info">_DATE ago, by _USER</span></li>';
		67
		68	graph.vertex = function(x, y, color, parity, cur) {
		69
		70	this.ctx.beginPath();
		71	color = this.setColor(color, 0.25, 0.75);
		72	this.ctx.arc(x, y, radius, 0, Math.PI * 2, true);
		73	this.ctx.fill();
		74
		75	var bg = '<li class="bg parity' + parity + '"></li>';
		76	var left = (this.columns + 1) * this.bg_height;
		77	var nstyle = 'padding-left: ' + left + 'px;';
		78	var item = revlink.replace(/_STYLE/, nstyle);
		79	item = item.replace(/_PARITY/, 'parity' + parity);
		80	item = item.replace(/_NODEID/, cur[0]);
		81	item = item.replace(/_NODEID/, cur[0]);
		82	item = item.replace(/_DESC/, cur[3]);
		83	item = item.replace(/_USER/, cur[4]);
		84	item = item.replace(/_DATE/, cur[5]);
		85
		86	var tagspan = '';
		87	if (cur[7].length \|\| (cur[6][0] != 'default' \|\| cur[6][1])) {
		88	tagspan = '<span class="logtags">';
		89	if (cur[6][1]) {
		90	tagspan += '<span class="branchtag" title="' + cur[6][0] + '">';
		91	tagspan += cur[6][0] + '</span> ';
		92	} else if (!cur[6][1] && cur[6][0] != 'default') {
		93	tagspan += '<span class="inbranchtag" title="' + cur[6][0] + '">';
		94	tagspan += cur[6][0] + '</span> ';
		95	}
		96	if (cur[7].length) {
		97	for (var t in cur[7]) {
		98	var tag = cur[7][t];
		99	tagspan += '<span class="tagtag">' + tag + '</span> ';
		100	}
		101	}
		102	tagspan += '</span>';
		103	}
		104
		105	item = item.replace(/_TAGS/, tagspan);
		106	return [bg, item];
		107
		108	}
		109
		110	graph.render(data);
		111
		112	// stop hiding script -->
		113	</script>
		114
		115	<div class="page_nav">
		116	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountless}">less</a>
		117	<a href="{url}graph/{uprev}{sessionvars%urlparameter}?revcount={revcountmore}">more</a>
		118	\| {changenav%navgraphentry}
		119	</div>
		120
		121	#footer#

templates/graph.tmpl

0 created 644 +97 0

			@@ -0,0 +1,97
		1	#header#
		2	<title>#repo\|escape#: graph</title>
		3	<link rel="alternate" type="application/atom+xml"
		4	href="#url#atom-tags" title="Atom feed for #repo\|escape#: tags">
		5	<link rel="alternate" type="application/rss+xml"
		6	href="#url#rss-tags" title="RSS feed for #repo\|escape#: tags">
		7	<!--[if IE]><script type="text/javascript" src="#staticurl#excanvas.js"></script><![endif]-->
		8	</head>
		9	<body>
		10
		11	<div class="buttons">
		12	<a href="#url#log{sessionvars%urlparameter}">changelog</a>
		13	<a href="#url#shortlog{sessionvars%urlparameter}">shortlog</a>
		14	<a href="#url#tags{sessionvars%urlparameter}">tags</a>
		15	<a href="#url#file/#node\|short#/{sessionvars%urlparameter}">files</a>
		16	</div>
		17
		18	<h2>graph</h2>
		19
		20	<form action="#url#log">
		21	{sessionvars%hiddenformentry}
		22	<p>
		23	<label for="search1">search:</label>
		24	<input name="rev" id="search1" type="text" size="30">
		25	navigate: <small class="navigate">#changenav%navgraphentry#</small>
		26	</p>
		27	</form>
		28
		29	<div id="noscript">The revision graph only works with JavaScript-enabled browsers.</div>
		30
		31	<div id="wrapper">
		32	<ul id="nodebgs"></ul>
		33	<canvas id="graph" width="224" height="#canvasheight#"></canvas>
		34	<ul id="graphnodes"></ul>
		35	</div>
		36
		37	<script type="text/javascript" src="#staticurl#graph.js"></script>
		38	<script>
		39	<!-- hide script content
		40
		41	document.getElementById('noscript').style.display = 'none';
		42
		43	var data = {jsdata\|json};
		44	var graph = new Graph();
		45	graph.scale({bg_height});
		46
		47	graph.edge = function(x0, y0, x1, y1, color) {
		48
		49	this.setColor(color, 0.0, 0.65);
		50	this.ctx.beginPath();
		51	this.ctx.moveTo(x0, y0);
		52	this.ctx.lineTo(x1, y1);
		53	this.ctx.stroke();
		54
		55	}
		56
		57	var revlink = '<li style="_STYLE"><span class="desc">';
		58	revlink += '<a href="{url}rev/_NODEID{sessionvars%urlparameter}" title="_NODEID">_DESC</a>';
		59	revlink += '</span><span class="info">_DATE ago, by _USER</span></li>';
		60
		61	graph.vertex = function(x, y, color, parity, cur) {
		62
		63	this.ctx.beginPath();
		64	color = this.setColor(color, 0.25, 0.75);
		65	this.ctx.arc(x, y, radius, 0, Math.PI * 2, true);
		66	this.ctx.fill();
		67
		68	var bg = '<li class="bg parity' + parity + '"></li>';
		69	var left = (this.columns + 1) * this.bg_height;
		70	var nstyle = 'padding-left: ' + left + 'px;';
		71	var item = revlink.replace(/_STYLE/, nstyle);
		72	item = item.replace(/_PARITY/, 'parity' + parity);
		73	item = item.replace(/_NODEID/, cur[0]);
		74	item = item.replace(/_NODEID/, cur[0]);
		75	item = item.replace(/_DESC/, cur[3]);
		76	item = item.replace(/_USER/, cur[4]);
		77	item = item.replace(/_DATE/, cur[5]);
		78
		79	return [bg, item];
		80
		81	}
		82
		83	graph.render(data);
		84
		85	// stop hiding script -->
		86	</script>
		87
		88	<form action="#url#log">
		89	{sessionvars%hiddenformentry}
		90	<p>
		91	<label for="search1">search:</label>
		92	<input name="rev" id="search1" type="text" size="30">
		93	navigate: <small class="navigate">#changenav%navgraphentry#</small>
		94	</p>
		95	</form>
		96
		97	#footer#

templates/paper/header.tmpl

0 created 644 +7 0

			@@ -0,0 +1,7
		1	<!-- quirksmode -->
		2	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
		3	<html>
		4	<head>
		5	<link rel="icon" href="{staticurl}hgicon.png" type="image/png">
		6	<meta name="robots" content="index, nofollow" />
		7	<link rel="stylesheet" href="{staticurl}style-paper.css" type="text/css" />

templates/paper/map

0 created 644 +72 0

			@@ -0,0 +1,72
		1	default = 'shortlog'
		2
		3	mimetype = 'text/html; charset={encoding}'
		4	header = header.tmpl
		5	footer = ../coal/footer.tmpl
		6	search = ../coal/search.tmpl
		7
		8	changelog = ../coal/shortlog.tmpl
		9	shortlog = ../coal/shortlog.tmpl
		10	shortlogentry = ../coal/shortlogentry.tmpl
		11	graph = ../coal/graph.tmpl
		12
		13	naventry = '<a href="{url}log/{node\|short}{sessionvars%urlparameter}">{label\|escape}</a> '
		14	navshortentry = '<a href="{url}shortlog/{node\|short}{sessionvars%urlparameter}">{label\|escape}</a> '
		15	navgraphentry = '<a href="{url}graph/{node\|short}{sessionvars%urlparameter}">{label\|escape}</a> '
		16	filenaventry = '<a href="{url}log/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{label\|escape}</a> '
		17	filedifflink = '<a href="{url}diff/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{file\|escape}</a> '
		18	filenodelink = '<a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{file\|escape}</a> '
		19	fileellipses = '...'
		20	changelogentry = ../coal/shortlogentry.tmpl
		21	searchentry = ../coal/shortlogentry.tmpl
		22	changeset = ../coal/changeset.tmpl
		23	manifest = ../coal/manifest.tmpl
		24
		25	direntry = '<tr class="fileline parity{parity}"><td class="name"><a href="{url}file/{node\|short}{path\|urlescape}{sessionvars%urlparameter}"><img src="{staticurl}coal-folder.png"> {basename\|escape}/</a><td class="size"></td><td class="permissions">drwxr-xr-x</td></tr>'
		26	fileentry = '<tr class="fileline parity{parity}"><td clase="filename"><a href="{url}file/{node\|short}/{file\|urlescape}#l1{sessionvars%urlparameter}"><img src="{staticurl}coal-file.png"> {basename\|escape}</a></td><td class="size">{size}</td><td class="permissions">{permissions\|permissions}</td></tr>'
		27
		28	filerevision = ../coal/filerevision.tmpl
		29	fileannotate = ../coal/fileannotate.tmpl
		30	filediff = ../coal/filediff.tmpl
		31	filelog = ../coal/filelog.tmpl
		32	fileline = '<tr class="parity{parity}"><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source">{line\|escape}</td></tr>'
		33	filelogentry = ../coal/filelogentry.tmpl
		34
		35	annotateline = '<tr class="parity{parity}"><td class="annotate"><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}#{targetline}" title="{node\|short}: {desc\|escape\|firstline}">{author\|user}@{rev}</a></td><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source">{line\|escape}</td></tr>'
		36
		37	diffblock = '<table class="bigtable parity{parity}">{lines}</table>'
		38	difflineplus = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source plusline">{line\|escape}</td></tr>'
		39	difflineminus = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source minusline">{line\|escape}</td></tr>'
		40	difflineat = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source atline">{line\|escape}</td></tr>'
		41	diffline = '<tr><td class="lineno"><a href="#{lineid}" id="{lineid}">{linenumber}</a></td><td class="source">{line\|escape}</td></tr>'
		42
		43	changelogparent = '<tr><th class="parent">parent {rev}:</th><td class="parent"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		44
		45	changesetparent = '<a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a> '
		46
		47	filerevparent = '<a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{rename%filerename}{node\|short}</a> '
		48	filerevchild = '<a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a> '
		49
		50	filerename = '{file\|escape}@'
		51	filelogrename = '<tr><th>base:</th><td><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{file\|escape}@{node\|short}</a></td></tr>'
		52	fileannotateparent = '<tr><td class="metatag">parent:</td><td><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{rename%filerename}{node\|short}</a></td></tr>'
		53	changesetchild = '<a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a>'
		54	changelogchild = '<tr><th class="child">child</th><td class="child"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		55	fileannotatechild = '<tr><td class="metatag">child:</td><td><a href="{url}annotate/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		56	tags = ../coal/tags.tmpl
		57	tagentry = '<tr class="tagEntry parity{parity}"><td><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{tag\|escape}</a></td><td class="node">{node\|short}</td></tr>'
		58	changelogtag = '<tr><th class="tag">tag:</th><td class="tag">{tag\|escape}</td></tr>'
		59	changelogtag = '<span class="tag">{name\|escape}</span> '
		60	changesettag = '<span class="tag">{tag\|escape}</span> '
		61	filediffparent = '<tr><th class="parent">parent {rev}:</th><td class="parent"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		62	filelogparent = '<tr><th>parent {rev}:</th><td><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		63	filediffchild = '<tr><th class="child">child {rev}:</th><td class="child"><a href="{url}rev/{node\|short}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		64	filelogchild = '<tr><th>child {rev}:</th><td><a href="{url}file/{node\|short}/{file\|urlescape}{sessionvars%urlparameter}">{node\|short}</a></td></tr>'
		65	indexentry = '<tr class="parity{parity}"><td><a href="{url}{sessionvars%urlparameter}">{name\|escape}</a></td><td>{description}</td><td>{contact\|obfuscate}</td><td class="age">{lastchange\|age} ago</td><td class="indexlinks">{archives%indexarchiveentry}</td></tr>\n'
		66	indexarchiveentry = '<a href="{url}archive/{node\|short}{extension\|urlescape}"> ↓{type\|escape}</a>'
		67	index = ../coal/index.tmpl
		68	archiveentry = '<li><a href="{url}archive/{node\|short}{extension\|urlescape}">{type\|escape}</a></li>'
		69	notfound = ../coal/notfound.tmpl
		70	error = ../coal/error.tmpl
		71	urlparameter = '{separator}{name}={value\|urlescape}'
		72	hiddenformentry = '<input type="hidden" name="{name}" value="{value\|escape}" />'

templates/static/background.png

0 created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

templates/static/coal-file.png

0 created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

templates/static/coal-folder.png

0 created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

templates/static/excanvas.js

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

templates/static/graph.js

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

templates/static/style-coal.css

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

templates/static/style-paper.css

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-1102

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-1102.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-bundle-type

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-bundle-type.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-casefolding

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-casefolding.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-cvs-branch

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-cvs-branch.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-cvs-builtincvsps

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-cvs-builtincvsps.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-dumprevlog

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-dumprevlog.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-hgk

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-hgk.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mactext

0 created 755 0 0

	1		NO CONTENT: new file 100755
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mactext.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-pull-http.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-revlog-ancestry.py

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

tests/test-revlog-ancestry.py.out

0 created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

.hgignore

0 +1 0

              *.mergebackup
              *.o
              *.so
+             *.pyd
              *.pyc
              *.swp
              *.prof

contrib/mercurial.el

0 +4 -2

              ;; This code has been developed under XEmacs 21.5, and may not work as
              ;; well under GNU Emacs (albeit tested under 21.4).  Patches to
              ;; enhance the portability of this code, fix bugs, and add features
-             ;; are most welcome.  You can clone a Mercurial repository for this
-             ;; package from http://www.serpentine.com/hg/hg-emacs
+             ;; are most welcome.
+             ;; As of version 22.3, GNU Emacs's VC mode has direct support for
+             ;; Mercurial, so this package may not prove as useful there.
              ;; Please send problem reports and suggestions to bos@serpentine.com.

contrib/zsh_completion

0 +5 -2

              _hg_config() {
                  typeset -a items
-                 local line
-                 items=(${${(%f)"$(_hg_cmd showconfig)"}%%\=*})
+                 items=(${${(%f)"$(_call_program hg hg showconfig)"}%%\=*})
                  (( $#items )) && _describe -t config 'config item' items
              }
                  '--cwd[change working directory]:new working directory:_files -/'
                  '(--noninteractive -y)'{-y,--noninteractive}'[do not prompt, assume yes for any required answers]'
                  '(--verbose -v)'{-v,--verbose}'[enable additional output]'
+                 '*--config[set/override config option]:defined config items:_hg_config'
                  '(--quiet -q)'{-q,--quiet}'[suppress output]'
                  '(--help -h)'{-h,--help}'[display help and exit]'
                  '--debug[debug mode]'
                  '--debugger[start debugger]'
+                 '--encoding[set the charset encoding (default: UTF8)]'
+                 '--encodingmode[set the charset encoding mode (default: strict)]'
+                 '--lsprof[print improved command execution profile]'
                  '--traceback[print traceback on exception]'
                  '--time[time how long the command takes]'
                  '--profile[profile]'

doc/gendoc.py

0 +2 -2

                      if f.startswith("debug"): continue
                      d = get_cmd(h[f])
                      # synopsis
+                     ui.write("[[%s]]\n" % d['cmd'])
                      ui.write("%s::\n" % d['synopsis'].replace("hg ","", 1))
                      # description
                      ui.write("%s\n\n" % d['desc'][1])
                          ui.write(_("    aliases: %s\n\n") % " ".join(d['aliases']))
                  # print topics
-                 for t in helptable:
+                 for t, doc in helptable:
                      l = t.split("|")
                      section = l[-1]
                      underlined(_(section).upper())
-                     doc = helptable[t]
                      if callable(doc):
                          doc = doc()
                      ui.write(_(doc))

doc/hg.1.txt

0 0 -52

		@@ -37,58 +37,6 repository path::
37	37
38	38	include::hg.1.gendoc.txt[]
39	39
40		SPECIFYING SINGLE REVISIONS
41		---------------------------
42
43		Mercurial accepts several notations for identifying individual
44		revisions.
45
46		A plain integer is treated as a revision number. Negative
47		integers are treated as offsets from the tip, with -1 denoting the
48		tip.
49
50		A 40-digit hexadecimal string is treated as a unique revision
51		identifier.
52
53		A hexadecimal string less than 40 characters long is treated as a
54		unique revision identifier, and referred to as a short-form
55		identifier. A short-form identifier is only valid if it is the
56		prefix of one full-length identifier.
57
58		Any other string is treated as a tag name, which is a symbolic
59		name associated with a revision identifier. Tag names may not
60		contain the ":" character.
61
62		The reserved name "tip" is a special tag that always identifies
63		the most recent revision.
64
65		The reserved name "null" indicates the null revision. This is the
66		revision of an empty repository, and the parent of revision 0.
67
68		The reserved name "." indicates the working directory parent. If
69		no working directory is checked out, it is equivalent to null.
70		If an uncommitted merge is in progress, "." is the revision of
71		the first parent.
72
73		SPECIFYING MULTIPLE REVISIONS
74		-----------------------------
75
76		When Mercurial accepts more than one revision, they may be
77		specified individually, or provided as a continuous range,
78		separated by the ":" character.
79
80		The syntax of range notation is [BEGIN]:[END], where BEGIN and END
81		are revision identifiers. Both BEGIN and END are optional. If
82		BEGIN is not specified, it defaults to revision number 0. If END
83		is not specified, it defaults to the tip. The range ":" thus
84		means "all revisions".
85
86		If BEGIN is greater than END, revisions are treated in reverse
87		order.
88
89		A range acts as a closed interval. This means that a range of 3:5
90		gives 3, 4 and 5. Similarly, a range of 4:2 gives 4, 3, and 2.
91
92	40	FILES
93	41	-----
94	42	.hgignore::

doc/hgrc.5.txt

0 +25 -1

              Mercurial "hgrc" file, the purpose of each section, its possible
              keys, and their possible values.
+             [[decode]]
              decode/encode::
                Filters for transforming files on checkout/checkin. This would
                typically be used for newline processing or other
                  [decode]
                  **.txt = dumbdecode:
+             [[defaults]]
              defaults::
                Use the [defaults] section to define command defaults, i.e. the
                default options/arguments to pass to the specified commands.
                defining command defaults. The command defaults will also be
                applied to the aliases of the commands defined.
+             [[diff]]
              diff::
                Settings used when displaying diffs. They are all boolean and
                defaults to False.
                ignoreblanklines;;
                  Ignore changes whose lines are all blank.
+             [[email]]
              email::
                Settings for extensions that send email messages.
                from;;
                  from = Joseph User <joe.user@example.com>
                  method = /usr/sbin/sendmail
+             [[extensions]]
              extensions::
                Mercurial has an extension mechanism for adding new features. To
                enable an extension, create an entry for it in this section.
                  # (this extension will get loaded from the file specified)
                  myfeature = ~/.hgext/myfeature.py
+             [[format]]
              format::
                usestore;;
                  you to store longer filenames in some situations at the expense of
                  compatibility.
+             [[merge-patterns]]
              merge-patterns::
                This section specifies merge tools to associate with particular file
                patterns. Tools matched here will take precedence over the default
                  **.c = kdiff3
                  **.jpg = myimgmerge
+             [[merge-tools]]
              merge-tools::
                This section configures external merge tools to use for file-level
                merges.
                  myHtmlTool.priority = 1
                Supported arguments:
                priority;;
                  The priority in which to evaluate this tool.
                  Default: 0.
                fixeol;;
                  Attempt to fix up EOL changes caused by the merge tool.
                  Default: False
-               gui:;
+               gui;;
                  This tool requires a graphical interface to run. Default: False
                regkey;;
                  Windows registry key which describes install location of this tool.
                  String to append to the value read from the registry, typically the
-                 executable name of the tool.  Default: None
+             [[hooks]]
              hooks::
                Commands or Python functions that get automatically executed by
                various actions such as starting or finishing a commit. Multiple
                If a Python hook returns a "true" value or raises an exception, this
                is treated as failure of the hook.
+             [[http_proxy]]
              http_proxy::
                Used to access web-based Mercurial repositories through a HTTP
                proxy.
                user;;
-                 Optional.  User name to authenticate with at the proxy server.
+             [[smtp]]
              smtp::
                Configuration for extensions that need to send email messages.
                host;;
-                 Optional.  It's the hostname that the sender can use to identify itself
                  to the MTA.
+             [[paths]]
              paths::
-               Assigns symbolic names to repositories.  The left side is the
                symbolic name, and the right gives the directory or URL that is the
-                 Optional.  Directory or URL to use when pushing if no destination
                  is specified.
+             [[server]]
              server::
                Controls generic server settings.
                uncompressed;;
 Mbps), uncompressed streaming is slower, because of the extra
-                 data transfer overhead.  Default is False.
+             [[trusted]]
              trusted::
                For security reasons, Mercurial will not use the settings in
                the .hg/hgrc file from a repository if it doesn't belong to a
                groups;;
                  Comma-separated list of trusted groups.
+             [[ui]]
              ui::
                User interface controls.
                archivemeta;;
                  (hashes for the repository base and for tip) in archives created by
                  the hg archive command or downloaded via hgweb.
                  Default is true.
+               askusername;;
+                 Whether to prompt for a username when committing. If True, and
+                 neither $HGUSER nor $EMAIL has been specified, then the user will
+                 be prompted to enter a username.  If no username is entered, the
+                 default USER@HOST is used instead.
+                 Default is False.
                debug;;
-                 Print debugging information.  True or False.  Default is False.
                editor;;
                      fail to merge
                  See the merge-tools section for more information on configuring tools.
                patch;;
                  command to use to apply patches. Look for 'gpatch' or 'patch' in PATH if
                  unset.
-                 Increase the amount of output printed.  True or False.  Default is False.
+             [[web]]
              web::
                Web interface configuration.
                accesslog;;

hgext/acl.py

0 +29 -63

		@@ -46,79 +46,45
46	46	# ** = user6
47	47
48	48	from mercurial.i18n import _
49		from mercurial.node import bin, short
50	49	from mercurial import util
51	50	import getpass
52	51
53		class checker(object):
54		'''acl checker.'''
55
56		def buildmatch(self, key):
	52	def buildmatch(ui, repo, user, key):
57	53	'''return tuple of (match function, list enabled).'''
58		if not ~~self~~.ui.has_section(key):
59		~~self~~.ui.debug(_('acl: %s not enabled\n') % key)
60		return None, ~~False~~
61
62		thisuser = self.getuser()
63		pats = [pat for pat, users in self.ui.configitems(key)
64		if thisuser in users.replace(',', ' ').split()]
65		self.ui.debug(_('acl: %s enabled, %d entries for user %s\n') %
66		(key, len(pats), thisuser))
67		if pats:
68		match = util.matcher(self.repo.root, names=pats)[1]
69		else:
70		match = util.never
71		return match, True
72
73		def getuser(self):
74		'''return name of authenticated user.'''
75		return self.user
	54	if not ui.has_section(key):
	55	ui.debug(_('acl: %s not enabled\n') % key)
	56	return None
76	57
77		def __init__(self, ui, repo):
78		self.ui = ui
79		self.repo = repo
80		self.user = getpass.getuser()
81		cfg = self.ui.config('acl', 'config')
82		if cfg:
83		self.ui.readsections(cfg, 'acl.allow', 'acl.deny')
84		self.allow, self.allowable = self.buildmatch('acl.allow')
85		self.deny, self.deniable = self.buildmatch('acl.deny')
86
87		def skipsource(self, source):
88		'''true if incoming changes from this source should be skipped.'''
89		ok_sources = self.ui.config('acl', 'sources', 'serve').split()
90		return source not in ok_sources
91
92		def check(self, node):
93		'''return if access allowed, raise exception if not.'''
94		files = self.repo.changectx(node).files()
95		if self.deniable:
96		for f in files:
97		if self.deny(f):
98		self.ui.debug(_('acl: user %s denied on %s\n') %
99		(self.getuser(), f))
100		raise util.Abort(_('acl: access denied for changeset %s') %
101		short(node))
102		if self.allowable:
103		for f in files:
104		if not self.allow(f):
105		self.ui.debug(_('acl: user %s not allowed on %s\n') %
106		(self.getuser(), f))
107		raise util.Abort(_('acl: access denied for changeset %s') %
108		short(node))
109		self.ui.debug(_('acl: allowing changeset %s\n') % short(node))
	58	pats = [pat for pat, users in ui.configitems(key)
	59	if user in users.replace(',', ' ').split()]
	60	ui.debug(_('acl: %s enabled, %d entries for user %s\n') %
	61	(key, len(pats), user))
	62	if pats:
	63	return util.matcher(repo.root, names=pats)[1]
	64	return util.never
110	65
111	66	def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
112	67	if hooktype != 'pretxnchangegroup':
113	68	raise util.Abort(_('config error - hook type "%s" cannot stop '
114	69	'incoming changesets') % hooktype)
115
116		c = checker(ui, repo)
117		if c.skipsource(source):
	70	if source not in ui.config('acl', 'sources', 'serve').split():
118	71	ui.debug(_('acl: changes have source "%s" - skipping\n') % source)
119	72	return
120	73
121		start = repo.changelog.rev(bin(node))
122		end = repo.changelog.count()
123		for rev in xrange(start, end):
124		c.check(repo.changelog.node(rev))
	74	user = getpass.getuser()
	75	cfg = ui.config('acl', 'config')
	76	if cfg:
	77	ui.readsections(cfg, 'acl.allow', 'acl.deny')
	78	allow = buildmatch(ui, repo, user, 'acl.allow')
	79	deny = buildmatch(ui, repo, user, 'acl.deny')
	80
	81	for rev in xrange(repo[node], len(repo)):
	82	ctx = repo[rev]
	83	for f in ctx.files():
	84	if deny and deny(f):
	85	ui.debug(_('acl: user %s denied on %s\n') % (user, f))
	86	raise util.Abort(_('acl: access denied for changeset %s') % ctx)
	87	if allow and not allow(f):
	88	ui.debug(_('acl: user %s not allowed on %s\n') % (user, f))
	89	raise util.Abort(_('acl: access denied for changeset %s') % ctx)
	90	ui.debug(_('acl: allowing changeset %s\n') % ctx)

hgext/bugzilla.py

0 +5 -9

              from mercurial.i18n import _
              from mercurial.node import short
              from mercurial import cmdutil, templater, util
-             import os, re, time
+             import re, time
              MySQLdb = None
                  def filter_real_bug_ids(self, ids):
                      '''filter not-existing bug ids from list.'''
                      self.run('select bug_id from bugs where bug_id in %s' % buglist(ids))
-                     ids = [c[0] for c in self.cursor.fetchall()]
-                     ids.sort()
-                     return ids
+                     return util.sort([c[0] for c in self.cursor.fetchall()])
                  def filter_unknown_bug_ids(self, node, ids):
                      '''filter bug ids from list that already refer to this changeset.'''
                          self.ui.status(_('bug %d already knows about changeset %s\n') %
                                         (id, short(node)))
                          unknown.pop(id, None)
-                     ids = unknown.keys()
-                     ids.sort()
-                     return ids
+                     return util.sort(unknown.keys())
                  def notify(self, ids):
                      '''tell bugzilla to send mail.'''
                          cmd = self.ui.config('bugzilla', 'notify',
                                             'cd /var/www/html/bugzilla && '
                                             './processmail %s nobody@nowhere.com') % id
-                         fp = os.popen('(%s) 2>&1' % cmd)
+                         fp = util.popen('(%s) 2>&1' % cmd)
                          out = fp.read()
                          ret = fp.close()
                          if ret:
                                       hooktype)
                  try:
                      bz = bugzilla(ui, repo)
-                     ctx = repo.changectx(node)
+                     ctx = repo[node]
                      ids = bz.find_bug_ids(ctx)
                      if ids:
                          for id in ids:

hgext/children.py

0 +1 -1

                  if file_:
                      ctx = repo.filectx(file_, changeid=rev)
                  else:
-                     ctx = repo.changectx(rev)
+                     ctx = repo[rev]
                  displayer = cmdutil.show_changeset(ui, repo, opts)
                  for node in [cp.node() for cp in ctx.children()]:

hgext/churn.py

0 +49 -136

		@@ -4,15 +4,10
4	4	#
5	5	# This software may be used and distributed according to the terms
6	6	# of the GNU General Public License, incorporated herein by reference.
7		#
8		#
9		# Aliases map file format is simple one alias per line in the following
10		# format:
11		#
12		# <alias email> <actual email>
	7	'''allow graphing the number of lines changed per contributor'''
13	8
14	9	from mercurial.i18n import gettext as _
15		from mercurial import ~~mdiff~~, cmdutil, util, node
	10	from mercurial import patch, cmdutil, util, node
16	11	import os, sys
17	12
18	13	def get_tty_width():
		@@ -36,98 +31,41 def get_tty_width():
36	31	pass
37	32	return 80
38	33
39		def __gather(ui, repo, node1, node2):
40		def dirtywork(f, mmap1, mmap2):
41		lines = 0
42
43		to = mmap1 and repo.file(f).read(mmap1[f]) or None
44		tn = mmap2 and repo.file(f).read(mmap2[f]) or None
45
46		diff = mdiff.unidiff(to, "", tn, "", f, f).split("\n")
47
48		for line in diff:
49		if not line:
50		continue # skip EOF
51		if line.startswith(" "):
52		continue # context line
53		if line.startswith("--- ") or line.startswith("+++ "):
54		continue # begining of diff
55		if line.startswith("@@ "):
56		continue # info line
57
58		# changed lines
59		lines += 1
60
61		return lines
62
63		##
64
65		lines = 0
66
67		changes = repo.status(node1, node2, None, util.always)[:5]
68
69		modified, added, removed, deleted, unknown = changes
70
71		who = repo.changelog.read(node2)[1]
72		who = util.email(who) # get the email of the person
73
74		mmap1 = repo.manifest.read(repo.changelog.read(node1)[0])
75		mmap2 = repo.manifest.read(repo.changelog.read(node2)[0])
76		for f in modified:
77		lines += dirtywork(f, mmap1, mmap2)
78
79		for f in added:
80		lines += dirtywork(f, None, mmap2)
81
82		for f in removed:
83		lines += dirtywork(f, mmap1, None)
84
85		for f in deleted:
86		lines += dirtywork(f, mmap1, mmap2)
87
88		for f in unknown:
89		lines += dirtywork(f, mmap1, mmap2)
90
91		return (who, lines)
92
93		def gather_stats(ui, repo, amap, revs=None, progress=False):
	34	def countrevs(ui, repo, amap, revs, progress=False):
94	35	stats = {}
95
96		cl = repo.changelog
97
	36	count = pct = 0
98	37	if not revs:
99		revs = range(0, cl.~~count~~())
100
101		nr_revs = len(revs)
102		cur_rev = 0
	38	revs = range(len(repo))
103	39
104	40	for rev in revs:
105		cur_rev += 1 # next revision
106
107		node2 = cl.node(rev)
108		node1 = cl.parents(node2)[0]
109
110		if cl.parents(node2)[1] != node.nullid:
	41	ctx2 = repo[rev]
	42	parents = ctx2.parents()
	43	if len(parents) > 1:
111	44	ui.note(_('Revision %d is a merge, ignoring...\n') % (rev,))
112	45	continue
113	46
114		who, lines = __gather(ui, repo, node1, node2)
	47	ctx1 = parents[0]
	48	lines = 0
	49	ui.pushbuffer()
	50	patch.diff(repo, ctx1.node(), ctx2.node())
	51	diff = ui.popbuffer()
115	52
116		# remap the owner if possible
117		if who in amap:
118		ui.note("using '%s' alias for '%s'\n" % (amap[who], who))
119		who = amap[who]
	53	for l in diff.split('\n'):
	54	if (l.startswith("+") and not l.startswith("+++ ") or
	55	l.startswith("-") and not l.startswith("--- ")):
	56	lines += 1
120	57
121		if not who in stats:
122		stats[who] = 0
123		stats[~~who~~] += lines
124
125		ui.note("rev %d: %d lines by %s\n" % (rev, lines, who))
	58	user = util.email(ctx2.user())
	59	user = amap.get(user, user) # remap
	60	stats[user] = stats.get(user, 0) + lines
	61	ui.debug("rev %d: %d lines by %s\n" % (rev, lines, user))
126	62
127	63	if progress:
128		nr_revs = max(nr_revs, 1)
129		if int(100.0(cur_rev - 1)/nr_revs) < int(100.0cur_rev/nr_revs):
130		ui.write("\rGenerating stats: %d%%" % (int(100.0*cur_rev/nr_revs),))
	64	count += 1
	65	newpct = int(100.0 * count / max(len(revs), 1))
	66	if pct < newpct:
	67	pct = newpct
	68	ui.write("\rGenerating stats: %d%%" % pct)
131	69	sys.stdout.flush()
132	70
133	71	if progress:
		@@ -137,64 +75,39 def gather_stats(ui, repo, amap, revs=No
137	75	return stats
138	76
139	77	def churn(ui, repo, **opts):
140		"Graphs the number of lines changed"
	78	'''graphs the number of lines changed
	79
	80	The map file format used to specify aliases is fairly simple:
	81
	82	<alias email> <actual email>'''
141	83
142	84	def pad(s, l):
143		if len(s) < l:
144		return s + " " * (l-len(s))
145		return s[0:l]
146
147		def graph(n, maximum, width, char):
148		maximum = max(1, maximum)
149		n = int(n * width / float(maximum))
150
151		return char * (n)
152
153		def get_aliases(f):
154		aliases = {}
155
156		for l in f.readlines():
157		l = l.strip()
158		alias, actual = l.split()
159		aliases[alias] = actual
160
161		return aliases
	85	return (s + " " * l)[:l]
162	86
163	87	amap = {}
164	88	aliases = opts.get('aliases')
165	89	if aliases:
166		try:
167		f = ~~open~~(~~aliases~~,~~"r"~~)
168		except OSError, e:
169		print "Error: " + e
	90	for l in open(aliases, "r"):
	91	l = l.strip()
	92	alias, actual = l.split()
	93	amap[alias] = actual
	94
	95	revs = util.sort([int(r) for r in cmdutil.revrange(repo, opts['rev'])])
	96	stats = countrevs(ui, repo, amap, revs, opts.get('progress'))
	97	if not stats:
170	98	return
171	99
172		amap = get_aliases(f)
173		f.close()
174
175		revs = [int(r) for r in cmdutil.revrange(repo, opts['rev'])]
176		revs.sort()
177		stats = gather_stats(ui, repo, amap, revs, opts.get('progress'))
	100	stats = util.sort([(-l, u, l) for u,l in stats.items()])
	101	maxchurn = float(max(1, stats[0][2]))
	102	maxuser = max([len(u) for k, u, l in stats])
178	103
179		# make a list of tuples (name, lines) and sort it in descending order
180		ordered = stats.items()
181		if not ordered:
182		return
183		ordered.sort(lambda x, y: cmp(y[1], x[1]))
184		max_churn = ordered[0][1]
	104	ttywidth = get_tty_width()
	105	ui.debug(_("assuming %i character terminal\n") % ttywidth)
	106	width = ttywidth - maxuser - 2 - 6 - 2 - 2
185	107
186		tty_width = get_tty_width()
187		ui.note(_("assuming %i character terminal\n") % tty_width)
188		tty_width -= 1
189
190		max_user_width = max([len(user) for user, churn in ordered])
191
192		graph_width = tty_width - max_user_width - 1 - 6 - 2 - 2
193
194		for user, churn in ordered:
195		print "%s %6d %s" % (pad(user, max_user_width),
196		churn,
197		graph(churn, max_churn, graph_width, '*'))
	108	for k, user, churn in stats:
	109	print "%s %6d %s" % (pad(user, maxuser), churn,
	110	"" int(churn * width / maxchurn))
198	111
199	112	cmdtable = {
200	113	"churn":

hgext/convert/__init__.py

0 +45 0

		@@ -4,6 +4,7
4	4	#
5	5	# This software may be used and distributed according to the terms
6	6	# of the GNU General Public License, incorporated herein by reference.
	7	'''converting foreign VCS repositories to Mercurial'''
7	8
8	9	import convcmd
9	10	from mercurial import commands
		@@ -85,6 +86,50 def convert(ui, src, dest=None, revmapfi
85	86	--config convert.hg.saverev=True (boolean)
86	87	allow target to preserve source revision ID
87	88
	89	CVS Source
	90	----------
	91
	92	CVS source will use a sandbox (i.e. a checked-out copy) from CVS
	93	to indicate the starting point of what will be converted. Direct
	94	access to the repository files is not needed, unless of course
	95	the repository is :local:. The conversion uses the top level
	96	directory in the sandbox to find the CVS repository, and then uses
	97	CVS rlog commands to find files to convert. This means that unless
	98	a filemap is given, all files under the starting directory will be
	99	converted, and that any directory reorganisation in the CVS
	100	sandbox is ignored.
	101
	102	Because CVS does not have changesets, it is necessary to collect
	103	individual commits to CVS and merge them into changesets. CVS source
	104	can use the external 'cvsps' program (this is a legacy option and may
	105	be removed in future) or use its internal changeset merging code.
	106	External cvsps is default, and options may be passed to it by setting
	107	--config convert.cvsps='cvsps -A -u --cvs-direct -q'
	108	The options shown are the defaults.
	109
	110	Internal cvsps is selected by setting
	111	--config convert.cvsps=builtin
	112	and has a few more configurable options:
	113	--config convert.cvsps.fuzz=60 (integer)
	114	Specify the maximum time (in seconds) that is allowed between
	115	commits with identical user and log message in a single
	116	changeset. When very large files were checked in as part
	117	of a changeset then the default may not be long enough.
	118	--config convert.cvsps.mergeto='{{mergetobranch ([-\w]+)}}'
	119	Specify a regular expression to which commit log messages are
	120	matched. If a match occurs, then the conversion process will
	121	insert a dummy revision merging the branch on which this log
	122	message occurs to the branch indicated in the regex.
	123	--config convert.cvsps.mergefrom='{{mergefrombranch ([-\w]+)}}'
	124	Specify a regular expression to which commit log messages are
	125	matched. If a match occurs, then the conversion process will
	126	add the most recent revision on the branch indicated in the
	127	regex as the second parent of the changeset.
	128
	129	The hgext/convert/cvsps wrapper script allows the builtin changeset
	130	merging code to be run without doing a conversion. Its parameters and
	131	output are similar to that of cvsps 2.1.
	132
88	133	Subversion Source
89	134	-----------------
90	135

hgext/convert/common.py

0 +10 -18

                      mapping equivalent authors identifiers for each system."""
                      return None
-                 def putfile(self, f, e, data):
-                     """Put file for next putcommit().
-                     f: path to file
-                     e: '', 'x', or 'l' (regular file, executable, or symlink)
-                     data: file contents"""
-                     raise NotImplementedError()
-                 def delfile(self, f):
-                     """Delete file for next putcommit().
-                     f: path to file"""
-                     raise NotImplementedError()
-                 def putcommit(self, files, parents, commit):
+                 def putcommit(self, files, copies, parents, commit, source):
                      """Create a revision with all changed files listed in 'files'
                      and having listed parents. 'commit' is a commit object containing
                      at a minimum the author, date, and message for this changeset.
-                     Called after putfile() and delfile() calls. Note that the sink
-                     repository is not told to update itself to a particular revision
-                     (or even what that revision would be) before it receives the
-                     file data."""
+                     'files' is a list of (path, version) tuples, 'copies'is a dictionary
+                     mapping destinations to sources, and 'source' is the source repository.
+                     Only getfile() and getmode() should be called on 'source'.
+                     Note that the sink repository is not told to update itself to
+                     a particular revision (or even what that revision would be)
+                     before it receives the file data.
+                     """
                      raise NotImplementedError()
                  def puttags(self, tags):
                      raise NotImplementedError()
                  def setbranch(self, branch, pbranches):
-                     """Set the current branch name. Called before the first putfile
+                     """Set the current branch name. Called before the first putcommit
                      on the branch.
                      branch: branch name for subsequent commits
                      pbranches: (converted parent revision, parent branch) tuples"""

hgext/convert/convcmd.py

0 +1 -18

                  def copy(self, rev):
                      commit = self.commitcache[rev]
-                     do_copies = hasattr(self.dest, 'copyfile')
-                     filenames = []
                      changes = self.source.getchanges(rev)
                      if isinstance(changes, basestring):
                              pbranches.append((self.map[prev],
                                                self.commitcache[prev].branch))
                      self.dest.setbranch(commit.branch, pbranches)
-                     for f, v in files:
-                         filenames.append(f)
-                         try:
-                             data = self.source.getfile(f, v)
-                         except IOError, inst:
-                             self.dest.delfile(f)
-                         else:
-                             e = self.source.getmode(f, v)
-                             self.dest.putfile(f, e, data)
-                             if do_copies:
-                                 if f in copies:
-                                     copyf = copies[f]
-                                     # Merely marks that a copy happened.
-                                     self.dest.copyfile(copyf, f)
                      try:
                          parents = self.splicemap[rev].replace(',', ' ').split()
                          self.ui.status('spliced in %s as parents of %s\n' %
                          parents = [self.map.get(p, p) for p in parents]
                      except KeyError:
                          parents = [b[0] for b in pbranches]
-                     newnode = self.dest.putcommit(filenames, parents, commit)
+                     newnode = self.dest.putcommit(files, copies, parents, commit, self.source)
                      self.source.converted(rev, newnode)
                      self.map[rev] = newnode

hgext/convert/cvs.py

0 +46 -12

              import os, locale, re, socket
              from cStringIO import StringIO
              from mercurial import util
+             from mercurial.i18n import _
              from common import NoRepo, commit, converter_source, checktool
+             import cvsps
              class convert_cvs(converter_source):
                  def __init__(self, ui, path, rev=None):
                      if not os.path.exists(cvs):
                          raise NoRepo("%s does not look like a CVS checkout" % path)
+                     checktool('cvs')
                      self.cmd = ui.config('convert', 'cvsps', 'cvsps -A -u --cvs-direct -q')
                      cvspsexe = self.cmd.split(None, 1)[0]
-                     for tool in (cvspsexe, 'cvs'):
-                         checktool(tool)
+                     self.builtin = cvspsexe == 'builtin'
+                     if not self.builtin:
+                         checktool(cvspsexe)
                      self.changeset = {}
                      self.files = {}
                      self.cvsroot = file(os.path.join(cvs, "Root")).read()[:-1]
                      self.cvsrepo = file(os.path.join(cvs, "Repository")).read()[:-1]
                      self.encoding = locale.getpreferredencoding()
-                     self._parse()
+                     self._parse(ui)
                      self._connect()
-                 def _parse(self):
+                 def _parse(self, ui):
                      if self.changeset:
                          return
                          id = None
                          state = 0
                          filerevids = {}
+                         if self.builtin:
+                             # builtin cvsps code
+                             ui.status(_('using builtin cvsps\n'))
+                             db = cvsps.createlog(ui, cache='update')
+                             db = cvsps.createchangeset(ui, db,
+                                   fuzz=int(ui.config('convert', 'cvsps.fuzz', 60)),
+                                   mergeto=ui.config('convert', 'cvsps.mergeto', None),
+                                   mergefrom=ui.config('convert', 'cvsps.mergefrom', None))
+                             for cs in db:
+                                 if maxrev and cs.id>maxrev:
+                                     break
+                                 id = str(cs.id)
+                                 cs.author = self.recode(cs.author)
+                                 self.lastbranch[cs.branch] = id
+                                 cs.comment = self.recode(cs.comment)
+                                 date = util.datestr(cs.date)
+                                 self.tags.update(dict.fromkeys(cs.tags, id))
+                                 files = {}
+                                 for f in cs.entries:
+                                     files[f.file] = "%s%s" % ('.'.join([str(x) for x in f.revision]),
+                                                               ['', '(DEAD)'][f.dead])
+                                 # add current commit to set
+                                 c = commit(author=cs.author, date=date,
+                                          parents=[str(p.id) for p in cs.parents],
+                                          desc=cs.comment, branch=cs.branch or '')
+                                 self.changeset[id] = c
+                                 self.files[id] = files
+                         else:
+                             # external cvsps
                          for l in util.popen(cmd):
                              if state == 0: # header
                                  if l.startswith("PatchSet"):
                  def getchanges(self, rev):
                      self.modecache = {}
-                     files = self.files[rev]
-                     cl = files.items()
-                     cl.sort()
-                     return (cl, {})
+                     return util.sort(self.files[rev].items()), {}
                  def getcommit(self, rev):
                      return self.changeset[rev]
                      return self.tags
                  def getchangedfiles(self, rev, i):
-                     files = self.files[rev].keys()
-                     files.sort()
-                     return files
+                     return util.sort(self.files[rev].keys())

hgext/convert/darcs.py

0 +1 -2

                              copies[elt.get('from')] = elt.get('to')
                          else:
                              changes.append((elt.text.strip(), rev))
-                     changes.sort()
                      self.lastrev = rev
-                     return changes, copies
+                     return util.sort(changes), copies
                  def getfile(self, name, rev):
                      if rev != self.lastrev:

hgext/convert/gnuarch.py

0 +1 -3

                          for c in cps:
                              copies[c] = cps[c]
-                     changes.sort()
                      self.lastrev = rev
-                     return changes, copies
+                     return util.sort(changes), copies
                  def getcommit(self, rev):
                      changes = self.changes[rev]

hgext/convert/hg.py

0 +39 -56

              from mercurial.i18n import _
              from mercurial.repo import RepoError
              from mercurial.node import bin, hex, nullid
-             from mercurial import hg, revlog, util
+             from mercurial import hg, revlog, util, context
              from common import NoRepo, commit, converter_source, converter_sink
                      self.ui.debug(_('run hg sink pre-conversion action\n'))
                      self.wlock = self.repo.wlock()
                      self.lock = self.repo.lock()
-                     self.repo.dirstate.clear()
                  def after(self):
                      self.ui.debug(_('run hg sink post-conversion action\n'))
-                     self.repo.dirstate.invalidate()
                      self.lock = None
                      self.wlock = None
                      h = self.repo.changelog.heads()
                      return [ hex(x) for x in h ]
-                 def putfile(self, f, e, data):
-                     self.repo.wwrite(f, data, e)
-                     if f not in self.repo.dirstate:
-                         self.repo.dirstate.normallookup(f)
-                 def copyfile(self, source, dest):
-                     self.repo.copy(source, dest)
-                 def delfile(self, f):
-                     try:
-                         util.unlink(self.repo.wjoin(f))
-                         #self.repo.remove([f])
-                     except OSError:
-                         pass
                  def setbranch(self, branch, pbranches):
                      if not self.clonebranches:
                          return
                              self.repo.pull(prepo, [prepo.lookup(h) for h in heads])
                          self.before()
-                 def putcommit(self, files, parents, commit):
-                     seen = {}
+                 def putcommit(self, files, copies, parents, commit, source):
+                     files = dict(files)
+                     def getfilectx(repo, memctx, f):
+                         v = files[f]
+                         data = source.getfile(f, v)
+                         e = source.getmode(f, v)
+                         return context.memfilectx(f, data, 'l' in e, 'x' in e, copies.get(f))
                      pl = []
                      for p in parents:
-                         if p not in seen:
+                         if p not in pl:
                              pl.append(p)
-                             seen[p] = 1
                      parents = pl
                      nparents = len(parents)
                      if self.filemapmode and nparents == 1:
                      while parents:
                          p1 = p2
                          p2 = parents.pop(0)
-                         a = self.repo.rawcommit(files, text, commit.author, commit.date,
-                                                 bin(p1), bin(p2), extra=extra)
-                         self.repo.dirstate.clear()
+                         ctx = context.memctx(self.repo, (p1, p2), text, files.keys(), getfilectx,
+                                              commit.author, commit.date, extra)
+                         a = self.repo.commitctx(ctx)
                          text = "(octopus merge fixup)\n"
                          p2 = hex(self.repo.changelog.tip())
                          mnode = self.repo.changelog.read(bin(p2))[0]
                          if not man.cmp(m1node, man.revision(mnode)):
                              self.repo.rollback()
-                             self.repo.dirstate.clear()
                              return parent
                      return p2
                  def puttags(self, tags):
                      try:
-                         old = self.repo.wfile(".hgtags").read()
-                         oldlines = old.splitlines(1)
-                         oldlines.sort()
+                          parentctx = self.repo[self.tagsbranch]
+                          tagparent = parentctx.node()
+                      except RepoError, inst:
+                          parentctx = None
+                          tagparent = nullid
+                      try:
+                          oldlines = util.sort(parentctx['.hgtags'].data().splitlines(1))
                      except:
                          oldlines = []
-                     k = tags.keys()
-                     k.sort()
-                     newlines = []
-                     for tag in k:
-                         newlines.append("%s %s\n" % (tags[tag], tag))
+                      newlines = util.sort([("%s %s\n" % (tags[tag], tag)) for tag in tags])
-                     newlines.sort()
+                      if newlines == oldlines:
+                          return None
+                      data = "".join(newlines)
-                     if newlines != oldlines:
+                      def getfilectx(repo, memctx, f):
+                         return context.memfilectx(f, data, False, False, None)
-                         self.ui.status("updating tags\n")
-                         f = self.repo.wfile(".hgtags", "w")
-                         f.write("".join(newlines))
-                         f.close()
-                         if not oldlines: self.repo.add([".hgtags"])
-                         date = "%s 0" % int(time.mktime(time.gmtime()))
-                         extra = {}
-                         if self.tagsbranch != 'default':
-                             extra['branch'] = self.tagsbranch
-                         try:
-                             tagparent = self.repo.changectx(self.tagsbranch).node()
-                         except RepoError, inst:
-                             tagparent = nullid
-                         self.repo.rawcommit([".hgtags"], "update tags", "convert-repo",
-                                             date, tagparent, nullid, extra=extra)
+                      extra = {'branch': self.tagsbranch}
+                      ctx = context.memctx(self.repo, (tagparent, None), "update tags",
+                                           [".hgtags"], getfilectx, "convert-repo", date,
+                                           extra)
+                      self.repo.commitctx(ctx)
-                         return hex(self.repo.changelog.tip())
                  def setfilemapmode(self, active):
                  def changectx(self, rev):
                      if self.lastrev != rev:
-                         self.lastctx = self.repo.changectx(rev)
+                         self.lastctx = self.repo[rev]
                          self.lastrev = rev
                      return self.lastctx
                  def getheads(self):
                      if self.rev:
-                         return [hex(self.repo.changectx(self.rev).node())]
+                         return [hex(self.repo[self.rev].node())]
                      else:
                          return [hex(node) for node in self.repo.heads()]
                  def getfile(self, name, rev):
                      try:
-                         return self.changectx(rev).filectx(name).data()
+                         return self.changectx(rev)[name].data()
                      except revlog.LookupError, err:
                          raise IOError(err)
                  def getmode(self, name, rev):
-                     m = self.changectx(rev).manifest()
-                     return (m.execf(name) and 'x' or '') + (m.linkf(name) and 'l' or '')
+                     return self.changectx(rev).manifest().flags(name)
                  def getchanges(self, rev):
                      ctx = self.changectx(rev)
                      else:
                          m, a, r = self.repo.status(ctx.parents()[0].node(), ctx.node())[:3]
                      changes = [(name, rev) for name in m + a + r]
-                     changes.sort()
-                     return (changes, self.getcopies(ctx, m + a))
+                     return util.sort(changes), self.getcopies(ctx, m + a)
                  def getcopies(self, ctx, files):
                      copies = {}

hgext/convert/subversion.py

0 +18 -15

                              # This will fail if a directory was copied
                              # from another branch and then some of its files
                              # were deleted in the same transaction.
-                             children = self._find_children(path, revnum)
-                             children.sort()
+                             children = util.sort(self._find_children(path, revnum))
                              for child in children:
                                  # Can we move a child directory and its
                                  # parent in the same commit? (probably can). Could
                          parents = []
                          # check whether this revision is the start of a branch or part
                          # of a branch renaming
-                         orig_paths = orig_paths.items()
-                         orig_paths.sort()
+                         orig_paths = util.sort(orig_paths.items())
                          root_paths = [(p,e) for p,e in orig_paths if self.module.startswith(p)]
                          if root_paths:
                              path, ent = root_paths[-1]
                              if 'x' in flags:
                                  self.setexec.append(filename)
-                 def delfile(self, name):
-                     self.delete.append(name)
-                 def copyfile(self, source, dest):
-                     self.copies.append([source, dest])
                  def _copyfile(self, source, dest):
                      # SVN's copy command pukes if the destination file exists, but
                      # our copyfile method expects to record a copy that has
                      return dirs
                  def add_dirs(self, files):
-                     add_dirs = [d for d in self.dirs_of(files)
+                     add_dirs = [d for d in util.sort(self.dirs_of(files))
                                  if not os.path.exists(self.wjoin(d, '.svn', 'entries'))]
                      if add_dirs:
-                         add_dirs.sort()
                          self.xargs(add_dirs, 'add', non_recursive=True, quiet=True)
                      return add_dirs
                      return files
                  def tidy_dirs(self, names):
-                     dirs = list(self.dirs_of(names))
-                     dirs.sort()
+                     dirs = util.sort(self.dirs_of(names))
                      dirs.reverse()
                      deleted = []
                      for d in dirs:
                  def revid(self, rev):
                      return u"svn:%s@%s" % (self.uuid, rev)
-                 def putcommit(self, files, parents, commit):
+                 def putcommit(self, files, copies, parents, commit, source):
+                     # Apply changes to working copy
+                     for f, v in files:
+                         try:
+                             data = source.getfile(f, v)
+                         except IOError, inst:
+                             self.delete.append(f)
+                         else:
+                             e = source.getmode(f, v)
+                             self.putfile(f, e, data)
+                             if f in copies:
+                                 self.copies.append([copies[f], f])
+                     files = [f[0] for f in files]
                      for parent in parents:
                          try:
                              return self.revid(self.childmap[parent])

hgext/extdiff.py

0 +6 -7

              def snapshot_node(ui, repo, files, node, tmproot):
                  '''snapshot files as of some revision'''
-                 mf = repo.changectx(node).manifest()
                  dirname = os.path.basename(repo.root)
                  if dirname == "":
                      dirname = "root"
                  os.mkdir(base)
                  ui.note(_('making snapshot of %d files from rev %s\n') %
                          (len(files), short(node)))
+                 ctx = repo[node]
                  for fn in files:
-                     if not fn in mf:
+                     wfn = util.pconvert(fn)
+                     if not wfn in ctx:
                          # skipping new file after a merge ?
                          continue
-                     wfn = util.pconvert(fn)
                      ui.note('  %s\n' % wfn)
                      dest = os.path.join(base, wfn)
                      destdir = os.path.dirname(dest)
                      if not os.path.isdir(destdir):
                          os.makedirs(destdir)
-                     data = repo.wwritedata(wfn, repo.file(wfn).read(mf[wfn]))
+                     data = repo.wwritedata(wfn, ctx[wfn].data())
                      open(dest, 'wb').write(data)
                  return dirname
                  - just invoke the diff for a single file in the working dir
                  '''
                  node1, node2 = cmdutil.revpair(repo, opts['rev'])
-                 files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
-                 modified, added, removed, deleted, unknown = repo.status(
-                     node1, node2, files, match=matchfn)[:5]
+                 matcher = cmdutil.match(repo, pats, opts)
+                 modified, added, removed = repo.status(node1, node2, matcher)[:3]
                  if not (modified or added or removed):
                      return 0

hgext/fetch.py

0 +1 0

              #
              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
+             '''pulling, updating and merging in one command'''
              from mercurial.i18n import _
              from mercurial.node import nullid, short

hgext/gpg.py

0 +1 -1

                      repo.opener("localsigs", "ab").write(sigmessage)
                      return
-                 for x in repo.status()[:5]:
+                 for x in repo.status(unknown=True)[:5]:
                      if ".hgsigs" in x and not opts["force"]:
                          raise util.Abort(_("working copy of .hgsigs is changed "
                                             "(please commit .hgsigs manually "

hgext/graphlog.py

0 +6 -6

              #
              # This software may be used and distributed according to the terms of
              # the GNU General Public License, incorporated herein by reference.
+             '''show revision graphs in terminal windows'''
              import os
              import sys
              from mercurial.i18n import _
              from mercurial.node import nullrev
              from mercurial.util import Abort, canonpath
+             from mercurial import util
              def revision_grapher(repo, start_rev, stop_rev):
                  """incremental revision grapher
                      for parent in parents:
                          if parent not in next_revs:
                              parents_to_add.append(parent)
-                     parents_to_add.sort()
-                     next_revs[rev_index:rev_index + 1] = parents_to_add
+                     next_revs[rev_index:rev_index + 1] = util.sort(parents_to_add)
                      edges = []
                      for parent in parents:
                  assert start_rev >= stop_rev
                  curr_rev = start_rev
                  revs = []
-                 filerev = repo.file(path).count() - 1
+                 filerev = len(repo.file(path)) - 1
                  while filerev >= 0:
                      fctx = repo.filectx(path, fileid=filerev)
                      for parent in parents:
                          if parent not in next_revs:
                              parents_to_add.append(parent)
-                     parents_to_add.sort()
-                     next_revs[rev_index:rev_index + 1] = parents_to_add
+                     next_revs[rev_index:rev_index + 1] = util.sort(parents_to_add)
                      edges = []
                      for parent in parents:
                      revs = revrange(repo, rev_opt)
                      return (max(revs), min(revs))
                  else:
-                     return (repo.changelog.count() - 1, 0)
+                     return (len(repo) - 1, 0)
              def graphlog(ui, repo, path=None, **opts):
                  """show revision history alongside an ASCII revision graph

hgext/hgk.py

0 +52 -54

              #
              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
+             #
-             # The hgk extension allows browsing the history of a repository in a
-             # graphical way. It requires Tcl/Tk version 8.4 or later. (Tcl/Tk is
-             # not distributed with Mercurial.)
+             #
-             # hgk consists of two parts: a Tcl script that does the displaying and
-             # querying of information, and an extension to mercurial named hgk.py,
-             # which provides hooks for hgk to get information. hgk can be found in
-             # the contrib directory, and hgk.py can be found in the hgext
-             # directory.
+             #
-             # To load the hgext.py extension, add it to your .hgrc file (you have
-             # to use your global $HOME/.hgrc file, not one in a repository). You
-             # can specify an absolute path:
+             #
-             #   [extensions]
-             #   hgk=/usr/local/lib/hgk.py
+             #
-             # Mercurial can also scan the default python library path for a file
-             # named 'hgk.py' if you set hgk empty:
+             #
-             #   [extensions]
-             #   hgk=
+             #
-             # The hg view command will launch the hgk Tcl script. For this command
-             # to work, hgk must be in your search path. Alternately, you can
-             # specify the path to hgk in your .hgrc file:
+             #
-             #   [hgk]
-             #   path=/location/of/hgk
+             #
-             # hgk can make use of the extdiff extension to visualize
-             # revisions. Assuming you had already configured extdiff vdiff
-             # command, just add:
+             #
-             #   [hgk]
-             #   vdiff=vdiff
+             #
-             # Revisions context menu will now display additional entries to fire
-             # vdiff on hovered and selected revisions.
+             '''browsing the repository in a graphical way
+             The hgk extension allows browsing the history of a repository in a
+             graphical way. It requires Tcl/Tk version 8.4 or later. (Tcl/Tk is
+             not distributed with Mercurial.)
+             hgk consists of two parts: a Tcl script that does the displaying and
+             querying of information, and an extension to mercurial named hgk.py,
+             which provides hooks for hgk to get information. hgk can be found in
+             the contrib directory, and hgk.py can be found in the hgext directory.
+             To load the hgext.py extension, add it to your .hgrc file (you have
+             to use your global $HOME/.hgrc file, not one in a repository). You
+             can specify an absolute path:
+               [extensions]
+               hgk=/usr/local/lib/hgk.py
+             Mercurial can also scan the default python library path for a file
+             named 'hgk.py' if you set hgk empty:
+               [extensions]
+               hgk=
+             The hg view command will launch the hgk Tcl script. For this command
+             to work, hgk must be in your search path. Alternately, you can
+             specify the path to hgk in your .hgrc file:
+               [hgk]
+               path=/location/of/hgk
+             hgk can make use of the extdiff extension to visualize revisions.
+             Assuming you had already configured extdiff vdiff command, just add:
+               [hgk]
+               vdiff=vdiff
+             Revisions context menu will now display additional entries to fire
+             vdiff on hovered and selected revisions.'''
              import os
-             from mercurial import commands, util, patch, revlog
+             from mercurial import commands, util, patch, revlog, cmdutil
              from mercurial.node import nullid, nullrev, short
              def difftree(ui, repo, node1=None, node2=None, *files, **opts):
                  """diff trees from two commits"""
                  def __difftree(repo, node1, node2, files=[]):
                      assert node2 is not None
-                     mmap = repo.changectx(node1).manifest()
-                     mmap2 = repo.changectx(node2).manifest()
-                     status = repo.status(node1, node2, files=files)[:5]
-                     modified, added, removed, deleted, unknown = status
+                     mmap = repo[node1].manifest()
+                     mmap2 = repo[node2].manifest()
+                     m = cmdutil.match(repo, files)
+                     modified, added, removed  = repo.status(node1, node2, m)[:3]
                      empty = short(nullid)
                      for f in modified:
                      if opts['patch']:
                          if opts['pretty']:
                              catcommit(ui, repo, node2, "")
-                         patch.diff(repo, node1, node2,
-                                    files=files,
+                         m = cmdutil.match(repo, files)
+                         patch.diff(repo, node1, node2, match=m,
                                     opts=patch.diffopts(ui, {'git': True}))
                      else:
                          __difftree(repo, node1, node2, files=files)
              def catcommit(ui, repo, n, prefix, ctx=None):
                  nlprefix = '\n' + prefix;
                  if ctx is None:
-                     ctx = repo.changectx(n)
-                 (p1, p2) = ctx.parents()
+                     ctx = repo[n]
                  ui.write("tree %s\n" % short(ctx.changeset()[0])) # use ctx.node() instead ??
-                 if p1: ui.write("parent %s\n" % short(p1.node()))
-                 if p2: ui.write("parent %s\n" % short(p2.node()))
+                 for p in ctx.parents():
+                     ui.write("parent %s\n" % p)
                  date = ctx.date()
                  description = ctx.description().replace("\0", "")
                  lines = description.splitlines()
              # you can specify a commit to stop at by starting the sha1 with ^
              def revtree(ui, args, repo, full="tree", maxnr=0, parents=False):
                  def chlogwalk():
-                     count = repo.changelog.count()
+                     count = len(repo)
                      i = count
                      l = [0] * 100
                      chunk = 100
                                  l[chunk - x:] = [0] * (chunk - x)
                                  break
                              if full != None:
-                                 l[x] = repo.changectx(i + x)
+                                 l[x] = repo[i + x]
                                  l[x].changeset() # force reading
                              else:
                                  l[x] = 1

hgext/highlight.py

0 +29 -29

-             """
-             This is Mercurial extension for syntax highlighting in the file
-             revision view of hgweb.
+             """a mercurial extension for syntax highlighting in hgweb
              It depends on the pygments syntax highlighting library:
              http://pygments.org/
              [web]
              pygments_style = <style>
-             The default is 'colorful'.  If this is changed the corresponding CSS
-             file should be re-generated by running
-             # pygmentize -f html -S <newstyle>
+             The default is 'colorful'.
              -- Adam Hupp <adam@hupp.org>
              """
              from mercurial import demandimport
-             demandimport.ignore.extend(['pkgutil',
-                                         'pkg_resources',
-                                         '__main__',])
+             demandimport.ignore.extend(['pkgutil', 'pkg_resources', '__main__',])
-             from mercurial.hgweb.hgweb_mod import hgweb
+             from mercurial.hgweb import webcommands, webutil, common
              from mercurial import util
              from mercurial.templatefilters import filters
              from pygments.lexers import guess_lexer, guess_lexer_for_filename, TextLexer
              from pygments.formatters import HtmlFormatter
-             SYNTAX_CSS = ('\n<link rel="stylesheet" href="#staticurl#highlight.css" '
+             SYNTAX_CSS = ('\n<link rel="stylesheet" href="{url}highlightcss" '
                            'type="text/css" />')
-             def pygmentize(self, tmpl, fctx, field):
+             def pygmentize(field, fctx, style, tmpl):
                  # append a <link ...> to the syntax highlighting css
                  old_header = ''.join(tmpl('header'))
                  if SYNTAX_CSS not in old_header:
                  if util.binary(text):
                      return
-                 style = self.config("web", "pygments_style", "colorful")
                  # To get multi-line strings right, we can't format line-by-line
                  try:
                      lexer = guess_lexer_for_filename(fctx.path(), text[:1024],
                  newl = oldl.replace('line|escape', 'line|colorize')
                  tmpl.cache[field] = newl
-             def filerevision_highlight(self, tmpl, fctx):
-                 pygmentize(self, tmpl, fctx, 'fileline')
+             web_filerevision = webcommands._filerevision
+             web_annotate = webcommands.annotate
-                 return realrevision(self, tmpl, fctx)
+             def filerevision_highlight(web, tmpl, fctx):
+                 style = web.config('web', 'pygments_style', 'colorful')
+                 pygmentize('fileline', fctx, style, tmpl)
+                 return web_filerevision(web, tmpl, fctx)
-             def fileannotate_highlight(self, tmpl, fctx):
-                 pygmentize(self, tmpl, fctx, 'annotateline')
+             def annotate_highlight(web, req, tmpl):
+                 fctx = webutil.filectx(web.repo, req)
+                 style = web.config('web', 'pygments_style', 'colorful')
+                 pygmentize('annotateline', fctx, style, tmpl)
+                 return web_annotate(web, req, tmpl)
-                 return realannotate(self, tmpl, fctx)
+             def generate_css(web, req, tmpl):
+                 pg_style = web.config('web', 'pygments_style', 'colorful')
+                 fmter = HtmlFormatter(style = pg_style)
+                 req.respond(common.HTTP_OK, 'text/css')
+                 return ['/* pygments_style = %s */\n\n' % pg_style, fmter.get_style_defs('')]
              # monkeypatch in the new version
-             # should be safer than overriding the method in a derived class
-             # and then patching the class
-             realrevision = hgweb.filerevision
-             hgweb.filerevision = filerevision_highlight
-             realannotate = hgweb.fileannotate
-             hgweb.fileannotate = fileannotate_highlight
+             webcommands._filerevision = filerevision_highlight
+             webcommands.annotate = annotate_highlight
+             webcommands.highlightcss = generate_css
+             webcommands.__all__.append('highlightcss')

hgext/inotify/__init__.py

0 +6 -7

                      # to recurse.
                      inotifyserver = False
-                     def status(self, files, match, list_ignored, list_clean,
-                                list_unknown=True):
+                     def status(self, match, ignored, clean, unknown=True):
+                         files = match.files()
                          try:
-                             if not list_ignored and not self.inotifyserver:
+                             if not ignored and not self.inotifyserver:
                                  result = client.query(ui, repo, files, match, False,
-                                                       list_clean, list_unknown)
+                                                       clean, unknown)
                                  if result is not None:
                                      return result
                          except socket.error, err:
                                  if query:
                                      try:
                                          return query(ui, repo, files or [], match,
-                                                      list_ignored, list_clean, list_unknown)
+                                                      ignored, clean, unknown)
                                      except socket.error, err:
                                          ui.warn(_('could not talk to new inotify '
                                                         'server: %s\n') % err[1])
                                          ui.print_exc()
                          return super(inotifydirstate, self).status(
-                             files, match or util.always, list_ignored, list_clean,
-                             list_unknown)
+                             match, ignored, clean, unknown)
                  repo.dirstate.__class__ = inotifydirstate

hgext/inotify/client.py

0 +4 -4

              import common
              import os, select, socket, stat, struct, sys
-             def query(ui, repo, names, match, list_ignored, list_clean, list_unknown=True):
+             def query(ui, repo, names, match, ignored, clean, unknown=True):
                  sock = socket.socket(socket.AF_UNIX)
                  sockpath = repo.join('inotify.sock')
                  sock.connect(sockpath)
                      for n in names or []:
                          yield n
                      states = 'almrx!'
-                     if list_ignored:
+                     if ignored:
                          raise ValueError('this is insanity')
-                     if list_clean: states += 'n'
-                     if list_unknown: states += '?'
+                     if clean: states += 'n'
+                     if unknown: states += '?'
                      yield states
                  req = '\0'.join(genquery())

hgext/inotify/server.py

0 +1 -3

                              self.ui.note('%s processing %d deferred events as %d\n' %
                                           (self.event_time(), self.deferred,
                                            len(self.eventq)))
-                         eventq = self.eventq.items()
-                         eventq.sort()
-                         for wpath, evts in eventq:
+                         for wpath, evts in util.sort(self.eventq.items()):
                              for evt in evts:
                                  self.deferred_event(wpath, evt)
                          self.eventq.clear()

hgext/keyword.py

0 +113 -107

              "Log = {desc}" expands to the first line of the changeset description.
              '''
-             from mercurial import commands, cmdutil, context, dispatch, filelog, revlog
+             from mercurial import commands, cmdutil, dispatch, filelog, revlog
              from mercurial import patch, localrepo, templater, templatefilters, util
              from mercurial.hgweb import webcommands
              from mercurial.node import nullid, hex
              commands.optionalrepo += ' kwdemo'
              # hg commands that do not act on keywords
-             nokwcommands = ('add addremove bundle copy export grep incoming init'
-                             ' log outgoing push rename rollback tip'
+             nokwcommands = ('add addremove annotate bundle copy export grep incoming init'
+                             ' log outgoing push rename rollback tip verify'
                              ' convert email glog')
              # hg commands that trigger expansion only when writing to working dir,
                  '''Returns hgdate in cvs-like UTC format.'''
                  return time.strftime('%Y/%m/%d %H:%M:%S', time.gmtime(date[0]))
              # make keyword tools accessible
-             kwtools = {'templater': None, 'hgcmd': None}
-             # store originals of monkeypatches
-             _patchfile_init = patch.patchfile.__init__
-             _patch_diff = patch.diff
-             _dispatch_parse = dispatch._parse
-             def _kwpatchfile_init(self, ui, fname, missing=False):
-                 '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
-                 rejects or conflicts due to expanded keywords in working dir.'''
-                 _patchfile_init(self, ui, fname, missing=missing)
-                 # shrink keywords read from working dir
-                 kwt = kwtools['templater']
-                 self.lines = kwt.shrinklines(self.fname, self.lines)
-             def _kw_diff(repo, node1=None, node2=None, files=None, match=util.always,
-                          fp=None, changes=None, opts=None):
-                 '''Monkeypatch patch.diff to avoid expansion except when
-                 comparing against working dir.'''
-                 if node2 is not None:
-                     kwtools['templater'].matcher = util.never
-                 elif node1 is not None and node1 != repo.changectx().node():
-                     kwtools['templater'].restrict = True
-                 _patch_diff(repo, node1=node1, node2=node2, files=files, match=match,
-                             fp=fp, changes=changes, opts=opts)
-             def _kwweb_changeset(web, req, tmpl):
-                 '''Wraps webcommands.changeset turning off keyword expansion.'''
-                 kwtools['templater'].matcher = util.never
-                 return web.changeset(tmpl, web.changectx(req))
-             def _kwweb_filediff(web, req, tmpl):
-                 '''Wraps webcommands.filediff turning off keyword expansion.'''
-                 kwtools['templater'].matcher = util.never
-                 return web.filediff(tmpl, web.filectx(req))
-             def _kwdispatch_parse(ui, args):
-                 '''Monkeypatch dispatch._parse to obtain running hg command.'''
-                 cmd, func, args, options, cmdoptions = _dispatch_parse(ui, args)
-                 kwtools['hgcmd'] = cmd
-                 return cmd, func, args, options, cmdoptions
-             # dispatch._parse is run before reposetup, so wrap it here
-             dispatch._parse = _kwdispatch_parse
+             kwtools = {'templater': None, 'hgcmd': '', 'inc': [], 'exc': ['.hg*']}
              class kwtemplater(object):
                      'Header': '{root}/{file},v {node|short} {date|utcdate} {author|user}',
                  }
-                 def __init__(self, ui, repo, inc, exc):
+                 def __init__(self, ui, repo):
                      self.ui = ui
                      self.repo = repo
-                     self.matcher = util.matcher(repo.root, inc=inc, exc=exc)[1]
+                     self.matcher = util.matcher(repo.root,
+                                                 inc=kwtools['inc'], exc=kwtools['exc'])[1]
                      self.restrict = kwtools['hgcmd'] in restricted.split()
                      kwmaps = self.ui.configitems('keywordmaps')
                      if kwmaps: # override default templates
-                         kwmaps = [(k, templater.parsestring(v, quoted=False))
+                         kwmaps = [(k, templater.parsestring(v, False))
                                    for (k, v) in kwmaps]
                          self.templates = dict(kwmaps)
                      escaped = map(re.escape, self.templates.keys())
                  def getnode(self, path, fnode):
                      '''Derives changenode from file path and filenode.'''
                      # used by kwfilelog.read and kwexpand
-                     c = context.filectx(self.repo, path, fileid=fnode)
+                     c = self.repo.filectx(path, fileid=fnode)
                      return c.node()
                  def substitute(self, data, path, node, subfunc):
                          return self.substitute(data, path, changenode, self.re_kw.sub)
                      return data
-                 def iskwfile(self, path, islink):
+                 def iskwfile(self, path, flagfunc):
                      '''Returns true if path matches [keyword] pattern
                      and is not a symbolic link.
                      Caveat: localrepository._link fails on Windows.'''
-                     return self.matcher(path) and not islink(path)
+                     return self.matcher(path) and not 'l' in flagfunc(path)
-                 def overwrite(self, node=None, expand=True, files=None):
+                 def overwrite(self, node, expand, files):
                      '''Overwrites selected files expanding/shrinking keywords.'''
-                     ctx = self.repo.changectx(node)
+                     if node is not None:     # commit
+                         ctx = self.repo[node]
                      mf = ctx.manifest()
-                     if node is not None:     # commit
                          files = [f for f in ctx.files() if f in mf]
                          notify = self.ui.debug
                      else:                    # kwexpand/kwshrink
+                         ctx = self.repo['.']
+                         mf = ctx.manifest()
                          notify = self.ui.note
-                     candidates = [f for f in files if self.iskwfile(f, mf.linkf)]
+                     candidates = [f for f in files if self.iskwfile(f, ctx.flags)]
                      if candidates:
                          self.restrict = True # do not expand when reading
-                         candidates.sort()
                          action = expand and 'expanding' or 'shrinking'
                          for f in candidates:
                              fp = self.repo.file(f)
                  Subclass of filelog to hook into its read, add, cmp methods.
                  Keywords are "stored" unexpanded, and processed on reading.
                  '''
-                 def __init__(self, opener, path):
+                 def __init__(self, opener, kwt, path):
                      super(kwfilelog, self).__init__(opener, path)
-                     self.kwt = kwtools['templater']
+                     self.kwt = kwt
                      self.path = path
                  def read(self, node):
                  def add(self, text, meta, tr, link, p1=None, p2=None):
                      '''Removes keyword substitutions when adding to filelog.'''
                      text = self.kwt.shrink(self.path, text)
-                     return super(kwfilelog, self).add(text, meta, tr, link, p1=p1, p2=p2)
+                     return super(kwfilelog, self).add(text, meta, tr, link, p1, p2)
                  def cmp(self, node, text):
                      '''Removes keyword substitutions for comparison.'''
                          return t2 != text
                      return revlog.revlog.cmp(self, node, text)
-             def _status(ui, repo, kwt, *pats, **opts):
+             def _status(ui, repo, kwt, unknown, *pats, **opts):
                  '''Bails out if [keyword] configuration is not active.
                  Returns status of working directory.'''
                  if kwt:
-                     files, match, anypats = cmdutil.matchpats(repo, pats, opts)
-                     return repo.status(files=files, match=match, list_clean=True)
+                     matcher = cmdutil.match(repo, pats, opts)
+                     return repo.status(match=matcher, unknown=unknown, clean=True)
                  if ui.configitems('keyword'):
                      raise util.Abort(_('[keyword] patterns cannot match'))
                  raise util.Abort(_('no [keyword] patterns configured'))
              def _kwfwrite(ui, repo, expand, *pats, **opts):
                  '''Selects files and passes them to kwtemplater.overwrite.'''
+                 if repo.dirstate.parents()[1] != nullid:
+                     raise util.Abort(_('outstanding uncommitted merge'))
                  kwt = kwtools['templater']
-                 status = _status(ui, repo, kwt, *pats, **opts)
-                 modified, added, removed, deleted, unknown, ignored, clean = status
+                 status = _status(ui, repo, kwt, False, *pats, **opts)
+                 modified, added, removed, deleted = status[:4]
                  if modified or added or removed or deleted:
-                     raise util.Abort(_('outstanding uncommitted changes in given files'))
+                     raise util.Abort(_('outstanding uncommitted changes'))
                  wlock = lock = None
                  try:
                      wlock = repo.wlock()
                      lock = repo.lock()
-                     kwt.overwrite(expand=expand, files=clean)
+                     kwt.overwrite(None, expand, status[6])
                  finally:
                      del wlock, lock
                  branchname = 'demobranch'
                  tmpdir = tempfile.mkdtemp('', 'kwdemo.')
                  ui.note(_('creating temporary repo at %s\n') % tmpdir)
-                 repo = localrepo.localrepository(ui, path=tmpdir, create=True)
+                 repo = localrepo.localrepository(ui, tmpdir, True)
                  ui.setconfig('keyword', fn, '')
                  if args or opts.get('rcfile'):
                      kwstatus = 'custom'
                      ui.readconfig(repo.join('hgrc'))
                  if not opts.get('default'):
                      kwmaps = dict(ui.configitems('keywordmaps')) or kwtemplater.templates
+                 uisetup(ui)
                  reposetup(ui, repo)
                  for k, v in ui.configitems('extensions'):
                      if k.endswith('keyword'):
                  That is, files matched by [keyword] config patterns but not symlinks.
                  '''
                  kwt = kwtools['templater']
-                 status = _status(ui, repo, kwt, *pats, **opts)
+                 status = _status(ui, repo, kwt, opts.get('untracked'), *pats, **opts)
                  modified, added, removed, deleted, unknown, ignored, clean = status
-                 files = modified + added + clean
-                 if opts.get('untracked'):
-                     files += unknown
-                 files.sort()
-                 wctx = repo.workingctx()
-                 islink = lambda p: 'l' in wctx.fileflags(p)
-                 kwfiles = [f for f in files if kwt.iskwfile(f, islink)]
+                 files = util.sort(modified + added + clean + unknown)
+                 wctx = repo[None]
+                 kwfiles = [f for f in files if kwt.iskwfile(f, wctx.flags)]
                  cwd = pats and repo.getcwd() or ''
                  kwfstats = not opts.get('ignore') and (('K', kwfiles),) or ()
                  if opts.get('all') or opts.get('ignore'):
                  _kwfwrite(ui, repo, False, *pats, **opts)
+             def uisetup(ui):
+                 '''Collects [keyword] config in kwtools.
+                 Monkeypatches dispatch._parse if needed.'''
+                 for pat, opt in ui.configitems('keyword'):
+                     if opt != 'ignore':
+                         kwtools['inc'].append(pat)
+                     else:
+                         kwtools['exc'].append(pat)
+                 if kwtools['inc']:
+                     def kwdispatch_parse(ui, args):
+                         '''Monkeypatch dispatch._parse to obtain running hg command.'''
+                         cmd, func, args, options, cmdoptions = dispatch_parse(ui, args)
+                         kwtools['hgcmd'] = cmd
+                         return cmd, func, args, options, cmdoptions
+                     dispatch_parse = dispatch._parse
+                     dispatch._parse = kwdispatch_parse
              def reposetup(ui, repo):
                  '''Sets up repo as kwrepo for keyword substitution.
                  Overrides file method to return kwfilelog instead of filelog
                  if file matches user configuration.
                  Wraps commit to overwrite configured files with updated
                  keyword substitutions.
-                 This is done for local repos only, and only if there are
-                 files configured at all for keyword substitution.'''
+                 Monkeypatches patch and webcommands.'''
                  try:
-                     if (not repo.local() or kwtools['hgcmd'] in nokwcommands.split()
+                     if (not repo.local() or not kwtools['inc']
+                         or kwtools['hgcmd'] in nokwcommands.split()
                          or '.hg' in util.splitpath(repo.root)
                          or repo._url.startswith('bundle:')):
                          return
                  except AttributeError:
                      pass
-                 inc, exc = [], ['.hg*']
-                 for pat, opt in ui.configitems('keyword'):
-                     if opt != 'ignore':
-                         inc.append(pat)
-                     else:
-                         exc.append(pat)
-                 if not inc:
-                     return
-                 kwtools['templater'] = kwt = kwtemplater(ui, repo, inc, exc)
+                 kwtools['templater'] = kwt = kwtemplater(ui, repo)
                  class kwrepo(repo.__class__):
                      def file(self, f):
                          if f[0] == '/':
                              f = f[1:]
-                         return kwfilelog(self.sopener, f)
+                         return kwfilelog(self.sopener, kwt, f)
                      def wread(self, filename):
                          data = super(kwrepo, self).wread(filename)
                          return kwt.wread(filename, data)
                      def commit(self, files=None, text='', user=None, date=None,
-                                match=util.always, force=False, force_editor=False,
+                                match=None, force=False, force_editor=False,
                                 p1=None, p2=None, extra={}, empty_ok=False):
                          wlock = lock = None
                          _p1 = _p2 = None
                                  else:
                                      _p2 = hex(_p2)
-                             node = super(kwrepo,
-                                          self).commit(files=files, text=text, user=user,
-                                                       date=date, match=match, force=force,
-                                                       force_editor=force_editor,
-                                                       p1=p1, p2=p2, extra=extra,
-                                                       empty_ok=empty_ok)
+                             n = super(kwrepo, self).commit(files, text, user, date, match,
+                                                            force, force_editor, p1, p2,
+                                                            extra, empty_ok)
                              # restore commit hooks
                              for name, cmd in commithooks.iteritems():
                                  ui.setconfig('hooks', name, cmd)
-                             if node is not None:
-                                 kwt.overwrite(node=node)
-                                 repo.hook('commit', node=node, parent1=_p1, parent2=_p2)
-                             return node
+                             if n is not None:
+                                 kwt.overwrite(n, True, None)
+                                 repo.hook('commit', node=n, parent1=_p1, parent2=_p2)
+                             return n
                          finally:
                              del wlock, lock
+                 # monkeypatches
+                 def kwpatchfile_init(self, ui, fname, missing=False):
+                     '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
+                     rejects or conflicts due to expanded keywords in working dir.'''
+                     patchfile_init(self, ui, fname, missing)
+                     # shrink keywords read from working dir
+                     self.lines = kwt.shrinklines(self.fname, self.lines)
+                 def kw_diff(repo, node1=None, node2=None, match=None,
+                             fp=None, changes=None, opts=None):
+                     '''Monkeypatch patch.diff to avoid expansion except when
+                     comparing against working dir.'''
+                     if node2 is not None:
+                         kwt.matcher = util.never
+                     elif node1 is not None and node1 != repo['.'].node():
+                         kwt.restrict = True
+                     patch_diff(repo, node1, node2, match, fp, changes, opts)
+                 def kwweb_annotate(web, req, tmpl):
+                     '''Wraps webcommands.annotate turning off keyword expansion.'''
+                     kwt.matcher = util.never
+                     return webcommands_annotate(web, req, tmpl)
+                 def kwweb_changeset(web, req, tmpl):
+                     '''Wraps webcommands.changeset turning off keyword expansion.'''
+                     kwt.matcher = util.never
+                     return webcommands_changeset(web, req, tmpl)
+                 def kwweb_filediff(web, req, tmpl):
+                     '''Wraps webcommands.filediff turning off keyword expansion.'''
+                     kwt.matcher = util.never
+                     return webcommands_filediff(web, req, tmpl)
                  repo.__class__ = kwrepo
-                 patch.patchfile.__init__ = _kwpatchfile_init
-                 patch.diff = _kw_diff
-                 webcommands.changeset = webcommands.rev = _kwweb_changeset
-                 webcommands.filediff = webcommands.diff = _kwweb_filediff
+                 patchfile_init = patch.patchfile.__init__
+                 patch_diff = patch.diff
+                 webcommands_annotate = webcommands.annotate
+                 webcommands_changeset = webcommands.changeset
+                 webcommands_filediff = webcommands.filediff
+                 patch.patchfile.__init__ = kwpatchfile_init
+                 patch.diff = kw_diff
+                 webcommands.annotate = kwweb_annotate
+                 webcommands.changeset = webcommands.rev = kwweb_changeset
+                 webcommands.filediff = webcommands.diff = kwweb_filediff
              cmdtable = {

hgext/mq.py

0 +101 -49

                          bad = self.check_guard(guard)
                          if bad:
                              raise util.Abort(bad)
-                     guards = dict.fromkeys(guards).keys()
-                     guards.sort()
+                     guards = util.sort(util.unique(guards))
                      self.ui.debug('active guards: %s\n' % ' '.join(guards))
                      self.active_guards = guards
                      self.guards_dirty = True
                  def printdiff(self, repo, node1, node2=None, files=None,
                                fp=None, changes=None, opts={}):
-                     fns, matchfn, anypats = cmdutil.matchpats(repo, files, opts)
-                     patch.diff(repo, node1, node2, fns, match=matchfn,
-                                fp=fp, changes=changes, opts=self.diffopts())
+                     m = cmdutil.match(repo, files, opts)
+                     patch.diff(repo, node1, node2, m, fp, changes, self.diffopts())
                  def mergeone(self, repo, mergeq, head, patch, rev):
                      # first try just applying the patch
                      hg.clean(repo, head)
                      self.strip(repo, n, update=False, backup='strip')
-                     ctx = repo.changectx(rev)
+                     ctx = repo[rev]
                      ret = hg.merge(repo, rev)
                      if ret:
                          raise util.Abort(_("update returned %d") % ret)
                                  repo.dirstate.merge(f)
                              p1, p2 = repo.dirstate.parents()
                              repo.dirstate.setparents(p1, merge)
                          files = patch.updatedir(self.ui, repo, files)
-                         n = repo.commit(files, message, user, date, match=util.never,
+                         match = cmdutil.matchfiles(repo, files or [])
+                         n = repo.commit(files, message, user, date, match=match,
                                          force=True)
                          if n == None:
                              break
                      return (err, n)
+                 def _clean_series(self, patches):
+                     indices = util.sort([self.find_series(p) for p in patches])
+                     for i in indices[-1::-1]:
+                         del self.full_series[i]
+                     self.parse_series()
+                     self.series_dirty = 1
+                 def finish(self, repo, revs):
+                     revs.sort()
+                     firstrev = repo[self.applied[0].rev].rev()
+                     appliedbase = 0
+                     patches = []
+                     for rev in util.sort(revs):
+                         if rev < firstrev:
+                             raise util.Abort(_('revision %d is not managed') % rev)
+                         base = revlog.bin(self.applied[appliedbase].rev)
+                         node = repo.changelog.node(rev)
+                         if node != base:
+                             raise util.Abort(_('cannot delete revision %d above '
+                                                'applied patches') % rev)
+                         patches.append(self.applied[appliedbase].name)
+                         appliedbase += 1
+                     r = self.qrepo()
+                     if r:
+                         r.remove(patches, True)
+                     else:
+                         for p in patches:
+                             os.unlink(self.join(p))
+                     del self.applied[:appliedbase]
+                     self.applied_dirty = 1
+                     self._clean_series(patches)
                  def delete(self, repo, patches, opts):
                      if not patches and not opts.get('rev'):
                          raise util.Abort(_('qdelete requires at least one revision or '
                      if appliedbase:
                          del self.applied[:appliedbase]
                          self.applied_dirty = 1
-                     indices = [self.find_series(p) for p in realpatches]
-                     indices.sort()
-                     for i in indices[-1::-1]:
-                         del self.full_series[i]
-                     self.parse_series()
-                     self.series_dirty = 1
+                     self._clean_series(realpatches)
                  def check_toppatch(self, repo):
                      if len(self.applied) > 0:
                      if os.path.exists(self.join(patch)):
                          raise util.Abort(_('patch "%s" already exists') % patch)
                      if opts.get('include') or opts.get('exclude') or pats:
-                         fns, match, anypats = cmdutil.matchpats(repo, pats, opts)
-                         m, a, r, d = repo.status(files=fns, match=match)[:4]
+                         match = cmdutil.match(repo, pats, opts)
+                         m, a, r, d = repo.status(match=match)[:4]
                      else:
                          m, a, r, d = self.check_localchanges(repo, force)
-                         fns, match, anypats = cmdutil.matchpats(repo, m + a + r)
+                         match = cmdutil.match(repo, m + a + r)
                      commitfiles = m + a + r
                      self.check_toppatch(repo)
                      wlock = repo.wlock()
                      finally:
                          del wlock
-                 def strip(self, repo, rev, update=True, backup="all"):
+                 def strip(self, repo, rev, update=True, backup="all", force=None):
                      wlock = lock = None
                      try:
                          wlock = repo.wlock()
                          lock = repo.lock()
                          if update:
-                             self.check_localchanges(repo, refresh=False)
+                             self.check_localchanges(repo, force=force, refresh=False)
                              urev = self.qparents(repo, rev)
                              hg.clean(repo, urev)
                              repo.dirstate.write()
                              self.ui.warn(_('cleaning up working directory...'))
                              node = repo.dirstate.parents()[0]
                              hg.revert(repo, node, None)
-                             unknown = repo.status()[4]
+                             unknown = repo.status(unknown=True)[4]
                              # only remove unknown files that we know we touched or
                              # created while patching
                              for f in unknown:
                              qp = self.qparents(repo, rev)
                              changes = repo.changelog.read(qp)
                              mmap = repo.manifest.read(changes[0])
-                             m, a, r, d, u = repo.status(qp, top)[:5]
+                             m, a, r, d = repo.status(qp, top)[:4]
                              if d:
                                  raise util.Abort("deletions found between repo revs")
                              for f in m:
                          self.ui.write("No patches applied\n")
                          return
                      qp = self.qparents(repo, top)
-                     if opts.get('git'):
-                         self.diffopts().git = True
-                     if opts.get('unified') is not None:
-                         self.diffopts().context = opts['unified']
+                     self._diffopts = patch.diffopts(self.ui, opts)
                      self.printdiff(repo, qp, files=pats, opts=opts)
                  def refresh(self, repo, pats=None, **opts):
                          if opts.get('git'):
                              self.diffopts().git = True
-                         fns, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
+                         matchfn = cmdutil.match(repo, pats, opts)
                          tip = repo.changelog.tip()
                          if top == tip:
                              # if the top of our patch queue is also the tip, there is an
                              # patch already
                              #
                              # this should really read:
-                             #   mm, dd, aa, aa2, uu = repo.status(tip, patchparent)[:5]
+                             #   mm, dd, aa, aa2 = repo.status(tip, patchparent)[:4]
                              # but we do it backwards to take advantage of manifest/chlog
                              # caching against the next repo.status call
                              #
-                             mm, aa, dd, aa2, uu = repo.status(patchparent, tip)[:5]
+                             mm, aa, dd, aa2 = repo.status(patchparent, tip)[:4]
                              changes = repo.changelog.read(tip)
                              man = repo.manifest.read(changes[0])
                              aaa = aa[:]
                              if opts.get('short'):
-                                 filelist = mm + aa + dd
-                                 match = dict.fromkeys(filelist).__contains__
+                                 match = cmdutil.matchfiles(repo, mm + aa + dd)
                              else:
-                                 filelist = None
-                                 match = util.always
-                             m, a, r, d, u = repo.status(files=filelist, match=match)[:5]
+                                 match = cmdutil.matchall(repo)
+                             m, a, r, d = repo.status(match=match)[:4]
                              # we might end up with files that were added between
                              # tip and the dirstate parent, but then changed in the
                              m = util.unique(mm)
                              r = util.unique(dd)
                              a = util.unique(aa)
-                             c = [filter(matchfn, l) for l in (m, a, r, [], u)]
-                             filelist = util.unique(c[0] + c[1] + c[2])
-                             patch.diff(repo, patchparent, files=filelist, match=matchfn,
+                             c = [filter(matchfn, l) for l in (m, a, r)]
+                             match = cmdutil.matchfiles(repo, util.unique(c[0] + c[1] + c[2]))
+                             patch.diff(repo, patchparent, match=match,
                                         fp=patchf, changes=c, opts=self.diffopts())
                              patchf.close()
                              self.applied_dirty = 1
                              self.strip(repo, top, update=False,
                                         backup='strip')
-                             n = repo.commit(filelist, message, user, date, match=matchfn,
+                             n = repo.commit(match.files(), message, user, date, match=match,
                                              force=1)
                              self.applied.append(statusentry(revlog.hex(n), patchfn))
                              self.removeundo(repo)
                                                 self.guards_path)
                                      and not fl.startswith('.')):
                                      msng_list.append(fl)
-                         msng_list.sort()
-                         for x in msng_list:
+                         for x in util.sort(msng_list):
                              pfx = self.ui.verbose and ('D ') or ''
                              self.ui.write("%s%s\n" % (pfx, displayname(x)))
                  the --rev parameter. At least one patch or revision is required.
                  With --rev, mq will stop managing the named revisions (converting
-                 them to regular mercurial changesets). The patches must be applied
-                 and at the base of the stack. This option is useful when the patches
-                 have been applied upstream.
+                 them to regular mercurial changesets). The qfinish command should be
+                 used as an alternative for qdel -r, as the latter option is deprecated.
                  With --keep, the patch files are preserved in the patch directory."""
                  q = repo.mq
                  elif rev not in (cl.ancestor(p[0], rev), cl.ancestor(p[1], rev)):
                      update = False
-                 repo.mq.strip(repo, rev, backup=backup, update=update)
+                 repo.mq.strip(repo, rev, backup=backup, update=update, force=opts['force'])
                  return 0
              def select(ui, repo, *args, **opts):
                      finally:
                          q.save_dirty()
+             def finish(ui, repo, *revrange, **opts):
+                 """move applied patches into repository history
+                 Finishes the specified revisions (corresponding to applied patches) by
+                 moving them out of mq control into regular repository history.
+                 Accepts a revision range or the --all option. If --all is specified, all
+                 applied mq revisions are removed from mq control. Otherwise, the given
+                 revisions must be at the base of the stack of applied patches.
+                 This can be especially useful if your changes have been applied to an
+                 upstream repository, or if you are about to push your changes to upstream.
+                 """
+                 if not opts['applied'] and not revrange:
+                     raise util.Abort(_('no revisions specified'))
+                 elif opts['applied']:
+                     revrange = ('qbase:qtip',) + revrange
+                 q = repo.mq
+                 if not q.applied:
+                     ui.status(_('no patches applied\n'))
+                     return 0
+                 revs = cmdutil.revrange(repo, revrange)
+                 q.finish(repo, revs)
+                 q.save_dirty()
+                 return 0
              def reposetup(ui, repo):
                  class mqrepo(repo.__class__):
                      def abort_if_wdir_patched(self, errmsg, force=False):
                          # we might as well use it, but we won't save it.
                          # update the cache up to the tip
-                         self._updatebranchcache(partial, start, cl.count())
+                         self._updatebranchcache(partial, start, len(cl))
                          return partial
                       _('hg qcommit [OPTION]... [FILE]...')),
                  "^qdiff":
                      (diff,
-                      [('g', 'git', None, _('use git extended diff format')),
-                       ('U', 'unified', 3, _('number of lines of context to show')),
-                      ] + commands.walkopts,
-                      _('hg qdiff [-I] [-X] [-U NUM] [-g] [FILE]...')),
+                      commands.diffopts + commands.diffopts2 + commands.walkopts,
+                      _('hg qdiff [OPTION]... [FILE]...')),
                  "qdelete|qremove|qrm":
                      (delete,
                       [('k', 'keep', None, _('keep patch file')),
                       _('hg qseries [-ms]')),
                  "^strip":
                      (strip,
-                      [('b', 'backup', None, _('bundle unrelated changesets')),
+                      [('f', 'force', None, _('force removal with local changes')),
+                       ('b', 'backup', None, _('bundle unrelated changesets')),
                        ('n', 'nobackup', None, _('no backups'))],
                       _('hg strip [-f] [-b] [-n] REV')),
                  "qtop": (top, [] + seriesopts, _('hg qtop [-s]')),
                  "qunapplied": (unapplied, [] + seriesopts, _('hg qunapplied [-s] [PATCH]')),
+                 "qfinish":
+                     (finish,
+                      [('a', 'applied', None, _('finish all applied changesets'))],
+                      _('hg qfinish [-a] [REV...]')),
              }

hgext/notify.py

0 +4 -6

                          if fnmatch.fnmatch(self.repo.root, pat):
                              for user in users.split(','):
                                  subs[self.fixmail(user)] = 1
-                     subs = subs.keys()
-                     subs.sort()
-                     return subs
+                     return util.sort(subs)
                  def url(self, path=None):
                      return self.ui.config('web', 'baseurl') + (path or self.root)
                  node = bin(node)
                  ui.pushbuffer()
                  if hooktype == 'changegroup':
-                     start = repo.changelog.rev(node)
-                     end = repo.changelog.count()
+                     start = repo[node].rev()
+                     end = len(repo)
                      count = end - start
                      for rev in xrange(start, end):
-                         n.node(repo.changelog.node(rev))
+                         n.node(repo[node].rev())
                      n.diff(node, repo.changelog.tip())
                  else:
                      count = 1

hgext/pager.py

0 +45 -15

		@@ -10,26 +10,56
10	10	# [extension]
11	11	# hgext.pager =
12	12	#
13		# To set the pager that should be used, set the application variable:
14		#
15		# [pager]
16		# pager = LESS='FSRX' less
17		#
18		# If no pager is set, the pager extensions uses the environment
19		# variable $PAGER. If neither pager.pager, nor $PAGER is set, no pager
20		# is used.
21		#
22		# If you notice "BROKEN PIPE" error messages, you can disable them
23		# by setting:
24		#
25		# [pager]
26		# quiet = True
	13	# Run "hg help pager" to get info on configuration.
	14
	15	'''browse command output with external pager
	16
	17	To set the pager that should be used, set the application variable:
	18
	19	[pager]
	20	pager = LESS='FSRX' less
	21
	22	If no pager is set, the pager extensions uses the environment
	23	variable $PAGER. If neither pager.pager, nor $PAGER is set, no pager
	24	is used.
	25
	26	If you notice "BROKEN PIPE" error messages, you can disable them
	27	by setting:
	28
	29	[pager]
	30	quiet = True
	31
	32	You can disable the pager for certain commands by adding them to the
	33	pager.ignore list:
	34
	35	[pager]
	36	ignore = version, help, update
	37
	38	You can also enable the pager only for certain commands using pager.attend:
	39
	40	[pager]
	41	attend = log
	42
	43	If pager.attend is present, pager.ignore will be ignored.
	44
	45	To ignore global commands like "hg version" or "hg help", you have to specify
	46	them in the global .hgrc
	47	'''
27	48
28	49	import sys, os, signal
	50	from mercurial import dispatch, util
29	51
30	52	def uisetup(ui):
	53	def pagecmd(ui, options, cmd, cmdfunc):
31	54	p = ui.config("pager", "pager", os.environ.get("PAGER"))
32	55	if p and sys.stdout.isatty() and '--debugger' not in sys.argv:
	56	attend = ui.configlist('pager', 'attend')
	57	if (cmd in attend or
	58	(cmd not in ui.configlist('pager', 'ignore') and not attend)):
	59	sys.stderr = sys.stdout = util.popen(p, "wb")
33	60	if ui.configbool('pager', 'quiet'):
34	61	signal.signal(signal.SIGPIPE, signal.SIG_DFL)
35		sys.stderr = sys.stdout = os.popen(p, "wb")
	62	return oldrun(ui, options, cmd, cmdfunc)
	63
	64	oldrun = dispatch._runcommand
	65	dispatch._runcommand = pagecmd

hgext/patchbomb.py

0 +73 -71

		@@ -1,72 +1,69
1		~~# Command for~~ sending ~~a collection of~~ Mercurial changesets as a series
2		# of patch emails.
3		#
4		# The series is started off with a "[PATCH 0 of N]" introduction,
5		# which describes the series as a whole.
6		#
7		# Each patch email has a Subject line of "[PATCH M of N] ...", using
8		# the first line of the changeset description as the subject text.
9		# The message contains two or three body parts:
10		#
11		# The remainder of the changeset description.
12		#
13		# [Optional] If the diffstat program is installed, the result of
14		# running diffstat on the patch.
15		#
16		# The patch itself, as generated by "hg export".
17		#
18		# Each message refers to all of its predecessors using the In-Reply-To
19		# and References headers, so they will show up as a sequence in
20		# threaded mail and news readers, and in mail archives.
21		#
22		# For each changeset, you will be prompted with a diffstat summary and
23		# the changeset summary, so you can be sure you are sending the right
24		# changes.
25		#
26		# To enable this extension:
27		#
28		# [extensions]
29		# hgext.patchbomb =
30		#
31		# To configure other defaults, add a section like this to your hgrc
32		# file:
33		#
34		# [email]
35		# from = My Name <my@email>
36		# to = recipient1, recipient2, ...
37		# cc = cc1, cc2, ...
38		# bcc = bcc1, bcc2, ...
39		#
40		# Then you can use the "hg email" command to mail a series of changesets
41		# as a patchbomb.
42		#
43		# To avoid sending patches prematurely, it is a good idea to first run
44		# the "email" command with the "-n" option (test only). You will be
45		# prompted for an email recipient address, a subject an an introductory
46		# message describing the patches of your patchbomb. Then when all is
47		# done, patchbomb messages are displayed. If PAGER environment variable
48		# is set, your pager will be fired up once for each patchbomb message, so
49		# you can verify everything is alright.
50		#
51		# The "-m" (mbox) option is also very useful. Instead of previewing
52		# each patchbomb message in a pager or sending the messages directly,
53		# it will create a UNIX mailbox file with the patch emails. This
54		# mailbox file can be previewed with any mail user agent which supports
55		# UNIX mbox files, i.e. with mutt:
56		#
57		# % mutt -R -f mbox
58		#
59		# When you are previewing the patchbomb messages, you can use `formail'
60		# (a utility that is commonly installed as part of the procmail package),
61		# to send each message out:
62		#
63		# % formail -s sendmail -bm -t < mbox
64		#
65		# That should be all. Now your patchbomb is on its way out.
	1	'''sending Mercurial changesets as a series of patch emails
	2
	3	The series is started off with a "[PATCH 0 of N]" introduction,
	4	which describes the series as a whole.
	5
	6	Each patch email has a Subject line of "[PATCH M of N] ...", using
	7	the first line of the changeset description as the subject text.
	8	The message contains two or three body parts:
	9
	10	The remainder of the changeset description.
	11
	12	[Optional] If the diffstat program is installed, the result of
	13	running diffstat on the patch.
	14
	15	The patch itself, as generated by "hg export".
	16
	17	Each message refers to all of its predecessors using the In-Reply-To
	18	and References headers, so they will show up as a sequence in
	19	threaded mail and news readers, and in mail archives.
	20
	21	For each changeset, you will be prompted with a diffstat summary and
	22	the changeset summary, so you can be sure you are sending the right changes.
	23
	24	To enable this extension:
	25
	26	[extensions]
	27	hgext.patchbomb =
	28
	29	To configure other defaults, add a section like this to your hgrc file:
66	30
67		import os, errno, socket, tempfile
	31	[email]
	32	from = My Name <my@email>
	33	to = recipient1, recipient2, ...
	34	cc = cc1, cc2, ...
	35	bcc = bcc1, bcc2, ...
	36
	37	Then you can use the "hg email" command to mail a series of changesets
	38	as a patchbomb.
	39
	40	To avoid sending patches prematurely, it is a good idea to first run
	41	the "email" command with the "-n" option (test only). You will be
	42	prompted for an email recipient address, a subject an an introductory
	43	message describing the patches of your patchbomb. Then when all is
	44	done, patchbomb messages are displayed. If PAGER environment variable
	45	is set, your pager will be fired up once for each patchbomb message, so
	46	you can verify everything is alright.
	47
	48	The "-m" (mbox) option is also very useful. Instead of previewing
	49	each patchbomb message in a pager or sending the messages directly,
	50	it will create a UNIX mailbox file with the patch emails. This
	51	mailbox file can be previewed with any mail user agent which supports
	52	UNIX mbox files, i.e. with mutt:
	53
	54	% mutt -R -f mbox
	55
	56	When you are previewing the patchbomb messages, you can use `formail'
	57	(a utility that is commonly installed as part of the procmail package),
	58	to send each message out:
	59
	60	% formail -s sendmail -bm -t < mbox
	61
	62	That should be all. Now your patchbomb is on its way out.'''
	63
	64	import os, errno, socket, tempfile, cStringIO
68	65	import email.MIMEMultipart, email.MIMEText, email.MIMEBase
69		import email.Utils, email.Encoders
	66	import email.Utils, email.Encoders, email.Generator
70	67	from mercurial import cmdutil, commands, hg, mail, patch, util
71	68	from mercurial.i18n import _
72	69	from mercurial.node import bin
		@@ -404,11 +401,12 def patchbomb(ui, repo, revs, *opts):
404	401	ui.status('Displaying ', m['Subject'], ' ...\n')
405	402	ui.flush()
406	403	if 'PAGER' in os.environ:
407		fp = os.popen(os.environ['PAGER'], 'w')
	404	fp = util.popen(os.environ['PAGER'], 'w')
408	405	else:
409	406	fp = ui
	407	generator = email.Generator.Generator(fp, mangle_from_=False)
410	408	try:
411		fp.write(m.as_string(0))
	409	generator.flatten(m, 0)
412	410	fp.write('\n')
413	411	except IOError, inst:
414	412	if inst.errno != errno.EPIPE:
		@@ -418,9 +416,10 def patchbomb(ui, repo, revs, *opts):
418	416	elif opts.get('mbox'):
419	417	ui.status('Writing ', m['Subject'], ' ...\n')
420	418	fp = open(opts.get('mbox'), 'In-Reply-To' in m and 'ab+' or 'wb+')
	419	generator = email.Generator.Generator(fp, mangle_from_=True)
421	420	date = util.datestr(start_time, '%a %b %d %H:%M:%S %Y')
422	421	fp.write('From %s %s\n' % (sender_addr, date))
423		fp.write(m.as_string(0))
	422	generator.flatten(m, 0)
424	423	fp.write('\n\n')
425	424	fp.close()
426	425	else:
		@@ -429,7 +428,10 def patchbomb(ui, repo, revs, *opts):
429	428	ui.status('Sending ', m['Subject'], ' ...\n')
430	429	# Exim does not remove the Bcc field
431	430	del m['Bcc']
432		sendmail(sender, to + bcc + cc, m.as_string(0))
	431	fp = cStringIO.StringIO()
	432	generator = email.Generator.Generator(fp, mangle_from_=False)
	433	generator.flatten(m, 0)
	434	sendmail(sender, to + bcc + cc, fp.getvalue())
433	435
434	436	cmdtable = {
435	437	"email":

hgext/purge.py

0 +30 -82

		@@ -27,79 +27,10
27	27	# along with this program; if not, write to the Free Software
28	28	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29	29
30		from mercurial import util, commands
	30	from mercurial import util, commands, cmdutil
31	31	from mercurial.i18n import _
32	32	import os
33	33
34		def dopurge(ui, repo, dirs=None, act=True, ignored=False,
35		abort_on_err=False, eol='\n',
36		force=False, include=None, exclude=None):
37		def error(msg):
38		if abort_on_err:
39		raise util.Abort(msg)
40		else:
41		ui.warn(_('warning: %s\n') % msg)
42
43		def remove(remove_func, name):
44		if act:
45		try:
46		remove_func(os.path.join(repo.root, name))
47		except OSError, e:
48		error(_('%s cannot be removed') % name)
49		else:
50		ui.write('%s%s' % (name, eol))
51
52		if not force:
53		_check_fs(ui, repo)
54
55		directories = []
56		files = []
57		missing = []
58		roots, match, anypats = util.cmdmatcher(repo.root, repo.getcwd(), dirs,
59		include, exclude)
60		for src, f, st in repo.dirstate.statwalk(files=roots, match=match,
61		ignored=ignored, directories=True):
62		if src == 'd':
63		directories.append(f)
64		elif src == 'm':
65		missing.append(f)
66		elif src == 'f' and f not in repo.dirstate:
67		files.append(f)
68
69		directories.sort()
70
71		for f in files:
72		if f not in repo.dirstate:
73		ui.note(_('Removing file %s\n') % f)
74		remove(os.remove, f)
75
76		for f in directories[::-1]:
77		if match(f) and not os.listdir(repo.wjoin(f)):
78		ui.note(_('Removing directory %s\n') % f)
79		remove(os.rmdir, f)
80
81		def _check_fs(ui, repo):
82		"""Abort if there is the chance of having problems with name-mangling fs
83
84		In a name mangling filesystem (e.g. a case insensitive one)
85		dirstate.walk() can yield filenames different from the ones
86		stored in the dirstate. This already confuses the status and
87		add commands, but with purge this may cause data loss.
88
89		To prevent this, this function will abort if there are uncommitted
90		changes.
91		"""
92
93		# We can't use (files, match) to do a partial walk here - we wouldn't
94		# notice a modified README file if the user ran "hg purge readme"
95		modified, added, removed, deleted = repo.status()[:4]
96		if modified or added or removed or deleted:
97		if not util.checkfolding(repo.path) and not ui.quiet:
98		ui.warn(_("Purging on name mangling filesystems is not "
99		"fully supported.\n"))
100		raise util.Abort(_("outstanding uncommitted changes"))
101
102
103	34	def purge(ui, repo, dirs, *opts):
104	35	'''removes files not tracked by mercurial
105	36
		@@ -125,25 +56,42 def purge(ui, repo, dirs, *opts):
125	56	files that this program would delete use the --print option.
126	57	'''
127	58	act = not opts['print']
128		ignored = bool(opts['all'])
129		abort_on_err = bool(opts['abort_on_err'])
130		eol = opts['print0'] and '\0' or '\n'
131		if eol == '\0':
132		# --print0 implies --print
133		act = False
134		force = bool(opts['force'])
135		include = opts['include']
136		exclude = opts['exclude']
137		dopurge(ui, repo, dirs, act, ignored, abort_on_err,
138		eol, force, include, exclude)
	59	eol = '\n'
	60	if opts['print0']:
	61	eol = '\0'
	62	act = False # --print0 implies --print
139	63
	64	def remove(remove_func, name):
	65	if act:
	66	try:
	67	remove_func(os.path.join(repo.root, name))
	68	except OSError, e:
	69	m = _('%s cannot be removed') % name
	70	if opts['abort_on_err']:
	71	raise util.Abort(m)
	72	ui.warn(_('warning: %s\n') % m)
	73	else:
	74	ui.write('%s%s' % (name, eol))
	75
	76	directories = []
	77	match = cmdutil.match(repo, dirs, opts)
	78	match.dir = directories.append
	79	status = repo.status(match=match, ignored=opts['all'], unknown=True)
	80
	81	for f in util.sort(status[4] + status[5]):
	82	ui.note(_('Removing file %s\n') % f)
	83	remove(os.remove, f)
	84
	85	for f in util.sort(directories)[::-1]:
	86	if match(f) and not os.listdir(repo.wjoin(f)):
	87	ui.note(_('Removing directory %s\n') % f)
	88	remove(os.rmdir, f)
140	89
141	90	cmdtable = {
142	91	'purge\|clean':
143	92	(purge,
144	93	[('a', 'abort-on-err', None, _('abort if an error occurs')),
145	94	('', 'all', None, _('purge ignored files too')),
146		('f', 'force', None, _('purge even when there are uncommitted changes')),
147	95	('p', 'print', None, _('print the file names instead of deleting them')),
148	96	('0', 'print0', None, _('end filenames with NUL, for use with xargs'
149	97	' (implies -p)')),

hgext/record.py

0 +10 -9

                  if not ui.interactive:
                      raise util.Abort(_('running non-interactively, use commit instead'))
-                 def recordfunc(ui, repo, files, message, match, opts):
+                 def recordfunc(ui, repo, message, match, opts):
                      """This is generic record driver.
                      It's job is to interactively filter local changes, and accordingly
                      In the end we'll record intresting changes, and everything else will be
                      left in place, so the user can continue his work.
                      """
-                     if files:
+                     if match.files():
                          changes = None
                      else:
-                         changes = repo.status(files=files, match=match)[:5]
-                         modified, added, removed = changes[:3]
-                         files = modified + added + removed
+                         changes = repo.status(match=match)[:3]
+                         modified, added, removed = changes
+                         match = cmdutil.matchfiles(repo, modified + added + removed)
                      diffopts = mdiff.diffopts(git=True, nodates=True)
                      fp = cStringIO.StringIO()
-                     patch.diff(repo, repo.dirstate.parents()[0], files=files,
-                                match=match, changes=changes, opts=diffopts, fp=fp)
+                     patch.diff(repo, repo.dirstate.parents()[0], match=match,
+                                changes=changes, opts=diffopts, fp=fp)
                      fp.seek(0)
                      # 1. filter patch, so we have intending-to apply subset of it
                          try: contenders.update(dict.fromkeys(h.files()))
                          except AttributeError: pass
-                     newfiles = [f for f in files if f in contenders]
+                     newfiles = [f for f in match.files() if f in contenders]
                      if not newfiles:
                          ui.status(_('no changes to record\n'))
                          return 0
                      if changes is None:
-                         changes = repo.status(files=newfiles, match=match)[:5]
+                         match = cmdutil.matchfiles(repo, newfiles)
+                         changes = repo.status(match=match)
                      modified = dict.fromkeys(changes[0])
                      # 2. backup changed files, so we can restore them in the end

hgext/transplant.py

0 +2 -10

                  def apply(self, repo, source, revmap, merges, opts={}):
                      '''apply the revisions in revmap one by one in revision order'''
-                     revs = revmap.keys()
-                     revs.sort()
+                     revs = util.sort(revmap)
                      p1, p2 = repo.dirstate.parents()
                      pulls = []
                      diffopts = patch.diffopts(self.ui, opts)
                      if not os.path.isdir(self.path):
                          os.mkdir(self.path)
                      series = self.opener('series', 'w')
-                     revs = revmap.keys()
-                     revs.sort()
-                     for rev in revs:
+                     for rev in util.sort(revmap):
                          series.write(revlog.hex(revmap[rev]) + '\n')
                      if merges:
                          series.write('# Merges\n')
                      for r in merges:
                          revmap[source.changelog.rev(r)] = r
-                     revs = revmap.keys()
-                     revs.sort()
-                     pulls = []
                      tp.apply(repo, source, revmap, merges, opts)
                  finally:
                      if bundle:

hgext/win32text.py

0 +59 -21

-             # win32text.py - LF <-> CRLF translation utilities for Windows users
+             # win32text.py - LF <-> CRLF/CR translation utilities for Windows/Mac users
              #
              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
              # hgext.win32text =
              # [encode]
              # ** = cleverencode:
+             # # or ** = macencode:
              # [decode]
              # ** = cleverdecode:
+             # # or ** = macdecode:
              #
-             # If not doing conversion, to make sure you do not commit CRLF by accident:
+             # If not doing conversion, to make sure you do not commit CRLF/CR by accident:
              #
              # [hooks]
              # pretxncommit.crlf = python:hgext.win32text.forbidcrlf
+             # # or pretxncommit.cr = python:hgext.win32text.forbidcr
              #
-             # To do the same check on a server to prevent CRLF from being pushed or pulled:
+             # To do the same check on a server to prevent CRLF/CR from being pushed or
+             # pulled:
              #
              # [hooks]
              # pretxnchangegroup.crlf = python:hgext.win32text.forbidcrlf
+             # # or pretxnchangegroup.cr = python:hgext.win32text.forbidcr
              from mercurial.i18n import gettext as _
              from mercurial.node import bin, short
+             from mercurial import util
              import re
              # regexp for single LF without CR preceding.
              re_single_lf = re.compile('(^|[^\r])\n', re.MULTILINE)
-             def dumbdecode(s, cmd, ui=None, repo=None, filename=None, **kwargs):
-                 # warn if already has CRLF in repository.
+             newlinestr = {'\r\n': 'CRLF', '\r': 'CR'}
+             filterstr = {'\r\n': 'clever', '\r': 'mac'}
+             def checknewline(s, newline, ui=None, repo=None, filename=None):
+                 # warn if already has 'newline' in repository.
                  # it might cause unexpected eol conversion.
                  # see issue 302:
                  #   http://www.selenic.com/mercurial/bts/issue302
-                 if '\r\n' in s and ui and filename and repo:
-                     ui.warn(_('WARNING: %s already has CRLF line endings\n'
+                 if newline in s and ui and filename and repo:
+                     ui.warn(_('WARNING: %s already has %s line endings\n'
                                'and does not need EOL conversion by the win32text plugin.\n'
                                'Before your next commit, please reconsider your '
                                'encode/decode settings in \nMercurial.ini or %s.\n') %
-                             (filename, repo.join('hgrc')))
+                             (filename, newlinestr[newline], repo.join('hgrc')))
+             def dumbdecode(s, cmd, **kwargs):
+                 checknewline(s, '\r\n', **kwargs)
                  # replace single LF to CRLF
                  return re_single_lf.sub('\\1\r\n', s)
              def dumbencode(s, cmd):
                  return s.replace('\r\n', '\n')
-             def clevertest(s, cmd):
-                 if '\0' in s: return False
-                 return True
+             def macdumbdecode(s, cmd, **kwargs):
+                 checknewline(s, '\r', **kwargs)
+                 return s.replace('\n', '\r')
+             def macdumbencode(s, cmd):
+                 return s.replace('\r', '\n')
              def cleverdecode(s, cmd, **kwargs):
-                 if clevertest(s, cmd):
+                 if not util.binary(s):
                      return dumbdecode(s, cmd, **kwargs)
                  return s
              def cleverencode(s, cmd):
-                 if clevertest(s, cmd):
+                 if not util.binary(s):
                      return dumbencode(s, cmd)
                  return s
+             def macdecode(s, cmd, **kwargs):
+                 if not util.binary(s):
+                     return macdumbdecode(s, cmd, **kwargs)
+                 return s
+             def macencode(s, cmd):
+                 if not util.binary(s):
+                     return macdumbencode(s, cmd)
+                 return s
              _filters = {
                  'dumbdecode:': dumbdecode,
                  'dumbencode:': dumbencode,
                  'cleverdecode:': cleverdecode,
                  'cleverencode:': cleverencode,
+                 'macdumbdecode:': macdumbdecode,
+                 'macdumbencode:': macdumbencode,
+                 'macdecode:': macdecode,
+                 'macencode:': macencode,
                  }
-             def forbidcrlf(ui, repo, hooktype, node, **kwargs):
+             def forbidnewline(ui, repo, hooktype, node, newline, **kwargs):
                  halt = False
-                 for rev in xrange(repo.changelog.rev(bin(node)), repo.changelog.count()):
-                     c = repo.changectx(rev)
+                 for rev in xrange(repo[node].rev(), len(repo)):
+                     c = repo[rev]
                      for f in c.files():
                          if f not in c:
                              continue
                          data = c[f].data()
-                         if '\0' not in data and '\r\n' in data:
+                         if not util.binary(data) and newline in data:
                              if not halt:
                                  ui.warn(_('Attempt to commit or push text file(s) '
-                                           'using CRLF line endings\n'))
+                                           'using %s line endings\n') %
+                                           newlinestr[newline])
                              ui.warn(_('in %s: %s\n') % (short(c.node()), f))
                              halt = True
                  if halt and hooktype == 'pretxnchangegroup':
+                     crlf = newlinestr[newline].lower()
+                     filter = filterstr[newline]
                      ui.warn(_('\nTo prevent this mistake in your local repository,\n'
                                'add to Mercurial.ini or .hg/hgrc:\n'
                                '\n'
                                '[hooks]\n'
-                               'pretxncommit.crlf = python:hgext.win32text.forbidcrlf\n'
+                               'pretxncommit.%s = python:hgext.win32text.forbid%s\n'
                                '\n'
                                'and also consider adding:\n'
                                '\n'
                                '[extensions]\n'
                                'hgext.win32text =\n'
                                '[encode]\n'
-                               '** = cleverencode:\n'
+                               '** = %sencode:\n'
                                '[decode]\n'
-                               '** = cleverdecode:\n'))
+                               '** = %sdecode:\n') % (crlf, crlf, filter, filter))
                  return halt
+             def forbidcrlf(ui, repo, hooktype, node, **kwargs):
+                 return forbidnewline(ui, repo, hooktype, node, '\r\n', **kwargs)
+             def forbidcr(ui, repo, hooktype, node, **kwargs):
+                 return forbidnewline(ui, repo, hooktype, node, '\r', **kwargs)
              def reposetup(ui, repo):
                  if not repo.local():
                      return

mercurial/archival.py

0 +8 -8

                      def _write_gzip_header(self):
                          self.fileobj.write('\037\213')             # magic header
                          self.fileobj.write('\010')                 # compression method
-                         fname = self.filename[:-3]
+                         # Python 2.6 deprecates self.filename
+                         fname = getattr(self, 'name', None) or self.filename
                          flags = 0
                          if fname:
                              flags = gzip.FNAME
                          data = repo.wwritedata(name, data)
                      archiver.addfile(name, mode, islink, data)
-                 ctx = repo.changectx(node)
                  if kind not in archivers:
                      raise util.Abort(_("unknown archive type '%s'" % kind))
+                 ctx = repo[node]
                  archiver = archivers[kind](dest, prefix, mtime or ctx.date()[0])
-                 m = ctx.manifest()
-                 items = m.items()
-                 items.sort()
                  if repo.ui.configbool("ui", "archivemeta", True):
                      write('.hg_archival.txt', 0644, False,
                            lambda: 'repo: %s\nnode: %s\n' % (
                                hex(repo.changelog.node(0)), hex(node)))
-                 for filename, filenode in items:
-                     write(filename, m.execf(filename) and 0755 or 0644, m.linkf(filename),
-                           lambda: repo.file(filename).read(filenode))
+                 for f in ctx:
+                     ff = ctx.flags(f)
+                     write(f, 'x' in ff and 0755 or 0644, 'l' in ff, ctx[f].data)
                  archiver.done()

mercurial/bundlerepo.py

0 +7 -4

              from node import hex, nullid, short
              from i18n import _
-             import changegroup, util, os, struct, bz2, tempfile, shutil, mdiff
+             import changegroup, util, os, struct, bz2, zlib, tempfile, shutil, mdiff
              import repo, localrepo, changelog, manifest, filelog, revlog
              class bundlerevlog(revlog.revlog):
                          for chunk in changegroup.chunkiter(bundlefile):
                              pos = bundlefile.tell()
                              yield chunk, pos - len(chunk)
-                     n = self.count()
+                     n = len(self)
                      prev = None
                      for chunk, start in chunkpositer():
                          size = len(chunk)
                  def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
                      raise NotImplementedError
-                 def addgroup(self, revs, linkmapper, transaction, unique=0):
+                 def addgroup(self, revs, linkmapper, transaction):
                      raise NotImplementedError
                  def strip(self, rev, minlink):
                      raise NotImplementedError
                          raise util.Abort(_("%s: not a Mercurial bundle file") % bundlename)
                      elif not header.startswith("HG10"):
                          raise util.Abort(_("%s: unknown bundle version") % bundlename)
-                     elif header == "HG10BZ":
+                     elif (header == "HG10BZ") or (header == "HG10GZ"):
                          fdtemp, temp = tempfile.mkstemp(prefix="hg-bundle-",
                                                          suffix=".hg10un", dir=self.path)
                          self.tempfile = temp
                          fptemp = os.fdopen(fdtemp, 'wb')
                          def generator(f):
+                             if header == "HG10BZ":
                              zd = bz2.BZ2Decompressor()
                              zd.decompress("BZ")
+                             elif header == "HG10GZ":
+                                 zd = zlib.decompressobj()
                              for chunk in f:
                                  yield zd.decompress(chunk)
                          gen = generator(util.filechunkiter(self.bundlefile, 4096))

mercurial/changelog.py

0 +6 -9

                      "delay visibility of index updates to other readers"
                      self._realopener = self.opener
                      self.opener = self._delayopener
-                     self._delaycount = self.count()
+                     self._delaycount = len(self)
                      self._delaybuf = []
                      self._delayname = None
                      # if we're doing an initial clone, divert to another file
                      if self._delaycount == 0:
                          self._delayname = fp.name
-                         if not self.count():
+                         if not len(self):
                              # make sure to truncate the file
                              mode = mode.replace('a', 'w')
                          return self._realopener(name + ".a", mode)
                  def encode_extra(self, d):
                      # keys must be sorted to produce a deterministic changelog entry
-                     keys = d.keys()
-                     keys.sort()
-                     items = [_string_escape('%s:%s' % (k, d[k])) for k in keys]
+                     items = [_string_escape('%s:%s' % (k, d[k])) for k in util.sort(d)]
                      return "\0".join(items)
                  def read(self, node):
                      files = l[3:]
                      return (manifest, user, (time, timezone), files, desc, extra)
-                 def add(self, manifest, list, desc, transaction, p1=None, p2=None,
+                 def add(self, manifest, files, desc, transaction, p1=None, p2=None,
                                user=None, date=None, extra={}):
                      user, desc = util.fromlocal(user), util.fromlocal(desc)
                      if extra:
                          extra = self.encode_extra(extra)
                          parseddate = "%s %s" % (parseddate, extra)
-                     list.sort()
-                     l = [hex(manifest), user, parseddate] + list + ["", desc]
+                     l = [hex(manifest), user, parseddate] + util.sort(files) + ["", desc]
                      text = "\n".join(l)
-                     return self.addrevision(text, transaction, self.count(), p1, p2)
+                     return self.addrevision(text, transaction, len(self), p1, p2)

mercurial/cmdutil.py

0 +57 -61

              from i18n import _
              import os, sys, bisect, stat
              import mdiff, bdiff, util, templater, templatefilters, patch, errno
+             import match as _match
              revrangesep = ':'
                      if revrangesep in revs[0]:
                          start, end = revs[0].split(revrangesep, 1)
                          start = revfix(repo, start, 0)
-                         end = revfix(repo, end, repo.changelog.count() - 1)
+                         end = revfix(repo, end, len(repo) - 1)
                      else:
                          start = revfix(repo, revs[0], None)
                  elif len(revs) == 2:
                      if revrangesep in spec:
                          start, end = spec.split(revrangesep, 1)
                          start = revfix(repo, start, 0)
-                         end = revfix(repo, end, repo.changelog.count() - 1)
+                         end = revfix(repo, end, len(repo) - 1)
                          step = start > end and -1 or 1
                          for rev in xrange(start, end+step, step):
                              if rev in seen:
                                            pathname),
                              mode)
-             def matchpats(repo, pats=[], opts={}, globbed=False, default=None):
-                 cwd = repo.getcwd()
-                 return util.cmdmatcher(repo.root, cwd, pats or [], opts.get('include'),
-                                        opts.get('exclude'), globbed=globbed,
-                                        default=default)
+             def match(repo, pats=[], opts={}, globbed=False, default='relpath'):
+                 if not globbed and default == 'relpath':
+                     pats = util.expand_glob(pats or [])
+                 m = _match.match(repo.root, repo.getcwd(), pats,
+                                 opts.get('include'), opts.get('exclude'), default)
+                 def badfn(f, msg):
+                     repo.ui.warn("%s: %s\n" % (m.rel(f), msg))
+                     return False
+                 m.bad = badfn
+                 return m
-             def walk(repo, pats=[], opts={}, node=None, badmatch=None, globbed=False,
-                      default=None):
-                 files, matchfn, anypats = matchpats(repo, pats, opts, globbed=globbed,
-                                                     default=default)
-                 exact = dict.fromkeys(files)
-                 cwd = repo.getcwd()
-                 for src, fn in repo.walk(node=node, files=files, match=matchfn,
-                                          badmatch=badmatch):
-                     yield src, fn, repo.pathto(fn, cwd), fn in exact
+             def matchall(repo):
+                 return _match.always(repo.root, repo.getcwd())
+             def matchfiles(repo, files):
+                 return _match.exact(repo.root, repo.getcwd(), files)
              def findrenames(repo, added=None, removed=None, threshold=0.5):
                  '''find renamed files -- yields (before, after, score) tuples'''
                  if added is None or removed is None:
                      added, removed = repo.status()[1:3]
-                 ctx = repo.changectx()
+                 ctx = repo['.']
                  for a in added:
                      aa = repo.wread(a)
                      bestname, bestscore = None, threshold
                  add, remove = [], []
                  mapping = {}
                  audit_path = util.path_auditor(repo.root)
-                 for src, abs, rel, exact in walk(repo, pats, opts):
+                 m = match(repo, pats, opts)
+                 for abs in repo.walk(m):
                      target = repo.wjoin(abs)
                      good = True
                      try:
                          audit_path(abs)
                      except:
                          good = False
-                     if src == 'f' and good and abs not in repo.dirstate:
+                     rel = m.rel(abs)
+                     exact = m.exact(abs)
+                     if good and abs not in repo.dirstate:
                          add.append(abs)
-                         mapping[abs] = rel, exact
+                         mapping[abs] = rel, m.exact(abs)
                          if repo.ui.verbose or not exact:
                              repo.ui.status(_('adding %s\n') % ((pats and rel) or abs))
                      if repo.dirstate[abs] != 'r' and (not good or not util.lexists(target)
                  def walkpat(pat):
                      srcs = []
-                     for tag, abs, rel, exact in walk(repo, [pat], opts, globbed=True):
+                     m = match(repo, [pat], opts, globbed=True)
+                     for abs in repo.walk(m):
                          state = repo.dirstate[abs]
+                         rel = m.rel(abs)
+                         exact = m.exact(abs)
                          if state in '?r':
                              if exact and state == '?':
                                  ui.warn(_('%s: not copying - file is not managed\n') % rel)
                          self.ui.write(_("copies:      %s\n") % ' '.join(copies))
                      if extra and self.ui.debugflag:
-                         extraitems = extra.items()
-                         extraitems.sort()
-                         for key, value in extraitems:
+                         for key, value in util.sort(extra.items()):
                              self.ui.write(_("extra:       %s=%s\n")
                                            % (key, value.encode('string_escape')))
                          return showlist('tag', self.repo.nodetags(changenode), **args)
                      def showextras(**args):
-                         extras = changes[5].items()
-                         extras.sort()
-                         for key, value in extras:
+                         for key, value in util.sort(changes[5].items()):
                              args = args.copy()
                              args.update(dict(key=key, value=value))
                              yield self.t('extra', **args)
                  # options
                  patch = False
                  if opts.get('patch'):
-                     patch = matchfn or util.always
+                     patch = matchfn or matchall(repo)
                  tmpl = opts.get('template')
                  mapfile = None
              def finddate(ui, repo, date):
                  """Find the tipmost changeset that matches the given date spec"""
                  df = util.matchdate(date)
-                 get = util.cachefunc(lambda r: repo.changectx(r).changeset())
+                 get = util.cachefunc(lambda r: repo[r].changeset())
                  changeiter, matchfn = walkchangerevs(ui, repo, [], get, {'rev':None})
                  results = {}
                  for st, rev, fns in changeiter:
                              if windowsize < sizelimit:
                                  windowsize *= 2
-                 files, matchfn, anypats = matchpats(repo, pats, opts)
+                 m = match(repo, pats, opts)
                  follow = opts.get('follow') or opts.get('follow_first')
-                 if repo.changelog.count() == 0:
-                     return [], matchfn
+                 if not len(repo):
+                     return [], m
                  if follow:
-                     defrange = '%s:0' % repo.changectx().rev()
+                     defrange = '%s:0' % repo['.'].rev()
                  else:
                      defrange = '-1:0'
                  revs = revrange(repo, opts['rev'] or [defrange])
                  wanted = {}
-                 slowpath = anypats or opts.get('removed')
+                 slowpath = m.anypats() or opts.get('removed')
                  fncache = {}
-                 if not slowpath and not files:
+                 if not slowpath and not m.files():
                      # No files, no patterns.  Display all revs.
                      wanted = dict.fromkeys(revs)
                  copies = []
                  if not slowpath:
                      # Only files, no patterns.  Check the history of each file.
                      def filerevgen(filelog, node):
-                         cl_count = repo.changelog.count()
+                         cl_count = len(repo)
                          if node is None:
-                             last = filelog.count() - 1
+                             last = len(filelog) - 1
                          else:
                              last = filelog.rev(node)
                          for i, window in increasing_windows(last, nullrev):
                                  if rev[0] < cl_count:
                                      yield rev
                      def iterfiles():
-                         for filename in files:
+                         for filename in m.files():
                              yield filename, None
                          for filename_node in copies:
                              yield filename_node
                      minrev, maxrev = min(revs), max(revs)
                      for file_, node in iterfiles():
                          filelog = repo.file(file_)
-                         if filelog.count() == 0:
+                         if not len(filelog):
                              if node is None:
                                  # A zero count may be a directory or deleted file, so
                                  # try to find matching entries on the slow path.
                      # The slow path checks files modified in every changeset.
                      def changerevgen():
-                         for i, window in increasing_windows(repo.changelog.count()-1,
-                                                             nullrev):
+                         for i, window in increasing_windows(len(repo) - 1, nullrev):
                              for j in xrange(i - window, i + 1):
                                  yield j, change(j)[3]
                      for rev, changefiles in changerevgen():
-                         matches = filter(matchfn, changefiles)
+                         matches = filter(m, changefiles)
                          if matches:
                              fncache[rev] = matches
                              wanted[rev] = 1
                              del wanted[x]
                  def iterate():
-                     if follow and not files:
+                     if follow and not m.files():
                          ff = followfilter(onlyfirst=opts.get('follow_first'))
                          def want(rev):
                              if ff.match(rev) and rev in wanted:
                      for i, window in increasing_windows(0, len(revs)):
                          yield 'window', revs[0] < revs[-1], revs[-1]
                          nrevs = [rev for rev in revs[i:i+window] if want(rev)]
-                         srevs = list(nrevs)
-                         srevs.sort()
-                         for rev in srevs:
+                         for rev in util.sort(list(nrevs)):
                              fns = fncache.get(rev)
                              if not fns:
                                  def fns_generator():
                                      for f in change(rev)[3]:
-                                         if matchfn(f):
+                                         if m(f):
                                              yield f
                                  fns = fns_generator()
                              yield 'add', rev, fns
                          for rev in nrevs:
                              yield 'iter', rev, None
-                 return iterate(), matchfn
+                 return iterate(), m
              def commit(ui, repo, commitfunc, pats, opts):
                  '''commit the specified files or all outstanding changes'''
                  if opts.get('addremove'):
                      addremove(repo, pats, opts)
-                 fns, match, anypats = matchpats(repo, pats, opts)
+                 m = match(repo, pats, opts)
                  if pats:
-                     status = repo.status(files=fns, match=match)
-                     modified, added, removed, deleted, unknown = status[:5]
-                     files = modified + added + removed
+                     modified, added, removed = repo.status(match=m)[:3]
+                     files = util.sort(modified + added + removed)
                      slist = None
-                     for f in fns:
+                     for f in m.files():
                          if f == '.':
                              continue
                          if f not in files:
                                  raise util.Abort(_("file %s not found!") % rel)
                              if stat.S_ISDIR(mode):
                                  name = f + '/'
-                                 if slist is None:
-                                     slist = list(files)
-                                     slist.sort()
-                                 i = bisect.bisect(slist, name)
-                                 if i >= len(slist) or not slist[i].startswith(name):
+                                 i = bisect.bisect(files, name)
+                                 if i >= len(files) or not files[i].startswith(name):
                                      raise util.Abort(_("no match under directory %s!")
                                                       % rel)
                              elif not (stat.S_ISREG(mode) or stat.S_ISLNK(mode)):
                                                     "unsupported file type!") % rel)
                              elif f not in repo.dirstate:
                                  raise util.Abort(_("file %s not tracked!") % rel)
-                 else:
-                     files = []
+                     m = matchfiles(repo, files)
                  try:
-                     return commitfunc(ui, repo, files, message, match, opts)
+                     return commitfunc(ui, repo, message, m, opts)
                  except ValueError, inst:
                      raise util.Abort(str(inst))

mercurial/commands.py

0 +296 -271

              import difflib, patch, time, help, mdiff, tempfile
              import version, socket
              import archival, changegroup, cmdutil, hgweb.server, sshserver, hbisect
+             import merge as merge_
              # Commands start here, listed alphabetically
                  rejected = None
                  exacts = {}
                  names = []
-                 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
-                                                          badmatch=util.always):
-                     if exact:
+                 m = cmdutil.match(repo, pats, opts)
+                 m.bad = lambda x,y: True
+                 for abs in repo.walk(m):
+                     if m.exact(abs):
                          if ui.verbose:
-                             ui.status(_('adding %s\n') % rel)
+                             ui.status(_('adding %s\n') % m.rel(abs))
                          names.append(abs)
                          exacts[abs] = 1
                      elif abs not in repo.dirstate:
-                         ui.status(_('adding %s\n') % rel)
+                         ui.status(_('adding %s\n') % m.rel(abs))
                          names.append(abs)
                  if not opts.get('dry_run'):
                      rejected = repo.add(names)
                      lastfunc = funcmap[-1]
                      funcmap[-1] = lambda x: "%s:%s" % (lastfunc(x), x[1])
-                 ctx = repo.changectx(opts['rev'])
-                 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
-                                                          node=ctx.node()):
-                     fctx = ctx.filectx(abs)
+                 ctx = repo[opts['rev']]
+                 m = cmdutil.match(repo, pats, opts)
+                 for abs in ctx.walk(m):
+                     fctx = ctx[abs]
                      if not opts['text'] and util.binary(fctx.data()):
-                         ui.write(_("%s: binary file\n") % ((pats and rel) or abs))
+                         ui.write(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))
                          continue
                      lines = fctx.annotate(follow=opts.get('follow'),
                  The default is the basename of the archive, with suffixes removed.
                  '''
-                 ctx = repo.changectx(opts['rev'])
+                 ctx = repo[opts['rev']]
                  if not ctx:
                      raise util.Abort(_('repository has no revisions'))
                  node = ctx.node()
                  dest = cmdutil.make_filename(repo, dest, node)
                  if os.path.realpath(dest) == repo.root:
                      raise util.Abort(_('repository root cannot be destination'))
-                 dummy, matchfn, dummy = cmdutil.matchpats(repo, [], opts)
+                 matchfn = cmdutil.match(repo, [], opts)
                  kind = opts.get('type') or 'files'
                  prefix = opts['prefix']
                  if dest == '-':
-                 hand.  The result of this merge is not committed, as for a normal
                  merge.
-                 See 'hg help dates' for a list of formats valid for -d/--date.
+                 See \'hg help dates\' for a list of formats valid for -d/--date.
                  '''
                  if rev and node:
                      raise util.Abort(_("please specify just one revision"))
                  if label:
                      if not opts.get('force') and label in repo.branchtags():
-                         if label not in [p.branch() for p in repo.workingctx().parents()]:
+                         if label not in [p.branch() for p in repo.parents()]:
                              raise util.Abort(_('a branch of the same name already exists'
                                                 ' (use --force to override)'))
                      repo.dirstate.setbranch(util.fromlocal(label))
                  Use the command 'hg update' to switch to an existing branch.
                  """
                  hexfunc = ui.debugflag and hex or short
-                 activebranches = [util.tolocal(repo.changectx(n).branch())
+                 activebranches = [util.tolocal(repo[n].branch())
                                          for n in repo.heads()]
-                 branches = [(tag in activebranches, repo.changelog.rev(node), tag)
-                                         for tag, node in repo.branchtags().items()]
-                 branches.sort()
+                 branches = util.sort([(tag in activebranches, repo.changelog.rev(node), tag)
+                                       for tag, node in repo.branchtags().items()])
                  branches.reverse()
                  for isactive, node, tag in branches:
                  If no destination repository is specified the destination is
                  assumed to have all the nodes specified by one or more --base
-                 parameters.  To create a bundle containing all changesets, use
-                 --all (or --base null).
+                 --all (or --base null). To change the compression method applied,
+                 use the -t option (by default, bundles are compressed using bz2).
                  The bundle file can then be transferred using conventional means and
                  applied to another repository with the unbundle or pull command.
                      cg = repo.changegroupsubset(o, revs, 'bundle')
                  else:
                      cg = repo.changegroup(o, 'bundle')
-                 changegroup.writebundle(cg, fname, "HG10BZ")
+                 bundletype = opts.get('type', 'bzip2').lower()
+                 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
+                 bundletype = btypes.get(bundletype)
+                 if bundletype not in changegroup.bundletypes:
+                     raise util.Abort(_('unknown bundle type specified with --type'))
+                 changegroup.writebundle(cg, fname, bundletype)
              def cat(ui, repo, file1, *pats, **opts):
                  """output the current or given revision of files
                  %d   dirname of file being printed, or '.' if in repo root
                  %p   root-relative path name of file being printed
                  """
-                 ctx = repo.changectx(opts['rev'])
+                 ctx = repo[opts['rev']]
                  err = 1
-                 for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,
-                                                          ctx.node()):
+                 m = cmdutil.match(repo, (file1,) + pats, opts)
+                 for abs in ctx.walk(m):
                      fp = cmdutil.make_file(repo, opts['output'], ctx.node(), pathname=abs)
-                     data = ctx.filectx(abs).data()
+                     data = ctx[abs].data()
                      if opts.get('decode'):
                          data = repo.wwritedata(abs, data)
                      fp.write(data)
-                 do not report errors.  In these cases, use the --pull option to
                  avoid hardlinking.
-                 You can safely clone repositories and checked out files using full
-                 hardlinks with
+                 In some cases, you can clone repositories and checked out files
+                 using full hardlinks with
                    $ cp -al REPO REPOCLONE
-                 which is the fastest way to clone. However, the operation is not
-                 atomic (making sure REPO is not modified during the operation is
-                 up to you) and you have to make sure your editor breaks hardlinks
-                 (Emacs and most Linux Kernel tools do so).
+                 This is the fastest way to clone, but it is not always safe.  The
+                 operation is not atomic (making sure REPO is not modified during
+                 the operation is up to you) and you have to make sure your editor
+                 breaks hardlinks (Emacs and most Linux Kernel tools do so).  Also,
+                 this is not compatible with certain extensions that place their
+                 metadata under the .hg directory, such as mq.
                  If you use the -r option to clone up to a specific revision, no
                  subsequent revisions will be present in the cloned repository.
                  See 'hg help dates' for a list of formats valid for -d/--date.
                  """
-                 def commitfunc(ui, repo, files, message, match, opts):
-                     return repo.commit(files, message, opts['user'], opts['date'], match,
-                                        force_editor=opts.get('force_editor'))
+                 def commitfunc(ui, repo, message, match, opts):
+                     return repo.commit(match.files(), message, opts['user'], opts['date'],
+                                        match, force_editor=opts.get('force_editor'))
                  node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
                  if not node:
                      ui.write("%s\n" % "\n".join(options))
                      return
-                 clist = cmdutil.findpossible(ui, cmd, table).keys()
-                 clist.sort()
-                 ui.write("%s\n" % "\n".join(clist))
+                 ui.write("%s\n" % "\n".join(util.sort(cmdutil.findpossible(ui, cmd, table))))
              def debugfsinfo(ui, path = "."):
                  file('.debugfsinfo', 'w').write('')
                  ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no'))
                  ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no'))
-                 ui.write('case-sensitive: %s\n' % (util.checkfolding('.debugfsinfo')
+                 ui.write('case-sensitive: %s\n' % (util.checkcase('.debugfsinfo')
                                              and 'yes' or 'no'))
                  os.unlink('.debugfsinfo')
-             def debugrebuildstate(ui, repo, rev=""):
+             def debugrebuildstate(ui, repo, rev="tip"):
                  """rebuild the dirstate as it would look like for the given revision"""
-                 if rev == "":
-                     rev = repo.changelog.tip()
-                 ctx = repo.changectx(rev)
-                 files = ctx.manifest()
+                 ctx = repo[rev]
                  wlock = repo.wlock()
                  try:
-                     repo.dirstate.rebuild(rev, files)
+                     repo.dirstate.rebuild(ctx.node(), ctx.manifest())
                  finally:
                      del wlock
              def debugcheckstate(ui, repo):
                  """validate the correctness of the current dirstate"""
                  parent1, parent2 = repo.dirstate.parents()
-                 m1 = repo.changectx(parent1).manifest()
-                 m2 = repo.changectx(parent2).manifest()
+                 m1 = repo[parent1].manifest()
+                 m2 = repo[parent2].manifest()
                  errors = 0
                  for f in repo.dirstate:
                      state = repo.dirstate[f]
              def debugstate(ui, repo, nodates=None):
                  """show the contents of the current dirstate"""
-                 k = repo.dirstate._map.items()
-                 k.sort()
                  timestr = ""
                  showdate = not nodates
-                 for file_, ent in k:
+                 for file_, ent in util.sort(repo.dirstate._map.items()):
                      if showdate:
                          if ent[3] == -1:
                              # Pad or slice to locale representation
                  r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
                  ui.write("   rev    offset  length   base linkrev" +
                           " nodeid       p1           p2\n")
-                 for i in xrange(r.count()):
+                 for i in r:
                      node = r.node(i)
                      try:
                          pp = r.parents(node)
                  """dump an index DAG as a .dot file"""
                  r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
                  ui.write("digraph G {\n")
-                 for i in xrange(r.count()):
+                 for i in r:
                      node = r.node(i)
                      pp = r.parents(node)
                      ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
              def debugrename(ui, repo, file1, *pats, **opts):
                  """dump rename information"""
-                 ctx = repo.changectx(opts.get('rev', 'tip'))
-                 for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,
-                                                          ctx.node()):
-                     fctx = ctx.filectx(abs)
-                     m = fctx.filelog().renamed(fctx.filenode())
-                     if m:
-                         ui.write(_("%s renamed from %s:%s\n") % (rel, m[0], hex(m[1])))
+                 ctx = repo[opts.get('rev')]
+                 m = cmdutil.match(repo, (file1,) + pats, opts)
+                 for abs in ctx.walk(m):
+                     fctx = ctx[abs]
+                     o = fctx.filelog().renamed(fctx.filenode())
+                     rel = m.rel(abs)
+                     if o:
+                         ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
                      else:
                          ui.write(_("%s not renamed\n") % rel)
              def debugwalk(ui, repo, *pats, **opts):
                  """show how files match on given patterns"""
-                 items = list(cmdutil.walk(repo, pats, opts))
+                 m = cmdutil.match(repo, pats, opts)
+                 items = list(repo.walk(m))
                  if not items:
                      return
-                 fmt = '%%s  %%-%ds  %%-%ds  %%s' % (
-                     max([len(abs) for (src, abs, rel, exact) in items]),
-                     max([len(rel) for (src, abs, rel, exact) in items]))
-                 for src, abs, rel, exact in items:
-                     line = fmt % (src, abs, rel, exact and 'exact' or '')
+                 fmt = 'f  %%-%ds  %%-%ds  %%s' % (
+                     max([len(abs) for abs in items]),
+                     max([len(m.rel(abs)) for abs in items]))
+                 for abs in items:
+                     line = fmt % (abs, m.rel(abs), m.exact(abs) and 'exact' or '')
                      ui.write("%s\n" % line.rstrip())
              def diff(ui, repo, *pats, **opts):
                  """
                  node1, node2 = cmdutil.revpair(repo, opts['rev'])
-                 fns, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
-                 patch.diff(repo, node1, node2, fns, match=matchfn,
-                            opts=patch.diffopts(ui, opts))
+                 m = cmdutil.match(repo, pats, opts)
+                 patch.diff(repo, node1, node2, match=m, opts=patch.diffopts(ui, opts))
              def export(ui, repo, *changesets, **opts):
                  """dump the header and diffs for one or more changesets
                          self.colstart = colstart
                          self.colend = colend
+                     def __hash__(self):
+                         return hash((self.linenum, self.line))
                      def __eq__(self, other):
                          return self.line == other.line
                  fstate = {}
                  skip = {}
-                 get = util.cachefunc(lambda r: repo.changectx(r).changeset())
+                 get = util.cachefunc(lambda r: repo[r].changeset())
                  changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
                  found = False
                  follow = opts.get('follow')
                      if st == 'window':
                          matches.clear()
                      elif st == 'add':
-                         ctx = repo.changectx(rev)
+                         ctx = repo[rev]
                          matches[rev] = {}
                          for fn in fns:
                              if fn in skip:
                              except revlog.LookupError:
                                  pass
                      elif st == 'iter':
-                         states = matches[rev].items()
-                         states.sort()
-                         for fn, m in states:
+                         for fn, m in util.sort(matches[rev].items()):
                              copy = copies.get(rev, {}).get(fn)
                              if fn in skip:
                                  if copy:
                                  fstate[copy] = m
                              prev[fn] = rev
-                 fstate = fstate.items()
-                 fstate.sort()
-                 for fn, state in fstate:
+                 for fn, state in util.sort(fstate.items()):
                      if fn in skip:
                          continue
                      if fn not in copies.get(prev[fn], {}):
                      heads = []
                      visitedset = util.set()
                      for branchrev in branchrevs:
-                         branch = repo.changectx(branchrev).branch()
+                         branch = repo[branchrev].branch()
                          if branch in visitedset:
                              continue
                          visitedset.add(branch)
                      if with_version:
                          version_(ui)
                          ui.write('\n')
+                     try:
                      aliases, i = cmdutil.findcmd(ui, name, table)
+                     except cmdutil.AmbiguousCommand, inst:
+                         select = lambda c: c.lstrip('^').startswith(inst.args[0])
+                         helplist(_('list of commands:\n\n'), select)
+                         return
                      # synopsis
                      ui.write("%s\n" % i[2])
                          return
                      ui.status(header)
-                     fns = h.keys()
-                     fns.sort()
+                     fns = util.sort(h)
                      m = max(map(len, fns))
                      for f in fns:
                          if ui.verbose:
                  def helptopic(name):
                      v = None
-                     for i in help.helptable:
+                     for i, d in help.helptable:
                          l = i.split('|')
                          if name in l:
                              v = i
                              header = l[-1]
+                             doc = d
                      if not v:
                          raise cmdutil.UnknownCommand(name)
                      # description
-                     doc = help.helptable[v]
                      if not doc:
                          doc = _("(No help text available)")
                      if callable(doc):
                                                       and _(" (default: %s)") % default
                                                       or "")))
+                 if ui.verbose:
+                     ui.write(_("\nspecial help topics:\n"))
+                     topics = []
+                     for i, d in help.helptable:
+                         l = i.split('|')
+                         topics.append((", ".join(l[:-1]), l[-1]))
+                     topics_len = max([len(s[0]) for s in topics])
+                     for t, desc in topics:
+                         ui.write(" %-*s  %s\n" % (topics_len, t, desc))
                  if opt_output:
                      opts_len = max([len(line[0]) for line in opt_output if line[1]] or [0])
                      for first, second in opt_output:
                              "can't query remote revision number, branch, or tags")
                      output = [hexfunc(srepo.lookup(rev))]
                  elif not rev:
-                     ctx = repo.workingctx()
+                     ctx = repo[None]
                      parents = ctx.parents()
                      changed = False
                      if default or id or num:
                          output.append("%s%s" % ('+'.join([str(p.rev()) for p in parents]),
                                                  (changed) and "+" or ""))
                  else:
-                     ctx = repo.changectx(rev)
+                     ctx = repo[rev]
                      if default or id:
                          output = [hexfunc(ctx.node())]
                      if num:
                                  message = None
                              ui.debug(_('message:\n%s\n') % message)
-                             wp = repo.workingctx().parents()
+                             wp = repo.parents()
                              if opts.get('exact'):
                                  if not nodeid or not p1:
                                      raise util.Abort(_('not a mercurial patch'))
                  that contain white space as multiple filenames.
                  """
                  end = opts['print0'] and '\0' or '\n'
-                 rev = opts['rev']
-                 if rev:
-                     node = repo.lookup(rev)
-                 else:
-                     node = None
+                 rev = opts.get('rev') or None
                  ret = 1
-                 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts, node=node,
-                                                          badmatch=util.always,
-                                                          default='relglob'):
-                     if src == 'b':
-                         continue
-                     if not node and abs not in repo.dirstate:
+                 m = cmdutil.match(repo, pats, opts, default='relglob')
+                 m.bad = lambda x,y: False
+                 for abs in repo[rev].walk(m):
+                     if not rev and abs not in repo.dirstate:
                          continue
                      if opts['fullpath']:
                          ui.write(os.path.join(repo.root, abs), end)
                      else:
-                         ui.write(((pats and rel) or abs), end)
+                         ui.write(((pats and m.rel(abs)) or abs), end)
                      ret = 0
                  return ret
                  """
-                 get = util.cachefunc(lambda r: repo.changectx(r).changeset())
+                 get = util.cachefunc(lambda r: repo[r].changeset())
                  changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
                  limit = cmdutil.loglimit(opts)
                  if opts['copies'] and opts['rev']:
                      endrev = max(cmdutil.revrange(repo, opts['rev'])) + 1
                  else:
-                     endrev = repo.changelog.count()
+                     endrev = len(repo)
                  rcache = {}
                  ncache = {}
                  def getrenamed(fn, rev):
                          rcache[fn] = {}
                          ncache[fn] = {}
                          fl = repo.file(fn)
-                         for i in xrange(fl.count()):
+                         for i in fl:
                              node = fl.node(i)
                              lr = fl.linkrev(node)
                              renamed = fl.renamed(node)
                      # filectx logic.
                      try:
-                         return repo.changectx(rev).filectx(fn).renamed()
+                         return repo[rev][fn].renamed()
                      except revlog.LookupError:
                          pass
                      return None
                  if not node:
                      node = rev
-                 m = repo.changectx(node).manifest()
-                 files = m.keys()
-                 files.sort()
-                 for f in files:
+                 decor = {'l':'644 @ ', 'x':'755 * ', '':'644   '}
+                 ctx = repo[node]
+                 for f in ctx:
                      if ui.debugflag:
-                         ui.write("%40s " % hex(m[f]))
+                         ui.write("%40s " % hex(ctx.manifest()[f]))
                      if ui.verbose:
-                         type = m.execf(f) and "*" or m.linkf(f) and "@" or " "
-                         perm = m.execf(f) and "755" or "644"
-                         ui.write("%3s %1s " % (perm, type))
+                         ui.write(decor[ctx.flags(f)])
                      ui.write("%s\n" % f)
              def merge(ui, repo, node=None, force=None, rev=None):
                  performed before any further updates are allowed.
                  If no revision is specified, the working directory's parent is a
-                 head revision, and the repository contains exactly one other head,
+                 head revision, and the current branch contains exactly one other head,
-                 the other head is merged with by default.  Otherwise, an explicit
                  revision to merge with must be provided.
                  """
                      node = rev
                  if not node:
-                     heads = repo.heads()
-                     if len(heads) > 2:
-                         raise util.Abort(_('repo has %d heads - '
-                                            'please merge with an explicit rev') %
-                                          len(heads))
+                     branch = repo.changectx(None).branch()
+                     bheads = repo.branchheads(branch)
+                     if len(bheads) > 2:
+                         raise util.Abort(_("branch '%s' has %d heads - "
+                                            "please merge with an explicit rev") %
+                                          (branch, len(bheads)))
                      parent = repo.dirstate.parents()[0]
-                     if len(heads) == 1:
+                     if len(bheads) == 1:
+                         if len(repo.heads()) > 1:
+                             raise util.Abort(_("branch '%s' has one head - "
+                                                "please merge with an explicit rev") %
+                                              branch)
                          msg = _('there is nothing to merge')
-                         if parent != repo.lookup(repo.workingctx().branch()):
+                         if parent != repo.lookup(repo[None].branch()):
                              msg = _('%s - use "hg update" instead') % msg
                          raise util.Abort(msg)
-                     if parent not in heads:
+                     if parent not in bheads:
                          raise util.Abort(_('working dir not at a head rev - '
                                             'use "hg update" or merge with an explicit rev'))
-                     node = parent == heads[0] and heads[-1] or heads[0]
+                     node = parent == bheads[0] and bheads[-1] or bheads[0]
                  return hg.merge(repo, node, force=force)
              def outgoing(ui, repo, dest=None, **opts):
                  """
                  rev = opts.get('rev')
                  if rev:
-                     ctx = repo.changectx(rev)
+                     ctx = repo[rev]
                  else:
-                     ctx = repo.workingctx()
+                     ctx = repo[None]
                  if file_:
-                     files, match, anypats = cmdutil.matchpats(repo, (file_,), opts)
-                     if anypats or len(files) != 1:
+                     m = cmdutil.match(repo, (file_,), opts)
+                     if m.anypats() or len(m.files()) != 1:
                          raise util.Abort(_('can only specify an explicit file name'))
-                     file_ = files[0]
+                     file_ = m.files()[0]
                      filenodes = []
                      for cp in ctx.parents():
                          if not cp:
                  Valid URLs are of the form:
                    local/filesystem/path (or file://local/filesystem/path)
-                   http://[user@]host[:port]/[path]
-                   https://[user@]host[:port]/[path]
-                   ssh://[user@]host[:port]/[path]
+                   http://[user[:pass]@]host[:port]/[path]
+                   https://[user[:pass]@]host[:port]/[path]
+                   ssh://[user[:pass]@]host[:port]/[path]
                    static-http://host[:port]/[path]
                  Paths in the local filesystem can either point to Mercurial
                  Valid URLs are of the form:
                    local/filesystem/path (or file://local/filesystem/path)
-                   ssh://[user@]host[:port]/[path]
-                   http://[user@]host[:port]/[path]
-                   https://[user@]host[:port]/[path]
+                   ssh://[user[:pass]@]host[:port]/[path]
+                   http://[user[:pass]@]host[:port]/[path]
+                   https://[user[:pass]@]host[:port]/[path]
                  An optional identifier after # indicates a particular branch, tag,
                  or changeset to push. If -r is used, the named changeset and all its
                  message = cmdutil.logmessage(opts)
-                 files, match, anypats = cmdutil.matchpats(repo, pats, opts)
+                 files = cmdutil.match(repo, pats, opts).files()
                  if opts['files']:
                      files += open(opts['files']).read().splitlines()
                  if not pats and not after:
                      raise util.Abort(_('no files specified'))
-                 files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
-                 mardu = map(dict.fromkeys, repo.status(files=files, match=matchfn))[:5]
-                 modified, added, removed, deleted, unknown = mardu
-                 remove, forget = [], []
-                 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts):
-                     reason = None
-                     if abs in removed or abs in unknown:
-                         continue
-                     # last column
-                     elif abs in deleted:
-                         remove.append(abs)
-                     # rest of the third row
-                     elif after and not force:
-                         reason = _('still exists (use -f to force removal)')
-                     # rest of the first column
-                     elif abs in added:
-                         if not force:
-                             reason = _('has been marked for add (use -f to force removal)')
+                 m = cmdutil.match(repo, pats, opts)
+                 s = repo.status(match=m, clean=True)
+                 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
+                 def warn(files, reason):
+                     for f in files:
+                         ui.warn(_('not removing %s: file %s (use -f to force removal)\n')
+                                 % (m.rel(f), reason))
+                 if force:
+                     remove, forget = modified + deleted + clean, added
+                 elif after:
+                     remove, forget = deleted, []
+                     warn(modified + added + clean, _('still exists'))
-                         else:
-                             forget.append(abs)
-                     # rest of the third column
-                     elif abs in modified:
-                         if not force:
-                             reason = _('is modified (use -f to force removal)')
-                         else:
-                             remove.append(abs)
-                     # rest of the second column
-                     elif not reason:
-                         remove.append(abs)
-                     if reason:
-                         ui.warn(_('not removing %s: file %s\n') % (rel, reason))
-                     elif ui.verbose or not exact:
-                         ui.status(_('removing %s\n') % rel)
+                     remove, forget = deleted + clean, []
+                     warn(modified, _('is modified'))
+                     warn(added, _('has been marked for add'))
+                 for f in util.sort(remove + forget):
+                     if ui.verbose or not m.exact(f):
+                         ui.status(_('removing %s\n') % m.rel(f))
                  repo.forget(forget)
                  repo.remove(remove, unlink=not after)
                  finally:
                      del wlock
+             def resolve(ui, repo, *pats, **opts):
+                 """resolve file merges from a branch merge or update
+                 This command will attempt to resolve unresolved merges from the
+                 last update or merge command. This will use the local file
+                 revision preserved at the last update or merge to cleanly retry
+                 the file merge attempt. With no file or options specified, this
+                 command will attempt to resolve all unresolved files.
+                 The codes used to show the status of files are:
+                 U = unresolved
+                 R = resolved
+                 """
+                 if len([x for x in opts if opts[x]]) > 1:
+                     raise util.Abort(_("too many options specified"))
+                 ms = merge_.mergestate(repo)
+                 m = cmdutil.match(repo, pats, opts)
+                 for f in ms:
+                     if m(f):
+                         if opts.get("list"):
+                             ui.write("%s %s\n" % (ms[f].upper(), f))
+                         elif opts.get("mark"):
+                             ms.mark(f, "r")
+                         elif opts.get("unmark"):
+                             ms.mark(f, "u")
+                         else:
+                             wctx = repo[None]
+                             mctx = wctx.parents()[-1]
+                             ms.resolve(f, wctx, mctx)
              def revert(ui, repo, *pats, **opts):
                  """restore individual files or dirs to an earlier state
                  if not opts['rev'] and p2 != nullid:
                      raise util.Abort(_('uncommitted merge - please provide a '
                                         'specific revision'))
-                 ctx = repo.changectx(opts['rev'])
+                 ctx = repo[opts['rev']]
                  node = ctx.node()
                  mf = ctx.manifest()
                  if node == parent:
                  try:
                      # walk dirstate.
                      files = []
-                     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
-                                                              badmatch=mf.has_key):
-                         names[abs] = (rel, exact)
-                         if src != 'b':
-                             files.append(abs)
+                     m = cmdutil.match(repo, pats, opts)
+                     m.bad = lambda x,y: False
+                     for abs in repo.walk(m):
+                         names[abs] = m.rel(abs), m.exact(abs)
                      # walk target manifest.
-                     def badmatch(path):
+                     def badfn(path, msg):
                          if path in names:
-                             return True
+                             return False
                          path_ = path + '/'
                          for f in names:
                              if f.startswith(path_):
-                                 return True
+                                 return False
+                         repo.ui.warn("%s: %s\n" % (m.rel(path), msg))
                          return False
-                     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts, node=node,
-                                                              badmatch=badmatch):
-                         if abs in names or src == 'b':
-                             continue
-                         names[abs] = (rel, exact)
-                     changes = repo.status(files=files, match=names.has_key)[:4]
+                     m = cmdutil.match(repo, pats, opts)
+                     m.bad = badfn
+                     for abs in repo[node].walk(m):
+                         if abs not in names:
+                             names[abs] = m.rel(abs), m.exact(abs)
+                     m = cmdutil.matchfiles(repo, names)
+                     changes = repo.status(match=m)[:4]
                      modified, added, removed, deleted = map(dict.fromkeys, changes)
                      # if f is a rename, also revert the source
                          (deleted, revert, remove, False, False),
                          )
-                     entries = names.items()
-                     entries.sort()
-                     for abs, (rel, exact) in entries:
+                     for abs, (rel, exact) in util.sort(names.items()):
                          mfentry = mf.get(abs)
                          target = repo.wjoin(abs)
                          def handle(xlist, dobackup):
                              if pmf is None:
                                  # only need parent manifest in this unlikely case,
                                  # so do not read by default
-                                 pmf = repo.changectx(parent).manifest()
+                                 pmf = repo[parent].manifest()
                              if abs in pmf:
                                  if mfentry:
                                      # if version of file is same in parent and target
                      if not opts.get('dry_run'):
                          def checkout(f):
                              fc = ctx[f]
-                             repo.wwrite(f, fc.data(), fc.fileflags())
+                             repo.wwrite(f, fc.data(), fc.flags())
                          audit_path = util.path_auditor(repo.root)
                          for f in remove[0]:
                          if port == ':80':
                              port = ''
-                         ui.status(_('listening at http://%s%s/%s (%s:%d)\n') %
-                                   (self.httpd.fqaddr, port, prefix, self.httpd.addr, self.httpd.port))
+                         bindaddr = self.httpd.addr
+                         if bindaddr == '0.0.0.0':
+                             bindaddr = '*'
+                         elif ':' in bindaddr: # IPv6
+                             bindaddr = '[%s]' % bindaddr
+                         fqaddr = self.httpd.fqaddr
+                         if ':' in fqaddr:
+                             fqaddr = '[%s]' % fqaddr
+                         ui.status(_('listening at http://%s%s/%s (bound to %s:%d)\n') %
+                                   (fqaddr, port, prefix, bindaddr, self.httpd.port))
                      def run(self):
                          self.httpd.serve_forever()
                    = the previous added file was copied from here
                  """
-                 all = opts['all']
                  node1, node2 = cmdutil.revpair(repo, opts.get('rev'))
-                 files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
                  cwd = (pats and repo.getcwd()) or ''
-                 modified, added, removed, deleted, unknown, ignored, clean = [
-                     n for n in repo.status(node1=node1, node2=node2, files=files,
-                                            match=matchfn,
-                                            list_ignored=opts['ignored']
-                                                         or all and not ui.quiet,
-                                            list_clean=opts['clean'] or all,
-                                            list_unknown=opts['unknown']
-                                                         or not (ui.quiet or
-                                                                 opts['modified'] or
-                                                                 opts['added'] or
-                                                                 opts['removed'] or
-                                                                 opts['deleted'] or
-                                                                 opts['ignored']))]
-                 changetypes = (('modified', 'M', modified),
-                                ('added', 'A', added),
-                                ('removed', 'R', removed),
-                                ('deleted', '!', deleted),
-                                ('unknown', '?', unknown),
-                                ('ignored', 'I', ignored))
-                 explicit_changetypes = changetypes + (('clean', 'C', clean),)
+                 end = opts['print0'] and '\0' or '\n'
                  copy = {}
-                 showcopy = {}
-                 if ((all or opts.get('copies')) and not opts.get('no_status')):
-                     if opts.get('rev') == []:
-                         # fast path, more correct with merge parents
-                         showcopy = copy = repo.dirstate.copies().copy()
-                     else:
-                         ctxn = repo.changectx(nullid)
-                         ctx1 = repo.changectx(node1)
-                         ctx2 = repo.changectx(node2)
+                 states = 'modified added removed deleted unknown ignored clean'.split()
+                 show = [k for k in states if opts[k]]
+                 if opts['all']:
+                     show += ui.quiet and (states[:4] + ['clean']) or states
+                 if not show:
+                     show = ui.quiet and states[:4] or states[:5]
+                 stat = repo.status(node1, node2, cmdutil.match(repo, pats, opts),
+                                    'ignored' in show, 'clean' in show, 'unknown' in show)
+                 changestates = zip(states, 'MAR!?IC', stat)
+                 if (opts['all'] or opts['copies']) and not opts['no_status']:
+                     ctxn = repo[nullid]
+                     ctx1 = repo[node1]
+                     ctx2 = repo[node2]
+                     added = stat[1]
-                         if node2 is None:
-                             ctx2 = repo.workingctx()
-                         copy, diverge = copies.copies(repo, ctx1, ctx2, ctxn)
-                         for k, v in copy.items():
+                         added = stat[0] + stat[1] # merged?
+                     for k, v in copies.copies(repo, ctx1, ctx2, ctxn)[0].items():
+                         if k in added:
+                             copy[k] = v
+                         elif v in added:
                              copy[v] = k
-                 end = opts['print0'] and '\0' or '\n'
-                 for opt, char, changes in ([ct for ct in explicit_changetypes
-                                             if all or opts[ct[0]]]
-                                            or changetypes):
+                 for state, char, files in changestates:
+                     if state in show:
+                         format = "%s %%s%s" % (char, end)
                      if opts['no_status']:
                          format = "%%s%s" % end
-                     else:
-                         format = "%s %%s%s" % (char, end)
-                     for f in changes:
+                         for f in files:
                          ui.write(format % repo.pathto(f, cwd))
-                         if f in copy and (f in added or f in showcopy):
+                             if f in copy:
                              ui.write('  %s%s' % (repo.pathto(copy[f], cwd), end))
              def tag(ui, repo, name1, *names, **opts):
                  See 'hg help dates' for a list of formats valid for -d/--date.
                  """
-                 rev_ = None
+                 rev_ = "."
                  names = (name1,) + names
                  if len(names) != len(dict.fromkeys(names)):
                      raise util.Abort(_('tag names must be unique'))
                  if not rev_ and repo.dirstate.parents()[1] != nullid:
                      raise util.Abort(_('uncommitted merge - please provide a '
                                         'specific revision'))
-                 r = repo.changectx(rev_).node()
+                 r = repo[rev_].node()
                  if not message:
                      message = (_('Added tag %s for changeset %s') %
                  that repository becomes the current tip. The "tip" tag is special
                  and cannot be renamed or assigned to a different changeset.
                  """
-                 cmdutil.show_changeset(ui, repo, opts).show(nullrev+repo.changelog.count())
+                 cmdutil.show_changeset(ui, repo, opts).show(len(repo) - 1)
              def unbundle(ui, repo, fname1, *fnames, **opts):
                  """apply one or more changegroup files
              def update(ui, repo, node=None, rev=None, clean=False, date=None):
                  """update working directory
-                 Update the working directory to the specified revision, or the
-                 tip of the current branch if none is specified.
+                 Update the repository's working directory to the specified revision,
+                 or the tip of the current branch if none is specified.
                  If the requested revision is a descendant of the working
                  directory, any outstanding changes in the working directory will
                  ('M', 'no-merges', None, _('do not show merges')),
              ] + templateopts
+             diffopts = [
+                 ('a', 'text', None, _('treat all files as text')),
+                 ('g', 'git', None, _('use git extended diff format')),
+                 ('', 'nodates', None, _("don't include dates in diff headers"))
+             ]
+             diffopts2 = [
+                 ('p', 'show-function', None, _('show which function each change is in')),
+                 ('w', 'ignore-all-space', None,
+                  _('ignore white space when comparing lines')),
+                 ('b', 'ignore-space-change', None,
+                  _('ignore changes in the amount of white space')),
+                 ('B', 'ignore-blank-lines', None,
+                  _('ignore changes whose lines are all blank')),
+                 ('U', 'unified', '', _('number of lines of context to show'))
+             ]
              table = {
                  "^add": (add, walkopts + dryrunopts, _('hg add [OPTION]... [FILE]...')),
                  "addremove":
                         _('a changeset up to which you would like to bundle')),
                        ('', 'base', [],
                         _('a base changeset to specify instead of a destination')),
-                       ('a', 'all', None,
-                        _('bundle all changesets in the repository')),
+                       ('a', 'all', None, _('bundle all changesets in the repository')),
+                       ('t', 'type', 'bzip2', _('bundle compression type to use')),
                       ] + remoteopts,
                       _('hg bundle [-f] [-a] [-r REV]... [--base REV]... FILE [DEST]')),
                  "cat":
                  "debugwalk": (debugwalk, walkopts, _('hg debugwalk [OPTION]... [FILE]...')),
                  "^diff":
                      (diff,
-                      [('r', 'rev', [], _('revision')),
-                       ('a', 'text', None, _('treat all files as text')),
-                       ('p', 'show-function', None,
-                        _('show which function each change is in')),
-                       ('g', 'git', None, _('use git extended diff format')),
-                       ('', 'nodates', None, _("don't include dates in diff headers")),
-                       ('w', 'ignore-all-space', None,
-                        _('ignore white space when comparing lines')),
-                       ('b', 'ignore-space-change', None,
-                        _('ignore changes in the amount of white space')),
-                       ('B', 'ignore-blank-lines', None,
-                        _('ignore changes whose lines are all blank')),
-                       ('U', 'unified', '',
-                        _('number of lines of context to show'))
-                      ] + walkopts,
+                      [('r', 'rev', [], _('revision'))
+                      ] + diffopts + diffopts2 + walkopts,
                       _('hg diff [OPTION]... [-r REV1 [-r REV2]] [FILE]...')),
                  "^export":
                      (export,
                       [('o', 'output', '', _('print output to file with formatted name')),
-                       ('a', 'text', None, _('treat all files as text')),
-                       ('g', 'git', None, _('use git extended diff format')),
-                       ('', 'nodates', None, _("don't include dates in diff headers")),
-                       ('', 'switch-parent', None, _('diff against the second parent'))],
+                       ('', 'switch-parent', None, _('diff against the second parent'))
+                       ] + diffopts,
                       _('hg export [OPTION]... [-o OUTFILESPEC] REV...')),
                  "grep":
                      (grep,
                         _('forcibly copy over an existing managed file')),
                       ] + walkopts + dryrunopts,
                       _('hg rename [OPTION]... SOURCE... DEST')),
+                 "resolve":
+                     (resolve,
+                      [('l', 'list', None, _('list state of files needing merge')),
+                       ('m', 'mark', None, _('mark files as resolved')),
+                       ('u', 'unmark', None, _('unmark files as resolved'))],
+                       ('hg resolve [OPTION] [FILES...]')),
                  "revert":
                      (revert,
                       [('a', 'all', None, _('revert all changes when no arguments given')),
                       _('hg unbundle [-u] FILE...')),
                  "^update|up|checkout|co":
                      (update,
-                      [('C', 'clean', None, _('overwrite locally modified files')),
+                      [('C', 'clean', None, _('overwrite locally modified files (no backup)')),
                        ('d', 'date', '', _('tipmost revision matching date')),
                        ('r', 'rev', '', _('revision'))],
                       _('hg update [-C] [-d DATE] [[-r] REV]')),

mercurial/context.py

0 +210 -62

              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
-             from node import nullid, nullrev, short
+             from node import nullid, nullrev, short, hex
              from i18n import _
              import ancestor, bdiff, revlog, util, os, errno
              class changectx(object):
                  """A changecontext object makes access to data related to a particular
                  changeset convenient."""
-                 def __init__(self, repo, changeid=None):
+                 def __init__(self, repo, changeid=''):
                      """changeid is a revision number, node, or tag"""
+                     if changeid == '':
+                         changeid = '.'
                      self._repo = repo
-                     if not changeid and changeid != 0:
-                         p1, p2 = self._repo.dirstate.parents()
-                         self._rev = self._repo.changelog.rev(p1)
-                         if self._rev == -1:
-                             changeid = 'tip'
-                         else:
-                             self._node = p1
-                             return
                      self._node = self._repo.lookup(changeid)
                      self._rev = self._repo.changelog.rev(self._node)
                  def __str__(self):
                      return short(self.node())
+                 def __int__(self):
+                     return self.rev()
                  def __repr__(self):
                      return "<changectx %s>" % str(self)
+                 def __hash__(self):
+                     try:
+                         return hash(self._rev)
+                     except AttributeError:
+                         return id(self)
                  def __eq__(self, other):
                      try:
                          return self._rev == other._rev
                          md = self._repo.manifest.readdelta(self._changeset[0])
                          self._manifestdelta = md
                          return self._manifestdelta
+                     elif name == '_parents':
+                         p = self._repo.changelog.parents(self._node)
+                         if p[1] == nullid:
+                             p = p[:-1]
+                         self._parents = [changectx(self._repo, x) for x in p]
+                         return self._parents
                      else:
                          raise AttributeError, name
                      return self.filectx(key)
                  def __iter__(self):
-                     a = self._manifest.keys()
-                     a.sort()
-                     for f in a:
+                     for f in util.sort(self._manifest):
                          yield f
                  def changeset(self): return self._changeset
                  def rev(self): return self._rev
                  def node(self): return self._node
+                 def hex(self): return hex(self._node)
                  def user(self): return self._changeset[1]
                  def date(self): return self._changeset[2]
                  def files(self): return self._changeset[3]
                  def parents(self):
                      """return contexts for each parent changeset"""
-                     p = self._repo.changelog.parents(self._node)
-                     return [changectx(self._repo, x) for x in p]
+                     return self._parents
                  def children(self):
                      """return contexts for each child changeset"""
                      c = self._repo.changelog.children(self._node)
                      return [changectx(self._repo, x) for x in c]
+                 def ancestors(self):
+                     for a in self._repo.changelog.ancestors(self._rev):
+                         yield changectx(self._repo, a)
+                 def descendants(self):
+                     for d in self._repo.changelog.descendants(self._rev):
+                         yield changectx(self._repo, d)
                  def _fileinfo(self, path):
                      if '_manifest' in self.__dict__:
                          try:
                  def filenode(self, path):
                      return self._fileinfo(path)[0]
-                 def fileflags(self, path):
+                 def flags(self, path):
                      try:
                          return self._fileinfo(path)[1]
                      except revlog.LookupError:
                      return filectx(self._repo, path, fileid=fileid,
                                     changectx=self, filelog=filelog)
-                 def filectxs(self):
-                     """generate a file context for each file in this changeset's
-                        manifest"""
-                     mf = self.manifest()
-                     m = mf.keys()
-                     m.sort()
-                     for f in m:
-                         yield self.filectx(f, fileid=mf[f])
                  def ancestor(self, c2):
                      """
                      return the ancestor context of self and c2
                      n = self._repo.changelog.ancestor(self._node, c2._node)
                      return changectx(self._repo, n)
+                 def walk(self, match):
+                     fdict = dict.fromkeys(match.files())
+                     # for dirstate.walk, files=['.'] means "walk the whole tree".
+                     # follow that here, too
+                     fdict.pop('.', None)
+                     for fn in self:
+                         for ffn in fdict:
+                             # match if the file is the exact name or a directory
+                             if ffn == fn or fn.startswith("%s/" % ffn):
+                                 del fdict[ffn]
+                                 break
+                         if match(fn):
+                             yield fn
+                     for fn in util.sort(fdict):
+                         if match.bad(fn, 'No such file in rev ' + str(self)) and match(fn):
+                             yield fn
              class filectx(object):
                  """A filecontext object makes access to data related to a particular
                     filerevision convenient."""
                  def __repr__(self):
                      return "<filectx %s>" % str(self)
+                 def __hash__(self):
+                     try:
+                         return hash((self._path, self._fileid))
+                     except AttributeError:
+                         return id(self)
                  def __eq__(self, other):
                      try:
                          return (self._path == other._path
                  def filerev(self): return self._filerev
                  def filenode(self): return self._filenode
-                 def fileflags(self): return self._changectx.fileflags(self._path)
-                 def isexec(self): return 'x' in self.fileflags()
-                 def islink(self): return 'l' in self.fileflags()
+                 def flags(self): return self._changectx.flags(self._path)
                  def filelog(self): return self._filelog
                  def rev(self):
                      # sort by revision (per file) which is a topological order
                      visit = []
                      for f in files:
-                         fn = [(n.rev(), n) for n in needed.keys() if n._path == f]
+                         fn = [(n.rev(), n) for n in needed if n._path == f]
                          visit.extend(fn)
-                     visit.sort()
                      hist = {}
-                     for r, f in visit:
+                     for r, f in util.sort(visit):
                          curr = decorate(f.data(), f)
                          for p in parents(f):
                              if p != nullid:
              class workingctx(changectx):
                  """A workingctx object makes access to data related to
-                 the current working directory convenient."""
-                 def __init__(self, repo):
+                 the current working directory convenient.
+                 parents - a pair of parent nodeids, or None to use the dirstate.
+                 date - any valid date string or (unixtime, offset), or None.
+                 user - username string, or None.
+                 extra - a dictionary of extra values, or None.
+                 changes - a list of file lists as returned by localrepo.status()
+                            or None to use the repository status.
+                 """
+                 def __init__(self, repo, parents=None, text="", user=None, date=None,
+                              extra=None, changes=None):
                      self._repo = repo
                      self._rev = None
                      self._node = None
+                     self._text = text
+                     if date:
+                         self._date = util.parsedate(date)
+                     if user:
+                         self._user = user
+                     if parents:
+                         self._parents = [changectx(self._repo, p) for p in parents]
+                     if changes:
+                         self._status = list(changes)
+                     self._extra = {}
+                     if extra:
+                         self._extra = extra.copy()
+                     if 'branch' not in self._extra:
+                         branch = self._repo.dirstate.branch()
+                         try:
+                             branch = branch.decode('UTF-8').encode('UTF-8')
+                         except UnicodeDecodeError:
+                             raise util.Abort(_('branch name not in UTF-8!'))
+                         self._extra['branch'] = branch
+                     if self._extra['branch'] == '':
+                         self._extra['branch'] = 'default'
                  def __str__(self):
                      return str(self._parents[0]) + "+"
                  def __nonzero__(self):
                      return True
+                 def __contains__(self, key):
+                     return self._dirstate[key] not in "?r"
                  def __getattr__(self, name):
-                     if name == '_parents':
-                         self._parents = self._repo.parents()
-                         return self._parents
                      if name == '_status':
-                         self._status = self._repo.status()
+                         self._status = self._repo.status(unknown=True)
                          return self._status
+                     elif name == '_user':
+                         self._user = self._repo.ui.username()
+                         return self._user
+                     elif name == '_date':
+                         self._date = util.makedate()
+                         return self._date
                      if name == '_manifest':
                          self._buildmanifest()
                          return self._manifest
+                     elif name == '_parents':
+                         p = self._repo.dirstate.parents()
+                         if p[1] == nullid:
+                             p = p[:-1]
+                         self._parents = [changectx(self._repo, x) for x in p]
+                         return self._parents
                      else:
                          raise AttributeError, name
                      man = self._parents[0].manifest().copy()
                      copied = self._repo.dirstate.copies()
-                     is_exec = util.execfunc(self._repo.root,
-                                             lambda p: man.execf(copied.get(p,p)))
-                     is_link = util.linkfunc(self._repo.root,
-                                             lambda p: man.linkf(copied.get(p,p)))
+                     cf = lambda x: man.flags(copied.get(x, x))
+                     ff = self._repo.dirstate.flagfunc(cf)
                      modified, added, removed, deleted, unknown = self._status[:5]
                      for i, l in (("a", added), ("m", modified), ("u", unknown)):
                          for f in l:
                              man[f] = man.get(copied.get(f, f), nullid) + i
                              try:
-                                 man.set(f, is_exec(f), is_link(f))
+                                 man.set(f, ff(f))
                              except OSError:
                                  pass
                  def manifest(self): return self._manifest
-                 def user(self): return self._repo.ui.username()
-                 def date(self): return util.makedate()
-                 def description(self): return ""
+                 def user(self): return self._user or self._repo.ui.username()
+                 def date(self): return self._date
+                 def description(self): return self._text
                  def files(self):
-                     f = self.modified() + self.added() + self.removed()
-                     f.sort()
-                     return f
+                     return util.sort(self._status[0] + self._status[1] + self._status[2])
                  def modified(self): return self._status[0]
                  def added(self): return self._status[1]
                  def deleted(self): return self._status[3]
                  def unknown(self): return self._status[4]
                  def clean(self): return self._status[5]
-                 def branch(self): return self._repo.dirstate.branch()
+                 def branch(self): return self._extra['branch']
+                 def extra(self): return self._extra
                  def tags(self):
                      t = []
                      [t.extend(p.tags()) for p in self.parents()]
                      return t
-                 def parents(self):
-                     """return contexts for each parent changeset"""
-                     return self._parents
                  def children(self):
                      return []
-                 def fileflags(self, path):
+                 def flags(self, path):
                      if '_manifest' in self.__dict__:
                          try:
                              return self._manifest.flags(path)
                      pnode = self._parents[0].changeset()[0]
                      orig = self._repo.dirstate.copies().get(path, path)
                      node, flag = self._repo.manifest.find(pnode, orig)
-                     is_link = util.linkfunc(self._repo.root,
-                                             lambda p: flag and 'l' in flag)
-                     is_exec = util.execfunc(self._repo.root,
-                                             lambda p: flag and 'x' in flag)
                      try:
-                         return (is_link(path) and 'l' or '') + (is_exec(path) and 'x' or '')
+                         ff = self._repo.dirstate.flagfunc(lambda x: flag or '')
+                         return ff(path)
                      except OSError:
                          pass
                      """return the ancestor context of self and c2"""
                      return self._parents[0].ancestor(c2) # punt on two parents for now
+                 def walk(self, match):
+                     return util.sort(self._repo.dirstate.walk(match, True, False).keys())
              class workingfilectx(filectx):
                  """A workingfilectx object makes access to data related to a particular
                     file in the working directory convenient."""
                          return (t, tz)
                  def cmp(self, text): return self._repo.wread(self._path) == text
+             class memctx(object):
+                 """A memctx is a subset of changectx supposed to be built on memory
+                 and passed to commit functions.
+                 NOTE: this interface and the related memfilectx are experimental and
+                 may change without notice.
+                 parents - a pair of parent nodeids.
+                 filectxfn - a callable taking (repo, memctx, path) arguments and
+                 returning a memctx object.
+                 date - any valid date string or (unixtime, offset), or None.
+                 user - username string, or None.
+                 extra - a dictionary of extra values, or None.
+                 """
+                 def __init__(self, repo, parents, text, files, filectxfn, user=None,
+                              date=None, extra=None):
+                     self._repo = repo
+                     self._rev = None
+                     self._node = None
+                     self._text = text
+                     self._date = date and util.parsedate(date) or util.makedate()
+                     self._user = user
+                     parents = [(p or nullid) for p in parents]
+                     p1, p2 = parents
+                     self._parents = [changectx(self._repo, p) for p in (p1, p2)]
+                     files = util.sort(list(files))
+                     self._status = [files, [], [], [], []]
+                     self._filectxfn = filectxfn
+                     self._extra = extra and extra.copy() or {}
+                     if 'branch' not in self._extra:
+                         self._extra['branch'] = 'default'
+                     elif self._extra.get('branch') == '':
+                         self._extra['branch'] = 'default'
+                 def __str__(self):
+                     return str(self._parents[0]) + "+"
+                 def __int__(self):
+                     return self._rev
+                 def __nonzero__(self):
+                     return True
+                 def user(self): return self._user or self._repo.ui.username()
+                 def date(self): return self._date
+                 def description(self): return self._text
+                 def files(self): return self.modified()
+                 def modified(self): return self._status[0]
+                 def added(self): return self._status[1]
+                 def removed(self): return self._status[2]
+                 def deleted(self): return self._status[3]
+                 def unknown(self): return self._status[4]
+                 def clean(self): return self._status[5]
+                 def branch(self): return self._extra['branch']
+                 def extra(self): return self._extra
+                 def flags(self, f): return self[f].flags()
+                 def parents(self):
+                     """return contexts for each parent changeset"""
+                     return self._parents
+                 def filectx(self, path, filelog=None):
+                     """get a file context from the working directory"""
+                     return self._filectxfn(self._repo, self, path)
+             class memfilectx(object):
+                 """A memfilectx is a subset of filectx supposed to be built by client
+                 code and passed to commit functions.
+                 """
+                 def __init__(self, path, data, islink, isexec, copied):
+                     """copied is the source file path, or None."""
+                     self._path = path
+                     self._data = data
+                     self._flags = (islink and 'l' or '') + (isexec and 'x' or '')
+                     self._copied = None
+                     if copied:
+                         self._copied = (copied, nullid)
+                 def __nonzero__(self): return True
+                 def __str__(self): return "%s@%s" % (self.path(), self._changectx)
+                 def path(self): return self._path
+                 def data(self): return self._data
+                 def flags(self): return self._flags
+                 def isexec(self): return 'x' in self._flags
+                 def islink(self): return 'l' in self._flags
+                 def renamed(self): return self._copied

mercurial/copies.py

0 +7 -7

              def _nonoverlap(d1, d2, d3):
                  "Return list of elements in d1 not in d2 or d3"
-                 l = [d for d in d1 if d not in d3 and d not in d2]
-                 l.sort()
-                 return l
+                 return util.sort([d for d in d1 if d not in d3 and d not in d2])
              def _dirname(f):
                  s = f.rfind("/")
                      visit += [(p, depth - 1) for p in fc.parents()]
                  # return old names sorted by depth
-                 old = old.values()
-                 old.sort()
-                 return [o[1] for o in old]
+                 return [o[1] for o in util.sort(old.values())]
              def _findlimit(repo, a, b):
                  "find the earliest revision that's an ancestor of a or b but not both"
                  #   - quit when interesting revs is zero
                  cl = repo.changelog
-                 working = cl.count() # pseudo rev for the working directory
+                 working = len(cl) # pseudo rev for the working directory
                  if a is None:
                      a = working
                  if b is None:
                  if not c1 or not c2 or c1 == c2:
                      return {}, {}
+                 # avoid silly behavior for parent -> working dir
+                 if c2.node() == None and c1.node() == repo.dirstate.parents()[0]:
+                     return repo.dirstate.copies(), {}
                  limit = _findlimit(repo, c1.rev(), c2.rev())
                  m1 = c1.manifest()
                  m2 = c2.manifest()

mercurial/dirstate.py

0 +217 -260

              from node import nullid
              from i18n import _
-             import struct, os, bisect, stat, strutil, util, errno, ignore
+             import struct, os, bisect, stat, util, errno, ignore
              import cStringIO, osutil, sys
              _unknown = ('?', 0, 0, 0)
              _format = ">cllll"
+             def _finddirs(path):
+                 pos = len(path)
+                 while 1:
+                     pos = path.rfind('/', 0, pos)
+                     if pos == -1:
+                         break
+                     yield path[:pos]
              class dirstate(object):
                  def __init__(self, opener, ui, root):
                      elif name == '_copymap':
                          self._read()
                          return self._copymap
+                     elif name == '_foldmap':
+                         _foldmap = {}
+                         for name in self._map:
+                             norm = os.path.normcase(os.path.normpath(name))
+                             _foldmap[norm] = name
+                         self._foldmap = _foldmap
+                         return self._foldmap
                      elif name == '_branch':
                          try:
                              self._branch = (self._opener("branch").read().strip()
                              if err.errno != errno.ENOENT: raise
                          return self._pl
                      elif name == '_dirs':
-                         self._dirs = {}
-                         for f in self._map:
-                             if self[f] != 'r':
-                                 self._incpath(f)
+                         dirs = {}
+                         for f,s in self._map.items():
+                             if s[0] != 'r':
+                                 for base in _finddirs(f):
+                                     dirs[base] = dirs.get(base, 0) + 1
+                         self._dirs = dirs
                          return self._dirs
                      elif name == '_ignore':
                          files = [self._join('.hgignore')]
                      elif name == '_slash':
                          self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/'
                          return self._slash
+                     elif name == '_checklink':
+                         self._checklink = util.checklink(self._root)
+                         return self._checklink
                      elif name == '_checkexec':
                          self._checkexec = util.checkexec(self._root)
                          return self._checkexec
+                     elif name == '_checkcase':
+                         self._checkcase = not util.checkcase(self._join('.hg'))
+                         return self._checkcase
+                     elif name == 'normalize':
+                         if self._checkcase:
+                             self.normalize = self._normalize
+                         else:
+                             self.normalize = lambda x: x
+                         return self.normalize
                      else:
                          raise AttributeError, name
                  def _join(self, f):
                      return os.path.join(self._root, f)
+                 def flagfunc(self, fallback):
+                     if self._checklink:
+                         if self._checkexec:
+                             def f(x):
+                                 p = os.path.join(self._root, x)
+                                 if os.path.islink(p):
+                                     return 'l'
+                                 if util.is_exec(p):
+                                     return 'x'
+                                 return ''
+                             return f
+                         def f(x):
+                             if os.path.islink(os.path.join(self._root, x)):
+                                 return 'l'
+                             if 'x' in fallback(x):
+                                 return 'x'
+                             return ''
+                         return f
+                     if self._checkexec:
+                         def f(x):
+                             if 'l' in fallback(x):
+                                 return 'l'
+                             if util.is_exec(os.path.join(self._root, x)):
+                                 return 'x'
+                             return ''
+                         return f
+                     return fallback
                  def getcwd(self):
                      cwd = os.getcwd()
                      if cwd == self._root: return ''
                      return key in self._map
                  def __iter__(self):
-                     a = self._map.keys()
-                     a.sort()
-                     for x in a:
+                     for x in util.sort(self._map):
                          yield x
                  def parents(self):
                          dmap[f] = e # we hold onto e[4] because making a subtuple is slow
                  def invalidate(self):
-                     for a in "_map _copymap _branch _pl _dirs _ignore".split():
+                     for a in "_map _copymap _foldmap _branch _pl _dirs _ignore".split():
                          if a in self.__dict__:
                              delattr(self, a)
                      self._dirty = False
                  def copies(self):
                      return self._copymap
-                 def _incpath(self, path):
-                     c = path.rfind('/')
-                     if c >= 0:
+                 def _droppath(self, f):
+                     if self[f] not in "?r" and "_dirs" in self.__dict__:
                          dirs = self._dirs
-                         base = path[:c]
-                         if base not in dirs:
-                             self._incpath(base)
-                             dirs[base] = 1
-                         else:
-                             dirs[base] += 1
-                 def _decpath(self, path):
-                     c = path.rfind('/')
-                     if c >= 0:
-                         base = path[:c]
-                         dirs = self._dirs
+                         for base in _finddirs(f):
                          if dirs[base] == 1:
                              del dirs[base]
-                             self._decpath(base)
                          else:
                              dirs[base] -= 1
-                 def _incpathcheck(self, f):
+                 def _addpath(self, f, check=False):
+                     oldstate = self[f]
+                     if check or oldstate == "r":
                      if '\r' in f or '\n' in f:
-                         raise util.Abort(_("'\\n' and '\\r' disallowed in filenames: %r")
-                                          % f)
-                     # shadows
+                             raise util.Abort(
+                                 _("'\\n' and '\\r' disallowed in filenames: %r") % f)
                      if f in self._dirs:
                          raise util.Abort(_('directory %r already in dirstate') % f)
-                     for c in strutil.rfindall(f, '/'):
-                         d = f[:c]
+                         # shadows
+                         for d in _finddirs(f):
                          if d in self._dirs:
                              break
                          if d in self._map and self[d] != 'r':
-                             raise util.Abort(_('file %r in dirstate clashes with %r') %
-                                              (d, f))
-                     self._incpath(f)
-                 def _changepath(self, f, newstate, relaxed=False):
-                     # handle upcoming path changes
-                     oldstate = self[f]
-                     if oldstate not in "?r" and newstate in "?r":
-                         if "_dirs" in self.__dict__:
-                             self._decpath(f)
-                         return
-                     if oldstate in "?r" and newstate not in "?r":
-                         if relaxed and oldstate == '?':
-                             # XXX
-                             # in relaxed mode we assume the caller knows
-                             # what it is doing, workaround for updating
-                             # dir-to-file revisions
-                             if "_dirs" in self.__dict__:
-                                 self._incpath(f)
-                             return
-                         self._incpathcheck(f)
-                         return
+                                 raise util.Abort(
+                                     _('file %r in dirstate clashes with %r') % (d, f))
+                     if oldstate in "?r" and "_dirs" in self.__dict__:
+                         dirs = self._dirs
+                         for base in _finddirs(f):
+                             dirs[base] = dirs.get(base, 0) + 1
                  def normal(self, f):
                      'mark a file normal and clean'
                      self._dirty = True
-                     self._changepath(f, 'n', True)
+                     self._addpath(f)
                      s = os.lstat(self._join(f))
                      self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0)
                      if f in self._copymap:
                          if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
                              return
                      self._dirty = True
-                     self._changepath(f, 'n', True)
+                     self._addpath(f)
                      self._map[f] = ('n', 0, -1, -1, 0)
                      if f in self._copymap:
                          del self._copymap[f]
                  def normaldirty(self, f):
                      'mark a file normal, but dirty'
                      self._dirty = True
-                     self._changepath(f, 'n', True)
+                     self._addpath(f)
                      self._map[f] = ('n', 0, -2, -1, 0)
                      if f in self._copymap:
                          del self._copymap[f]
                  def add(self, f):
                      'mark a file added'
                      self._dirty = True
-                     self._changepath(f, 'a')
+                     self._addpath(f, True)
                      self._map[f] = ('a', 0, -1, -1, 0)
                      if f in self._copymap:
                          del self._copymap[f]
                  def remove(self, f):
                      'mark a file removed'
                      self._dirty = True
-                     self._changepath(f, 'r')
+                     self._droppath(f)
                      size = 0
                      if self._pl[1] != nullid and f in self._map:
                          entry = self._map[f]
                      'mark a file merged'
                      self._dirty = True
                      s = os.lstat(self._join(f))
-                     self._changepath(f, 'm', True)
+                     self._addpath(f)
                      self._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime, 0)
                      if f in self._copymap:
                          del self._copymap[f]
                      'forget a file'
                      self._dirty = True
                      try:
-                         self._changepath(f, '?')
+                         self._droppath(f)
                          del self._map[f]
                      except KeyError:
                          self._ui.warn(_("not in dirstate: %s\n") % f)
+                 def _normalize(self, path):
+                     if path not in self._foldmap:
+                         if not os.path.exists(path):
+                             return path
+                         self._foldmap[path] = util.fspath(path, self._root)
+                     return self._foldmap[path]
                  def clear(self):
                      self._map = {}
                      if "_dirs" in self.__dict__:
                  def rebuild(self, parent, files):
                      self.clear()
                      for f in files:
-                         if files.execf(f):
+                         if 'x' in files.flags(f):
                              self._map[f] = ('n', 0777, -1, 0, 0)
                          else:
                              self._map[f] = ('n', 0666, -1, 0, 0)
                      st.rename()
                      self._dirty = self._dirtypl = False
-                 def _filter(self, files):
-                     ret = {}
-                     unknown = []
-                     for x in files:
-                         if x == '.':
-                             return self._map.copy()
-                         if x not in self._map:
-                             unknown.append(x)
-                         else:
-                             ret[x] = self._map[x]
-                     if not unknown:
-                         return ret
+                 def _dirignore(self, f):
+                     if f == '.':
+                         return False
+                     if self._ignore(f):
+                         return True
+                     for p in _finddirs(f):
+                         if self._ignore(p):
+                             return True
+                     return False
-                     b = self._map.keys()
-                     b.sort()
-                     blen = len(b)
+                 def walk(self, match, unknown, ignored):
+                     '''
+                     walk recursively through the directory tree, finding all files
+                     matched by the match function
+                     results are yielded in a tuple (filename, stat), where stat
+                     and st is the stat result if the file was found in the directory.
+                     '''
-                     for x in unknown:
-                         bs = bisect.bisect(b, "%s%s" % (x, '/'))
-                         while bs < blen:
-                             s = b[bs]
-                             if len(s) > len(x) and s.startswith(x):
-                                 ret[s] = self._map[s]
-                             else:
-                                 break
-                             bs += 1
-                     return ret
+                     def fwarn(f, msg):
+                         self._ui.warn('%s: %s\n' % (self.pathto(ff), msg))
+                         return False
+                     badfn = fwarn
+                     if hasattr(match, 'bad'):
+                         badfn = match.bad
-                 def _supported(self, f, mode, verbose=False):
-                     if stat.S_ISREG(mode) or stat.S_ISLNK(mode):
-                         return True
-                     if verbose:
+                     def badtype(f, mode):
                          kind = 'unknown'
                          if stat.S_ISCHR(mode): kind = _('character device')
                          elif stat.S_ISBLK(mode): kind = _('block device')
                          elif stat.S_ISDIR(mode): kind = _('directory')
                          self._ui.warn(_('%s: unsupported file type (type is %s)\n')
                                        % (self.pathto(f), kind))
-                     return False
-                 def _dirignore(self, f):
-                     if f == '.':
-                         return False
-                     if self._ignore(f):
-                         return True
-                     for c in strutil.findall(f, '/'):
-                         if self._ignore(f[:c]):
-                             return True
-                     return False
-                 def walk(self, files=None, match=util.always, badmatch=None):
-                     # filter out the stat
-                     for src, f, st in self.statwalk(files, match, badmatch=badmatch):
-                         yield src, f
-                 def statwalk(self, files=None, match=util.always, unknown=True,
-                              ignored=False, badmatch=None, directories=False):
-                     '''
-                     walk recursively through the directory tree, finding all files
-                     matched by the match function
-                     results are yielded in a tuple (src, filename, st), where src
-                     is one of:
-                     'f' the file was found in the directory tree
-                     'd' the file is a directory of the tree
-                     'm' the file was only in the dirstate and not in the tree
-                     'b' file was not found and matched badmatch
-                     and st is the stat result if the file was found in the directory.
-                     '''
-                     # walk all files by default
-                     if not files:
-                         files = ['.']
-                         dc = self._map.copy()
-                     else:
-                         files = util.unique(files)
-                         dc = self._filter(files)
-                     def imatch(file_):
-                         if file_ not in dc and self._ignore(file_):
-                             return False
-                         return match(file_)
                      # TODO: don't walk unknown directories if unknown and ignored are False
                      ignore = self._ignore
                      dirignore = self._dirignore
                      if ignored:
-                         imatch = match
                          ignore = util.never
                          dirignore = util.never
-                     # self._root may end with a path separator when self._root == '/'
-                     common_prefix_len = len(self._root)
-                     if not util.endswithsep(self._root):
-                         common_prefix_len += 1
+                     matchfn = match.matchfn
+                     dmap = self._map
                      normpath = util.normpath
+                     normalize = self.normalize
                      listdir = osutil.listdir
                      lstat = os.lstat
                      bisect_left = bisect.bisect_left
-                     isdir = os.path.isdir
                      pconvert = util.pconvert
-                     join = os.path.join
-                     s_isdir = stat.S_ISDIR
-                     supported = self._supported
-                     _join = self._join
-                     known = {'.hg': 1}
+                     getkind = stat.S_IFMT
+                     dirkind = stat.S_IFDIR
+                     regkind = stat.S_IFREG
+                     lnkkind = stat.S_IFLNK
+                     join = self._join
+                     work = []
+                     wadd = work.append
+                     files = util.unique(match.files())
+                     if not files or '.' in files:
+                         files = ['']
+                     results = {'.hg': None}
+                     # step 1: find all explicit files
+                     for ff in util.sort(files):
+                         nf = normalize(normpath(ff))
+                         if nf in results:
+                             continue
-                     # recursion free walker, faster than os.walk.
-                     def findfiles(s):
-                         work = [s]
-                         wadd = work.append
-                         found = []
-                         add = found.append
-                         if directories:
-                             add((normpath(s[common_prefix_len:]), 'd', lstat(s)))
+                         try:
+                             st = lstat(join(nf))
+                             kind = getkind(st.st_mode)
+                             if kind == dirkind:
+                                 if not dirignore(nf):
+                                     wadd(nf)
+                             elif kind == regkind or kind == lnkkind:
+                                 results[nf] = st
+                             else:
+                                 badtype(ff, kind)
+                                 if nf in dmap:
+                                     results[nf] = None
+                         except OSError, inst:
+                             keep = False
+                             prefix = nf + "/"
+                             for fn in dmap:
+                                 if nf == fn or fn.startswith(prefix):
+                                     keep = True
+                                     break
+                             if not keep:
+                                 if inst.errno != errno.ENOENT:
+                                     fwarn(ff, inst.strerror)
+                                 elif badfn(ff, inst.strerror):
+                                     if (nf in dmap or not ignore(nf)) and matchfn(nf):
+                                         results[nf] = None
+                     # step 2: visit subdirectories
-                         while work:
-                             top = work.pop()
-                             entries = listdir(top, stat=True)
-                             # nd is the top of the repository dir tree
-                             nd = normpath(top[common_prefix_len:])
+                         nd = work.pop()
+                         if hasattr(match, 'dir'):
+                             match.dir(nd)
+                         entries = listdir(join(nd), stat=True)
-                             if nd == '.':
-                                 nd = ''
-                             else:
-                                 # do not recurse into a repo contained in this
-                                 # one. use bisect to find .hg directory so speed
-                                 # is good on big directory.
-                                 names = [e[0] for e in entries]
-                                 hg = bisect_left(names, '.hg')
-                                 if hg < len(names) and names[hg] == '.hg':
-                                     if isdir(join(top, '.hg')):
+                             hg = bisect_left(entries, ('.hg'))
+                             if hg < len(entries) and entries[hg][0] == '.hg' \
+                                     and entries[hg][1] == dirkind:
-                                         continue
-                             for f, kind, st in entries:
-                                 np = pconvert(join(nd, f))
-                                 if np in known:
-                                     continue
-                                 known[np] = 1
-                                 p = join(top, f)
-                                 # don't trip over symlinks
-                                 if kind == stat.S_IFDIR:
-                                     if not ignore(np):
-                                         wadd(p)
-                                         if directories:
-                                             add((np, 'd', st))
-                                     if np in dc and match(np):
-                                         add((np, 'm', st))
-                                 elif imatch(np):
-                                     if supported(np, st.st_mode):
-                                         add((np, 'f', st))
-                                     elif np in dc:
-                                         add((np, 'm', st))
-                         found.sort()
-                         return found
+                             nf = normalize(nd and (nd + "/" + f) or f)
+                             if nf not in results:
+                                 if kind == dirkind:
+                                     if not ignore(nf):
+                                         wadd(nf)
+                                     if nf in dmap and matchfn(nf):
+                                         results[nf] = None
+                                 elif kind == regkind or kind == lnkkind:
+                                     if nf in dmap:
+                                         if matchfn(nf):
+                                             results[nf] = st
+                                     elif matchfn(nf) and not ignore(nf):
+                                         results[nf] = st
+                                 elif nf in dmap and matchfn(nf):
+                                     results[nf] = None
-                     # step one, find all files that match our criteria
-                     files.sort()
-                     for ff in files:
-                         nf = normpath(ff)
-                         f = _join(ff)
+                     # step 3: report unseen items in the dmap hash
+                     visit = [f for f in dmap if f not in results and match(f)]
+                     for nf in util.sort(visit):
+                         results[nf] = None
                          try:
-                             st = lstat(f)
+                             st = lstat(join(nf))
+                             kind = getkind(st.st_mode)
+                             if kind == regkind or kind == lnkkind:
+                                 results[nf] = st
                          except OSError, inst:
-                             found = False
-                             for fn in dc:
-                                 if nf == fn or (fn.startswith(nf) and fn[len(nf)] == '/'):
-                                     found = True
-                                     break
-                             if not found:
-                                 if inst.errno != errno.ENOENT or not badmatch:
-                                     self._ui.warn('%s: %s\n' %
-                                                   (self.pathto(ff), inst.strerror))
-                                 elif badmatch and badmatch(ff) and imatch(nf):
-                                     yield 'b', ff, None
-                             continue
-                         if s_isdir(st.st_mode):
-                             if not dirignore(nf):
-                                 for f, src, st in findfiles(f):
-                                     yield src, f, st
-                         else:
-                             if nf in known:
-                                 continue
-                             known[nf] = 1
-                             if match(nf):
-                                 if supported(ff, st.st_mode, verbose=True):
-                                     yield 'f', nf, st
-                                 elif ff in dc:
-                                     yield 'm', nf, st
+                             if inst.errno not in (errno.ENOENT, errno.ENOTDIR):
+                                 raise
-                     # step two run through anything left in the dc hash and yield
-                     # if we haven't already seen it
-                     ks = dc.keys()
-                     ks.sort()
-                     for k in ks:
-                         if k in known:
-                             continue
-                         known[k] = 1
-                         if imatch(k):
-                             yield 'm', k, None
+                     del results['.hg']
+                     return results
-                 def status(self, files, match, list_ignored, list_clean, list_unknown=True):
+                 def status(self, match, ignored, clean, unknown):
+                     listignored, listclean, listunknown = ignored, clean, unknown
                      lookup, modified, added, unknown, ignored = [], [], [], [], []
                      removed, deleted, clean = [], [], []
-                     files = files or []
                      _join = self._join
                      lstat = os.lstat
                      cmap = self._copymap
                      dadd = deleted.append
                      cadd = clean.append
-                     for src, fn, st in self.statwalk(files, match, unknown=list_unknown,
-                                                      ignored=list_ignored):
-                         if fn in dmap:
-                             type_, mode, size, time, foo = dmap[fn]
-                         else:
-                             if (list_ignored or fn in files) and self._dirignore(fn):
-                                 if list_ignored:
+                     for fn, st in self.walk(match, listunknown, listignored).iteritems():
+                         if fn not in dmap:
+                             if (listignored or match.exact(fn)) and self._dirignore(fn):
+                                 if listignored:
                                      iadd(fn)
-                             elif list_unknown:
+                             elif listunknown:
                                  uadd(fn)
                              continue
-                         if src == 'm':
-                             nonexistent = True
-                             if not st:
-                                 try:
-                                     st = lstat(_join(fn))
-                                 except OSError, inst:
-                                     if inst.errno not in (errno.ENOENT, errno.ENOTDIR):
-                                         raise
-                                     st = None
-                                 # We need to re-check that it is a valid file
-                                 if st and self._supported(fn, st.st_mode):
-                                     nonexistent = False
-                             # XXX: what to do with file no longer present in the fs
-                             # who are not removed in the dirstate ?
-                             if nonexistent and type_ in "nma":
+                         state, mode, size, time, foo = dmap[fn]
+                         if not st and state in "nma":
-                                 dadd(fn)
-                                 continue
-                         # check the common case first
-                         if type_ == 'n':
-                             if not st:
-                                 st = lstat(_join(fn))
+                         elif state == 'n':
                              if (size >= 0 and
                                  (size != st.st_size
                                   or ((mode ^ st.st_mode) & 0100 and self._checkexec))
                                  madd(fn)
                              elif time != int(st.st_mtime):
                                  ladd(fn)
-                             elif list_clean:
+                             elif listclean:
                                  cadd(fn)
-                         elif type_ == 'm':
+                         elif state == 'm':
                              madd(fn)
-                         elif type_ == 'a':
+                         elif state == 'a':
                              aadd(fn)
-                         elif type_ == 'r':
+                         elif state == 'r':
                              radd(fn)
                      return (lookup, modified, added, removed, deleted, unknown, ignored,

mercurial/filemerge.py

0 +27 -28

              # 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
+             from node import nullrev, short
              from i18n import _
              import util, os, tempfile, simplemerge, re, filecmp
                      if t not in tools:
                          tools[t] = int(_toolstr(ui, t, "priority", "0"))
                  names = tools.keys()
-                 tools = [(-p,t) for t,p in tools.items()]
-                 tools.sort()
+                 tools = util.sort([(-p,t) for t,p in tools.items()])
                  uimerge = ui.config("ui", "merge")
                  if uimerge:
                      if uimerge not in names:
                          if newdata != data:
                              open(file, "wb").write(newdata)
-             def filemerge(repo, fw, fd, fo, wctx, mctx):
+             def filemerge(repo, mynode, orig, fcd, fco, fca):
                  """perform a 3-way merge in the working directory
-                 fw = original filename in the working directory
-                 fd = destination filename in the working directory
-                 fo = filename in other parent
-                 wctx, mctx = working and merge changecontexts
+                 mynode = parent node before merge
+                 orig = original local filename before merge
+                 fco = other file context
+                 fca = ancestor file context
+                 fcd = local file context for current/destination file
                  """
                  def temp(prefix, ctx):
                      except IOError:
                          return False
-                 fco = mctx.filectx(fo)
-                 if not fco.cmp(wctx.filectx(fd).data()): # files identical?
+                 if not fco.cmp(fcd.data()): # files identical?
                      return None
                  ui = repo.ui
-                 fcm = wctx.filectx(fw)
-                 fca = fcm.ancestor(fco) or repo.filectx(fw, fileid=nullrev)
-                 binary = isbin(fcm) or isbin(fco) or isbin(fca)
-                 symlink = fcm.islink() or fco.islink()
-                 tool, toolpath = _picktool(repo, ui, fw, binary, symlink)
+                 fd = fcd.path()
+                 binary = isbin(fcd) or isbin(fco) or isbin(fca)
+                 symlink = 'l' in fcd.flags() + fco.flags()
+                 tool, toolpath = _picktool(repo, ui, fd, binary, symlink)
                  ui.debug(_("picked tool '%s' for %s (binary %s symlink %s)\n") %
-                            (tool, fw, binary, symlink))
+                            (tool, fd, binary, symlink))
                  if not tool:
                      tool = "internal:local"
                      if ui.prompt(_(" no tool found to merge %s\n"
-                                    "keep (l)ocal or take (o)ther?") % fw,
+                                    "keep (l)ocal or take (o)ther?") % fd,
                                   _("[lo]"), _("l")) != _("l"):
                          tool = "internal:other"
                  if tool == "internal:local":
                      return 0
                  if tool == "internal:other":
-                     repo.wwrite(fd, fco.data(), fco.fileflags())
+                     repo.wwrite(fd, fco.data(), fco.flags())
                      return 0
                  if tool == "internal:fail":
                      return 1
                  back = a + ".orig"
                  util.copyfile(a, back)
-                 if fw != fo:
-                     repo.ui.status(_("merging %s and %s\n") % (fw, fo))
+                 if orig != fco.path():
+                     repo.ui.status(_("merging %s and %s to %s\n") % (orig, fco.path(), fd))
                  else:
-                     repo.ui.status(_("merging %s\n") % fw)
-                 repo.ui.debug(_("my %s other %s ancestor %s\n") % (fcm, fco, fca))
+                     repo.ui.status(_("merging %s\n") % fd)
+                 repo.ui.debug(_("my %s other %s ancestor %s\n") % (fcd, fco, fca))
                  # do we attempt to simplemerge first?
                  if _toolbool(ui, tool, "premerge", not (binary or symlink)):
                      util.copyfile(back, a) # restore from backup and try again
                  env = dict(HG_FILE=fd,
-                            HG_MY_NODE=str(wctx.parents()[0]),
-                            HG_OTHER_NODE=str(mctx),
-                            HG_MY_ISLINK=fcm.islink(),
-                            HG_OTHER_ISLINK=fco.islink(),
-                            HG_BASE_ISLINK=fca.islink())
+                            HG_MY_NODE=short(mynode),
+                            HG_OTHER_NODE=str(fco.changectx()),
+                            HG_MY_ISLINK='l' in fcd.flags(),
+                            HG_OTHER_ISLINK='l' in fco.flags(),
+                            HG_BASE_ISLINK='l' in fca.flags())
                  if tool == "internal:merge":
                      r = simplemerge.simplemerge(a, b, c, label=['local', 'other'])
                      r = util.system(toolpath + ' ' + args, cwd=repo.root, environ=env)
                  if not r and _toolbool(ui, tool, "checkconflicts"):
-                     if re.match("^(<<<<<<< .*|=======|>>>>>>> .*)$", fcm.data()):
+                     if re.match("^(<<<<<<< .*|=======|>>>>>>> .*)$", fcd.data()):
                          r = 1
                  if not r and _toolbool(ui, tool, "checkchanged"):

mercurial/hbisect.py

0 +2 -2

                      badrev = min([changelog.rev(n) for n in bad])
                      goodrevs = [changelog.rev(n) for n in good]
                      # build ancestors array
-                     ancestors = [[]] * (changelog.count() + 1) # an extra for [-1]
+                     ancestors = [[]] * (len(changelog) + 1) # an extra for [-1]
                      # clear good revs from array
                      for node in goodrevs:
                          ancestors[node] = None
-                     for rev in xrange(changelog.count(), -1, -1):
+                     for rev in xrange(len(changelog), -1, -1):
                          if ancestors[rev] is None:
                              for prev in clparents(rev):
                                  ancestors[prev] = None

mercurial/help.py

0 +94 -42

		@@ -5,8 +5,8
5	5	# This software may be used and distributed according to the terms
6	6	# of the GNU General Public License, incorporated herein by reference.
7	7
8		helptable = {
9		"dates\|Date Formats":
	8	helptable = (
	9	("dates\|Date Formats",
10	10	r'''
11	11	Some commands allow the user to specify a date:
12	12	backout, commit, import, tag: Specify the commit date.
		@@ -21,7 +21,7 helptable = {
21	21	"13:18" (today assumed)
22	22	"3:39" (3:39AM assumed)
23	23	"3:39pm" (15:39)
24		"2006-12-6 13:18:29" (ISO 8601 format)
	24	"2006-12-06 13:18:29" (ISO 8601 format)
25	25	"2006-12-6 13:18"
26	26	"2006-12-6"
27	27	"12-6"
		@@ -43,9 +43,55 helptable = {
43	43	">{date}" - on or after a given date
44	44	"{date} to {date}" - a date range, inclusive
45	45	"-{days}" - within a given number of days of today
46		''',
	46	'''),
	47
	48	("patterns\|File Name Patterns",
	49	r'''
	50	Mercurial accepts several notations for identifying one or more
	51	files at a time.
	52
	53	By default, Mercurial treats filenames as shell-style extended
	54	glob patterns.
	55
	56	Alternate pattern notations must be specified explicitly.
	57
	58	To use a plain path name without any pattern matching, start a
	59	name with "path:". These path names must match completely, from
	60	the root of the current repository.
	61
	62	To use an extended glob, start a name with "glob:". Globs are
	63	rooted at the current directory; a glob such as "*.c" will match
	64	files ending in ".c" in the current directory only.
	65
	66	The supported glob syntax extensions are "**" to match any string
	67	across path separators, and "{a,b}" to mean "a or b".
47	68
48		'environment\|env\|Environment Variables':
	69	To use a Perl/Python regular expression, start a name with "re:".
	70	Regexp pattern matching is anchored at the root of the repository.
	71
	72	Plain examples:
	73
	74	path:foo/bar a name bar in a directory named foo in the root of
	75	the repository
	76	path:path:name a file or directory named "path:name"
	77
	78	Glob examples:
	79
	80	glob:*.c any name ending in ".c" in the current directory
	81	*.c any name ending in ".c" in the current directory
	82	**.c any name ending in ".c" in the current directory, or
	83	any subdirectory
	84	foo/*.c any name ending in ".c" in the directory foo
	85	foo/**.c any name ending in ".c" in the directory foo, or any
	86	subdirectory
	87
	88	Regexp examples:
	89
	90	re:.*\.c$ any name ending in ".c", anywhere in the repository
	91
	92	'''),
	93
	94	('environment\|env\|Environment Variables',
49	95	r'''
50	96	HG::
51	97	Path to the 'hg' executable, automatically passed when running hooks,
		@@ -114,51 +160,57 EDITOR::
114	160	PYTHONPATH::
115	161	This is used by Python to find imported modules and may need to be set
116	162	appropriately if Mercurial is not installed system-wide.
117		''',
	163	'''),
118	164
119		"patterns\|File Name Patterns": r'''
120		Mercurial accepts several notations for identifying one or more
121		files at a time.
	165	('revs\|revisions\|Specifying Single Revisions',
	166	r'''
	167	Mercurial accepts several notations for identifying individual
	168	revisions.
122	169
123		By default, Mercurial treats filenames as shell-style extended
124		glob patterns.
125
126		Alternate pattern notations must be specified explicitly.
	170	A plain integer is treated as a revision number. Negative
	171	integers are treated as offsets from the tip, with -1 denoting the
	172	tip.
127	173
128		To use a plain path name without any pattern matching, start a
129		name with "path:". These path names must match completely, from
130		the root of the current repository.
	174	A 40-digit hexadecimal string is treated as a unique revision
	175	identifier.
131	176
132		To use an extended glob, start a name with "glob:". Globs are
133		rooted at the current directory; a glob such as "*.c" will match
134		files ending in ".c" in the current directory only.
	177	A hexadecimal string less than 40 characters long is treated as a
	178	unique revision identifier, and referred to as a short-form
	179	identifier. A short-form identifier is only valid if it is the
	180	prefix of one full-length identifier.
135	181
136		The supported glob syntax extensions are "**" to match any string
137		across path separators, and "{a,b}" to mean "a or b".
	182	Any other string is treated as a tag name, which is a symbolic
	183	name associated with a revision identifier. Tag names may not
	184	contain the ":" character.
	185
	186	The reserved name "tip" is a special tag that always identifies
	187	the most recent revision.
138	188
139		To use a Perl/Python regular expression, start a name with "re:".
140		Regexp pattern matching is anchored at the root of the repository.
141
142		Plain examples:
	189	The reserved name "null" indicates the null revision. This is the
	190	revision of an empty repository, and the parent of revision 0.
143	191
144		path:foo/bar a name bar in a directory named foo in the root of
145		the repository
146		path:path:name a file or directory named "path:name"
147
148		Glob examples:
	192	The reserved name "." indicates the working directory parent. If
	193	no working directory is checked out, it is equivalent to null.
	194	If an uncommitted merge is in progress, "." is the revision of
	195	the first parent.
	196	'''),
149	197
150		glob:*.c any name ending in ".c" in the current directory
151		*.c any name ending in ".c" in the current directory
152		**.c any name ending in ".c" in the current directory, or
153		any subdirectory
154		foo/*.c any name ending in ".c" in the directory foo
155		foo/**.c any name ending in ".c" in the directory foo, or any
156		subdirectory
	198	('mrevs\|multirevs\|Specifying Multiple Revisions',
	199	r'''
	200	When Mercurial accepts more than one revision, they may be
	201	specified individually, or provided as a continuous range,
	202	separated by the ":" character.
157	203
158		Regexp examples:
159
160		re:.*\.c$ any name ending in ".c", anywhere in the repository
	204	The syntax of range notation is [BEGIN]:[END], where BEGIN and END
	205	are revision identifiers. Both BEGIN and END are optional. If
	206	BEGIN is not specified, it defaults to revision number 0. If END
	207	is not specified, it defaults to the tip. The range ":" thus
	208	means "all revisions".
161	209
162		''',
163		}
	210	If BEGIN is greater than END, revisions are treated in reverse
	211	order.
164	212
	213	A range acts as a closed interval. This means that a range of 3:5
	214	gives 3, 4 and 5. Similarly, a range of 4:2 gives 4, 3, and 2.
	215	'''),
	216	)

mercurial/hg.py

0 +17 -26

                  return (os.path.isfile(util.drop_scheme('file', path)) and
                          bundlerepo or localrepo)
-             def parseurl(url, revs):
+             def parseurl(url, revs=[]):
                  '''parse url#branch, returning url, branch + revs'''
                  if '#' not in url:
                  '''return default destination of clone if none is given'''
                  return os.path.basename(os.path.normpath(source))
+             def localpath(path):
+                 if path.startswith('file://localhost/'):
+                     return path[16:]
+                 if path.startswith('file://'):
+                     return path[7:]
+                 if path.startswith('file:'):
+                     return path[5:]
+                 return path
              def clone(ui, source, dest=None, pull=False, rev=None, update=True,
                        stream=False):
                  """Make a copy of an existing repository.
                  rev: revision to clone up to (implies pull=True)
                  update: update working directory after clone completes, if
-                 destination is local repository
+                 destination is local repository (True means update to default rev,
+                 anything else is treated as a revision)
                  """
                  if isinstance(source, str):
                      dest = defaultdest(source)
                      ui.status(_("destination directory: %s\n") % dest)
-                 def localpath(path):
-                     if path.startswith('file://localhost/'):
-                         return path[16:]
-                     if path.startswith('file://'):
-                         return path[7:]
-                     if path.startswith('file:'):
-                         return path[5:]
-                     return path
                  dest = localpath(dest)
                  source = localpath(source)
                          if update:
                              dest_repo.ui.status(_("updating working directory\n"))
-                             if not checkout:
+                             if update is not True:
+                                 checkout = update
+                             elif not checkout:
                                  try:
                                      checkout = dest_repo.lookup("default")
                                  except:
                  stats = _merge.update(repo, node, False, False, None)
                  _showstats(repo, stats)
                  if stats[3]:
-                     repo.ui.status(_("There are unresolved merges with"
-                                      " locally modified files.\n"))
-                     if stats[1]:
-                         repo.ui.status(_("You can finish the partial merge using:\n"))
-                     else:
-                         repo.ui.status(_("You can redo the full merge using:\n"))
-                     # len(pl)==1, otherwise _merge.update() would have raised util.Abort:
-                     repo.ui.status(_("  hg update %s\n  hg update %s\n")
-                                    % (pl[0].rev(), repo.changectx(node).rev()))
+                     repo.ui.status(_("use 'hg resolve' to retry unresolved file merges\n"))
                  return stats[3] > 0
              def clean(repo, node, show_stats=True):
                  _showstats(repo, stats)
                  if stats[3]:
                      pl = repo.parents()
-                     repo.ui.status(_("There are unresolved merges,"
-                                      " you can redo the full merge using:\n"
-                                      "  hg update -C %s\n"
-                                      "  hg merge %s\n")
-                                    % (pl[0].rev(), pl[1].rev()))
+                     repo.ui.status(_("use 'hg resolve' to retry unresolved file merges\n"))
                  elif remind:
                      repo.ui.status(_("(branch merge, don't forget to commit)\n"))
                  return stats[3] > 0

mercurial/hgweb/hgweb_mod.py

0 +58 -672

This diff has been collapsed as it changes many lines, (730 lines changed) Show them Hide them
			@@ -6,79 +6,22
	6	6	# This software may be used and distributed according to the terms
	7	7	# of the GNU General Public License, incorporated herein by reference.
	8	8
	9		import os, mimetypes, re, ~~mimetools~~, ~~cStringIO~~
	10		from mercurial.node import hex, nullid, ~~short~~
		9	import os, mimetypes
		10	from mercurial.node import hex, nullid
	11	11	from mercurial.repo import RepoError
	12		from mercurial import mdiff, ui, hg, util, ~~archival~~, patch, hook
	13		from mercurial import revlog, templater, templatefilters, ~~changegroup~~
	14		from common import get_mtime, style_map, paritygen, countgen, ~~get_contact~~
	15		from common import ErrorResponse
		12	from mercurial import mdiff, ui, hg, util, patch, hook
		13	from mercurial import revlog, templater, templatefilters
		14	from common import get_mtime, style_map, paritygen, countgen, ErrorResponse
	16	15	from common import HTTP_OK, HTTP_BAD_REQUEST, HTTP_NOT_FOUND, HTTP_SERVER_ERROR
	17	16	from request import wsgirequest
	18		import webcommands, protocol
	19
	20		shortcuts = {
	21		'cl': [('cmd', ['changelog']), ('rev', None)],
	22		'sl': [('cmd', ['shortlog']), ('rev', None)],
	23		'cs': [('cmd', ['changeset']), ('node', None)],
	24		'f': [('cmd', ['file']), ('filenode', None)],
	25		'fl': [('cmd', ['filelog']), ('filenode', None)],
	26		'fd': [('cmd', ['filediff']), ('node', None)],
	27		'fa': [('cmd', ['annotate']), ('filenode', None)],
	28		'mf': [('cmd', ['manifest']), ('manifest', None)],
	29		'ca': [('cmd', ['archive']), ('node', None)],
	30		'tags': [('cmd', ['tags'])],
	31		'tip': [('cmd', ['changeset']), ('node', ['tip'])],
	32		'static': [('cmd', ['static']), ('file', None)]
	33		}
	34
	35		def _up(p):
	36		if p[0] != "/":
	37		p = "/" + p
	38		if p[-1] == "/":
	39		p = p[:-1]
	40		up = os.path.dirname(p)
	41		if up == "/":
	42		return "/"
	43		return up + "/"
		17	import webcommands, protocol, webutil
	44	18
	45		def revnavgen(pos, pagelen, limit, nodefunc):
	46		def seq(factor, limit=None):
	47		if limit:
	48		yield limit
	49		if limit >= 20 and limit <= 40:
	50		yield 50
	51		else:
	52		yield 1 * factor
	53		yield 3 * factor
	54		for f in seq(factor * 10):
	55		yield f
	56
	57		def nav(**map):
	58		l = []
	59		last = 0
	60		for f in seq(1, pagelen):
	61		if f < pagelen or f <= last:
	62		continue
	63		if f > limit:
	64		break
	65		last = f
	66		if pos + f < limit:
	67		l.append(("+%d" % f, hex(nodefunc(pos + f).node())))
	68		if pos - f >= 0:
	69		l.insert(0, ("-%d" % f, hex(nodefunc(pos - f).node())))
	70
	71		try:
	72		yield {"label": "(0)", "node": hex(nodefunc('0').node())}
	73
	74		for label, node in l:
	75		yield {"label": label, "node": node}
	76
	77		yield {"label": "tip", "node": "tip"}
	78		except RepoError:
	79		pass
	80
	81		return nav
		19	perms = {
		20	'changegroup': 'pull',
		21	'changegroupsubset': 'pull',
		22	'unbundle': 'push',
		23	'stream_out': 'pull',
		24	}
	82	25
	83	26	class hgweb(object):
	84	27	def __init__(self, repo, name=None):
			@@ -93,7 +36,6 class hgweb(object):
	93	36	self.reponame = name
	94	37	self.archives = 'zip', 'gz', 'bz2'
	95	38	self.stripecount = 1
	96		self._capabilities = None
	97	39	# a repo owner may set web.templates in .hg/hgrc to get any file
	98	40	# readable by the user running the CGI script
	99	41	self.templatepath = self.config("web", "templates",
			@@ -125,18 +67,6 class hgweb(object):
	125	67	self.maxfiles = int(self.config("web", "maxfiles", 10))
	126	68	self.allowpull = self.configbool("web", "allowpull", True)
	127	69	self.encoding = self.config("web", "encoding", util._encoding)
	128		self._capabilities = None
	129
	130		def capabilities(self):
	131		if self._capabilities is not None:
	132		return self._capabilities
	133		caps = ['lookup', 'changegroupsubset']
	134		if self.configbool('server', 'uncompressed'):
	135		caps.append('stream=%d' % self.repo.changelog.version)
	136		if changegroup.bundlepriority:
	137		caps.append('unbundle=%s' % ','.join(changegroup.bundlepriority))
	138		self._capabilities = caps
	139		return caps
	140	70
	141	71	def run(self):
	142	72	if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."):
			@@ -146,22 +76,22 class hgweb(object):
	146	76
	147	77	def __call__(self, env, respond):
	148	78	req = wsgirequest(env, respond)
	149		self.run_wsgi(req)
	150		return req
		79	return self.run_wsgi(req)
	151	80
	152	81	def run_wsgi(self, req):
	153	82
	154	83	self.refresh()
	155	84
	156		# expand form shortcuts
		85	# process this if it's a protocol request
		86	# protocol bits don't need to create any URLs
		87	# and the clients always use the old URL structure
	157	88
	158		for k in shortcuts.iterkeys():
	159		if k in req.form:
	160		for name, value in shortcuts[k]:
	161		if value is None:
	162		value = req.form[k]
	163		req.form[name] = value
	164		del req.form[k]
		89	cmd = req.form.get('cmd', [''])[0]
		90	if cmd and cmd in protocol.__all__:
		91	if cmd in perms and not self.check_perm(req, perms[cmd]):
		92	return []
		93	method = getattr(protocol, cmd)
		94	return method(self.repo, req)
	165	95
	166	96	# work with CGI variables to create coherent structure
	167	97	# use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME
			@@ -194,8 +124,10 class hgweb(object):
	194	124	cmd = cmd[style+1:]
	195	125
	196	126	# avoid accepting e.g. style parameter as command
	197		if hasattr(webcommands, cmd) or ~~hasattr~~(~~protocol~~, ~~cmd~~):
		127	if hasattr(webcommands, cmd):
	198	128	req.form['cmd'] = [cmd]
		129	else:
		130	cmd = ''
	199	131
	200	132	if args and args[0]:
	201	133	node = args.pop(0)
			@@ -213,30 +145,13 class hgweb(object):
	213	145	req.form['node'] = [fn[:-len(ext)]]
	214	146	req.form['type'] = [type_]
	215	147
	216		# process this if it's a protocol request
	217
	218		cmd = req.form.get('cmd', [''])[0]
	219		if cmd in protocol.__all__:
	220		method = getattr(protocol, cmd)
	221		method(self, req)
	222		return
	223
	224	148	# process the web interface request
	225	149
	226	150	try:
	227	151
	228	152	tmpl = self.templater(req)
	229		try:
	230	153	ctype = tmpl('mimetype', encoding=self.encoding)
	231	154	ctype = templater.stringify(ctype)
	232		except KeyError:
	233		# old templates with inline HTTP headers?
	234		if 'mimetype' in tmpl:
	235		raise
	236		header = tmpl('header', encoding=self.encoding)
	237		header_file = cStringIO.StringIO(templater.stringify(header))
	238		msg = mimetools.Message(header_file, 0)
	239		ctype = msg['content-type']
	240	155
	241	156	if cmd == '':
	242	157	req.form['cmd'] = [tmpl.cache['default']]
			@@ -254,6 +169,7 class hgweb(object):
	254	169
	255	170	req.write(content)
	256	171	del tmpl
		172	return []
	257	173
	258	174	except revlog.LookupError, err:
	259	175	req.respond(HTTP_NOT_FOUND, ctype)
			@@ -261,12 +177,15 class hgweb(object):
	261	177	if 'manifest' not in msg:
	262	178	msg = 'revision not found: %s' % err.name
	263	179	req.write(tmpl('error', error=msg))
		180	return []
	264	181	except (RepoError, revlog.RevlogError), inst:
	265	182	req.respond(HTTP_SERVER_ERROR, ctype)
	266	183	req.write(tmpl('error', error=str(inst)))
		184	return []
	267	185	except ErrorResponse, inst:
	268	186	req.respond(inst.code, ctype)
	269	187	req.write(tmpl('error', error=inst.message))
		188	return []
	270	189
	271	190	def templater(self, req):
	272	191
			@@ -291,13 +210,7 class hgweb(object):
	291	210	# some functions for the templater
	292	211
	293	212	def header(**map):
	294		~~header~~ = tmpl('header', encoding=self.encoding, **map)
	295		if 'mimetype' not in tmpl:
	296		# old template with inline HTTP headers
	297		header_file = cStringIO.StringIO(templater.stringify(header))
	298		msg = mimetools.Message(header_file, 0)
	299		header = header_file.read()
	300		yield header
		213	yield tmpl('header', encoding=self.encoding, **map)
	301	214
	302	215	def footer(**map):
	303	216	yield tmpl("footer", **map)
			@@ -355,54 +268,6 class hgweb(object):
	355	268	if len(files) > self.maxfiles:
	356	269	yield tmpl("fileellipses")
	357	270
	358		def siblings(self, siblings=[], hiderev=None, **args):
	359		siblings = [s for s in siblings if s.node() != nullid]
	360		if len(siblings) == 1 and siblings[0].rev() == hiderev:
	361		return
	362		for s in siblings:
	363		d = {'node': hex(s.node()), 'rev': s.rev()}
	364		if hasattr(s, 'path'):
	365		d['file'] = s.path()
	366		d.update(args)
	367		yield d
	368
	369		def renamelink(self, fl, node):
	370		r = fl.renamed(node)
	371		if r:
	372		return [dict(file=r[0], node=hex(r[1]))]
	373		return []
	374
	375		def nodetagsdict(self, node):
	376		return [{"name": i} for i in self.repo.nodetags(node)]
	377
	378		def nodebranchdict(self, ctx):
	379		branches = []
	380		branch = ctx.branch()
	381		# If this is an empty repo, ctx.node() == nullid,
	382		# ctx.branch() == 'default', but branchtags() is
	383		# an empty dict. Using dict.get avoids a traceback.
	384		if self.repo.branchtags().get(branch) == ctx.node():
	385		branches.append({"name": branch})
	386		return branches
	387
	388		def nodeinbranch(self, ctx):
	389		branches = []
	390		branch = ctx.branch()
	391		if branch != 'default' and self.repo.branchtags().get(branch) != ctx.node():
	392		branches.append({"name": branch})
	393		return branches
	394
	395		def nodebranchnodefault(self, ctx):
	396		branches = []
	397		branch = ctx.branch()
	398		if branch != 'default':
	399		branches.append({"name": branch})
	400		return branches
	401
	402		def showtag(self, tmpl, t1, node=nullid, **args):
	403		for t in self.repo.nodetags(node):
	404		yield tmpl(t1, tag=t, **args)
	405
	406	271	def diff(self, tmpl, node1, node2, files):
	407	272	def filterfiles(filters, files):
	408	273	l = [x for x in files if x in filters]
			@@ -443,8 +308,8 class hgweb(object):
	443	308	linenumber="% 8s" % lineno)
	444	309
	445	310	r = self.repo
	446		c1 = r.~~changectx~~(node1)
	447		c2 = r.~~changectx~~(node2)
		311	c1 = r[node1]
		312	c2 = r[node2]
	448	313	date1 = util.datestr(c1.date())
	449	314	date2 = util.datestr(c2.date())
	450	315
			@@ -470,524 +335,45 class hgweb(object):
	470	335	yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
	471	336	opts=diffopts), f, tn)
	472	337
	473		def changelog(self, tmpl, ctx, shortlog=False):
	474		def changelist(limit=0,**map):
	475		cl = self.repo.changelog
	476		l = [] # build a list in forward order for efficiency
	477		for i in xrange(start, end):
	478		ctx = self.repo.changectx(i)
	479		n = ctx.node()
	480		showtags = self.showtag(tmpl, 'changelogtag', n)
	481
	482		l.insert(0, {"parity": parity.next(),
	483		"author": ctx.user(),
	484		"parent": self.siblings(ctx.parents(), i - 1),
	485		"child": self.siblings(ctx.children(), i + 1),
	486		"changelogtag": showtags,
	487		"desc": ctx.description(),
	488		"date": ctx.date(),
	489		"files": self.listfilediffs(tmpl, ctx.files(), n),
	490		"rev": i,
	491		"node": hex(n),
	492		"tags": self.nodetagsdict(n),
	493		"inbranch": self.nodeinbranch(ctx),
	494		"branches": self.nodebranchdict(ctx)})
	495
	496		if limit > 0:
	497		l = l[:limit]
	498
	499		for e in l:
	500		yield e
	501
	502		maxchanges = shortlog and self.maxshortchanges or self.maxchanges
	503		cl = self.repo.changelog
	504		count = cl.count()
	505		pos = ctx.rev()
	506		start = max(0, pos - maxchanges + 1)
	507		end = min(count, start + maxchanges)
	508		pos = end - 1
	509		parity = paritygen(self.stripecount, offset=start-end)
	510
	511		changenav = revnavgen(pos, maxchanges, count, self.repo.changectx)
	512
	513		return tmpl(shortlog and 'shortlog' or 'changelog',
	514		changenav=changenav,
	515		node=hex(cl.tip()),
	516		rev=pos, changesets=count,
	517		entries=lambda x: changelist(limit=0,x),
	518		latestentry=lambda x: changelist(limit=1,x),
	519		archives=self.archivelist("tip"))
	520
	521		def search(self, tmpl, query):
	522
	523		def changelist(**map):
	524		cl = self.repo.changelog
	525		count = 0
	526		qw = query.lower().split()
	527
	528		def revgen():
	529		for i in xrange(cl.count() - 1, 0, -100):
	530		l = []
	531		for j in xrange(max(0, i - 100), i + 1):
	532		ctx = self.repo.changectx(j)
	533		l.append(ctx)
	534		l.reverse()
	535		for e in l:
	536		yield e
	537
	538		for ctx in revgen():
	539		miss = 0
	540		for q in qw:
	541		if not (q in ctx.user().lower() or
	542		q in ctx.description().lower() or
	543		q in " ".join(ctx.files()).lower()):
	544		miss = 1
	545		break
	546		if miss:
	547		continue
	548
	549		count += 1
	550		n = ctx.node()
	551		showtags = self.showtag(tmpl, 'changelogtag', n)
	552
	553		yield tmpl('searchentry',
	554		parity=parity.next(),
	555		author=ctx.user(),
	556		parent=self.siblings(ctx.parents()),
	557		child=self.siblings(ctx.children()),
	558		changelogtag=showtags,
	559		desc=ctx.description(),
	560		date=ctx.date(),
	561		files=self.listfilediffs(tmpl, ctx.files(), n),
	562		rev=ctx.rev(),
	563		node=hex(n),
	564		tags=self.nodetagsdict(n),
	565		inbranch=self.nodeinbranch(ctx),
	566		branches=self.nodebranchdict(ctx))
	567
	568		if count >= self.maxchanges:
	569		break
	570
	571		cl = self.repo.changelog
	572		parity = paritygen(self.stripecount)
	573
	574		return tmpl('search',
	575		query=query,
	576		node=hex(cl.tip()),
	577		entries=changelist,
	578		archives=self.archivelist("tip"))
	579
	580		def changeset(self, tmpl, ctx):
	581		n = ctx.node()
	582		showtags = self.showtag(tmpl, 'changesettag', n)
	583		parents = ctx.parents()
	584		p1 = parents[0].node()
	585
	586		files = []
	587		parity = paritygen(self.stripecount)
	588		for f in ctx.files():
	589		files.append(tmpl("filenodelink",
	590		node=hex(n), file=f,
	591		parity=parity.next()))
	592
	593		def diff(**map):
	594		yield self.diff(tmpl, p1, n, None)
	595
	596		return tmpl('changeset',
	597		diff=diff,
	598		rev=ctx.rev(),
	599		node=hex(n),
	600		parent=self.siblings(parents),
	601		child=self.siblings(ctx.children()),
	602		changesettag=showtags,
	603		author=ctx.user(),
	604		desc=ctx.description(),
	605		date=ctx.date(),
	606		files=files,
	607		archives=self.archivelist(hex(n)),
	608		tags=self.nodetagsdict(n),
	609		branch=self.nodebranchnodefault(ctx),
	610		inbranch=self.nodeinbranch(ctx),
	611		branches=self.nodebranchdict(ctx))
	612
	613		def filelog(self, tmpl, fctx):
	614		f = fctx.path()
	615		fl = fctx.filelog()
	616		count = fl.count()
	617		pagelen = self.maxshortchanges
	618		pos = fctx.filerev()
	619		start = max(0, pos - pagelen + 1)
	620		end = min(count, start + pagelen)
	621		pos = end - 1
	622		parity = paritygen(self.stripecount, offset=start-end)
	623
	624		def entries(limit=0, **map):
	625		l = []
	626
	627		for i in xrange(start, end):
	628		ctx = fctx.filectx(i)
	629		n = fl.node(i)
	630
	631		l.insert(0, {"parity": parity.next(),
	632		"filerev": i,
	633		"file": f,
	634		"node": hex(ctx.node()),
	635		"author": ctx.user(),
	636		"date": ctx.date(),
	637		"rename": self.renamelink(fl, n),
	638		"parent": self.siblings(fctx.parents()),
	639		"child": self.siblings(fctx.children()),
	640		"desc": ctx.description()})
	641
	642		if limit > 0:
	643		l = l[:limit]
	644
	645		for e in l:
	646		yield e
	647
	648		nodefunc = lambda x: fctx.filectx(fileid=x)
	649		nav = revnavgen(pos, pagelen, count, nodefunc)
	650		return tmpl("filelog", file=f, node=hex(fctx.node()), nav=nav,
	651		entries=lambda x: entries(limit=0, x),
	652		latestentry=lambda x: entries(limit=1, x))
	653
	654		def filerevision(self, tmpl, fctx):
	655		f = fctx.path()
	656		text = fctx.data()
	657		fl = fctx.filelog()
	658		n = fctx.filenode()
	659		parity = paritygen(self.stripecount)
	660
	661		if util.binary(text):
	662		mt = mimetypes.guess_type(f)[0] or 'application/octet-stream'
	663		text = '(binary:%s)' % mt
	664
	665		def lines():
	666		for lineno, t in enumerate(text.splitlines(1)):
	667		yield {"line": t,
	668		"lineid": "l%d" % (lineno + 1),
	669		"linenumber": "% 6d" % (lineno + 1),
	670		"parity": parity.next()}
	671
	672		return tmpl("filerevision",
	673		file=f,
	674		path=_up(f),
	675		text=lines(),
	676		rev=fctx.rev(),
	677		node=hex(fctx.node()),
	678		author=fctx.user(),
	679		date=fctx.date(),
	680		desc=fctx.description(),
	681		branch=self.nodebranchnodefault(fctx),
	682		parent=self.siblings(fctx.parents()),
	683		child=self.siblings(fctx.children()),
	684		rename=self.renamelink(fl, n),
	685		permissions=fctx.manifest().flags(f))
	686
	687		def fileannotate(self, tmpl, fctx):
	688		f = fctx.path()
	689		n = fctx.filenode()
	690		fl = fctx.filelog()
	691		parity = paritygen(self.stripecount)
	692
	693		def annotate(**map):
	694		last = None
	695		if util.binary(fctx.data()):
	696		mt = (mimetypes.guess_type(fctx.path())[0]
	697		or 'application/octet-stream')
	698		lines = enumerate([((fctx.filectx(fctx.filerev()), 1),
	699		'(binary:%s)' % mt)])
	700		else:
	701		lines = enumerate(fctx.annotate(follow=True, linenumber=True))
	702		for lineno, ((f, targetline), l) in lines:
	703		fnode = f.filenode()
	704		name = self.repo.ui.shortuser(f.user())
	705
	706		if last != fnode:
	707		last = fnode
	708
	709		yield {"parity": parity.next(),
	710		"node": hex(f.node()),
	711		"rev": f.rev(),
	712		"author": name,
	713		"file": f.path(),
	714		"targetline": targetline,
	715		"line": l,
	716		"lineid": "l%d" % (lineno + 1),
	717		"linenumber": "% 6d" % (lineno + 1)}
	718
	719		return tmpl("fileannotate",
	720		file=f,
	721		annotate=annotate,
	722		path=_up(f),
	723		rev=fctx.rev(),
	724		node=hex(fctx.node()),
	725		author=fctx.user(),
	726		date=fctx.date(),
	727		desc=fctx.description(),
	728		rename=self.renamelink(fl, n),
	729		branch=self.nodebranchnodefault(fctx),
	730		parent=self.siblings(fctx.parents()),
	731		child=self.siblings(fctx.children()),
	732		permissions=fctx.manifest().flags(f))
	733
	734		def manifest(self, tmpl, ctx, path):
	735		mf = ctx.manifest()
	736		node = ctx.node()
	737
	738		files = {}
	739		parity = paritygen(self.stripecount)
	740
	741		if path and path[-1] != "/":
	742		path += "/"
	743		l = len(path)
	744		abspath = "/" + path
	745
	746		for f, n in mf.items():
	747		if f[:l] != path:
	748		continue
	749		remain = f[l:]
	750		if "/" in remain:
	751		short = remain[:remain.index("/") + 1] # bleah
	752		files[short] = (f, None)
	753		else:
	754		short = os.path.basename(remain)
	755		files[short] = (f, n)
	756
	757		if not files:
	758		raise ErrorResponse(HTTP_NOT_FOUND, 'path not found: ' + path)
	759
	760		def filelist(**map):
	761		fl = files.keys()
	762		fl.sort()
	763		for f in fl:
	764		full, fnode = files[f]
	765		if not fnode:
	766		continue
	767
	768		fctx = ctx.filectx(full)
	769		yield {"file": full,
	770		"parity": parity.next(),
	771		"basename": f,
	772		"date": fctx.changectx().date(),
	773		"size": fctx.size(),
	774		"permissions": mf.flags(full)}
	775
	776		def dirlist(**map):
	777		fl = files.keys()
	778		fl.sort()
	779		for f in fl:
	780		full, fnode = files[f]
	781		if fnode:
	782		continue
	783
	784		yield {"parity": parity.next(),
	785		"path": "%s%s" % (abspath, f),
	786		"basename": f[:-1]}
	787
	788		return tmpl("manifest",
	789		rev=ctx.rev(),
	790		node=hex(node),
	791		path=abspath,
	792		up=_up(abspath),
	793		upparity=parity.next(),
	794		fentries=filelist,
	795		dentries=dirlist,
	796		archives=self.archivelist(hex(node)),
	797		tags=self.nodetagsdict(node),
	798		inbranch=self.nodeinbranch(ctx),
	799		branches=self.nodebranchdict(ctx))
	800
	801		def tags(self, tmpl):
	802		i = self.repo.tagslist()
	803		i.reverse()
	804		parity = paritygen(self.stripecount)
	805
	806		def entries(notip=False,limit=0, **map):
	807		count = 0
	808		for k, n in i:
	809		if notip and k == "tip":
	810		continue
	811		if limit > 0 and count >= limit:
	812		continue
	813		count = count + 1
	814		yield {"parity": parity.next(),
	815		"tag": k,
	816		"date": self.repo.changectx(n).date(),
	817		"node": hex(n)}
	818
	819		return tmpl("tags",
	820		node=hex(self.repo.changelog.tip()),
	821		entries=lambda x: entries(False,0, x),
	822		entriesnotip=lambda x: entries(True,0, x),
	823		latestentry=lambda x: entries(True,1, x))
	824
	825		def summary(self, tmpl):
	826		i = self.repo.tagslist()
	827		i.reverse()
	828
	829		def tagentries(**map):
	830		parity = paritygen(self.stripecount)
	831		count = 0
	832		for k, n in i:
	833		if k == "tip": # skip tip
	834		continue;
	835
	836		count += 1
	837		if count > 10: # limit to 10 tags
	838		break;
	839
	840		yield tmpl("tagentry",
	841		parity=parity.next(),
	842		tag=k,
	843		node=hex(n),
	844		date=self.repo.changectx(n).date())
	845
	846
	847		def branches(**map):
	848		parity = paritygen(self.stripecount)
	849
	850		b = self.repo.branchtags()
	851		l = [(-self.repo.changelog.rev(n), n, t) for t, n in b.items()]
	852		l.sort()
	853
	854		for r,n,t in l:
	855		ctx = self.repo.changectx(n)
	856
	857		yield {'parity': parity.next(),
	858		'branch': t,
	859		'node': hex(n),
	860		'date': ctx.date()}
	861
	862		def changelist(**map):
	863		parity = paritygen(self.stripecount, offset=start-end)
	864		l = [] # build a list in forward order for efficiency
	865		for i in xrange(start, end):
	866		ctx = self.repo.changectx(i)
	867		n = ctx.node()
	868		hn = hex(n)
	869
	870		l.insert(0, tmpl(
	871		'shortlogentry',
	872		parity=parity.next(),
	873		author=ctx.user(),
	874		desc=ctx.description(),
	875		date=ctx.date(),
	876		rev=i,
	877		node=hn,
	878		tags=self.nodetagsdict(n),
	879		inbranch=self.nodeinbranch(ctx),
	880		branches=self.nodebranchdict(ctx)))
	881
	882		yield l
	883
	884		cl = self.repo.changelog
	885		count = cl.count()
	886		start = max(0, count - self.maxchanges)
	887		end = min(count, start + self.maxchanges)
	888
	889		return tmpl("summary",
	890		desc=self.config("web", "description", "unknown"),
	891		owner=get_contact(self.config) or "unknown",
	892		lastchange=cl.read(cl.tip())[2],
	893		tags=tagentries,
	894		branches=branches,
	895		shortlog=changelist,
	896		node=hex(cl.tip()),
	897		archives=self.archivelist("tip"))
	898
	899		def filediff(self, tmpl, fctx):
	900		n = fctx.node()
	901		path = fctx.path()
	902		parents = fctx.parents()
	903		p1 = parents and parents[0].node() or nullid
	904
	905		def diff(**map):
	906		yield self.diff(tmpl, p1, n, [path])
	907
	908		return tmpl("filediff",
	909		file=path,
	910		node=hex(n),
	911		rev=fctx.rev(),
	912		branch=self.nodebranchnodefault(fctx),
	913		parent=self.siblings(parents),
	914		child=self.siblings(fctx.children()),
	915		diff=diff)
	916
	917	338	archive_specs = {
	918	339	'bz2': ('application/x-tar', 'tbz2', '.tar.bz2', None),
	919	340	'gz': ('application/x-tar', 'tgz', '.tar.gz', None),
	920	341	'zip': ('application/zip', 'zip', '.zip', None),
	921	342	}
	922	343
	923		def ~~archive~~(self, ~~tmpl~~, req, ~~key~~, ~~type_~~):
	924		reponame = re.sub(r"\W+", "-", os.path.basename(self.reponame))
	925		cnode = self.repo.lookup(key)
	926		arch_version = key
	927		if cnode == key or key == 'tip':
	928		arch_version = short(cnode)
	929		name = "%s-%s" % (reponame, arch_version)
	930		mimetype, artype, extension, encoding = self.archive_specs[type_]
	931		headers = [
	932		('Content-Type', mimetype),
	933		('Content-Disposition', 'attachment; filename=%s%s' %
	934		(name, extension))
	935		]
	936		if encoding:
	937		headers.append(('Content-Encoding', encoding))
	938		req.header(headers)
	939		req.respond(HTTP_OK)
	940		archival.archive(self.repo, req, cnode, artype, prefix=name)
		344	def check_perm(self, req, op):
		345	'''Check permission for operation based on request data (including
		346	authentication info. Return true if op allowed, else false.'''
	941	347
	942		# add tags to things
	943		# tags -> list of changesets corresponding to tags
	944		# find tag, changeset, file
		348	def error(status, message):
		349	req.respond(status, protocol.HGTYPE)
		350	req.write('0\n%s\n' % message)
	945	351
	946		def cleanpath(self, path):
	947		path = path.lstrip('/')
	948		return util.canonpath(self.repo.root, '', path)
		352	if op == 'pull':
		353	return self.allowpull
	949	354
	950		def changectx(self, req):
	951		if 'node' in req.form:
	952		changeid = req.form['node'][0]
	953		elif 'manifest' in req.form:
	954		changeid = req.form['manifest'][0]
	955		else:
	956		changeid = self.repo.changelog.count() - 1
	957
	958		try:
	959		ctx = self.repo.changectx(changeid)
	960		except RepoError:
	961		man = self.repo.manifest
	962		mn = man.lookup(changeid)
	963		ctx = self.repo.changectx(man.linkrev(mn))
	964
	965		return ctx
		355	# enforce that you can only push using POST requests
		356	if req.env['REQUEST_METHOD'] != 'POST':
		357	error('405 Method Not Allowed', 'push requires POST request')
		358	return False
	966	359
	967		def filectx(self, req):
	968		path = self.cleanpath(req.form['file'][0])
	969		if 'node' in req.form:
	970		changeid = req.form['node'][0]
	971		else:
	972		changeid = req.form['filenode'][0]
	973		try:
	974		ctx = self.repo.changectx(changeid)
	975		fctx = ctx.filectx(path)
	976		except RepoError:
	977		fctx = self.repo.filectx(path, fileid=changeid)
	978
	979		return fctx
	980
	981		def check_perm(self, req, op, default):
	982		'''check permission for operation based on user auth.
	983		return true if op allowed, else false.
	984		default is policy to use if no config given.'''
		360	# require ssl by default for pushing, auth info cannot be sniffed
		361	# and replayed
		362	scheme = req.env.get('wsgi.url_scheme')
		363	if self.configbool('web', 'push_ssl', True) and scheme != 'https':
		364	error(HTTP_OK, 'ssl required')
		365	return False
	985	366
	986	367	user = req.env.get('REMOTE_USER')
	987	368
	988		deny = self.configlist('web', 'deny_' + op)
		369	deny = self.configlist('web', 'deny_push')
	989	370	if deny and (not user or deny == ['*'] or user in deny):
		371	error('401 Unauthorized', 'push not authorized')
	990	372	return False
	991	373
	992		allow = self.configlist('web', 'allow_' + op)
	993		re~~turn~~ (allow and (allow == ['*'] or user in allow)) or ~~default~~
		374	allow = self.configlist('web', 'allow_push')
		375	result = allow and (allow == ['*'] or user in allow)
		376	if not result:
		377	error('401 Unauthorized', 'push not authorized')
		378
		379	return result

mercurial/hgweb/hgwebdir_mod.py

0 +11 -27

              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
-             import os, mimetools, cStringIO
+             import os
              from mercurial.i18n import gettext as _
              from mercurial.repo import RepoError
              from mercurial import ui, hg, util, templater, templatefilters
              class hgwebdir(object):
                  def __init__(self, config, parentui=None):
                      def cleannames(items):
-                         return [(util.pconvert(name).strip('/'), path)
-                                 for name, path in items]
+                         return util.sort([(util.pconvert(name).strip('/'), path)
+                                           for name, path in items])
                      self.parentui = parentui or ui.ui(report_untrusted=False,
                                                        interactive = False)
                          self.repos_sorted = ('', False)
                      elif isinstance(config, dict):
                          self.repos = cleannames(config.items())
-                         self.repos.sort()
                      else:
                          if isinstance(config, util.configparser):
                              cp = config
                  def __call__(self, env, respond):
                      req = wsgirequest(env, respond)
-                     self.run_wsgi(req)
-                     return req
+                     return self.run_wsgi(req)
                  def run_wsgi(self, req):
                              virtual = req.env.get("PATH_INFO", "").strip('/')
                              tmpl = self.templater(req)
-                             try:
-                                 ctype = tmpl('mimetype', encoding=util._encoding)
-                                 ctype = templater.stringify(ctype)
-                             except KeyError:
-                                 # old templates with inline HTTP headers?
-                                 if 'mimetype' in tmpl:
-                                     raise
-                                 header = tmpl('header', encoding=util._encoding)
-                                 header_file = cStringIO.StringIO(templater.stringify(header))
-                                 msg = mimetools.Message(header_file, 0)
-                                 ctype = msg['content-type']
                              # a static file
                              if virtual.startswith('static/') or 'static' in req.form:
                                  else:
                                      fname = req.form['static'][0]
                                  req.write(staticfile(static, fname, req))
-                                 return
+                                 return []
                              # top-level index
                              elif not virtual:
                                  req.respond(HTTP_OK, ctype)
                                  req.write(self.makeindex(req, tmpl))
-                                 return
+                                 return []
                              # nested indexes and hgwebs
                                      req.env['REPO_NAME'] = virtual
                                      try:
                                          repo = hg.repository(self.parentui, real)
-                                         hgweb(repo).run_wsgi(req)
-                                         return
+                                         return hgweb(repo).run_wsgi(req)
                                      except IOError, inst:
                                          msg = inst.strerror
                                          raise ErrorResponse(HTTP_SERVER_ERROR, msg)
                                  if [r for r in repos if r.startswith(subdir)]:
                                      req.respond(HTTP_OK, ctype)
                                      req.write(self.makeindex(req, tmpl, subdir))
-                                     return
+                                     return []
                                  up = virtual.rfind('/')
                                  if up < 0:
                              # prefixes not found
                              req.respond(HTTP_NOT_FOUND, ctype)
                              req.write(tmpl("notfound", repo=virtual))
+                             return []
                          except ErrorResponse, err:
                              req.respond(err.code, ctype)
                              req.write(tmpl('error', error=err.message or ''))
+                             return []
                      finally:
                          tmpl = None
                  def templater(self, req):
                      def header(**map):
-                         header = tmpl('header', encoding=util._encoding, **map)
-                         if 'mimetype' not in tmpl:
-                             # old template with inline HTTP headers
-                             header_file = cStringIO.StringIO(templater.stringify(header))
-                             msg = mimetools.Message(header_file, 0)
-                             header = header_file.read()
-                         yield header
+                         yield tmpl('header', encoding=util._encoding, **map)
                      def footer(**map):
                          yield tmpl("footer", **map)

mercurial/hgweb/protocol.py

0 +53 -86

              HGTYPE = 'application/mercurial-0.1'
-             def lookup(web, req):
+             def lookup(repo, req):
                  try:
-                     r = hex(web.repo.lookup(req.form['key'][0]))
+                     r = hex(repo.lookup(req.form['key'][0]))
                      success = 1
                  except Exception,inst:
                      r = str(inst)
                      success = 0
                  resp = "%s %s\n" % (success, r)
                  req.respond(HTTP_OK, HGTYPE, length=len(resp))
-                 req.write(resp)
+                 yield resp
-             def heads(web, req):
-                 resp = " ".join(map(hex, web.repo.heads())) + "\n"
+             def heads(repo, req):
+                 resp = " ".join(map(hex, repo.heads())) + "\n"
                  req.respond(HTTP_OK, HGTYPE, length=len(resp))
-                 req.write(resp)
+                 yield resp
-             def branches(web, req):
+             def branches(repo, req):
                  nodes = []
                  if 'nodes' in req.form:
                      nodes = map(bin, req.form['nodes'][0].split(" "))
                  resp = cStringIO.StringIO()
-                 for b in web.repo.branches(nodes):
+                 for b in repo.branches(nodes):
                      resp.write(" ".join(map(hex, b)) + "\n")
                  resp = resp.getvalue()
                  req.respond(HTTP_OK, HGTYPE, length=len(resp))
-                 req.write(resp)
+                 yield resp
-             def between(web, req):
+             def between(repo, req):
                  if 'pairs' in req.form:
                      pairs = [map(bin, p.split("-"))
                               for p in req.form['pairs'][0].split(" ")]
                  resp = cStringIO.StringIO()
-                 for b in web.repo.between(pairs):
+                 for b in repo.between(pairs):
                      resp.write(" ".join(map(hex, b)) + "\n")
                  resp = resp.getvalue()
                  req.respond(HTTP_OK, HGTYPE, length=len(resp))
-                 req.write(resp)
+                 yield resp
-             def changegroup(web, req):
+             def changegroup(repo, req):
                  req.respond(HTTP_OK, HGTYPE)
                  nodes = []
-                 if not web.allowpull:
-                     return
                  if 'roots' in req.form:
                      nodes = map(bin, req.form['roots'][0].split(" "))
                  z = zlib.compressobj()
-                 f = web.repo.changegroup(nodes, 'serve')
+                 f = repo.changegroup(nodes, 'serve')
                  while 1:
                      chunk = f.read(4096)
                      if not chunk:
                          break
-                     req.write(z.compress(chunk))
+                     yield z.compress(chunk)
-                 req.write(z.flush())
+                 yield z.flush()
-             def changegroupsubset(web, req):
+             def changegroupsubset(repo, req):
                  req.respond(HTTP_OK, HGTYPE)
                  bases = []
                  heads = []
-                 if not web.allowpull:
-                     return
                  if 'bases' in req.form:
                      bases = [bin(x) for x in req.form['bases'][0].split(' ')]
                      heads = [bin(x) for x in req.form['heads'][0].split(' ')]
                  z = zlib.compressobj()
-                 f = web.repo.changegroupsubset(bases, heads, 'serve')
+                 f = repo.changegroupsubset(bases, heads, 'serve')
                  while 1:
                      chunk = f.read(4096)
                      if not chunk:
                          break
-                     req.write(z.compress(chunk))
+                     yield z.compress(chunk)
-                 req.write(z.flush())
+                 yield z.flush()
-             def capabilities(web, req):
-                 resp = ' '.join(web.capabilities())
-                 req.respond(HTTP_OK, HGTYPE, length=len(resp))
-                 req.write(resp)
+             def capabilities(repo, req):
+                 caps = ['lookup', 'changegroupsubset']
+                 if repo.ui.configbool('server', 'uncompressed', untrusted=True):
+                     caps.append('stream=%d' % repo.changelog.version)
+                 if changegroupmod.bundlepriority:
+                     caps.append('unbundle=%s' % ','.join(changegroupmod.bundlepriority))
+                 rsp = ' '.join(caps)
+                 req.respond(HTTP_OK, HGTYPE, length=len(rsp))
+                 yield rsp
-             def unbundle(web, req):
+             def unbundle(repo, req):
+                 errorfmt = '0\n%s\n'
+                 proto = req.env.get('wsgi.url_scheme') or 'http'
+                 their_heads = req.form['heads'][0].split(' ')
-                 def bail(response, headers={}):
+                 def check_heads():
+                     heads = map(hex, repo.heads())
+                     return their_heads == [hex('force')] or their_heads == heads
+                 # fail early if possible
+                 if not check_heads():
                      length = int(req.env.get('CONTENT_LENGTH', 0))
                      for s in util.filechunkiter(req, limit=length):
                          # drain incoming bundle, else client will not see
                          # response when run outside cgi script
                          pass
-                     status = headers.pop('status', HTTP_OK)
-                     req.header(headers.items())
-                     req.respond(status, HGTYPE)
-                     req.write('0\n')
-                     req.write(response)
-                 # enforce that you can only unbundle with POST requests
-                 if req.env['REQUEST_METHOD'] != 'POST':
-                     headers = {'status': '405 Method Not Allowed'}
-                     bail('unbundle requires POST request\n', headers)
-                     return
-                 # require ssl by default, auth info cannot be sniffed and
-                 # replayed
-                 ssl_req = web.configbool('web', 'push_ssl', True)
-                 if ssl_req:
-                     if req.env.get('wsgi.url_scheme') != 'https':
-                         bail('ssl required\n')
-                         return
-                     proto = 'https'
-                 else:
-                     proto = 'http'
-                 # do not allow push unless explicitly allowed
-                 if not web.check_perm(req, 'push', False):
-                     bail('push not authorized\n', headers={'status': '401 Unauthorized'})
-                     return
-                 their_heads = req.form['heads'][0].split(' ')
-                 def check_heads():
-                     heads = map(hex, web.repo.heads())
-                     return their_heads == [hex('force')] or their_heads == heads
-                 # fail early if possible
-                 if not check_heads():
-                     bail('unsynced changes\n')
-                     return
+                     req.respond(HTTP_OK, HGTYPE)
+                     return errorfmt % 'unsynced changes',
                  req.respond(HTTP_OK, HGTYPE)
                          fp.write(s)
                      try:
-                         lock = web.repo.lock()
+                         lock = repo.lock()
                          try:
                              if not check_heads():
-                                 req.write('0\n')
-                                 req.write('unsynced changes\n')
-                                 return
+                                 return errorfmt % 'unsynced changes',
                              fp.seek(0)
                              header = fp.read(6)
                                  url = 'remote:%s:%s' % (proto,
                                                          req.env.get('REMOTE_HOST', ''))
                                  try:
-                                     ret = web.repo.addchangegroup(gen, 'serve', url)
+                                     ret = repo.addchangegroup(gen, 'serve', url)
                                  except util.Abort, inst:
                                      sys.stdout.write("abort: %s\n" % inst)
                                      ret = 0
                              finally:
                                  val = sys.stdout.getvalue()
                                  sys.stdout, sys.stderr = oldio
-                             req.write('%d\n' % ret)
-                             req.write(val)
+                             return '%d\n%s' % (ret, val),
                          finally:
                              del lock
                      except ValueError, inst:
-                         req.write('0\n')
-                         req.write(str(inst) + '\n')
+                         return errorfmt % inst,
                      except (OSError, IOError), inst:
-                         req.write('0\n')
                          filename = getattr(inst, 'filename', '')
                          # Don't send our filesystem layout to the client
-                         if filename.startswith(web.repo.root):
-                             filename = filename[len(web.repo.root)+1:]
+                         if filename.startswith(repo.root):
+                             filename = filename[len(repo.root)+1:]
                          else:
                              filename = ''
                          error = getattr(inst, 'strerror', 'Unknown error')
                          else:
                              code = HTTP_SERVER_ERROR
                          req.respond(code)
-                         req.write('%s: %s\n' % (error, filename))
+                         return '0\n%s: %s\n' % (error, filename),
                  finally:
                      fp.close()
                      os.unlink(tempname)
-             def stream_out(web, req):
-                 if not web.allowpull:
-                     return
+             def stream_out(repo, req):
                  req.respond(HTTP_OK, HGTYPE)
-                 streamclone.stream_out(web.repo, req, untrusted=True)
+                 streamclone.stream_out(repo, req, untrusted=True)
+                 return []

mercurial/hgweb/request.py

0 +26 -1

              import socket, cgi, errno
              from common import ErrorResponse, statusmessage
+             shortcuts = {
+                 'cl': [('cmd', ['changelog']), ('rev', None)],
+                 'sl': [('cmd', ['shortlog']), ('rev', None)],
+                 'cs': [('cmd', ['changeset']), ('node', None)],
+                 'f': [('cmd', ['file']), ('filenode', None)],
+                 'fl': [('cmd', ['filelog']), ('filenode', None)],
+                 'fd': [('cmd', ['filediff']), ('node', None)],
+                 'fa': [('cmd', ['annotate']), ('filenode', None)],
+                 'mf': [('cmd', ['manifest']), ('manifest', None)],
+                 'ca': [('cmd', ['archive']), ('node', None)],
+                 'tags': [('cmd', ['tags'])],
+                 'tip': [('cmd', ['changeset']), ('node', ['tip'])],
+                 'static': [('cmd', ['static']), ('file', None)]
+             }
+             def expand(form):
+                 for k in shortcuts.iterkeys():
+                     if k in form:
+                         for name, value in shortcuts[k]:
+                             if value is None:
+                                 value = form[k]
+                             form[name] = value
+                         del form[k]
+                 return form
              class wsgirequest(object):
                  def __init__(self, wsgienv, start_response):
                      version = wsgienv['wsgi.version']
                      self.multiprocess = wsgienv['wsgi.multiprocess']
                      self.run_once = wsgienv['wsgi.run_once']
                      self.env = wsgienv
-                     self.form = cgi.parse(self.inp, self.env, keep_blank_values=1)
+                     self.form = expand(cgi.parse(self.inp, self.env, keep_blank_values=1))
                      self._start_response = start_response
                      self.server_write = None
                      self.headers = []

mercurial/hgweb/server.py

0 +2 -6

                      self.saved_headers = []
                      self.sent_headers = False
                      self.length = None
-                     self.server.application(env, self._start_response)
+                     for chunk in self.server.application(env, self._start_response):
+                         self._write(chunk)
                  def send_headers(self):
                      if not self.saved_status:
                          self.addr, self.port = self.socket.getsockname()[0:2]
                          self.prefix = prefix
                          self.fqaddr = socket.getfqdn(address)
-                         try:
-                             socket.getaddrbyhost(self.fqaddr)
-                         except:
-                             fqaddr = address
                  class IPv6HTTPServer(MercurialHTTPServer):
                      address_family = getattr(socket, 'AF_INET6', None)

mercurial/hgweb/webcommands.py

0 +508 -29

This diff has been collapsed as it changes many lines, (537 lines changed) Show them Hide them
			@@ -5,10 +5,15
	5	5	# This software may be used and distributed according to the terms
	6	6	# of the GNU General Public License, incorporated herein by reference.
	7	7
	8		import os, mimetypes
	9		from mercurial import revlog, util
		8	import os, mimetypes, re, cgi
		9	import webutil
		10	from mercurial import revlog, archival, templatefilters
		11	from mercurial.node import short, hex, nullid
		12	from mercurial.util import binary, datestr
	10	13	from mercurial.repo import RepoError
	11		from common import staticfile, ~~ErrorResponse~~, ~~HTTP_OK~~, ~~HTTP_NOT_FOUND~~
		14	from common import paritygen, staticfile, get_contact, ErrorResponse
		15	from common import HTTP_OK, HTTP_NOT_FOUND
		16	from mercurial import graphmod, util
	12	17
	13	18	# __all__ is populated with the allowed commands. Be sure to add to it if
	14	19	# you're adding a new command, or the new command won't work.
			@@ -16,7 +21,7 from common import staticfile, ErrorResp
	16	21	__all__ = [
	17	22	'log', 'rawfile', 'file', 'changelog', 'shortlog', 'changeset', 'rev',
	18	23	'manifest', 'tags', 'summary', 'filediff', 'diff', 'annotate', 'filelog',
	19		'archive', 'static',
		24	'archive', 'static', 'graph',
	20	25	]
	21	26
	22	27	def log(web, req, tmpl):
			@@ -26,17 +31,17 def log(web, req, tmpl):
	26	31	return changelog(web, req, tmpl)
	27	32
	28	33	def rawfile(web, req, tmpl):
	29		path = web.cleanpath(req.form.get('file', [''])[0])
		34	path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
	30	35	if not path:
	31		content = ~~web~~.manifest(~~tmpl~~, ~~web~~.~~changectx~~(req), ~~path~~)
		36	content = manifest(web, req, tmpl)
	32	37	req.respond(HTTP_OK, web.ctype)
	33	38	return content
	34	39
	35	40	try:
	36		fctx = web.filectx(req)
		41	fctx = webutil.filectx(web.repo, req)
	37	42	except revlog.LookupError, inst:
	38	43	try:
	39		content = ~~web~~.manifest(~~tmpl~~, ~~web~~.~~changectx~~(req), ~~path~~)
		44	content = manifest(web, req, tmpl)
	40	45	req.respond(HTTP_OK, web.ctype)
	41	46	return content
	42	47	except ErrorResponse:
			@@ -45,76 +50,514 def rawfile(web, req, tmpl):
	45	50	path = fctx.path()
	46	51	text = fctx.data()
	47	52	mt = mimetypes.guess_type(path)[0]
	48		if mt is None or ~~util~~.binary(text):
		53	if mt is None or binary(text):
	49	54	mt = mt or 'application/octet-stream'
	50	55
	51	56	req.respond(HTTP_OK, mt, path, len(text))
	52	57	return [text]
	53	58
		59	def _filerevision(web, tmpl, fctx):
		60	f = fctx.path()
		61	text = fctx.data()
		62	fl = fctx.filelog()
		63	n = fctx.filenode()
		64	parity = paritygen(web.stripecount)
		65
		66	if binary(text):
		67	mt = mimetypes.guess_type(f)[0] or 'application/octet-stream'
		68	text = '(binary:%s)' % mt
		69
		70	def lines():
		71	for lineno, t in enumerate(text.splitlines(1)):
		72	yield {"line": t,
		73	"lineid": "l%d" % (lineno + 1),
		74	"linenumber": "% 6d" % (lineno + 1),
		75	"parity": parity.next()}
		76
		77	return tmpl("filerevision",
		78	file=f,
		79	path=webutil.up(f),
		80	text=lines(),
		81	rev=fctx.rev(),
		82	node=hex(fctx.node()),
		83	author=fctx.user(),
		84	date=fctx.date(),
		85	desc=fctx.description(),
		86	branch=webutil.nodebranchnodefault(fctx),
		87	parent=webutil.siblings(fctx.parents()),
		88	child=webutil.siblings(fctx.children()),
		89	rename=webutil.renamelink(fctx),
		90	permissions=fctx.manifest().flags(f))
		91
	54	92	def file(web, req, tmpl):
	55		path = web.cleanpath(req.form.get('file', [''])[0])
		93	path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
	56	94	if not path:
	57		return web.manifest(tmpl, web.changectx(req), path)
		95	return manifest(web, req, tmpl)
	58	96	try:
	59		return web.~~filerevision~~(tmpl, web.filectx(req))
		97	return _filerevision(web, tmpl, webutil.filectx(web.repo, req))
	60	98	except revlog.LookupError, inst:
	61	99	try:
	62		return ~~web~~.manifest(~~tmpl~~, ~~web~~.~~changectx~~(req), ~~path~~)
		100	return manifest(web, req, tmpl)
	63	101	except ErrorResponse:
	64	102	raise inst
	65	103
		104	def _search(web, tmpl, query):
		105
		106	def changelist(**map):
		107	cl = web.repo.changelog
		108	count = 0
		109	qw = query.lower().split()
		110
		111	def revgen():
		112	for i in xrange(len(cl) - 1, 0, -100):
		113	l = []
		114	for j in xrange(max(0, i - 100), i + 1):
		115	ctx = web.repo[j]
		116	l.append(ctx)
		117	l.reverse()
		118	for e in l:
		119	yield e
		120
		121	for ctx in revgen():
		122	miss = 0
		123	for q in qw:
		124	if not (q in ctx.user().lower() or
		125	q in ctx.description().lower() or
		126	q in " ".join(ctx.files()).lower()):
		127	miss = 1
		128	break
		129	if miss:
		130	continue
		131
		132	count += 1
		133	n = ctx.node()
		134	showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n)
		135
		136	yield tmpl('searchentry',
		137	parity=parity.next(),
		138	author=ctx.user(),
		139	parent=webutil.siblings(ctx.parents()),
		140	child=webutil.siblings(ctx.children()),
		141	changelogtag=showtags,
		142	desc=ctx.description(),
		143	date=ctx.date(),
		144	files=web.listfilediffs(tmpl, ctx.files(), n),
		145	rev=ctx.rev(),
		146	node=hex(n),
		147	tags=webutil.nodetagsdict(web.repo, n),
		148	inbranch=webutil.nodeinbranch(web.repo, ctx),
		149	branches=webutil.nodebranchdict(web.repo, ctx))
		150
		151	if count >= web.maxchanges:
		152	break
		153
		154	cl = web.repo.changelog
		155	parity = paritygen(web.stripecount)
		156
		157	return tmpl('search',
		158	query=query,
		159	node=hex(cl.tip()),
		160	entries=changelist,
		161	archives=web.archivelist("tip"))
		162
	66	163	def changelog(web, req, tmpl, shortlog = False):
	67	164	if 'node' in req.form:
	68		ctx = web.changectx(req)
		165	ctx = webutil.changectx(web.repo, req)
	69	166	else:
	70	167	if 'rev' in req.form:
	71	168	hi = req.form['rev'][0]
	72	169	else:
	73		hi = web.repo.~~changelog~~.~~count~~() - 1
		170	hi = len(web.repo) - 1
	74	171	try:
	75		ctx = web.repo.~~changectx~~(hi)
		172	ctx = web.repo[hi]
	76	173	except RepoError:
	77		return web.~~search~~(tmpl, hi) # XXX redirect to 404 page?
		174	return _search(web, tmpl, hi) # XXX redirect to 404 page?
		175
		176	def changelist(limit=0, **map):
		177	cl = web.repo.changelog
		178	l = [] # build a list in forward order for efficiency
		179	for i in xrange(start, end):
		180	ctx = web.repo[i]
		181	n = ctx.node()
		182	showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n)
		183
		184	l.insert(0, {"parity": parity.next(),
		185	"author": ctx.user(),
		186	"parent": webutil.siblings(ctx.parents(), i - 1),
		187	"child": webutil.siblings(ctx.children(), i + 1),
		188	"changelogtag": showtags,
		189	"desc": ctx.description(),
		190	"date": ctx.date(),
		191	"files": web.listfilediffs(tmpl, ctx.files(), n),
		192	"rev": i,
		193	"node": hex(n),
		194	"tags": webutil.nodetagsdict(web.repo, n),
		195	"inbranch": webutil.nodeinbranch(web.repo, ctx),
		196	"branches": webutil.nodebranchdict(web.repo, ctx)
		197	})
	78	198
	79		return web.changelog(tmpl, ctx, shortlog = shortlog)
		199	if limit > 0:
		200	l = l[:limit]
		201
		202	for e in l:
		203	yield e
		204
		205	maxchanges = shortlog and web.maxshortchanges or web.maxchanges
		206	cl = web.repo.changelog
		207	count = len(cl)
		208	pos = ctx.rev()
		209	start = max(0, pos - maxchanges + 1)
		210	end = min(count, start + maxchanges)
		211	pos = end - 1
		212	parity = paritygen(web.stripecount, offset=start-end)
		213
		214	changenav = webutil.revnavgen(pos, maxchanges, count, web.repo.changectx)
		215
		216	return tmpl(shortlog and 'shortlog' or 'changelog',
		217	changenav=changenav,
		218	node=hex(ctx.node()),
		219	rev=pos, changesets=count,
		220	entries=lambda x: changelist(limit=0,x),
		221	latestentry=lambda x: changelist(limit=1,x),
		222	archives=web.archivelist("tip"))
	80	223
	81	224	def shortlog(web, req, tmpl):
	82	225	return changelog(web, req, tmpl, shortlog = True)
	83	226
	84	227	def changeset(web, req, tmpl):
	85		return web.changeset(tmpl, web.changectx(req))
		228	ctx = webutil.changectx(web.repo, req)
		229	n = ctx.node()
		230	showtags = webutil.showtag(web.repo, tmpl, 'changesettag', n)
		231	parents = ctx.parents()
		232	p1 = parents[0].node()
		233
		234	files = []
		235	parity = paritygen(web.stripecount)
		236	for f in ctx.files():
		237	files.append(tmpl("filenodelink",
		238	node=hex(n), file=f,
		239	parity=parity.next()))
		240
		241	diffs = web.diff(tmpl, p1, n, None)
		242	return tmpl('changeset',
		243	diff=diffs,
		244	rev=ctx.rev(),
		245	node=hex(n),
		246	parent=webutil.siblings(parents),
		247	child=webutil.siblings(ctx.children()),
		248	changesettag=showtags,
		249	author=ctx.user(),
		250	desc=ctx.description(),
		251	date=ctx.date(),
		252	files=files,
		253	archives=web.archivelist(hex(n)),
		254	tags=webutil.nodetagsdict(web.repo, n),
		255	branch=webutil.nodebranchnodefault(ctx),
		256	inbranch=webutil.nodeinbranch(web.repo, ctx),
		257	branches=webutil.nodebranchdict(web.repo, ctx))
	86	258
	87	259	rev = changeset
	88	260
	89	261	def manifest(web, req, tmpl):
	90		return web.manifest(tmpl, web.changectx(req),
	91		web.cleanpath(req.form['path'][0]))
		262	ctx = webutil.changectx(web.repo, req)
		263	path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
		264	mf = ctx.manifest()
		265	node = ctx.node()
		266
		267	files = {}
		268	parity = paritygen(web.stripecount)
		269
		270	if path and path[-1] != "/":
		271	path += "/"
		272	l = len(path)
		273	abspath = "/" + path
		274
		275	for f, n in mf.items():
		276	if f[:l] != path:
		277	continue
		278	remain = f[l:]
		279	if "/" in remain:
		280	short = remain[:remain.index("/") + 1] # bleah
		281	files[short] = (f, None)
		282	else:
		283	short = os.path.basename(remain)
		284	files[short] = (f, n)
		285
		286	if not files:
		287	raise ErrorResponse(HTTP_NOT_FOUND, 'path not found: ' + path)
		288
		289	def filelist(**map):
		290	for f in util.sort(files):
		291	full, fnode = files[f]
		292	if not fnode:
		293	continue
		294
		295	fctx = ctx.filectx(full)
		296	yield {"file": full,
		297	"parity": parity.next(),
		298	"basename": f,
		299	"date": fctx.date(),
		300	"size": fctx.size(),
		301	"permissions": mf.flags(full)}
		302
		303	def dirlist(**map):
		304	for f in util.sort(files):
		305	full, fnode = files[f]
		306	if fnode:
		307	continue
		308
		309	yield {"parity": parity.next(),
		310	"path": "%s%s" % (abspath, f),
		311	"basename": f[:-1]}
		312
		313	return tmpl("manifest",
		314	rev=ctx.rev(),
		315	node=hex(node),
		316	path=abspath,
		317	up=webutil.up(abspath),
		318	upparity=parity.next(),
		319	fentries=filelist,
		320	dentries=dirlist,
		321	archives=web.archivelist(hex(node)),
		322	tags=webutil.nodetagsdict(web.repo, node),
		323	inbranch=webutil.nodeinbranch(web.repo, ctx),
		324	branches=webutil.nodebranchdict(web.repo, ctx))
	92	325
	93	326	def tags(web, req, tmpl):
	94		return web.tags(tmpl)
		327	i = web.repo.tagslist()
		328	i.reverse()
		329	parity = paritygen(web.stripecount)
		330
		331	def entries(notip=False,limit=0, **map):
		332	count = 0
		333	for k, n in i:
		334	if notip and k == "tip":
		335	continue
		336	if limit > 0 and count >= limit:
		337	continue
		338	count = count + 1
		339	yield {"parity": parity.next(),
		340	"tag": k,
		341	"date": web.repo[n].date(),
		342	"node": hex(n)}
		343
		344	return tmpl("tags",
		345	node=hex(web.repo.changelog.tip()),
		346	entries=lambda x: entries(False,0, x),
		347	entriesnotip=lambda x: entries(True,0, x),
		348	latestentry=lambda x: entries(True,1, x))
	95	349
	96	350	def summary(web, req, tmpl):
	97		return web.summary(tmpl)
		351	i = web.repo.tagslist()
		352	i.reverse()
		353
		354	def tagentries(**map):
		355	parity = paritygen(web.stripecount)
		356	count = 0
		357	for k, n in i:
		358	if k == "tip": # skip tip
		359	continue
		360
		361	count += 1
		362	if count > 10: # limit to 10 tags
		363	break
		364
		365	yield tmpl("tagentry",
		366	parity=parity.next(),
		367	tag=k,
		368	node=hex(n),
		369	date=web.repo[n].date())
		370
		371	def branches(**map):
		372	parity = paritygen(web.stripecount)
		373
		374	b = web.repo.branchtags()
		375	l = [(-web.repo.changelog.rev(n), n, t) for t, n in b.items()]
		376	for r,n,t in util.sort(l):
		377	yield {'parity': parity.next(),
		378	'branch': t,
		379	'node': hex(n),
		380	'date': web.repo[n].date()}
		381
		382	def changelist(**map):
		383	parity = paritygen(web.stripecount, offset=start-end)
		384	l = [] # build a list in forward order for efficiency
		385	for i in xrange(start, end):
		386	ctx = web.repo[i]
		387	n = ctx.node()
		388	hn = hex(n)
		389
		390	l.insert(0, tmpl(
		391	'shortlogentry',
		392	parity=parity.next(),
		393	author=ctx.user(),
		394	desc=ctx.description(),
		395	date=ctx.date(),
		396	rev=i,
		397	node=hn,
		398	tags=webutil.nodetagsdict(web.repo, n),
		399	inbranch=webutil.nodeinbranch(web.repo, ctx),
		400	branches=webutil.nodebranchdict(web.repo, ctx)))
		401
		402	yield l
		403
		404	cl = web.repo.changelog
		405	count = len(cl)
		406	start = max(0, count - web.maxchanges)
		407	end = min(count, start + web.maxchanges)
		408
		409	return tmpl("summary",
		410	desc=web.config("web", "description", "unknown"),
		411	owner=get_contact(web.config) or "unknown",
		412	lastchange=cl.read(cl.tip())[2],
		413	tags=tagentries,
		414	branches=branches,
		415	shortlog=changelist,
		416	node=hex(cl.tip()),
		417	archives=web.archivelist("tip"))
	98	418
	99	419	def filediff(web, req, tmpl):
	100		return web.filediff(tmpl, web.filectx(req))
		420	fctx = webutil.filectx(web.repo, req)
		421	n = fctx.node()
		422	path = fctx.path()
		423	parents = fctx.parents()
		424	p1 = parents and parents[0].node() or nullid
		425
		426	diffs = web.diff(tmpl, p1, n, [path])
		427	return tmpl("filediff",
		428	file=path,
		429	node=hex(n),
		430	rev=fctx.rev(),
		431	date=fctx.date(),
		432	desc=fctx.description(),
		433	author=fctx.user(),
		434	rename=webutil.renamelink(fctx),
		435	branch=webutil.nodebranchnodefault(fctx),
		436	parent=webutil.siblings(parents),
		437	child=webutil.siblings(fctx.children()),
		438	diff=diffs)
	101	439
	102	440	diff = filediff
	103	441
	104	442	def annotate(web, req, tmpl):
	105		return web.fileannotate(tmpl, web.filectx(req))
		443	fctx = webutil.filectx(web.repo, req)
		444	f = fctx.path()
		445	n = fctx.filenode()
		446	fl = fctx.filelog()
		447	parity = paritygen(web.stripecount)
		448
		449	def annotate(**map):
		450	last = None
		451	if binary(fctx.data()):
		452	mt = (mimetypes.guess_type(fctx.path())[0]
		453	or 'application/octet-stream')
		454	lines = enumerate([((fctx.filectx(fctx.filerev()), 1),
		455	'(binary:%s)' % mt)])
		456	else:
		457	lines = enumerate(fctx.annotate(follow=True, linenumber=True))
		458	for lineno, ((f, targetline), l) in lines:
		459	fnode = f.filenode()
		460
		461	if last != fnode:
		462	last = fnode
		463
		464	yield {"parity": parity.next(),
		465	"node": hex(f.node()),
		466	"rev": f.rev(),
		467	"author": f.user(),
		468	"desc": f.description(),
		469	"file": f.path(),
		470	"targetline": targetline,
		471	"line": l,
		472	"lineid": "l%d" % (lineno + 1),
		473	"linenumber": "% 6d" % (lineno + 1)}
		474
		475	return tmpl("fileannotate",
		476	file=f,
		477	annotate=annotate,
		478	path=webutil.up(f),
		479	rev=fctx.rev(),
		480	node=hex(fctx.node()),
		481	author=fctx.user(),
		482	date=fctx.date(),
		483	desc=fctx.description(),
		484	rename=webutil.renamelink(fctx),
		485	branch=webutil.nodebranchnodefault(fctx),
		486	parent=webutil.siblings(fctx.parents()),
		487	child=webutil.siblings(fctx.children()),
		488	permissions=fctx.manifest().flags(f))
	106	489
	107	490	def filelog(web, req, tmpl):
	108		return web.filelog(tmpl, web.filectx(req))
		491	fctx = webutil.filectx(web.repo, req)
		492	f = fctx.path()
		493	fl = fctx.filelog()
		494	count = len(fl)
		495	pagelen = web.maxshortchanges
		496	pos = fctx.filerev()
		497	start = max(0, pos - pagelen + 1)
		498	end = min(count, start + pagelen)
		499	pos = end - 1
		500	parity = paritygen(web.stripecount, offset=start-end)
		501
		502	def entries(limit=0, **map):
		503	l = []
		504
		505	for i in xrange(start, end):
		506	ctx = fctx.filectx(i)
		507	n = fl.node(i)
		508
		509	l.insert(0, {"parity": parity.next(),
		510	"filerev": i,
		511	"file": f,
		512	"node": hex(ctx.node()),
		513	"author": ctx.user(),
		514	"date": ctx.date(),
		515	"rename": webutil.renamelink(fctx),
		516	"parent": webutil.siblings(fctx.parents()),
		517	"child": webutil.siblings(fctx.children()),
		518	"desc": ctx.description()})
		519
		520	if limit > 0:
		521	l = l[:limit]
		522
		523	for e in l:
		524	yield e
		525
		526	nodefunc = lambda x: fctx.filectx(fileid=x)
		527	nav = webutil.revnavgen(pos, pagelen, count, nodefunc)
		528	return tmpl("filelog", file=f, node=hex(fctx.node()), nav=nav,
		529	entries=lambda x: entries(limit=0, x),
		530	latestentry=lambda x: entries(limit=1, x))
		531
	109	532
	110	533	def archive(web, req, tmpl):
	111	534	type_ = req.form.get('type', [None])[0]
	112	535	allowed = web.configlist("web", "allow_archive")
	113		if (type_ in web.archives and (type_ in allowed or
		536	key = req.form['node'][0]
		537
		538	if not (type_ in web.archives and (type_ in allowed or
	114	539	web.configbool("web", "allow" + type_, False))):
	115		web.archive(tmpl, req, req.form['node'][0], type_)
		540	msg = 'Unsupported archive type: %s' % type_
		541	raise ErrorResponse(HTTP_NOT_FOUND, msg)
		542
		543	reponame = re.sub(r"\W+", "-", os.path.basename(web.reponame))
		544	cnode = web.repo.lookup(key)
		545	arch_version = key
		546	if cnode == key or key == 'tip':
		547	arch_version = short(cnode)
		548	name = "%s-%s" % (reponame, arch_version)
		549	mimetype, artype, extension, encoding = web.archive_specs[type_]
		550	headers = [
		551	('Content-Type', mimetype),
		552	('Content-Disposition', 'attachment; filename=%s%s' % (name, extension))
		553	]
		554	if encoding:
		555	headers.append(('Content-Encoding', encoding))
		556	req.header(headers)
		557	req.respond(HTTP_OK)
		558	archival.archive(web.repo, req, cnode, artype, prefix=name)
	116	559	return []
	117		raise ErrorResponse(HTTP_NOT_FOUND, 'unsupported archive type: %s' % type_)
		560
	118	561
	119	562	def static(web, req, tmpl):
	120	563	fname = req.form['file'][0]
			@@ -124,3 +567,39 def static(web, req, tmpl):
	124	567	os.path.join(web.templatepath, "static"),
	125	568	untrusted=False)
	126	569	return [staticfile(static, fname, req)]
		570
		571	def graph(web, req, tmpl):
		572	rev = webutil.changectx(web.repo, req).rev()
		573	bg_height = 39
		574
		575	max_rev = len(web.repo) - 1
		576	revcount = min(max_rev, int(req.form.get('revcount', [25])[0]))
		577	revnode = web.repo.changelog.node(rev)
		578	revnode_hex = hex(revnode)
		579	uprev = min(max_rev, rev + revcount)
		580	downrev = max(0, rev - revcount)
		581	lessrev = max(0, rev - revcount / 2)
		582
		583	maxchanges = web.maxshortchanges or web.maxchanges
		584	count = len(web.repo)
		585	changenav = webutil.revnavgen(rev, maxchanges, count, web.repo.changectx)
		586
		587	tree = list(graphmod.graph(web.repo, rev, rev - revcount))
		588	canvasheight = (len(tree) + 1) * bg_height - 27;
		589
		590	data = []
		591	for i, (ctx, vtx, edges) in enumerate(tree):
		592	node = short(ctx.node())
		593	age = templatefilters.age(ctx.date())
		594	desc = templatefilters.firstline(ctx.description())
		595	desc = cgi.escape(desc)
		596	user = cgi.escape(templatefilters.person(ctx.user()))
		597	branch = ctx.branch()
		598	branch = branch, web.repo.branchtags().get(branch) == ctx.node()
		599	data.append((node, vtx, edges, desc, user, age, branch, ctx.tags()))
		600
		601	return tmpl('graph', rev=rev, revcount=revcount, uprev=uprev,
		602	lessrev=lessrev, revcountmore=revcount and 2 * revcount or 1,
		603	revcountless=revcount / 2, downrev=downrev,
		604	canvasheight=canvasheight, bg_height=bg_height,
		605	jsdata=data, node=revnode_hex, changenav=changenav)

mercurial/hook.py

0 +3 -4

                      oldstdout = os.dup(sys.__stdout__.fileno())
                      os.dup2(sys.__stderr__.fileno(), sys.__stdout__.fileno())
-                 hooks = [(hname, cmd) for hname, cmd in ui.configitems("hooks")
-                          if hname.split(".", 1)[0] == name and cmd]
-                 hooks.sort()
-                 for hname, cmd in hooks:
+                 for hname, cmd in util.sort(ui.configitems('hooks')):
+                     if hname.split('.')[0] != name or not cmd:
+                         continue
                      if callable(cmd):
                          r = _pythonhook(ui, repo, name, hname, cmd, args, throw) or r
                      elif cmd.startswith('python:'):

mercurial/httprepo.py

0 +1 0

                      # 1.0 here is the _protocol_ version
                      opener.addheaders = [('User-agent', 'mercurial/proto-1.0')]
+                     opener.addheaders.append(('Accept', 'application/mercurial-0.1'))
                      urllib2.install_opener(opener)
                  def url(self):

mercurial/keepalive.py

0 +3 -1

              # Modified by Benoit Boissinot:
              #  - fix for digest auth (inspired from urllib2.py @ Python v2.4)
+             # Modified by Dirkjan Ochtman:
+             #  - import md5 function from a local util module
              """An HTTP handler for urllib2 that supports HTTP 1.1 and keepalive.
                  keepalive_handler.close_all()
              def continuity(url):
-                 import md5
+                 from util import md5
                  format = '%25s: %s'
                  # first fetch the file with the normal http handler

mercurial/localrepo.py

0 +190 -263

              from i18n import _
              import repo, changegroup
              import changelog, dirstate, filelog, manifest, context, weakref
-             import lock, transaction, stat, errno, ui
+             import lock, transaction, stat, errno, ui, store
              import os, revlog, time, util, extensions, hook, inspect
+             import match as match_
              class localrepository(repo.repository):
                  capabilities = util.set(('lookup', 'changegroupsubset'))
                          if r not in self.supported:
                              raise repo.RepoError(_("requirement '%s' not supported") % r)
-                     # setup store
-                     if "store" in requirements:
-                         self.encodefn = util.encodefilename
-                         self.decodefn = util.decodefilename
-                         self.spath = os.path.join(self.path, "store")
-                     else:
-                         self.encodefn = lambda x: x
-                         self.decodefn = lambda x: x
-                         self.spath = self.path
+                     self.store = store.store(requirements, self.path)
-                     try:
-                         # files in .hg/ will be created using this mode
-                         mode = os.stat(self.spath).st_mode
-                         # avoid some useless chmods
-                         if (0777 & ~util._umask) == (0777 & mode):
-                             mode = None
-                     except OSError:
-                         mode = None
-                     self._createmode = mode
-                     self.opener.createmode = mode
-                     sopener = util.opener(self.spath)
-                     sopener.createmode = mode
-                     self.sopener = util.encodedopener(sopener, self.encodefn)
+                     self.spath = self.store.path
+                     self.sopener = self.store.opener
+                     self.sjoin = self.store.join
+                     self._createmode = self.store.createmode
+                     self.opener.createmode = self.store.createmode
                      self.ui = ui.ui(parentui=parentui)
                      try:
                      else:
                          raise AttributeError, name
+                 def __getitem__(self, changeid):
+                     if changeid == None:
+                         return context.workingctx(self)
+                     return context.changectx(self, changeid)
+                 def __nonzero__(self):
+                     return True
+                 def __len__(self):
+                     return len(self.changelog)
+                 def __iter__(self):
+                     for i in xrange(len(self)):
+                         yield i
                  def url(self):
                      return 'file:' + self.root
                          if prevtags and prevtags[-1] != '\n':
                              fp.write('\n')
                          for name in names:
-                             fp.write('%s %s\n' % (hex(node), munge and munge(name) or name))
+                             m = munge and munge(name) or name
+                             if self._tagstypecache and name in self._tagstypecache:
+                                 old = self.tagscache.get(name, nullid)
+                                 fp.write('%s %s\n' % (hex(old), m))
+                             fp.write('%s %s\n' % (hex(node), m))
                          fp.close()
                      prevtags = ''
                              self.tagscache[k] = n
-                             self._tagstypecache[k] = tagtypes[k]
                      self.tagscache['tip'] = self.changelog.tip()
                      return self.tagscache
                  def tagtype(self, tagname):
                      last = {}
                      ret = []
                      for node in heads:
-                         c = self.changectx(node)
+                         c = self[node]
                          rev = c.rev()
                          try:
                              fnode = c.filenode('.hgtags')
                          except:
                              r = -2 # sort to the beginning of the list if unknown
                          l.append((r, t, n))
-                     l.sort()
-                     return [(t, n) for r, t, n in l]
+                     return [(t, n) for r, t, n in util.sort(l)]
                  def nodetags(self, node):
                      '''return the tags associated with a node'''
                      return self.nodetagscache.get(node, [])
                  def _branchtags(self, partial, lrev):
-                     tiprev = self.changelog.count() - 1
+                     tiprev = len(self) - 1
                      if lrev != tiprev:
                          self._updatebranchcache(partial, lrev+1, tiprev+1)
                          self._writebranchcache(partial, self.changelog.tip(), tiprev)
                      try:
                          last, lrev = lines.pop(0).split(" ", 1)
                          last, lrev = bin(last), int(lrev)
-                         if not (lrev < self.changelog.count() and
-                                 self.changelog.node(lrev) == last): # sanity check
+                         if lrev >= len(self) or self[lrev].node() != last:
                              # invalidate the cache
                              raise ValueError('invalidating branch cache (tip differs)')
                          for l in lines:
                  def _updatebranchcache(self, partial, start, end):
                      for r in xrange(start, end):
-                         c = self.changectx(r)
+                         c = self[r]
                          b = c.branch()
                          partial[b] = c.node()
                  def lookup(self, key):
                      if key == '.':
-                         key, second = self.dirstate.parents()
-                         if key == nullid:
-                             raise repo.RepoError(_("no revision checked out"))
-                         if second != nullid:
-                             self.ui.warn(_("warning: working directory has two parents, "
-                                            "tag '.' uses the first\n"))
+                         return self.dirstate.parents()[0]
                      elif key == 'null':
                          return nullid
                      n = self.changelog._match(key)
                  def join(self, f):
                      return os.path.join(self.path, f)
-                 def sjoin(self, f):
-                     f = self.encodefn(f)
-                     return os.path.join(self.spath, f)
                  def wjoin(self, f):
                      return os.path.join(self.root, f)
+                 def rjoin(self, f):
+                     return os.path.join(self.root, util.pconvert(f))
                  def file(self, f):
                      if f[0] == '/':
                          f = f[1:]
                      return filelog.filelog(self.sopener, f)
-                 def changectx(self, changeid=None):
-                     return context.changectx(self, changeid)
-                 def workingctx(self):
-                     return context.workingctx(self)
+                 def changectx(self, changeid):
+                     return self[changeid]
                  def parents(self, changeid=None):
-                     '''
-                     get list of changectxs for parents of changeid or working directory
-                     '''
-                     if changeid is None:
-                         pl = self.dirstate.parents()
-                     else:
-                         n = self.changelog.lookup(changeid)
-                         pl = self.changelog.parents(n)
-                     if pl[1] == nullid:
-                         return [self.changectx(pl[0])]
-                     return [self.changectx(pl[0]), self.changectx(pl[1])]
+                     '''get list of changectxs for parents of changeid'''
+                     return self[changeid].parents()
                  def filectx(self, path, changeid=None, fileid=None):
                      """changeid can be a changeset revision, node, or tag.
                      self._wlockref = weakref.ref(l)
                      return l
-                 def filecommit(self, fn, manifest1, manifest2, linkrev, tr, changelist):
+                 def filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
                      """
                      commit an individual file as part of a larger transaction
                      """
-                     t = self.wread(fn)
+                     fn = fctx.path()
+                     t = fctx.data()
                      fl = self.file(fn)
                      fp1 = manifest1.get(fn, nullid)
                      fp2 = manifest2.get(fn, nullid)
                      meta = {}
-                     cf = self.dirstate.copied(fn)
-                     if cf and cf != fn:
+                     cp = fctx.renamed()
+                     if cp and cp[0] != fn:
                          # Mark the new revision of this file as a copy of another
                          # file.  This copy data will effectively act as a parent
                          # of this new revision.  If this is a merge, the first
                          #    \- 2 --- 4        as the merge base
                          #
+                         cf = cp[0]
                          cr = manifest1.get(cf)
                          nfp = fp2
                          if not cr:
                              self.ui.debug(_(" %s: searching for copy revision for %s\n") %
                                            (fn, cf))
-                             p1 = self.dirstate.parents()[0]
-                             rev = self.changelog.rev(p1)
-                             seen = {-1:None}
-                             visit = [rev]
-                             while visit:
-                                 for p in self.changelog.parentrevs(visit.pop(0)):
-                                     if p not in seen:
-                                         seen[p] = True
-                                         visit.append(p)
-                                         ctx = self.changectx(p)
-                                         if cf in ctx:
-                                             cr = ctx[cf].filenode()
+             		for a in self['.'].ancestors():
+                                 if cf in a:
+                                     cr = a[cf].filenode()
-                                             break
                          self.ui.debug(_(" %s: copy %s:%s\n") % (fn, cf, hex(cr)))
                                         p1=p1, p2=p2, extra=extra, empty_ok=True)
                  def commit(self, files=None, text="", user=None, date=None,
-                            match=util.always, force=False, force_editor=False,
+                            match=None, force=False, force_editor=False,
                             p1=None, p2=None, extra={}, empty_ok=False):
-                     wlock = lock = tr = None
-                     valid = 0 # don't save the dirstate if this isn't set
+                     wlock = lock = None
                      if files:
                          files = util.unique(files)
                      try:
                          wlock = self.wlock()
                          lock = self.lock()
-                         commit = []
-                         remove = []
-                         changed = []
                          use_dirstate = (p1 is None) # not rawcommit
-                         extra = extra.copy()
-                         if use_dirstate:
-                             if files:
-                                 for f in files:
-                                     s = self.dirstate[f]
-                                     if s in 'nma':
-                                         commit.append(f)
-                                     elif s == 'r':
-                                         remove.append(f)
-                                     else:
-                                         self.ui.warn(_("%s not tracked!\n") % f)
-                             else:
-                                 changes = self.status(match=match)[:5]
-                                 modified, added, removed, deleted, unknown = changes
-                                 commit = modified + added
-                                 remove = removed
-                         else:
-                             commit = files
                          if use_dirstate:
                              p1, p2 = self.dirstate.parents()
                              update_dirstate = True
                              if (not force and p2 != nullid and
-                                 (files or match != util.always)):
+                                 (match and (match.files() or match.anypats()))):
                                  raise util.Abort(_('cannot partially commit a merge '
                                                     '(do not specify files or patterns)'))
+                             if files:
+                                 modified, removed = [], []
+                                 for f in files:
+                                     s = self.dirstate[f]
+                                     if s in 'nma':
+                                         modified.append(f)
+                                     elif s == 'r':
+                                         removed.append(f)
+                                     else:
+                                         self.ui.warn(_("%s not tracked!\n") % f)
+                                 changes = [modified, [], removed, [], []]
+                             else:
+                                 changes = self.status(match=match)
                          else:
                              p1, p2 = p1, p2 or nullid
                              update_dirstate = (self.dirstate.parents()[0] == p1)
+                             changes = [files, [], [], [], []]
+                         wctx = context.workingctx(self, (p1, p2), text, user, date,
+                                                   extra, changes)
+                         return self._commitctx(wctx, force, force_editor, empty_ok,
+                                                use_dirstate, update_dirstate)
+                     finally:
+                         del lock, wlock
+                 def commitctx(self, ctx):
+                     wlock = lock = None
+                     try:
+                         wlock = self.wlock()
+                         lock = self.lock()
+                         return self._commitctx(ctx, force=True, force_editor=False,
+                                                empty_ok=True, use_dirstate=False,
+                                                update_dirstate=False)
+                     finally:
+                         del lock, wlock
+                 def _commitctx(self, wctx, force=False, force_editor=False, empty_ok=False,
+                               use_dirstate=True, update_dirstate=True):
+                     tr = None
+                     valid = 0 # don't save the dirstate if this isn't set
+                     try:
+                         commit = util.sort(wctx.modified() + wctx.added())
+                         remove = wctx.removed()
+                         extra = wctx.extra().copy()
+                         branchname = extra['branch']
+                         user = wctx.user()
+                         text = wctx.description()
+                         p1, p2 = [p.node() for p in wctx.parents()]
                          c1 = self.changelog.read(p1)
                          c2 = self.changelog.read(p2)
                          m1 = self.manifest.read(c1[0]).copy()
                          m2 = self.manifest.read(c2[0])
                          if use_dirstate:
-                             branchname = self.workingctx().branch()
-                             try:
-                                 branchname = branchname.decode('UTF-8').encode('UTF-8')
-                             except UnicodeDecodeError:
-                                 raise util.Abort(_('branch name not in UTF-8!'))
-                         else:
-                             branchname = ""
-                         if use_dirstate:
                              oldname = c1[5].get("branch") # stored in UTF-8
                              if (not commit and not remove and not force and p2 == nullid
                                  and branchname == oldname):
                          # check in files
                          new = {}
-                         linkrev = self.changelog.count()
-                         commit.sort()
-                         is_exec = util.execfunc(self.root, m1.execf)
-                         is_link = util.linkfunc(self.root, m1.linkf)
+                         changed = []
+                         linkrev = len(self)
                          for f in commit:
                              self.ui.note(f + "\n")
                              try:
-                                 new[f] = self.filecommit(f, m1, m2, linkrev, trp, changed)
-                                 new_exec = is_exec(f)
-                                 new_link = is_link(f)
+                                 fctx = wctx.filectx(f)
+                                 newflags = fctx.flags()
+                                 new[f] = self.filecommit(fctx, m1, m2, linkrev, trp, changed)
                                  if ((not changed or changed[-1] != f) and
                                      m2.get(f) != new[f]):
                                      # mention the file in the changelog if some
                                      # flag changed, even if there was no content
                                      # change.
-                                     old_exec = m1.execf(f)
-                                     old_link = m1.linkf(f)
-                                     if old_exec != new_exec or old_link != new_link:
+                                     if m1.flags(f) != newflags:
                                          changed.append(f)
-                                 m1.set(f, new_exec, new_link)
+                                 m1.set(f, newflags)
                                  if use_dirstate:
                                      self.dirstate.normal(f)
                          # update manifest
                          m1.update(new)
-                         remove.sort()
                          removed = []
-                         for f in remove:
+                         for f in util.sort(remove):
                              if f in m1:
                                  del m1[f]
                                  removed.append(f)
                                                 (new, removed))
                          # add changeset
-                         new = new.keys()
-                         new.sort()
-                         user = user or self.ui.username()
                          if (not empty_ok and not text) or force_editor:
                              edittext = []
                              if text:
                              text = self.ui.edit("\n".join(edittext), user)
                              os.chdir(olddir)
-                         if branchname:
-                             extra["branch"] = branchname
                          lines = [line.rstrip() for line in text.rstrip().splitlines()]
                          while lines and not lines[0]:
                              del lines[0]
                          text = '\n'.join(lines)
                          n = self.changelog.add(mn, changed + removed, text, trp, p1, p2,
-                                                user, date, extra)
+                                                user, wctx.date(), extra)
                          self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
                                    parent2=xp2)
                          tr.close()
                      finally:
                          if not valid: # don't save our updated dirstate
                              self.dirstate.invalidate()
-                         del tr, lock, wlock
+                         del tr
-                 def walk(self, node=None, files=[], match=util.always, badmatch=None):
+                 def walk(self, match, node=None):
                      '''
                      walk recursively through the directory tree or a given
                      changeset, finding all files matched by the match
                      function
-                     results are yielded in a tuple (src, filename), where src
-                     is one of:
-                     'f' the file was found in the directory tree
-                     'm' the file was only in the dirstate and not in the tree
-                     'b' file was not found and matched badmatch
                      '''
+                     return self[node].walk(match)
-                     if node:
-                         fdict = dict.fromkeys(files)
-                         # for dirstate.walk, files=['.'] means "walk the whole tree".
-                         # follow that here, too
-                         fdict.pop('.', None)
-                         mdict = self.manifest.read(self.changelog.read(node)[0])
-                         mfiles = mdict.keys()
-                         mfiles.sort()
-                         for fn in mfiles:
-                             for ffn in fdict:
-                                 # match if the file is the exact name or a directory
-                                 if ffn == fn or fn.startswith("%s/" % ffn):
-                                     del fdict[ffn]
-                                     break
-                             if match(fn):
-                                 yield 'm', fn
-                         ffiles = fdict.keys()
-                         ffiles.sort()
-                         for fn in ffiles:
-                             if badmatch and badmatch(fn):
-                                 if match(fn):
-                                     yield 'b', fn
-                             else:
-                                 self.ui.warn(_('%s: No such file in rev %s\n')
-                                              % (self.pathto(fn), short(node)))
-                     else:
-                         for src, fn in self.dirstate.walk(files, match, badmatch=badmatch):
-                             yield src, fn
-                 def status(self, node1=None, node2=None, files=[], match=util.always,
-                            list_ignored=False, list_clean=False, list_unknown=True):
+                 def status(self, node1='.', node2=None, match=None,
+                            ignored=False, clean=False, unknown=False):
                      """return status of files between two nodes or node and working directory
                      If node1 is None, use the first dirstate parent instead.
                      If node2 is None, compare node1 with working directory.
                      """
-                     def fcmp(fn, getnode):
-                         t1 = self.wread(fn)
-                         return self.file(fn).cmp(getnode(fn), t1)
-                     def mfmatches(node):
-                         change = self.changelog.read(node)
-                         mf = self.manifest.read(change[0]).copy()
+                     def mfmatches(ctx):
+                         mf = ctx.manifest().copy()
                          for fn in mf.keys():
                              if not match(fn):
                                  del mf[fn]
                          return mf
-                     modified, added, removed, deleted, unknown = [], [], [], [], []
-                     ignored, clean = [], []
-                     compareworking = False
-                     if not node1 or (not node2 and node1 == self.dirstate.parents()[0]):
-                         compareworking = True
+                     ctx1 = self[node1]
+                     ctx2 = self[node2]
+                     working = ctx2 == self[None]
+                     parentworking = working and ctx1 == self['.']
+                     match = match or match_.always(self.root, self.getcwd())
+                     listignored, listclean, listunknown = ignored, clean, unknown
-                     if not compareworking:
-                         # read the manifest from node1 before the manifest from node2,
-                         # so that we'll hit the manifest cache if we're going through
-                         # all the revisions in parent->child order.
-                         mf1 = mfmatches(node1)
+                     if working: # we need to scan the working dir
+                         s = self.dirstate.status(match, listignored, listclean, listunknown)
+                         cmp, modified, added, removed, deleted, unknown, ignored, clean = s
-                     # are we comparing the working directory?
-                     if not node2:
-                         (lookup, modified, added, removed, deleted, unknown,
-                          ignored, clean) = self.dirstate.status(files, match,
-                                                                 list_ignored, list_clean,
-                                                                 list_unknown)
-                         # are we comparing working dir against its parent?
-                         if compareworking:
-                             if lookup:
+                         # check for any possibly clean files
+                         if parentworking and cmp:
-                                 fixup = []
-                                 # do a full compare of any files that might have changed
-                                 ctx = self.changectx()
-                                 mexec = lambda f: 'x' in ctx.fileflags(f)
-                                 mlink = lambda f: 'l' in ctx.fileflags(f)
-                                 is_exec = util.execfunc(self.root, mexec)
-                                 is_link = util.linkfunc(self.root, mlink)
-                                 def flags(f):
-                                     return is_link(f) and 'l' or is_exec(f) and 'x' or ''
-                                 for f in lookup:
-                                     if (f not in ctx or flags(f) != ctx.fileflags(f)
-                                         or ctx[f].cmp(self.wread(f))):
+                             for f in cmp:
+                                 if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
+                                     or ctx1[f].cmp(ctx2[f].data())):
-                                         modified.append(f)
-                                     else:
-                                         fixup.append(f)
-                                         if list_clean:
-                                             clean.append(f)
+                             if listclean:
+                                 clean += fixup
-                                 # update dirstate for files that are actually clean
-                                 if fixup:
-                                     try:
-                                         try:
-                                             wlock = self.wlock(False)
+                                         for f in fixup:
+                                             self.dirstate.normal(f)
-                                         except lock.LockException:
-                                             pass
-                                         if wlock:
-                                             for f in fixup:
-                                                 self.dirstate.normal(f)
-                                     finally:
-                                         del wlock
-                         else:
+                     if not parentworking:
+                         mf1 = mfmatches(ctx1)
+                         if working:
                              # we are comparing working dir against non-parent
                              # generate a pseudo-manifest for the working dir
-                             # XXX: create it in dirstate.py ?
-                             mf2 = mfmatches(self.dirstate.parents()[0])
-                             is_exec = util.execfunc(self.root, mf2.execf)
-                             is_link = util.linkfunc(self.root, mf2.linkf)
-                             for f in lookup + modified + added:
-                                 mf2[f] = ""
-                                 mf2.set(f, is_exec(f), is_link(f))
+                             mf2 = mfmatches(self['.'])
+                             for f in cmp + modified + added:
+                                 mf2[f] = None
+                                 mf2.set(f, ctx2.flags(f))
                              for f in removed:
                                  if f in mf2:
                                      del mf2[f]
                      else:
                          # we are comparing two revisions
-                         mf2 = mfmatches(node2)
-                     if not compareworking:
-                         # flush lists from dirstate before comparing manifests
-                         modified, added, clean = [], [], []
+                             deleted, unknown, ignored = [], [], []
+                             mf2 = mfmatches(ctx2)
-                         # make sure to sort the files so we talk to the disk in a
-                         # reasonable order
-                         mf2keys = mf2.keys()
-                         mf2keys.sort()
-                         getnode = lambda fn: mf1.get(fn, nullid)
-                         for fn in mf2keys:
+                         modified, added, clean = [], [], []
+                         for fn in mf2:
                              if fn in mf1:
                                  if (mf1.flags(fn) != mf2.flags(fn) or
                                      (mf1[fn] != mf2[fn] and
-                                      (mf2[fn] != "" or fcmp(fn, getnode)))):
+                                      (mf2[fn] or ctx1[fn].cmp(ctx2[fn].data())))):
                                      modified.append(fn)
-                                 elif list_clean:
+                                 elif listclean:
                                      clean.append(fn)
                                  del mf1[fn]
                              else:
                                  added.append(fn)
                          removed = mf1.keys()
-                     # sort and return results:
-                     for l in modified, added, removed, deleted, unknown, ignored, clean:
-                         l.sort()
-                     return (modified, added, removed, deleted, unknown, ignored, clean)
+                     r = modified, added, removed, deleted, unknown, ignored, clean
+                     [l.sort() for l in r]
+                     return r
                  def add(self, list):
                      wlock = self.wlock()
                      heads = self.changelog.heads(start)
                      # sort the output in rev descending order
                      heads = [(-self.changelog.rev(h), h) for h in heads]
-                     heads.sort()
-                     return [n for (r, n) in heads]
+                     return [n for (r, n) in util.sort(heads)]
-                 def branchheads(self, branch, start=None):
+                 def branchheads(self, branch=None, start=None):
+                     if branch is None:
+                         branch = self[None].branch()
                      branches = self.branchtags()
                      if branch not in branches:
                          return []
                          if rev in ancestors:
                              ancestors.update(self.changelog.parentrevs(rev))
                              ancestors.remove(rev)
-                         elif self.changectx(rev).branch() == branch:
+                         elif self[rev].branch() == branch:
                              heads.append(rev)
                              ancestors.update(self.changelog.parentrevs(rev))
                      heads = [self.changelog.node(rev) for rev in heads]
                      # Nor do we know which filenodes are missing.
                      msng_filenode_set = {}
-                     junk = mnfst.index[mnfst.count() - 1] # Get around a bug in lazyindex
+                     junk = mnfst.index[len(mnfst) - 1] # Get around a bug in lazyindex
                      junk = None
                      # A changeset always belongs to itself, so the changenode lookup
                                  add_extra_nodes(fname,
                                                  msng_filenode_set.setdefault(fname, {}))
                                  changedfiles[fname] = 1
-                         changedfiles = changedfiles.keys()
-                         changedfiles.sort()
                          # Go through all our files in order sorted by name.
-                         for fname in changedfiles:
+                         for fname in util.sort(changedfiles):
                              filerevlog = self.file(fname)
-                             if filerevlog.count() == 0:
+                             if not len(filerevlog):
                                  raise util.Abort(_("empty or missing revlog for %s") % fname)
                              # Toss out the filenodes that the recipient isn't really
                              # missing.
                      def identity(x):
                          return x
-                     def gennodelst(revlog):
-                         for r in xrange(0, revlog.count()):
-                             n = revlog.node(r)
-                             if revlog.linkrev(n) in revset:
+                     def gennodelst(log):
+                         for r in log:
+                             n = log.node(r)
+                             if log.linkrev(n) in revset:
                                  yield n
                      def changed_file_collector(changedfileset):
                          for chnk in cl.group(nodes, identity,
                                               changed_file_collector(changedfiles)):
                              yield chnk
-                         changedfiles = changedfiles.keys()
-                         changedfiles.sort()
                          mnfst = self.manifest
                          nodeiter = gennodelst(mnfst)
                          for chnk in mnfst.group(nodeiter, lookuprevlink_func(mnfst)):
                              yield chnk
-                         for fname in changedfiles:
+                         for fname in util.sort(changedfiles):
                              filerevlog = self.file(fname)
-                             if filerevlog.count() == 0:
+                             if not len(filerevlog):
                                  raise util.Abort(_("empty or missing revlog for %s") % fname)
                              nodeiter = gennodelst(filerevlog)
                              nodeiter = list(nodeiter)
                      """
                      def csmap(x):
                          self.ui.debug(_("add changeset %s\n") % short(x))
-                         return cl.count()
+                         return len(cl)
                      def revmap(x):
                          return cl.rev(x)
                          trp = weakref.proxy(tr)
                          # pull off the changeset group
                          self.ui.status(_("adding changesets\n"))
-                         cor = cl.count() - 1
+                         cor = len(cl) - 1
                          chunkiter = changegroup.chunkiter(source)
-                         if cl.addgroup(chunkiter, csmap, trp, 1) is None and not emptyok:
+                         if cl.addgroup(chunkiter, csmap, trp) is None and not emptyok:
                              raise util.Abort(_("received changelog group is empty"))
-                         cnr = cl.count() - 1
+                         cnr = len(cl) - 1
                          changesets = cnr - cor
                          # pull off the manifest group
                                  break
                              self.ui.debug(_("adding %s revisions\n") % f)
                              fl = self.file(f)
-                             o = fl.count()
+                             o = len(fl)
                              chunkiter = changegroup.chunkiter(source)
                              if fl.addgroup(chunkiter, revmap, trp) is None:
                                  raise util.Abort(_("received file revlog group is empty"))
-                             revisions += fl.count() - o
+                             revisions += len(fl) - o
                              files += 1
                          # make changelog see real files again
                          return self.stream_in(remote)
                      return self.pull(remote, heads)
+                 def storefiles(self):
+                     '''get all *.i and *.d files in the store
+                     Returns (list of (filename, size), total_bytes)'''
+                     lock = None
+                     try:
+                         self.ui.debug('scanning\n')
+                         entries = []
+                         total_bytes = 0
+                         # get consistent snapshot of repo, lock during scan
+                         lock = self.lock()
+                         for name, size in self.store.walk():
+                             entries.append((name, size))
+                             total_bytes += size
+                         return entries, total_bytes
+                     finally:
+                         del lock
              # used to avoid circular references so destructors work
              def aftertrans(files):
                  renamefiles = [tuple(t) for t in files]

mercurial/mail.py

0 +3 -2

              # of the GNU General Public License, incorporated herein by reference.
              from i18n import _
-             import os, smtplib, util, socket
+             import os, smtplib, socket
+             import util
              def _smtp(ui):
                  '''build an smtp connection and return a function to send mail'''
                  cmdline = '%s -f %s %s' % (program, util.email(sender),
                                             ' '.join(map(util.email, recipients)))
                  ui.note(_('sending mail: %s\n') % cmdline)
-                 fp = os.popen(cmdline, 'w')
+                 fp = util.popen(cmdline, 'w')
                  fp.write(msg)
                  ret = fp.close()
                  if ret:

mercurial/manifest.py

0 +9 -27

              from node import bin, hex, nullid
              from revlog import revlog, RevlogError
              from i18n import _
-             import array, struct, mdiff
+             import array, struct, mdiff, parsers, util
              class manifestdict(dict):
                  def __init__(self, mapping=None, flags=None):
                      self._flags = flags
                  def flags(self, f):
                      return self._flags.get(f, "")
-                 def execf(self, f):
-                     "test for executable in manifest flags"
-                     return "x" in self.flags(f)
-                 def linkf(self, f):
-                     "test for symlink in manifest flags"
-                     return "l" in self.flags(f)
-                 def set(self, f, execf=False, linkf=False):
-                     if linkf: self._flags[f] = "l"
-                     elif execf: self._flags[f] = "x"
-                     else: self._flags[f] = ""
+                 def set(self, f, flags):
+                     self._flags[f] = flags
                  def copy(self):
                      return manifestdict(dict.copy(self), dict.copy(self._flags))
                  def parse(self, lines):
                      mfdict = manifestdict()
-                     fdict = mfdict._flags
-                     for l in lines.splitlines():
-                         f, n = l.split('\0')
-                         if len(n) > 40:
-                             fdict[f] = n[40:]
-                             mfdict[f] = bin(n[:40])
-                         else:
-                             mfdict[f] = bin(n)
+                     parsers.parse_manifest(mfdict, mfdict._flags, lines)
                      return mfdict
                  def readdelta(self, node):
                          return "".join([struct.pack(">lll", d[0], d[1], len(d[2])) + d[2]
                                          for d in x ])
-                     def checkforbidden(f):
+                     def checkforbidden(l):
+                         for f in l:
                          if '\n' in f or '\r' in f:
                              raise RevlogError(_("'\\n' and '\\r' disallowed in filenames"))
                      # if we're using the listcache, make sure it is valid and
                      # parented by the same node we're diffing against
                      if not (changed and self.listcache and p1 and self.mapcache[0] == p1):
-                         files = map.keys()
-                         files.sort()
-                         for f in files:
-                             checkforbidden(f)
+                         files = util.sort(map)
+                         checkforbidden(files)
                          # if this is changed to support newlines in filenames,
                          # be sure to check the templates/ dir again (especially *-raw.tmpl)
                      else:
                          addlist = self.listcache
-                         for f in changed[0]:
-                             checkforbidden(f)
+                         checkforbidden(changed[0])
                          # combine the changed lists into one list for sorting
                          work = [[x, 0] for x in changed[0]]
                          work[len(work):] = [[x, 1] for x in changed[1]]

mercurial/mdiff.py

0 +2 -5

              # of the GNU General Public License, incorporated herein by reference.
              from i18n import _
-             import bdiff, mpatch, re, struct, util, md5
+             import bdiff, mpatch, re, struct, util
              def splitnewlines(text):
                  '''like str.splitlines, but only split on newlines.'''
                  epoch = util.datestr((0, 0))
                  if not opts.text and (util.binary(a) or util.binary(b)):
-                     def h(v):
-                         # md5 is used instead of sha1 because md5 is supposedly faster
-                         return md5.new(v).digest()
-                     if a and b and len(a) == len(b) and h(a) == h(b):
+                     if a and b and len(a) == len(b) and a == b:
                          return ""
                      l = ['Binary file %s has changed\n' % fn1]
                  elif not a:

mercurial/merge.py

0 +97 -15

              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
-             from node import nullid, nullrev
+             from node import nullid, nullrev, hex, bin
              from i18n import _
-             import errno, util, os, filemerge, copies
+             import errno, util, os, filemerge, copies, shutil
+             class mergestate(object):
+                 '''track 3-way merge state of individual files'''
+                 def __init__(self, repo):
+                     self._repo = repo
+                     self._read()
+                 def reset(self, node):
+                     self._state = {}
+                     self._local = node
+                     shutil.rmtree(self._repo.join("merge"), True)
+                 def _read(self):
+                     self._state = {}
+                     try:
+                         localnode = None
+                         f = self._repo.opener("merge/state")
+                         for i, l in enumerate(f):
+                             if i == 0:
+                                 localnode = l[:-1]
+                             else:
+                                 bits = l[:-1].split("\0")
+                                 self._state[bits[0]] = bits[1:]
+                         self._local = bin(localnode)
+                     except IOError, err:
+                         if err.errno != errno.ENOENT:
+                             raise
+                 def _write(self):
+                     f = self._repo.opener("merge/state", "w")
+                     f.write(hex(self._local) + "\n")
+                     for d, v in self._state.items():
+                         f.write("\0".join([d] + v) + "\n")
+                 def add(self, fcl, fco, fca, fd, flags):
+                     hash = util.sha1(fcl.path()).hexdigest()
+                     self._repo.opener("merge/" + hash, "w").write(fcl.data())
+                     self._state[fd] = ['u', hash, fcl.path(), fca.path(),
+                                        hex(fca.filenode()), fco.path(), flags]
+                     self._write()
+                 def __contains__(self, dfile):
+                     return dfile in self._state
+                 def __getitem__(self, dfile):
+                     return self._state[dfile][0]
+                 def __iter__(self):
+                     l = self._state.keys()
+                     l.sort()
+                     for f in l:
+                         yield f
+                 def mark(self, dfile, state):
+                     self._state[dfile][0] = state
+                     self._write()
+                 def resolve(self, dfile, wctx, octx):
+                     if self[dfile] == 'r':
+                         return 0
+                     state, hash, lfile, afile, anode, ofile, flags = self._state[dfile]
+                     f = self._repo.opener("merge/" + hash)
+                     self._repo.wwrite(dfile, f.read(), flags)
+                     fcd = wctx[dfile]
+                     fco = octx[ofile]
+                     fca = self._repo.filectx(afile, fileid=anode)
+                     r = filemerge.filemerge(self._repo, self._local, lfile, fcd, fco, fca)
+                     if not r:
+                         self.mark(dfile, 'r')
+                     return r
              def _checkunknown(wctx, mctx):
                  "check for collisions between unknown files and files in mctx"
                  return action
+             def actioncmp(a1, a2):
+                 m1 = a1[1]
+                 m2 = a2[1]
+                 if m1 == m2:
+                     return cmp(a1, a2)
+                 if m1 == 'r':
+                     return -1
+                 if m2 == 'r':
+                     return 1
+                 return cmp(a1, a2)
              def applyupdates(repo, action, wctx, mctx):
                  "apply the merge action list to the working directory"
                  updated, merged, removed, unresolved = 0, 0, 0, 0
-                 action.sort()
-                 # prescan for copy/renames
+                 ms = mergestate(repo)
+                 ms.reset(wctx.parents()[0].node())
+                 moves = []
+                 action.sort(actioncmp)
+                 # prescan for merges
                  for a in action:
                      f, m = a[:2]
                      if m == 'm': # merge
                          f2, fd, flags, move = a[2:]
-                         if f != fd:
-                             repo.ui.debug(_("copying %s to %s\n") % (f, fd))
-                             repo.wwrite(fd, repo.wread(f), flags)
+                         repo.ui.debug(_("preserving %s for resolve of %s\n") % (f, fd))
+                         fcl = wctx[f]
+                         fco = mctx[f2]
+                         fca = fcl.ancestor(fco) or repo.filectx(f, fileid=nullrev)
+                         ms.add(fcl, fco, fca, fd, flags)
+                         if f != fd and move:
+                             moves.append(f)
+                 # remove renamed files after safely stored
+                 for f in moves:
+                     if util.lexists(repo.wjoin(f)):
+                         repo.ui.debug(_("removing %s\n") % f)
+                         os.unlink(repo.wjoin(f))
                  audit_path = util.path_auditor(repo.root)
                          removed += 1
                      elif m == "m": # merge
                          f2, fd, flags, move = a[2:]
-                         r = filemerge.filemerge(repo, f, fd, f2, wctx, mctx)
+                         r = ms.resolve(fd, wctx, mctx)
                          if r > 0:
                              unresolved += 1
                          else:
                                  updated += 1
                              else:
                                  merged += 1
-                         util.set_flags(repo.wjoin(fd), flags)
-                         if f != fd and move and util.lexists(repo.wjoin(f)):
-                             repo.ui.debug(_("removing %s\n") % f)
-                             os.unlink(repo.wjoin(f))
                      elif m == "g": # get
                          flags = a[2]
                          repo.ui.note(_("getting %s\n") % f)
                  wlock = repo.wlock()
                  try:
-                     wc = repo.workingctx()
+                     wc = repo[None]
                      if node is None:
                          # tip of current branch
                          try:
                                  raise util.Abort(_("branch %s not found") % wc.branch())
                      overwrite = force and not branchmerge
                      pl = wc.parents()
-                     p1, p2 = pl[0], repo.changectx(node)
+                     p1, p2 = pl[0], repo[node]
                      pa = p1.ancestor(p2)
                      fp1, fp2, xp1, xp2 = p1.node(), p2.node(), str(p1), str(p2)
                      fastforward = False
                      action = []
                      if not force:
                          _checkunknown(wc, p2)
-                     if not util.checkfolding(repo.path):
+                     if not util.checkcase(repo.path):
                          _checkcollision(p2)
                      action += _forgetremoved(wc, p2, branchmerge)
                      action += manifestmerge(repo, wc, p2, pa, overwrite, partial)

mercurial/patch.py

0 +23 -43

              from i18n import _
              from node import hex, nullid, short
-             import base85, cmdutil, mdiff, util, context, revlog, diffhelpers, copies
-             import cStringIO, email.Parser, os, popen2, re, sha, errno
+             import base85, cmdutil, mdiff, util, revlog, diffhelpers, copies
+             import cStringIO, email.Parser, os, popen2, re, errno
              import sys, tempfile, zlib
              class PatchError(Exception):
                      repo.copy(src, dst)
                  removes = removes.keys()
                  if removes:
-                     removes.sort()
-                     repo.remove(removes, True)
+                     repo.remove(util.sort(removes), True)
                  for f in patches:
                      ctype, gp = patches[f]
                      if gp and gp.mode:
                  cmdutil.addremove(repo, cfiles)
                  files = patches.keys()
                  files.extend([r for r in removes if r not in files])
-                 files.sort()
-                 return files
+                 return util.sort(files)
              def b85diff(to, tn):
                  '''print base85-encoded binary diff'''
                      if not text:
                          return '0' * 40
                      l = len(text)
-                     s = sha.new('blob %d\0' % l)
+                     s = util.sha1('blob %d\0' % l)
                      s.update(text)
                      return s.hexdigest()
                  ret.append('\n')
                  return ''.join(ret)
-             def diff(repo, node1=None, node2=None, files=None, match=util.always,
+             def diff(repo, node1=None, node2=None, match=None,
                       fp=None, changes=None, opts=None):
                  '''print diff of changes to files between two nodes, or node and
                  working directory.
                  if node1 is None, use first dirstate parent instead.
                  if node2 is None, compare node1 with working directory.'''
+                 if not match:
+                     match = cmdutil.matchall(repo)
                  if opts is None:
                      opts = mdiff.defaultopts
                  if fp is None:
                  if not node1:
                      node1 = repo.dirstate.parents()[0]
-                 ccache = {}
-                 def getctx(r):
-                     if r not in ccache:
-                         ccache[r] = context.changectx(repo, r)
-                     return ccache[r]
                  flcache = {}
                  def getfilectx(f, ctx):
                      flctx = ctx.filectx(f, filelog=flcache.get(f))
                  # reading the data for node1 early allows it to play nicely
                  # with repo.status and the revlog cache.
-                 ctx1 = context.changectx(repo, node1)
+                 ctx1 = repo[node1]
                  # force manifest reading
                  man1 = ctx1.manifest()
                  date1 = util.datestr(ctx1.date())
                  if not changes:
-                     changes = repo.status(node1, node2, files, match=match)[:5]
-                 modified, added, removed, deleted, unknown = changes
+                     changes = repo.status(node1, node2, match=match)
+                 modified, added, removed = changes[:3]
                  if not modified and not added and not removed:
                      return
-                 if node2:
-                     ctx2 = context.changectx(repo, node2)
-                     execf2 = ctx2.manifest().execf
-                     linkf2 = ctx2.manifest().linkf
-                 else:
-                     ctx2 = context.workingctx(repo)
-                     execf2 = util.execfunc(repo.root, None)
-                     linkf2 = util.linkfunc(repo.root, None)
-                     if execf2 is None:
-                         mc = ctx2.parents()[0].manifest().copy()
-                         execf2 = mc.execf
-                         linkf2 = mc.linkf
+                 ctx2 = repo[node2]
                  if repo.ui.quiet:
                      r = None
                      r = [hexfunc(node) for node in [node1, node2] if node]
                  if opts.git:
-                     copy, diverge = copies.copies(repo, ctx1, ctx2, repo.changectx(nullid))
+                     copy, diverge = copies.copies(repo, ctx1, ctx2, repo[nullid])
                      for k, v in copy.items():
                          copy[v] = k
-                 all = modified + added + removed
-                 all.sort()
                  gone = {}
+                 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
-                 for f in all:
+                 for f in util.sort(modified + added + removed):
                      to = None
                      tn = None
                      dodiff = True
                          tn = getfilectx(f, ctx2).data()
                      a, b = f, f
                      if opts.git:
-                         def gitmode(x, l):
-                             return l and '120000' or (x and '100755' or '100644')
                          def addmodehdr(header, omode, nmode):
                              if omode != nmode:
                                  header.append('old mode %s\n' % omode)
                                  header.append('new mode %s\n' % nmode)
                          if f in added:
-                             mode = gitmode(execf2(f), linkf2(f))
+                             mode = gitmode[ctx2.flags(f)]
                              if f in copy:
                                  a = copy[f]
-                                 omode = gitmode(man1.execf(a), man1.linkf(a))
+                                 omode = gitmode[man1.flags(a)]
                                  addmodehdr(header, omode, mode)
                                  if a in removed and a not in gone:
                                      op = 'rename'
                              if f in copy and copy[f] in added and copy[copy[f]] == f:
                                  dodiff = False
                              else:
-                                 mode = gitmode(man1.execf(f), man1.linkf(f))
-                                 header.append('deleted file mode %s\n' % mode)
+                                 header.append('deleted file mode %s\n' %
+                                               gitmode[man1.flags(f)])
                          else:
-                             omode = gitmode(man1.execf(f), man1.linkf(f))
-                             nmode = gitmode(execf2(f), linkf2(f))
+                             omode = gitmode[man1.flags(f)]
+                             nmode = gitmode[ctx2.flags(f)]
                              addmodehdr(header, omode, nmode)
                              if util.binary(to) or util.binary(tn):
                                  dodiff = 'binary'
                  revwidth = max([len(str(rev)) for rev in revs])
                  def single(rev, seqno, fp):
-                     ctx = repo.changectx(rev)
+                     ctx = repo[rev]
                      node = ctx.node()
                      parents = [p.node() for p in ctx.parents() if p]
                      branch = ctx.branch()

mercurial/repair.py

0 +4 -5

                  """find out the filelogs affected by the strip"""
                  files = {}
-                 for x in xrange(striprev, repo.changelog.count()):
-                     for name in repo.changectx(x).files():
+                 for x in xrange(striprev, len(repo)):
+                     for name in repo[x].files():
                          if name in files:
                              continue
                          files[name] = 1
                  """return the nodes that have to be saved before the strip"""
                  def collectone(revlog):
                      extra = []
-                     startrev = count = revlog.count()
+                     startrev = count = len(revlog)
                      # find the truncation point of the revlog
                      for i in xrange(0, count):
                          node = revlog.node(i)
              def strip(ui, repo, node, backup="all"):
                  cl = repo.changelog
                  # TODO delete the undo files, and handle undo of merge sets
-                 pp = cl.parents(node)
                  striprev = cl.rev(node)
                  # Some revisions with rev > striprev may not be descendants of striprev.
                  tostrip = {striprev: 1}
                  saveheads = {}
                  savebases = []
-                 for r in xrange(striprev + 1, cl.count()):
+                 for r in xrange(striprev + 1, len(cl)):
                      parents = cl.parentrevs(r)
                      if parents[0] in tostrip or parents[1] in tostrip:
                          # r is a descendant of striprev

mercurial/repo.py

0 +6 0

                  def cancopy(self):
                      return self.local()
+                 def rjoin(self, path):
+                     url = self.url()
+                     if url.endswith('/'):
+                         return url + path
+                     return url + '/' + path

mercurial/revlog.py

0 +52 -29

              from node import bin, hex, nullid, nullrev, short
              from i18n import _
              import changegroup, errno, ancestor, mdiff
-             import sha, struct, util, zlib
+             import struct, util, zlib
              _pack = struct.pack
              _unpack = struct.unpack
              _compress = zlib.compress
              _decompress = zlib.decompress
-             _sha = sha.new
+             _sha = util.sha1
              # revlog flags
              REVLOGV0 = 0
              class RevlogError(Exception):
                  pass
-             class LookupError(RevlogError):
+             class LookupError(RevlogError, KeyError):
                  def __init__(self, name, index, message):
                      self.name = name
                      if isinstance(name, str) and len(name) == 20:
                          name = short(name)
                      RevlogError.__init__(self, _('%s@%s: %s') % (index, name, message))
+                 def __str__(self):
+                     return RevlogError.__str__(self)
              def getoffset(q):
                  return int(q >> 16)
                  def tip(self):
                      return self.node(len(self.index) - 2)
-                 def count(self):
+                 def __len__(self):
                      return len(self.index) - 1
+                 def __iter__(self):
+                     for i in xrange(len(self)):
+                         yield i
                  def rev(self, node):
                      try:
                          return self.nodemap[node]
                                  visit.append(p)
                      return reachable
+                 def ancestors(self, *revs):
+                     'Generate the ancestors of revs using a breadth-first visit'
+                     visit = list(revs)
+                     seen = util.set([nullrev])
+                     while visit:
+                         for parent in self.parentrevs(visit.pop(0)):
+                             if parent not in seen:
+                                 visit.append(parent)
+                                 seen.add(parent)
+                                 yield parent
+                 def descendants(self, *revs):
+                     'Generate the descendants of revs in topological order'
+                     seen = util.set(revs)
+                     for i in xrange(min(revs) + 1, len(self)):
+                         for x in self.parentrevs(i):
+                             if x != nullrev and x in seen:
+                                 seen.add(i)
+                                 yield i
+                                 break
                  def nodesbetween(self, roots=None, heads=None):
                      """Return a tuple containing three elements. Elements 1 and 2 contain
                      a final list bases and heads after all the unreachable ones have been
                          lowestrev = nullrev
                      if (lowestrev == nullrev) and (heads is None):
                          # We want _all_ the nodes!
-                         return ([self.node(r) for r in xrange(0, self.count())],
-                                 [nullid], list(self.heads()))
+                         return ([self.node(r) for r in self], [nullid], list(self.heads()))
                      if heads is None:
                          # All nodes are ancestors, so the latest ancestor is the last
                          # node.
-                         highestrev = self.count() - 1
+                         highestrev = len(self) - 1
                          # Set ancestors to None to signal that every node is an ancestor.
                          ancestors = None
                          # Set heads to an empty dictionary for later discovery of heads
                      as if they had no children
                      """
                      if start is None and stop is None:
-                         count = self.count()
+                         count = len(self)
                          if not count:
                              return [nullid]
                          ishead = [1] * (count + 1)
                          index = self.index
-                         for r in xrange(count):
+                         for r in self:
                              e = index[r]
                              ishead[e[5]] = ishead[e[6]] = 0
-                         return [self.node(r) for r in xrange(count) if ishead[r]]
+                         return [self.node(r) for r in self if ishead[r]]
                      if start is None:
                          start = nullid
                      heads = {startrev: 1}
                      parentrevs = self.parentrevs
-                     for r in xrange(startrev + 1, self.count()):
+                     for r in xrange(startrev + 1, len(self)):
                          for p in parentrevs(r):
                              if p in reachable:
                                  if r not in stoprevs:
                      """find the children of a given node"""
                      c = []
                      p = self.rev(node)
-                     for r in range(p + 1, self.count()):
+                     for r in range(p + 1, len(self)):
                          prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
                          if prevs:
                              for pr in prevs:
                          if str(rev) != id:
                              raise ValueError
                          if rev < 0:
-                             rev = self.count() + rev
-                         if rev < 0 or rev >= self.count():
+                             rev = len(self) + rev
+                         if rev < 0 or rev >= len(self):
                              raise ValueError
                          return self.node(rev)
                      except (ValueError, OverflowError):
                      df = self.opener(self.datafile, 'w')
                      try:
                          calc = self._io.size
-                         for r in xrange(self.count()):
+                         for r in self:
                              start = self.start(r) + (r + 1) * calc
                              length = self.length(r)
                              fp.seek(start)
                      fp = self.opener(self.indexfile, 'w', atomictemp=True)
                      self.version &= ~(REVLOGNGINLINEDATA)
                      self._inline = False
-                     for i in xrange(self.count()):
+                     for i in self:
                          e = self._io.packentry(self.index[i], self.node, self.version, i)
                          fp.write(e)
                      if node in self.nodemap:
                          return node
-                     curr = self.count()
+                     curr = len(self)
                      prev = curr - 1
                      base = self.base(prev)
                      offset = self.end(prev)
                      yield changegroup.closechunk()
-                 def addgroup(self, revs, linkmapper, transaction, unique=0):
+                 def addgroup(self, revs, linkmapper, transaction):
                      """
                      add a delta group
                      """
                      #track the base of the current delta log
-                     r = self.count()
+                     r = len(self)
                      t = r - 1
                      node = None
                              link = linkmapper(cs)
                              if node in self.nodemap:
                                  # this can happen if two branches make the same change
-                                 # if unique:
-                                 #    raise RevlogError(_("already have %s") % hex(node[:4]))
                                  chain = node
                                  continue
                              delta = buffer(chunk, 80)
                      trust that the caller has saved the revisions that shouldn't be
                      removed and that it'll readd them after this truncation.
                      """
-                     if self.count() == 0:
+                     if len(self) == 0:
                          return
                      if isinstance(self.index, lazyindex):
                          self._loadindexmap()
-                     for rev in xrange(0, self.count()):
+                     for rev in self:
                          if self.index[rev][4] >= minlink:
                              break
                      else:
                      # then reset internal state in memory to forget those revisions
                      self._cache = None
                      self._chunkcache = None
-                     for x in xrange(rev, self.count()):
+                     for x in xrange(rev, len(self)):
                          del self.nodemap[self.node(x)]
                      del self.index[rev:-1]
                  def checksize(self):
                      expected = 0
-                     if self.count():
-                         expected = max(0, self.end(self.count() - 1))
+                     if len(self):
+                         expected = max(0, self.end(len(self) - 1))
                      try:
                          f = self.opener(self.datafile)
                          di = actual - (i * s)
                          if self._inline:
                              databytes = 0
-                             for r in xrange(self.count()):
+                             for r in self:
                                  databytes += max(0, self.length(r))
                              dd = 0
-                             di = actual - self.count() * s - databytes
+                             di = actual - len(self) * s - databytes
                      except IOError, inst:
                          if inst.errno != errno.ENOENT:
                              raise

mercurial/statichttprepo.py

0 +5 -6

              from i18n import _
              import changelog, httprangereader
-             import repo, localrepo, manifest, util
+             import repo, localrepo, manifest, util, store
              import urllib, urllib2, errno
              class rangereader(httprangereader.httprangereader):
                      # setup store
                      if "store" in requirements:
-                         self.encodefn = util.encodefilename
-                         self.decodefn = util.decodefilename
                          self.spath = self.path + "/store"
                      else:
-                         self.encodefn = lambda x: x
-                         self.decodefn = lambda x: x
                          self.spath = self.path
-                     self.sopener = util.encodedopener(opener(self.spath), self.encodefn)
+                     self.encodefn = store.encodefn(requirements)
+                     so = opener(self.spath)
+                     self.sopener = lambda path, *args, **kw: so(
+                         self.encodefn(path), *args, **kw)
                      self.manifest = manifest.manifest(self.sopener)
                      self.changelog = changelog.changelog(self.sopener)

mercurial/streamclone.py

0 +2 -45

              # This software may be used and distributed according to the terms
              # of the GNU General Public License, incorporated herein by reference.
-             import os, osutil, stat, util, lock
+             import util, lock
              # if server supports streaming clone, it advertises "stream"
              # capability with value that is version+flags of repo it is serving.
              # client only streams if it can read that repo format.
-             def walkrepo(root):
-                 '''iterate over metadata files in repository.
-                 walk in natural (sorted) order.
-                 yields 2-tuples: name of .d or .i file, size of file.'''
-                 strip_count = len(root) + len(os.sep)
-                 def walk(path, recurse):
-                     for e, kind, st in osutil.listdir(path, stat=True):
-                         pe = os.path.join(path, e)
-                         if kind == stat.S_IFDIR:
-                             if recurse:
-                                 for x in walk(pe, True):
-                                     yield x
-                         else:
-                             if kind != stat.S_IFREG or len(e) < 2:
-                                 continue
-                             sfx = e[-2:]
-                             if sfx in ('.d', '.i'):
-                                 yield pe[strip_count:], st.st_size
-                 # write file data first
-                 for x in walk(os.path.join(root, 'data'), True):
-                     yield x
-                 # write manifest before changelog
-                 meta = list(walk(root, False))
-                 meta.sort()
-                 meta.reverse()
-                 for x in meta:
-                     yield x
              # stream file format is simple.
              #
              # server writes out line that says how many files, how many total
                      fileobj.write('1\n')
                      return
-                 # get consistent snapshot of repo. lock during scan so lock not
-                 # needed while we stream, and commits can happen.
-                 repolock = None
                  try:
-                     try:
-                         repolock = repo.lock()
+                     entries, total_bytes = repo.storefiles()
-                     except (lock.LockHeld, lock.LockUnavailable), inst:
-                         repo.ui.warn('locking the repository failed: %s\n' % (inst,))
-                         fileobj.write('2\n')
-                         return
-                     fileobj.write('0\n')
-                     repo.ui.debug('scanning\n')
-                     entries = []
-                     total_bytes = 0
-                     for name, size in walkrepo(repo.spath):
-                         name = repo.decodefn(util.pconvert(name))
-                         entries.append((name, size))
-                         total_bytes += size
-                 finally:
-                     del repolock
                  repo.ui.debug('%d files, %d bytes to transfer\n' %
                                (len(entries), total_bytes))
                  fileobj.write('%d %d\n' % (len(entries), total_bytes))

mercurial/templatefilters.py

0 +31 -1

                          .replace("'", '&#39;')) # &apos; invalid in HTML
                  return re.sub('[\x00-\x08\x0B\x0C\x0E-\x1F]', ' ', text)
+             _escapes = [
+                 ('\\', '\\\\'), ('"', '\\"'), ('\t', '\\t'), ('\n', '\\n'),
+                 ('\r', '\\r'), ('\f', '\\f'), ('\b', '\\b'),
+             ]
+             def json(obj):
+                 if obj is None or obj is False or obj is True:
+                     return {None: 'null', False: 'false', True: 'true'}[obj]
+                 elif isinstance(obj, int) or isinstance(obj, float):
+                     return str(obj)
+                 elif isinstance(obj, str):
+                     for k, v in _escapes:
+                         obj = obj.replace(k, v)
+                     return '"%s"' % obj
+                 elif isinstance(obj, unicode):
+                     return json(obj.encode('utf-8'))
+                 elif hasattr(obj, 'keys'):
+                     out = []
+                     for k, v in obj.iteritems():
+                         s = '%s: %s' % (json(k), json(v))
+                         out.append(s)
+                     return '{' + ', '.join(out) + '}'
+                 elif hasattr(obj, '__iter__'):
+                     out = []
+                     for i in obj:
+                         out.append(json(i))
+                     return '[' + ', '.join(out) + ']'
+                 else:
+                     raise TypeError('cannot encode type %s' % obj.__class__.__name__)
              filters = {
                  "addbreaks": nl2br,
                  "basename": os.path.basename,
                  "user": lambda x: util.shortuser(x),
                  "stringescape": lambda x: x.encode('string_escape'),
                  "xmlescape": xmlescape,
+                 "json": json,
                  }

mercurial/templater.py

0 +28 -7

                  def __contains__(self, key):
                      return key in self.cache or key in self.map
-                 def __call__(self, t, **map):
-                     '''perform expansion.
-                     t is name of map element to expand.
-                     map is added elements to use during expansion.'''
+                 def _template(self, t):
+                     '''Get the template for the given template name. Use a local cache.'''
                      if not t in self.cache:
                          try:
                              self.cache[t] = file(self.map[t]).read()
                          except IOError, inst:
                              raise IOError(inst.args[0], _('template file %s: %s') %
                                            (self.map[t], inst.args[1]))
-                     tmpl = self.cache[t]
+                     return self.cache[t]
+                 def _process(self, tmpl, map):
+                     '''Render a template. Returns a generator.'''
                      while tmpl:
                          m = self.template_re.search(tmpl)
                          if not m:
                              v = v(**map)
                          if format:
                              if not hasattr(v, '__iter__'):
-                                 raise SyntaxError(_("Error expanding '%s%s'")
+                                 raise SyntaxError(_("Error expanding '%s%%%s'")
                                                    % (key, format))
                              lm = map.copy()
                              for i in v:
                                  lm.update(i)
-                                 yield self(format, **lm)
+                                 t = self._template(format)
+                                 yield self._process(t, lm)
                          else:
                              if fl:
                                  for f in fl.split("|")[1:]:
                                      v = self.filters[f](v)
                              yield v
+                 def __call__(self, t, **map):
+                     '''Perform expansion. t is name of map element to expand. map contains
+                     added elements for use during expansion. Is a generator.'''
+                     tmpl = self._template(t)
+                     iters = [self._process(tmpl, map)]
+                     while iters:
+                         try:
+                             item = iters[0].next()
+                         except StopIteration:
+                             iters.pop(0)
+                             continue
+                         if isinstance(item, str):
+                             yield item
+                         elif item is None:
+                             yield ''
+                         elif hasattr(item, '__iter__'):
+                             iters.insert(0, iter(item))
+                         else:
+                             yield str(item)
              def templatepath(name=None):
                  '''return location of template file or directory (if no name).
                  returns None if not found.'''

mercurial/transaction.py

0 +5 -1

                  files = {}
                  for l in open(file).readlines():
                      f, o = l.split('\0')
-                     files[f] = o
+                     files[f] = int(o)
                  for f in files:
                      o = files[f]
+                     if o:
                      opener(f, "a").truncate(int(o))
+                     else:
+                         fn = opener(f).name
+                         os.unlink(fn)
                  os.unlink(file)

mercurial/ui.py

0 +6 -8

                      items = self._configitems(section, untrusted=untrusted, abort=True)
                      if self.debugflag and not untrusted and self.ucdata:
                          uitems = self._configitems(section, untrusted=True, abort=False)
-                         keys = uitems.keys()
-                         keys.sort()
-                         for k in keys:
+                         for k in util.sort(uitems):
                              if uitems[k] != items.get(k):
                                  self.warn(_("Ignoring untrusted configuration option "
                                              "%s.%s = %s\n") % (section, k, uitems[k]))
-                     x = items.items()
-                     x.sort()
-                     return x
+                     return util.sort(items.items())
                  def walkconfig(self, untrusted=False):
                      cdata = self._get_cdata(untrusted)
                      Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
                      and stop searching if one of these is set.
-                     If not found, use ($LOGNAME or $USER or $LNAME or
-                     $USERNAME) +"@full.hostname".
+                     If not found and ui.askusername is True, ask the user, else use
+                     ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
                      """
                      user = os.environ.get("HGUSER")
                      if user is None:
                          user = self.config("ui", "username")
                      if user is None:
                          user = os.environ.get("EMAIL")
+                     if user is None and self.configbool("ui", "askusername"):
+                         user = self.prompt(_("Enter a commit username:"), default=None)
                      if user is None:
                          try:
                              user = '%s@%s' % (util.getuser(), socket.getfqdn())

mercurial/util.py

0 +107 -67

              from i18n import _
              import cStringIO, errno, getpass, re, shutil, sys, tempfile
              import os, stat, threading, time, calendar, ConfigParser, locale, glob, osutil
-             import urlparse
+             import imp, urlparse
+             # Python compatibility
              try:
                  set = set
              except NameError:
                  from sets import Set as set, ImmutableSet as frozenset
+             _md5 = None
+             def md5(s):
+                 global _md5
+                 if _md5 is None:
+                     try:
+                         import hashlib
+                         _md5 = hashlib.md5
+                     except ImportError:
+                         import md5
+                         _md5 = md5.md5
+                 return _md5(s)
+             _sha1 = None
+             def sha1(s):
+                 global _sha1
+                 if _sha1 is None:
+                     try:
+                         import hashlib
+                         _sha1 = hashlib.sha1
+                     except ImportError:
+                         import sha
+                         _sha1 = sha.sha
+                 return _sha1(s)
              try:
                  _encoding = os.environ.get("HGENCODING")
                  if sys.platform == 'darwin' and not _encoding:
                  return pipefilter(s, cmd)
              def binary(s):
-                 """return true if a string is binary data using diff's heuristic"""
-                 if s and '\0' in s[:4096]:
+                 """return true if a string is binary data"""
+                 if s and '\0' in s:
                      return True
                  return False
                  """return the uniq elements of iterable g"""
                  return dict.fromkeys(g).keys()
+             def sort(l):
+                 if not isinstance(l, list):
+                     l = list(l)
+                 l.sort()
+                 return l
              class Abort(Exception):
                  """Raised if a command needs to print an error and exit."""
                      ret.append(p)
                  return ret
-             def patkind(name, dflt_pat='glob'):
+             def patkind(name, default):
                  """Split a string into an optional pattern kind prefix and the
                  actual pattern."""
                  for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':
                      if name.startswith(prefix + ':'): return name.split(':', 1)
-                 return dflt_pat, name
+                 return default, name
              def globre(pat, head='^', tail='$'):
                  "convert a glob pattern into a regexp"
                      raise Abort('%s not under root' % myname)
-             def matcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None):
-                 return _matcher(canonroot, cwd, names, inc, exc, 'glob', src)
-             def cmdmatcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None,
-                            globbed=False, default=None):
-                 default = default or 'relpath'
-                 if default == 'relpath' and not globbed:
-                     names = expand_glob(names)
-                 return _matcher(canonroot, cwd, names, inc, exc, default, src)
-             def _matcher(canonroot, cwd, names, inc, exc, dflt_pat, src):
+             def matcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None, dflt_pat='glob'):
                  """build a function to match a set of file patterns
                  arguments:
              _hgexecutable = None
+             def main_is_frozen():
+                 """return True if we are a frozen executable.
+                 The code supports py2exe (most common, Windows only) and tools/freeze
+                 (portable, not much used).
+                 """
+                 return (hasattr(sys, "frozen") or # new py2exe
+                         hasattr(sys, "importers") or # old py2exe
+                         imp.is_frozen("__main__")) # tools/freeze
              def hgexecutable():
                  """return location of the 'hg' executable.
                  Defaults to $HG or 'hg' in the search path.
                  """
                  if _hgexecutable is None:
-                     set_hgexecutable(os.environ.get('HG') or find_exe('hg', 'hg'))
+                     hg = os.environ.get('HG')
+                     if hg:
+                         set_hgexecutable(hg)
+                     elif main_is_frozen():
+                         set_hgexecutable(sys.executable)
+                     else:
+                         set_hgexecutable(find_exe('hg', 'hg'))
                  return _hgexecutable
              def set_hgexecutable(path):
              # File system features
-             def checkfolding(path):
+             def checkcase(path):
                  """
                  Check whether the given path is on a case-sensitive filesystem
                  except:
                      return True
+             _fspathcache = {}
+             def fspath(name, root):
+                 '''Get name in the case stored in the filesystem
+                 The name is either relative to root, or it is an absolute path starting
+                 with root. Note that this function is unnecessary, and should not be
+                 called, for case-sensitive filesystems (simply because it's expensive).
+                 '''
+                 # If name is absolute, make it relative
+                 if name.lower().startswith(root.lower()):
+                     l = len(root)
+                     if name[l] == os.sep or name[l] == os.altsep:
+                         l = l + 1
+                     name = name[l:]
+                 if not os.path.exists(os.path.join(root, name)):
+                     return None
+                 seps = os.sep
+                 if os.altsep:
+                     seps = seps + os.altsep
+                 # Protect backslashes. This gets silly very quickly.
+                 seps.replace('\\','\\\\')
+                 pattern = re.compile(r'([^%s]+)|([%s]+)' % (seps, seps))
+                 dir = os.path.normcase(os.path.normpath(root))
+                 result = []
+                 for part, sep in pattern.findall(name):
+                     if sep:
+                         result.append(sep)
+                         continue
+                     if dir not in _fspathcache:
+                         _fspathcache[dir] = os.listdir(dir)
+                     contents = _fspathcache[dir]
+                     lpart = part.lower()
+                     for n in contents:
+                         if n.lower() == lpart:
+                             result.append(n)
+                             break
+                     else:
+                         # Cannot happen, as the file exists!
+                         result.append(part)
+                     dir = os.path.join(dir, lpart)
+                 return ''.join(result)
              def checkexec(path):
                  """
                  Check whether the given path is on a filesystem with UNIX-like exec flags
                      return False
                  return not (new_file_has_exec or exec_flags_cannot_flip)
-             def execfunc(path, fallback):
-                 '''return an is_exec() function with default to fallback'''
-                 if checkexec(path):
-                     return lambda x: is_exec(os.path.join(path, x))
-                 return fallback
              def checklink(path):
                  """check whether the given path is on a symlink-capable filesystem"""
                  # mktemp is not racy because symlink creation will fail if the
                  except (OSError, AttributeError):
                      return False
-             def linkfunc(path, fallback):
-                 '''return an is_link() function with default to fallback'''
-                 if checklink(path):
-                     return lambda x: os.path.islink(os.path.join(path, x))
-                 return fallback
              _umask = os.umask(0)
              os.umask(_umask)
                      # through the current COMSPEC. cmd.exe suppress enclosing quotes.
                      return '"' + cmd + '"'
-                 def popen(command):
+                 def popen(command, mode='r'):
                      # Work around "popen spawned process may not write to stdout
                      # under windows"
                      # http://bugs.python.org/issue1366
                      command += " 2> %s" % nulldev
-                     return os.popen(quotecommand(command))
+                     return os.popen(quotecommand(command), mode)
                  def explain_exit(code):
                      return _("exited with status %d") % code, code
                  def quotecommand(cmd):
                      return cmd
-                 def popen(command):
-                     return os.popen(command)
+                 def popen(command, mode='r'):
+                     return os.popen(command, mode)
                  def testpid(pid):
                      '''return False if pid dead, True if running or not sure'''
                      return name
                  return find_in_path(name, os.environ.get('PATH', ''), default=default)
-             def _buildencodefun():
-                 e = '_'
-                 win_reserved = [ord(x) for x in '\\:*?"<>|']
-                 cmap = dict([ (chr(x), chr(x)) for x in xrange(127) ])
-                 for x in (range(32) + range(126, 256) + win_reserved):
-                     cmap[chr(x)] = "~%02x" % x
-                 for x in range(ord("A"), ord("Z")+1) + [ord(e)]:
-                     cmap[chr(x)] = e + chr(x).lower()
-                 dmap = {}
-                 for k, v in cmap.iteritems():
-                     dmap[v] = k
-                 def decode(s):
-                     i = 0
-                     while i < len(s):
-                         for l in xrange(1, 4):
-                             try:
-                                 yield dmap[s[i:i+l]]
-                                 i += l
-                                 break
-                             except KeyError:
-                                 pass
-                         else:
-                             raise KeyError
-                 return (lambda s: "".join([cmap[c] for c in s]),
-                         lambda s: "".join(list(decode(s))))
-             encodefilename, decodefilename = _buildencodefun()
-             def encodedopener(openerfn, fn):
-                 def o(path, *args, **kw):
-                     return openerfn(fn(path), *args, **kw)
-                 return o
              def mktempcopy(name, emptyok=False, createmode=None):
                  """Create a temporary file with the same contents from name

mercurial/verify.py

0 +118 -182

              from node import nullid, short
              from i18n import _
-             import revlog
+             import revlog, util
              def verify(repo):
                  lock = repo.lock()
                      del lock
              def _verify(repo):
+                 mflinkrevs = {}
                  filelinkrevs = {}
                  filenodes = {}
-                 changesets = revisions = files = 0
-                 firstbad = [None]
+                 revisions = 0
+                 badrevs = {}
                  errors = [0]
                  warnings = [0]
-                 neededmanifests = {}
+                 ui = repo.ui
+                 cl = repo.changelog
+                 mf = repo.manifest
                  def err(linkrev, msg, filename=None):
                      if linkrev != None:
-                         if firstbad[0] != None:
-                             firstbad[0] = min(firstbad[0], linkrev)
+                         badrevs[linkrev] = True
-                         else:
-                             firstbad[0] = linkrev
-                     else:
-                         linkrev = "?"
+                         linkrev = '?'
                      msg = "%s: %s" % (linkrev, msg)
                      if filename:
                          msg = "%s@%s" % (filename, msg)
-                     repo.ui.warn(" " + msg + "\n")
+                     ui.warn(" " + msg + "\n")
                      errors[0] += 1
+                 def exc(linkrev, msg, inst, filename=None):
+                     if isinstance(inst, KeyboardInterrupt):
+                         ui.warn(_("interrupted"))
+                         raise
+                     err(linkrev, "%s: %s" % (msg, inst), filename)
                  def warn(msg):
-                     repo.ui.warn(msg + "\n")
+                     ui.warn(msg + "\n")
                      warnings[0] += 1
-                 def checksize(obj, name):
+                 def checklog(obj, name):
+                     if not len(obj) and (havecl or havemf):
+                         err(0, _("empty or missing %s") % name)
+                         return
                      d = obj.checksize()
                      if d[0]:
                          err(None, _("data length off by %d bytes") % d[0], name)
                      if d[1]:
                          err(None, _("index contains %d extra bytes") % d[1], name)
-                 def checkversion(obj, name):
                      if obj.version != revlog.REVLOGV0:
                          if not revlogv1:
                              warn(_("warning: `%s' uses revlog format 1") % name)
                      elif revlogv1:
                          warn(_("warning: `%s' uses revlog format 0") % name)
-                 revlogv1 = repo.changelog.version != revlog.REVLOGV0
-                 if repo.ui.verbose or not revlogv1:
-                     repo.ui.status(_("repository uses revlog format %d\n") %
+                 def checkentry(obj, i, node, seen, linkrevs, f):
+                     lr = obj.linkrev(node)
+                     if lr < 0 or (havecl and lr not in linkrevs):
+                         t = "unexpected"
+                         if lr < 0 or lr >= len(cl):
+                             t = "nonexistent"
+                         err(None, _("rev %d point to %s changeset %d") % (i, t, lr), f)
+                         if linkrevs:
+                             warn(_(" (expected %s)") % " ".join(map(str,linkrevs)))
+                         lr = None # can't be trusted
+                     try:
+                         p1, p2 = obj.parents(node)
+                         if p1 not in seen and p1 != nullid:
+                             err(lr, _("unknown parent 1 %s of %s") %
+                                 (short(p1), short(n)), f)
+                         if p2 not in seen and p2 != nullid:
+                             err(lr, _("unknown parent 2 %s of %s") %
+                                 (short(p2), short(p1)), f)
+                     except Exception, inst:
+                         exc(lr, _("checking parents of %s") % short(node), inst, f)
+                     if node in seen:
+                         err(lr, _("duplicate revision %d (%d)") % (i, seen[n]), f)
+                     seen[n] = i
+                     return lr
+                 revlogv1 = cl.version != revlog.REVLOGV0
+                 if ui.verbose or not revlogv1:
+                     ui.status(_("repository uses revlog format %d\n") %
                                     (revlogv1 and 1 or 0))
-                 havecl = havemf = 1
-                 seen = {}
-                 repo.ui.status(_("checking changesets\n"))
-                 if repo.changelog.count() == 0 and repo.manifest.count() > 1:
-                     havecl = 0
-                     err(0, _("empty or missing 00changelog.i"))
-                 else:
-                     checksize(repo.changelog, "changelog")
+                 havecl = len(cl) > 0
+                 havemf = len(mf) > 0
-                 for i in xrange(repo.changelog.count()):
-                     changesets += 1
-                     n = repo.changelog.node(i)
-                     l = repo.changelog.linkrev(n)
-                     if l != i:
-                         err(i, _("incorrect link (%d) for changeset") %(l))
-                     if n in seen:
-                         err(i, _("duplicates changeset at revision %d") % seen[n])
-                     seen[n] = i
+                 ui.status(_("checking changesets\n"))
+                 seen = {}
+                 checklog(cl, "changelog")
+                 for i in repo:
+                     n = cl.node(i)
+                     checkentry(cl, i, n, seen, [i], "changelog")
-                     for p in repo.changelog.parents(n):
-                         if p not in repo.changelog.nodemap:
-                             err(i, _("changeset has unknown parent %s") % short(p))
                      try:
-                         changes = repo.changelog.read(n)
-                     except KeyboardInterrupt:
-                         repo.ui.warn(_("interrupted"))
-                         raise
-                     except Exception, inst:
-                         err(i, _("unpacking changeset: %s") % inst)
-                         continue
-                     if changes[0] not in neededmanifests:
-                         neededmanifests[changes[0]] = i
+                         changes = cl.read(n)
+                         mflinkrevs.setdefault(changes[0], []).append(i)
                      for f in changes[3]:
                          filelinkrevs.setdefault(f, []).append(i)
-                 seen = {}
-                 repo.ui.status(_("checking manifests\n"))
-                 if repo.changelog.count() > 0 and repo.manifest.count() == 0:
-                     havemf = 0
-                     err(0, _("empty or missing 00manifest.i"))
-                 else:
-                     checkversion(repo.manifest, "manifest")
-                     checksize(repo.manifest, "manifest")
-                 for i in xrange(repo.manifest.count()):
-                     n = repo.manifest.node(i)
-                     l = repo.manifest.linkrev(n)
+                     except Exception, inst:
+                         exc(i, _("unpacking changeset %s") % short(n), inst)
-                     if l < 0 or (havecl and l >= repo.changelog.count()):
-                         err(None, _("bad link (%d) at manifest revision %d") % (l, i))
-                     if n in neededmanifests:
-                         del neededmanifests[n]
-                     if n in seen:
-                         err(l, _("duplicates manifest from %d") % seen[n])
-                     seen[n] = l
-                     for p in repo.manifest.parents(n):
-                         if p not in repo.manifest.nodemap:
-                             err(l, _("manifest has unknown parent %s") % short(p))
+                 ui.status(_("checking manifests\n"))
+                 seen = {}
+                 checklog(mf, "manifest")
+                 for i in mf:
+                     n = mf.node(i)
+                     lr = checkentry(mf, i, n, seen, mflinkrevs.get(n, []), "manifest")
+                     if n in mflinkrevs:
+                         del mflinkrevs[n]
                      try:
-                         for f, fn in repo.manifest.readdelta(n).iteritems():
+                         for f, fn in mf.readdelta(n).iteritems():
+                             if not f:
+                                 err(lr, _("file without name in manifest"))
+                             elif f != "/dev/null":
                              fns = filenodes.setdefault(f, {})
                              if fn not in fns:
                                  fns[fn] = n
-                     except KeyboardInterrupt:
-                         repo.ui.warn(_("interrupted"))
-                         raise
                      except Exception, inst:
-                         err(l, _("reading manifest delta: %s") % inst)
-                         continue
-                 repo.ui.status(_("crosschecking files in changesets and manifests\n"))
+                         exc(lr, _("reading manifest delta %s") % short(n), inst)
-                 if havemf > 0:
-                     nm = [(c, m) for m, c in neededmanifests.items()]
-                     nm.sort()
-                     for c, m in nm:
-                         err(c, _("changeset refers to unknown manifest %s") % short(m))
-                     del neededmanifests, nm
-                 if havecl:
-                     fl = filenodes.keys()
-                     fl.sort()
-                     for f in fl:
-                         if f not in filelinkrevs:
-                             lrs = [repo.manifest.linkrev(n) for n in filenodes[f]]
-                             lrs.sort()
-                             err(lrs[0], _("in manifest but not in changeset"), f)
-                     del fl
+                 ui.status(_("crosschecking files in changesets and manifests\n"))
                  if havemf:
-                     fl = filelinkrevs.keys()
-                     fl.sort()
-                     for f in fl:
+                     for c, m in util.sort([(c, m) for m in mflinkrevs for c in mflinkrevs[m]]):
+                         err(c, _("changeset refers to unknown manifest %s") % short(m))
+                     del mflinkrevs
+                     for f in util.sort(filelinkrevs):
                          if f not in filenodes:
                              lr = filelinkrevs[f][0]
                              err(lr, _("in changeset but not in manifest"), f)
-                     del fl
-                 repo.ui.status(_("checking files\n"))
-                 ff = dict.fromkeys(filenodes.keys() + filelinkrevs.keys()).keys()
-                 ff.sort()
-                 for f in ff:
-                     if f == "/dev/null":
-                         continue
-                     files += 1
-                     if not f:
-                         lr = filelinkrevs[f][0]
-                         err(lr, _("file without name in manifest"))
-                         continue
+                 if havecl:
+                     for f in util.sort(filenodes):
+                         if f not in filelinkrevs:
+                             try:
+                                 lr = min([repo.file(f).linkrev(n) for n in filenodes[f]])
+                             except:
+                                 lr = None
+                             err(lr, _("in manifest but not in changeset"), f)
+                 ui.status(_("checking files\n"))
+                 files = util.sort(util.unique(filenodes.keys() + filelinkrevs.keys()))
+                 for f in files:
                      fl = repo.file(f)
-                     checkversion(fl, f)
-                     checksize(fl, f)
-                     if fl.count() == 0:
-                         err(filelinkrevs[f][0], _("empty or missing revlog"), f)
-                         continue
+                     checklog(fl, f)
                      seen = {}
-                     nodes = {nullid: 1}
-                     for i in xrange(fl.count()):
+                     for i in fl:
                          revisions += 1
                          n = fl.node(i)
-                         flr = fl.linkrev(n)
-                         if flr < 0 or (havecl and flr not in filelinkrevs.get(f, [])):
-                             if flr < 0 or flr >= repo.changelog.count():
-                                 err(None, _("rev %d point to nonexistent changeset %d")
-                                     % (i, flr), f)
-                             else:
-                                 err(None, _("rev %d points to unexpected changeset %d")
-                                     % (i, flr), f)
-                             if f in filelinkrevs:
-                                 warn(_(" (expected %s)") % filelinkrevs[f][0])
-                             flr = None # can't be trusted
-                         else:
-                             if havecl:
-                                 filelinkrevs[f].remove(flr)
-                         if n in seen:
-                             err(flr, _("duplicate revision %d") % i, f)
+                         lr = checkentry(fl, i, n, seen, filelinkrevs.get(f, []), f)
                          if f in filenodes:
                              if havemf and n not in filenodes[f]:
-                                 err(flr, _("%s not in manifests") % (short(n)), f)
+                                 err(lr, _("%s not in manifests") % (short(n)), f)
                              else:
                                  del filenodes[f][n]
                          # verify contents
                          try:
                              t = fl.read(n)
-                         except KeyboardInterrupt:
-                             repo.ui.warn(_("interrupted"))
-                             raise
+                             rp = fl.renamed(n)
+                             if len(t) != fl.size(i):
+                                 if not fl._readmeta(n): # ancient copy?
+                                     err(lr, _("unpacked size is %s, %s expected") %
+                                         (len(t), fl.size(i)), f)
                          except Exception, inst:
-                             err(flr, _("unpacking %s: %s") % (short(n), inst), f)
-                         # verify parents
-                         try:
-                             (p1, p2) = fl.parents(n)
-                             if p1 not in nodes:
-                                 err(flr, _("unknown parent 1 %s of %s") %
-                                     (short(p1), short(n)), f)
-                             if p2 not in nodes:
-                                 err(flr, _("unknown parent 2 %s of %s") %
-                                         (short(p2), short(p1)), f)
-                         except KeyboardInterrupt:
-                             repo.ui.warn(_("interrupted"))
-                             raise
-                         except Exception, inst:
-                             err(flr, _("checking parents of %s: %s") % (short(n), inst), f)
-                         nodes[n] = 1
+                             exc(lr, _("unpacking %s") % short(n), inst, f)
                          # check renames
                          try:
-                             rp = fl.renamed(n)
                              if rp:
                                  fl2 = repo.file(rp[0])
-                                 if fl2.count() == 0:
-                                     err(flr, _("empty or missing copy source revlog %s:%s")
+                                 if not len(fl2):
+                                     err(lr, _("empty or missing copy source revlog %s:%s")
                                          % (rp[0], short(rp[1])), f)
                                  elif rp[1] == nullid:
-                                     err(flr, _("copy source revision is nullid %s:%s")
+                                     err(lr, _("copy source revision is nullid %s:%s")
                                          % (rp[0], short(rp[1])), f)
                                  else:
                                      rev = fl2.rev(rp[1])
-                         except KeyboardInterrupt:
-                             repo.ui.warn(_("interrupted"))
-                             raise
                          except Exception, inst:
-                             err(flr, _("checking rename of %s: %s") %
-                                 (short(n), inst), f)
+                             exc(lr, _("checking rename of %s") % short(n), inst, f)
                      # cross-check
                      if f in filenodes:
-                         fns = [(repo.manifest.linkrev(filenodes[f][n]), n)
-                                for n in filenodes[f]]
-                         fns.sort()
-                         for lr, node in fns:
+                         fns = [(mf.linkrev(l), n) for n,l in filenodes[f].items()]
+                         for lr, node in util.sort(fns):
                              err(lr, _("%s in manifests not found") % short(node), f)
-                 repo.ui.status(_("%d files, %d changesets, %d total revisions\n") %
-                                (files, changesets, revisions))
+                 ui.status(_("%d files, %d changesets, %d total revisions\n") %
+                                (len(files), len(cl), revisions))
                  if warnings[0]:
-                     repo.ui.warn(_("%d warnings encountered!\n") % warnings[0])
+                     ui.warn(_("%d warnings encountered!\n") % warnings[0])
                  if errors[0]:
-                     repo.ui.warn(_("%d integrity errors encountered!\n") % errors[0])
-                     if firstbad[0]:
-                         repo.ui.warn(_("(first damaged changeset appears to be %d)\n")
-                                      % firstbad[0])
+                     ui.warn(_("%d integrity errors encountered!\n") % errors[0])
+                     if badrevs:
+                         ui.warn(_("(first damaged changeset appears to be %d)\n")
+                                 % min(badrevs))
                      return 1

setup.py

0 +8 -4

              import mercurial.version
              extra = {}
+             scripts = ['hg']
+             if os.name == 'nt':
+                 scripts.append('contrib/win32/hg.bat')
              # simplified version of distutils.ccompiler.CCompiler.has_function
              # that actually removes its temporary files.
              cmdclass = {'install_data': install_package_data}
              ext_modules=[
-                 Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
+                 Extension('mercurial.base85', ['mercurial/base85.c']),
                  Extension('mercurial.bdiff', ['mercurial/bdiff.c']),
-                 Extension('mercurial.base85', ['mercurial/base85.c']),
-                 Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c'])
+                 Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c']),
+                 Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
+                 Extension('mercurial.parsers', ['mercurial/parsers.c']),
                  ]
              packages = ['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert']
                    url='http://selenic.com/mercurial',
                    description='Scalable distributed SCM',
                    license='GNU GPL',
-                   scripts=['hg'],
+                   scripts=scripts,
                    packages=packages,
                    ext_modules=ext_modules,
                    data_files=[(os.path.join('mercurial', root),

templates/changelog.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#shortlog/#rev#{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#file/#node|short#{sessionvars%urlparameter}">files</a>
              #archives%archiveentry#

templates/changeset.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log/#rev#{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog/#rev#{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#file/#node|short#{sessionvars%urlparameter}">files</a>
              <a href="#url#raw-rev/#node|short#">raw</a>

templates/fileannotate.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log/#rev#{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog/#rev#{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#rev/#node|short#{sessionvars%urlparameter}">changeset</a>
              <a href="#url#file/#node|short##path|urlescape#{sessionvars%urlparameter}">files</a>

templates/filediff.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log/#rev#{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog/#rev#{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#rev/#node|short#{sessionvars%urlparameter}">changeset</a>
              <a href="#url#file/#node|short#/#file|urlescape#{sessionvars%urlparameter}">file</a>

templates/filelog.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#file/#node|short#/#file|urlescape#{sessionvars%urlparameter}">file</a>
              <a href="#url#annotate/#node|short#/#file|urlescape#{sessionvars%urlparameter}">annotate</a>

templates/filerevision.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log/#rev#{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog/#rev#{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#rev/#node|short#{sessionvars%urlparameter}">changeset</a>
              <a href="#url#file/#node|short##path|urlescape#{sessionvars%urlparameter}">files</a>

templates/gitweb/changelog.tmpl

0 +6 -1

              </form>
              <div class="page_nav">
-             <a href="{url}summary{sessionvars%urlparameter}">summary</a> | <a href="{url}shortlog/#rev#{sessionvars%urlparameter}">shortlog</a> | changelog | <a href="{url}tags{sessionvars%urlparameter}">tags</a> | <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a>#archives%archiveentry#
+             <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
+             <a href="{url}shortlog/#rev#{sessionvars%urlparameter}">shortlog</a> |
+             changelog |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
+             <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
+             <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a>#archives%archiveentry#
              <br/>
              #changenav%naventry#<br/>
              </div>

templates/gitweb/changeset.tmpl

0 +1 -1

              </div>
              <div class="page_nav">
-             <a href="{url}summary{sessionvars%urlparameter}">summary</a> | <a href="{url}shortlog/#rev#{sessionvars%urlparameter}">shortlog</a> | <a href="{url}log/#rev#{sessionvars%urlparameter}">changelog</a> | <a href="{url}tags{sessionvars%urlparameter}">tags</a> | <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a> | changeset | <a href="{url}raw-rev/#node|short#">raw</a> #archives%archiveentry#<br/>
+             <a href="{url}summary{sessionvars%urlparameter}">summary</a> | <a href="{url}shortlog/#rev#{sessionvars%urlparameter}">shortlog</a> | <a href="{url}log/#rev#{sessionvars%urlparameter}">changelog</a> | <a href="{url}graph{sessionvars%urlparameter}">graph</a> | <a href="{url}tags{sessionvars%urlparameter}">tags</a> | <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a> | changeset | <a href="{url}raw-rev/#node|short#">raw</a> #archives%archiveentry#<br/>
              </div>
              <div>

templates/gitweb/fileannotate.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/#node|short##path|urlescape#{sessionvars%urlparameter}">files</a> |
              <a href="{url}rev/#node|short#{sessionvars%urlparameter}">changeset</a> |

templates/gitweb/filediff.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/{node|short}{path|urlescape}{sessionvars%urlparameter}">files</a> |
              <a href="{url}rev/{node|short}{sessionvars%urlparameter}">changeset</a> |

templates/gitweb/filelog.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/{node|short}/#file|urlescape#{sessionvars%urlparameter}">file</a> |
              revisions |

templates/gitweb/filerevision.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/#node|short##path|urlescape#{sessionvars%urlparameter}">files</a> |
              <a href="{url}rev/#node|short#{sessionvars%urlparameter}">changeset</a> |

templates/gitweb/manifest.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              files |
              <a href="{url}rev/#node|short#{sessionvars%urlparameter}">changeset</a> #archives%archiveentry#<br/>

templates/gitweb/map

0 +3 -1

              notfound = notfound.tmpl
              naventry = '<a href="{url}log/{node|short}{sessionvars%urlparameter}">{label|escape}</a> '
              navshortentry = '<a href="{url}shortlog/{node|short}{sessionvars%urlparameter}">{label|escape}</a> '
+             navgraphentry = '<a href="{url}graph/{node|short}{sessionvars%urlparameter}">{label|escape}</a> '
              filenaventry = '<a href="{url}log/{node|short}/{file|urlescape}{sessionvars%urlparameter}">{label|escape}</a> '
              filedifflink = '<a href="#url#diff/#node|short#/#file|urlescape#{sessionvars%urlparameter}">#file|escape#</a> '
              filenodelink = '<tr class="parity#parity#"><td><a class="list" href="{url}diff/{node|short}/{file|urlescape}{sessionvars%urlparameter}">#file|escape#</a></td><td></td><td class="link"><a href="#url#file/#node|short#/#file|urlescape#{sessionvars%urlparameter}">file</a> | <a href="#url#annotate/#node|short#/#file|urlescape#{sessionvars%urlparameter}">annotate</a> | <a href="#url#diff/#node|short#/#file|urlescape#{sessionvars%urlparameter}">diff</a> | <a href="#url#log/#node|short#/#file|urlescape#{sessionvars%urlparameter}">revisions</a></td></tr>'
              filediff = filediff.tmpl
              filelog = filelog.tmpl
              fileline = '<div style="font-family:monospace" class="parity#parity#"><pre><a class="linenr" href="##lineid#" id="#lineid#">#linenumber#</a> #line|escape#</pre></div>'
-             annotateline = '<tr style="font-family:monospace" class="parity#parity#"><td class="linenr" style="text-align: right;"><a href="#url#annotate/#node|short#/#file|urlescape#{sessionvars%urlparameter}#l{targetline}">#author|obfuscate#@#rev#</a></td><td><pre><a class="linenr" href="##lineid#" id="#lineid#">#linenumber#</a></pre></td><td><pre>#line|escape#</pre></td></tr>'
+             annotateline = '<tr style="font-family:monospace" class="parity#parity#"><td class="linenr" style="text-align: right;"><a href="#url#annotate/#node|short#/#file|urlescape#{sessionvars%urlparameter}#l{targetline}" title="{node|short}: {desc|escape|firstline}">#author|user#@#rev#</a></td><td><pre><a class="linenr" href="##lineid#" id="#lineid#">#linenumber#</a></pre></td><td><pre>#line|escape#</pre></td></tr>'
              difflineplus = '<span style="color:#008800;"><a class="linenr" href="##lineid#" id="#lineid#">#linenumber#</a> #line|escape#</span>'
              difflineminus = '<span style="color:#cc0000;"><a class="linenr" href="##lineid#" id="#lineid#">#linenumber#</a> #line|escape#</span>'
              difflineat = '<span style="color:#990099;"><a class="linenr" href="##lineid#" id="#lineid#">#linenumber#</a> #line|escape#</span>'
              filediffchild = '<tr><td>child {rev}</td><td style="font-family:monospace"><a class="list" href="{url}diff/{node|short}/{file|urlescape}{sessionvars%urlparameter}">{node|short}</a></td></tr>'
              filelogchild = '<tr><td align="right">child #rev#:&nbsp;</td><td><a href="{url}file{node|short}/#file|urlescape#{sessionvars%urlparameter}">#node|short#</a></td></tr>'
              shortlog = shortlog.tmpl
+             graph = graph.tmpl
              tagtag = '<span class="tagtag" title="{name}">{name}</span> '
              branchtag = '<span class="branchtag" title="{name}">{name}</span> '
              inbranchtag = '<span class="inbranchtag" title="{name}">{name}</span> '

templates/gitweb/search.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a>#archives%archiveentry#
              <br/>

templates/gitweb/shortlog.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              shortlog |
              <a href="{url}log/#rev#{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a>#archives%archiveentry#
              <br/>

templates/gitweb/summary.tmpl

0 +1 0

              summary |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              <a href="{url}tags{sessionvars%urlparameter}">tags</a> |
              <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a>#archives%archiveentry#
              <br/>

templates/gitweb/tags.tmpl

0 +1 0

              <a href="{url}summary{sessionvars%urlparameter}">summary</a> |
              <a href="{url}shortlog{sessionvars%urlparameter}">shortlog</a> |
              <a href="{url}log{sessionvars%urlparameter}">changelog</a> |
+             <a href="{url}graph{sessionvars%urlparameter}">graph</a> |
              tags |
              <a href="{url}file/#node|short#{sessionvars%urlparameter}">files</a>
              <br/>

templates/manifest.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log/#rev#{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog/#rev#{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#rev/#node|short#{sessionvars%urlparameter}">changeset</a>
              #archives%archiveentry#

templates/map

0 +3 -1

              changelog = changelog.tmpl
              shortlog = shortlog.tmpl
              shortlogentry = shortlogentry.tmpl
+             graph = graph.tmpl
              naventry = '<a href="{url}log/{node|short}{sessionvars%urlparameter}">{label|escape}</a> '
              navshortentry = '<a href="{url}shortlog/{node|short}{sessionvars%urlparameter}">{label|escape}</a> '
+             navgraphentry = '<a href="{url}graph/{node|short}{sessionvars%urlparameter}">{label|escape}</a> '
              filenaventry = '<a href="{url}log/{node|short}/{file|urlescape}{sessionvars%urlparameter}">{label|escape}</a> '
              filedifflink = '<a href="#url#diff/#node|short#/#file|urlescape#{sessionvars%urlparameter}">#file|escape#</a> '
              filenodelink = '<a href="#url#file/#node|short#/#file|urlescape#{sessionvars%urlparameter}">#file|escape#</a> '
              filelog = filelog.tmpl
              fileline = '<div class="parity#parity#"><a class="lineno" href="##lineid#" id="#lineid#">#linenumber#</a>#line|escape#</div>'
              filelogentry = filelogentry.tmpl
-             annotateline = '<tr class="parity#parity#"><td class="annotate"><a href="#url#annotate/#node|short#/#file|urlescape#{sessionvars%urlparameter}#l{targetline}">#author|obfuscate#@#rev#</a></td><td><a class="lineno" href="##lineid#" id="#lineid#">#linenumber#</a></td><td><pre>#line|escape#</pre></td></tr>'
+             annotateline = '<tr class="parity#parity#"><td class="annotate"><a href="#url#annotate/#node|short#/#file|urlescape#{sessionvars%urlparameter}#l{targetline}" title="{node|short}: {desc|escape|firstline}">#author|user#@#rev#</a></td><td><a class="lineno" href="##lineid#" id="#lineid#">#linenumber#</a></td><td><pre>#line|escape#</pre></td></tr>'
              difflineplus = '<span class="plusline"><a class="lineno" href="##lineid#" id="#lineid#">#linenumber#</a>#line|escape#</span>'
              difflineminus = '<span class="minusline"><a class="lineno" href="##lineid#" id="#lineid#">#linenumber#</a>#line|escape#</span>'
              difflineat = '<span class="atline"><a class="lineno" href="##lineid#" id="#lineid#">#linenumber#</a>#line|escape#</span>'

templates/search.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log{sessionvars%urlparameter}">changelog</a>
              <a href="#url#shortlog{sessionvars%urlparameter}">shortlog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#file/#node|short#{sessionvars%urlparameter}">files</a>
              #archives%archiveentry#

templates/shortlog.tmpl

0 +1 0

              <div class="buttons">
              <a href="#url#log/#rev#{sessionvars%urlparameter}">changelog</a>
+             <a href="#url#graph{sessionvars%urlparameter}">graph</a>
              <a href="#url#tags{sessionvars%urlparameter}">tags</a>
              <a href="#url#file/#node|short#/{sessionvars%urlparameter}">files</a>
              #archives%archiveentry#

templates/static/hgicon.png

0 binary modified 0 0

NO CONTENT: modified file, binary diff hidden

templates/static/hglogo.png

0 binary modified 0 0

NO CONTENT: modified file, binary diff hidden

templates/static/style-gitweb.css

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

templates/static/style.css

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

templates/tags.tmpl

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/hghave

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/md5sum.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-acl.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-add.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-addremove-similar.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-addremove.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-archive

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-children.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-churn

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-command-template

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-commit

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-committer.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-conflict.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-context.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-baz

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-clonebranches

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-cvs

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-cvs.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-darcs

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-filemap

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-filemap.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-git

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-git.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-hg-source.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-svn-sink.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert-tla

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-convert.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-copy-move-merge.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-debugcomplete.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-double-merge.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-extension.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-globalopts.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-help.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-hgweb-commands

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-hgweb-commands.out

0 binary modified 0 0

NO CONTENT: modified file, binary diff hidden

tests/test-hgweb.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-highlight

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-highlight.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-imerge

0 755 ➡ 644 0 0

NO CONTENT: modified file chmod 100755 => 100644

tests/test-issue612.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-issue672.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-keyword

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-keyword.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-log.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-manifest

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-manifest.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge-commit.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge-default.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge-internal-tools-pattern.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge-local.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge-remove.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge-revert2.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge10.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge7.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge9

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-merge9.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mq

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mq-qdelete

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mq-qdelete.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mq-qdiff

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mq-qdiff.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-mq.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-newbranch

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-newbranch.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-parseindex

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-pull-http tests/test-push-http

0 copied 0 0

	1		NO CONTENT: file copied from tests/test-push-http to tests/test-pull-http
The requested commit or file is too big and content was truncated. Show full diff

tests/test-purge

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-purge.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-remove.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-rename-merge1.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-rename-merge2.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-serve

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-serve.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-tag.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-tags.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-transplant

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-transplant.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-up-local-change.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-update-reverse.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-walk.out

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

templates/static/highlight.css

0 removed 0 0

	1		NO CONTENT: file was removed
The requested commit or file is too big and content was truncated. Show full diff

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