Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	23876		Nov 30 2020, 6:23 AM	★	★
Diff 2	24306		Dec 16 2020, 8:12 AM	★	★
Diff 3	26621		Mar 28 2021, 8:55 PM	★	★
Diff 4	26629		Mar 29 2021, 8:42 PM	★	★
Diff 5	27131		Apr 20 2021, 11:35 AM	★	★
Diff 6	27133		Apr 20 2021, 12:22 PM	★	★
Diff 7	27134	rHG07b9ebea3ce8d32950a4c5c242efa25b584bbe1f	Mar 28 2021, 7:52 PM	★	★
Diff 8	27148		Apr 20 2021, 1:49 PM	★	★
Diff 9	27171		Apr 27 2021, 7:42 PM	★	★

Commit	Parents	Author	Summary	Date
8f57fa4736b2	b7e623ac98b6	Joerg Sonnenberger		Mar 28 2021, 7:52 PM

Status	Author	Revision
Closed	joerg.sonnenberger	D9465 node: replace nullid and friends with nodeconstants class
Closed	joerg.sonnenberger	D10290 refactor: prefer checks against nullrev over nullid
Closed	joerg.sonnenberger	D10280 refactor: prefer lookup by revision, even for null
Closed	joerg.sonnenberger	D10289 setdiscovery: simplify by using tiprev directly

Diff 27171

hgext/absorb.py


	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from mercurial import (			from mercurial import (
	cmdutil,			cmdutil,
	commands,			commands,
	context,			context,
	crecord,			crecord,
	error,			error,

	def __init__(self, repo):			def __init__(self, repo):
	self._repo = repo			self._repo = repo

	def data(self):			def data(self):
	return b''			return b''

	def node(self):			def node(self):
	return nullid			return self._repo.nullid


	def uniq(lst):			def uniq(lst):
	"""list -> list. remove duplicated items without changing the order"""			"""list -> list. remove duplicated items without changing the order"""
	seen = set()			seen = set()
	result = []			result = []
	for x in lst:			for x in lst:
	if x not in seen:			if x not in seen:
	return True			return True

	def _commitsingle(self, memworkingcopy, ctx, p1=None):			def _commitsingle(self, memworkingcopy, ctx, p1=None):
	"""(ctx, {path: content}, node) -> node. make a single commit			"""(ctx, {path: content}, node) -> node. make a single commit

	the commit is a clone from ctx, with a (optionally) different p1, and			the commit is a clone from ctx, with a (optionally) different p1, and
	different file contents replaced by memworkingcopy.			different file contents replaced by memworkingcopy.
	"""			"""
	parents = p1 and (p1, nullid)			parents = p1 and (p1, self.repo.nullid)
	extra = ctx.extra()			extra = ctx.extra()
	if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'):			if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'):
	extra[b'absorb_source'] = ctx.hex()			extra[b'absorb_source'] = ctx.hex()

	desc = rewriteutil.update_hash_refs(			desc = rewriteutil.update_hash_refs(
	ctx.repo(),			ctx.repo(),
	ctx.description(),			ctx.description(),
	{			{

hgext/convert/git.py

	# git.py - git support for the convert extension			# git.py - git support for the convert extension
	#			#
	# Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> and others			# Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> and others
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import nullhex			from mercurial.node import sha1nodeconstants
	from mercurial import (			from mercurial import (
	config,			config,
	error,			error,
	pycompat,			pycompat,
	)			)

	from . import common			from . import common

	for rev in self.revs:			for rev in self.revs:
	rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev)			rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev)
	heads.append(rawhead[:-1])			heads.append(rawhead[:-1])
	if ret:			if ret:
	raise error.Abort(_(b'cannot retrieve git head "%s"') % rev)			raise error.Abort(_(b'cannot retrieve git head "%s"') % rev)
	return heads			return heads

	def catfile(self, rev, ftype):			def catfile(self, rev, ftype):
	if rev == nullhex:			if rev == sha1nodeconstants.nullhex:
	raise IOError			raise IOError
	self.catfilepipe[0].write(rev + b'\n')			self.catfilepipe[0].write(rev + b'\n')
	self.catfilepipe[0].flush()			self.catfilepipe[0].flush()
	info = self.catfilepipe[1].readline().split()			info = self.catfilepipe[1].readline().split()
	if info[1] != ftype:			if info[1] != ftype:
	raise error.Abort(			raise error.Abort(
	_(b'cannot read %r object at %s')			_(b'cannot read %r object at %s')
	% (pycompat.bytestr(ftype), rev)			% (pycompat.bytestr(ftype), rev)
	)			)
	size = int(info[2])			size = int(info[2])
	data = self.catfilepipe[1].read(size)			data = self.catfilepipe[1].read(size)
	if len(data) < size:			if len(data) < size:
	raise error.Abort(			raise error.Abort(
	_(b'cannot read %r object at %s: unexpected size')			_(b'cannot read %r object at %s: unexpected size')
	% (ftype, rev)			% (ftype, rev)
	)			)
	# read the trailing newline			# read the trailing newline
	self.catfilepipe[1].read(1)			self.catfilepipe[1].read(1)
	return data			return data

	def getfile(self, name, rev):			def getfile(self, name, rev):
	if rev == nullhex:			if rev == sha1nodeconstants.nullhex:
	return None, None			return None, None
	if name == b'.hgsub':			if name == b'.hgsub':
	data = b'\n'.join([m.hgsub() for m in self.submoditer()])			data = b'\n'.join([m.hgsub() for m in self.submoditer()])
	mode = b''			mode = b''
	elif name == b'.hgsubstate':			elif name == b'.hgsubstate':
	data = b'\n'.join([m.hgsubstate() for m in self.submoditer()])			data = b'\n'.join([m.hgsubstate() for m in self.submoditer()])
	mode = b''			mode = b''
	else:			else:
	data = self.catfile(rev, b"blob")			data = self.catfile(rev, b"blob")
	mode = self.modecache[(name, rev)]			mode = self.modecache[(name, rev)]
	return data, mode			return data, mode

	def submoditer(self):			def submoditer(self):
	null = nullhex			null = sha1nodeconstants.nullhex
	for m in sorted(self.submodules, key=lambda p: p.path):			for m in sorted(self.submodules, key=lambda p: p.path):
	if m.node != null:			if m.node != null:
	yield m			yield m

	def parsegitmodules(self, content):			def parsegitmodules(self, content):
	"""Parse the formatted .gitmodules file, example file format:			"""Parse the formatted .gitmodules file, example file format:
	[submodule "sub"]\n			[submodule "sub"]\n
	\tpath = sub\n			\tpath = sub\n

	if f == b'.gitmodules':			if f == b'.gitmodules':
	if skipsubmodules:			if skipsubmodules:
	return			return

	subexists[0] = True			subexists[0] = True
	if entry[4] == b'D' or renamesource:			if entry[4] == b'D' or renamesource:
	subdeleted[0] = True			subdeleted[0] = True
	changes.append((b'.hgsub', nullhex))			changes.append((b'.hgsub', sha1nodeconstants.nullhex))
	else:			else:
	changes.append((b'.hgsub', b''))			changes.append((b'.hgsub', b''))
	elif entry[1] == b'160000' or entry[0] == b':160000':			elif entry[1] == b'160000' or entry[0] == b':160000':
	if not skipsubmodules:			if not skipsubmodules:
	subexists[0] = True			subexists[0] = True
	else:			else:
	if renamesource:			if renamesource:
	h = nullhex			h = sha1nodeconstants.nullhex
	self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b""			self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b""
	changes.append((f, h))			changes.append((f, h))

	while i < lcount:			while i < lcount:
	l = difftree[i]			l = difftree[i]
	i += 1			i += 1
	if not entry:			if not entry:
	if not l.startswith(b':'):			if not l.startswith(b':'):
	# .gitmodules isn't imported at all, so it being copied to			# .gitmodules isn't imported at all, so it being copied to
	# and fro doesn't really make sense			# and fro doesn't really make sense
	if f != b'.gitmodules' and fdest != b'.gitmodules':			if f != b'.gitmodules' and fdest != b'.gitmodules':
	copies[fdest] = f			copies[fdest] = f
	entry = None			entry = None

	if subexists[0]:			if subexists[0]:
	if subdeleted[0]:			if subdeleted[0]:
	changes.append((b'.hgsubstate', nullhex))			changes.append((b'.hgsubstate', sha1nodeconstants.nullhex))
	else:			else:
	self.retrievegitmodules(version)			self.retrievegitmodules(version)
	changes.append((b'.hgsubstate', b''))			changes.append((b'.hgsubstate', b''))
	return (changes, copies, set())			return (changes, copies, set())

	def getcommit(self, version):			def getcommit(self, version):
	c = self.catfile(version, b"commit") # read the commit hash			c = self.catfile(version, b"commit") # read the commit hash
	end = c.find(b"\n\n")			end = c.find(b"\n\n")

hgext/convert/hg.py

	import re			import re
	import time			import time

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.pycompat import open			from mercurial.pycompat import open
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullhex,			sha1nodeconstants,
	nullid,
	)			)
	from mercurial import (			from mercurial import (
	bookmarks,			bookmarks,
	context,			context,
	error,			error,
	exchange,			exchange,
	hg,			hg,
	lock as lockmod,			lock as lockmod,
	for line in data.splitlines():			for line in data.splitlines():
	s = line.split(b' ', 1)			s = line.split(b' ', 1)
	if len(s) != 2:			if len(s) != 2:
	self.ui.warn(_(b'invalid tag entry: "%s"\n') % line)			self.ui.warn(_(b'invalid tag entry: "%s"\n') % line)
	fp.write(b'%s\n' % line) # Bogus, but keep for hash stability			fp.write(b'%s\n' % line) # Bogus, but keep for hash stability
	continue			continue
	revid = revmap.get(source.lookuprev(s[0]))			revid = revmap.get(source.lookuprev(s[0]))
	if not revid:			if not revid:
	if s[0] == nullhex:			if s[0] == sha1nodeconstants.nullhex:
	revid = s[0]			revid = s[0]
	else:			else:
	# missing, but keep for hash stability			# missing, but keep for hash stability
	self.ui.warn(_(b'missing tag entry: "%s"\n') % line)			self.ui.warn(_(b'missing tag entry: "%s"\n') % line)
	fp.write(b'%s\n' % line)			fp.write(b'%s\n' % line)
	continue			continue
	fp.write(b'%s %s\n' % (revid, s[1]))			fp.write(b'%s %s\n' % (revid, s[1]))
	return fp.getvalue()			return fp.getvalue()

	def _rewritesubstate(self, source, data):			def _rewritesubstate(self, source, data):
	fp = stringio()			fp = stringio()
	for line in data.splitlines():			for line in data.splitlines():
	s = line.split(b' ', 1)			s = line.split(b' ', 1)
	if len(s) != 2:			if len(s) != 2:
	continue			continue

	revid = s[0]			revid = s[0]
	subpath = s[1]			subpath = s[1]
	if revid != nullhex:			if revid != sha1nodeconstants.nullhex:
	revmap = self.subrevmaps.get(subpath)			revmap = self.subrevmaps.get(subpath)
	if revmap is None:			if revmap is None:
	revmap = mapfile(			revmap = mapfile(
	self.ui, self.repo.wjoin(subpath, b'.hg/shamap')			self.ui, self.repo.wjoin(subpath, b'.hg/shamap')
	)			)
	self.subrevmaps[subpath] = revmap			self.subrevmaps[subpath] = revmap

	# It is reasonable that one or more of the subrepos don't			# It is reasonable that one or more of the subrepos don't
	pl.append(p)			pl.append(p)
	parents = pl			parents = pl
	nparents = len(parents)			nparents = len(parents)
	if self.filemapmode and nparents == 1:			if self.filemapmode and nparents == 1:
	m1node = self.repo.changelog.read(bin(parents[0]))[0]			m1node = self.repo.changelog.read(bin(parents[0]))[0]
	parent = parents[0]			parent = parents[0]

	if len(parents) < 2:			if len(parents) < 2:
	parents.append(nullid)			parents.append(self.repo.nullid)
	if len(parents) < 2:			if len(parents) < 2:
	parents.append(nullid)			parents.append(self.repo.nullid)
	p2 = parents.pop(0)			p2 = parents.pop(0)

	text = commit.desc			text = commit.desc

	sha1s = re.findall(sha1re, text)			sha1s = re.findall(sha1re, text)
	for sha1 in sha1s:			for sha1 in sha1s:
	oldrev = source.lookuprev(sha1)			oldrev = source.lookuprev(sha1)
	newrev = revmap.get(oldrev)			newrev = revmap.get(oldrev)
	if commit.rev and commit.saverev:			if commit.rev and commit.saverev:
	extra[b'convert_revision'] = commit.rev			extra[b'convert_revision'] = commit.rev

	while parents:			while parents:
	p1 = p2			p1 = p2
	p2 = parents.pop(0)			p2 = parents.pop(0)
	p1ctx = self.repo[p1]			p1ctx = self.repo[p1]
	p2ctx = None			p2ctx = None
	if p2 != nullid:			if p2 != self.repo.nullid:
	p2ctx = self.repo[p2]			p2ctx = self.repo[p2]
	fileset = set(files)			fileset = set(files)
	if full:			if full:
	fileset.update(self.repo[p1])			fileset.update(self.repo[p1])
	fileset.update(self.repo[p2])			fileset.update(self.repo[p2])

	if p2ctx:			if p2ctx:
	p2files = set(cleanp2)			p2files = set(cleanp2)
	if not closed and not man.cmp(m1node, man.revision(mnode)):			if not closed and not man.cmp(m1node, man.revision(mnode)):
	self.ui.status(_(b"filtering out empty revision\n"))			self.ui.status(_(b"filtering out empty revision\n"))
	self.repo.rollback(force=True)			self.repo.rollback(force=True)
	return parent			return parent
	return p2			return p2

	def puttags(self, tags):			def puttags(self, tags):
	tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True)			tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True)
	tagparent = tagparent or nullid			tagparent = tagparent or self.repo.nullid

	oldlines = set()			oldlines = set()
	for branch, heads in pycompat.iteritems(self.repo.branchmap()):			for branch, heads in pycompat.iteritems(self.repo.branchmap()):
	for h in heads:			for h in heads:
	if b'.hgtags' in self.repo[h]:			if b'.hgtags' in self.repo[h]:
	oldlines.update(			oldlines.update(
	set(self.repo[h][b'.hgtags'].data().splitlines(True))			set(self.repo[h][b'.hgtags'].data().splitlines(True))
	)			)

hgext/git/dirstate.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import contextlib			import contextlib
	import errno			import errno
	import os			import os

	from mercurial.node import nullid			from mercurial.node import sha1nodeconstants
	from mercurial import (			from mercurial import (
	error,			error,
	extensions,			extensions,
	match as matchmod,			match as matchmod,
	pycompat,			pycompat,
	scmutil,			scmutil,
	util,			util,
	)			)
	self._plchangecallbacks = {}			self._plchangecallbacks = {}

	def p1(self):			def p1(self):
	try:			try:
	return self.git.head.peel().id.raw			return self.git.head.peel().id.raw
	except pygit2.GitError:			except pygit2.GitError:
	# Typically happens when peeling HEAD fails, as in an			# Typically happens when peeling HEAD fails, as in an
	# empty repository.			# empty repository.
	return nullid			return sha1nodeconstants.nullid

	def p2(self):			def p2(self):
	# TODO: MERGE_HEAD? something like that, right?			# TODO: MERGE_HEAD? something like that, right?
	return nullid			return sha1nodeconstants.nullid

	def setparents(self, p1, p2=nullid):			def setparents(self, p1, p2=None):
	assert p2 == nullid, b'TODO merging support'			if p2 is None:
				p2 = sha1nodeconstants.nullid
				assert p2 == sha1nodeconstants.nullid, b'TODO merging support'
	self.git.head.set_target(gitutil.togitnode(p1))			self.git.head.set_target(gitutil.togitnode(p1))

	@util.propertycache			@util.propertycache
	def identity(self):			def identity(self):
	return util.filestat.frompath(			return util.filestat.frompath(
	os.path.join(self._root, b'.git', b'index')			os.path.join(self._root, b'.git', b'index')
	)			)

	def branch(self):			def branch(self):
	return b'default'			return b'default'

	def parents(self):			def parents(self):
	# TODO how on earth do we find p2 if a merge is in flight?			# TODO how on earth do we find p2 if a merge is in flight?
	return self.p1(), nullid			return self.p1(), sha1nodeconstants.nullid

	def __iter__(self):			def __iter__(self):
	return (pycompat.fsencode(f.path) for f in self.git.index)			return (pycompat.fsencode(f.path) for f in self.git.index)

	def items(self):			def items(self):
	for ie in self.git.index:			for ie in self.git.index:
	yield ie.path, None # value should be a dirstatetuple			yield ie.path, None # value should be a dirstatetuple

hgext/git/gitlog.py

	from __future__ import absolute_import			from __future__ import absolute_import

	from mercurial.i18n import _			from mercurial.i18n import _

	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullhex,
	nullid,
	nullrev,			nullrev,
	sha1nodeconstants,			sha1nodeconstants,
	wdirhex,
	)			)
	from mercurial import (			from mercurial import (
	ancestor,			ancestor,
	changelog as hgchangelog,			changelog as hgchangelog,
	dagop,			dagop,
	encoding,			encoding,
	error,			error,
	manifest,			manifest,
	self._db = db			self._db = db

	def __len__(self):			def __len__(self):
	return int(			return int(
	self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0]			self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0]
	)			)

	def rev(self, n):			def rev(self, n):
	if n == nullid:			if n == sha1nodeconstants.nullid:
	return -1			return -1
	t = self._db.execute(			t = self._db.execute(
	'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),)			'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),)
	).fetchone()			).fetchone()
	if t is None:			if t is None:
	raise error.LookupError(n, b'00changelog.i', _(b'no node %d'))			raise error.LookupError(n, b'00changelog.i', _(b'no node %d'))
	return t[0]			return t[0]

	def node(self, r):			def node(self, r):
	if r == nullrev:			if r == nullrev:
	return nullid			return sha1nodeconstants.nullid
	t = self._db.execute(			t = self._db.execute(
	'SELECT node FROM changelog WHERE rev = ?', (r,)			'SELECT node FROM changelog WHERE rev = ?', (r,)
	).fetchone()			).fetchone()
	if t is None:			if t is None:
	raise error.LookupError(r, b'00changelog.i', _(b'no node'))			raise error.LookupError(r, b'00changelog.i', _(b'no node'))
	return bin(t[0])			return bin(t[0])

	def hasnode(self, n):			def hasnode(self, n):
	return baselogindex(self)			return baselogindex(self)

	@property			@property
	def nodemap(self):			def nodemap(self):
	r = {			r = {
	bin(v[0]): v[1]			bin(v[0]): v[1]
	for v in self._db.execute('SELECT node, rev FROM changelog')			for v in self._db.execute('SELECT node, rev FROM changelog')
	}			}
	r[nullid] = nullrev			r[sha1nodeconstants.nullid] = nullrev
	return r			return r

	def tip(self):			def tip(self):
	t = self._db.execute(			t = self._db.execute(
	'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1'			'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1'
	).fetchone()			).fetchone()
	if t:			if t:
	return bin(t[0])			return bin(t[0])
	return nullid			return sha1nodeconstants.nullid

	def revs(self, start=0, stop=None):			def revs(self, start=0, stop=None):
	if stop is None:			if stop is None:
	stop = self.tip()			stop = self.tip()
	t = self._db.execute(			t = self._db.execute(
	'SELECT rev FROM changelog '			'SELECT rev FROM changelog '
	'WHERE rev >= ? AND rev <= ? '			'WHERE rev >= ? AND rev <= ? '
	'ORDER BY REV ASC',			'ORDER BY REV ASC',
	(start, stop),			(start, stop),
	)			)
	return (int(r[0]) for r in t)			return (int(r[0]) for r in t)

	def tiprev(self):			def tiprev(self):
	t = self._db.execute(			t = self._db.execute(
	'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1'			'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1'
	)			)
	return next(t)			return next(t)

	def _partialmatch(self, id):			def _partialmatch(self, id):
	if wdirhex.startswith(id):			if sha1nodeconstants.wdirhex.startswith(id):
	raise error.WdirUnsupported			raise error.WdirUnsupported
	candidates = [			candidates = [
	bin(x[0])			bin(x[0])
	for x in self._db.execute(			for x in self._db.execute(
	'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',)			'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',)
	)			)
	]			]
	if nullhex.startswith(id):			if sha1nodeconstants.nullhex.startswith(id):
	candidates.append(nullid)			candidates.append(sha1nodeconstants.nullid)
	if len(candidates) > 1:			if len(candidates) > 1:
	raise error.AmbiguousPrefixLookupError(			raise error.AmbiguousPrefixLookupError(
	id, b'00changelog.i', _(b'ambiguous identifier')			id, b'00changelog.i', _(b'ambiguous identifier')
	)			)
	if candidates:			if candidates:
	return candidates[0]			return candidates[0]
	return None			return None


	def changelogrevision(self, nodeorrev):			def changelogrevision(self, nodeorrev):
	# Ensure we have a node id			# Ensure we have a node id
	if isinstance(nodeorrev, int):			if isinstance(nodeorrev, int):
	n = self.node(nodeorrev)			n = self.node(nodeorrev)
	else:			else:
	n = nodeorrev			n = nodeorrev
	# handle looking up nullid			# handle looking up nullid
	if n == nullid:			if n == sha1nodeconstants.nullid:
	return hgchangelog._changelogrevision(extra={}, manifest=nullid)			return hgchangelog._changelogrevision(
				extra={}, manifest=sha1nodeconstants.nullid
				)
	hn = gitutil.togitnode(n)			hn = gitutil.togitnode(n)
	# We've got a real commit!			# We've got a real commit!
	files = [			files = [
	r[0]			r[0]
	for r in self._db.execute(			for r in self._db.execute(
	'SELECT filename FROM changedfiles '			'SELECT filename FROM changedfiles '
	'WHERE node = ? and filenode != ?',			'WHERE node = ? and filenode != ?',
	(hn, gitutil.nullgit),			(hn, gitutil.nullgit),
	)			)
	]			]
	filesremoved = [			filesremoved = [
	r[0]			r[0]
	for r in self._db.execute(			for r in self._db.execute(
	'SELECT filename FROM changedfiles '			'SELECT filename FROM changedfiles '
	'WHERE node = ? and filenode = ?',			'WHERE node = ? and filenode = ?',
	(hn, nullhex),			(hn, sha1nodeconstants.nullhex),
	)			)
	]			]
	c = self.gitrepo[hn]			c = self.gitrepo[hn]
	return hgchangelog._changelogrevision(			return hgchangelog._changelogrevision(
	manifest=n, # pretend manifest the same as the commit node			manifest=n, # pretend manifest the same as the commit node
	user=b'%s <%s>'			user=b'%s <%s>'
	% (c.author.name.encode('utf8'), c.author.email.encode('utf8')),			% (c.author.name.encode('utf8'), c.author.email.encode('utf8')),
	date=(c.author.time, -c.author.offset * 60),			date=(c.author.time, -c.author.offset * 60),

	The list is sorted by revision number, meaning it is			The list is sorted by revision number, meaning it is
	topologically sorted.			topologically sorted.

	'heads' and 'common' are both lists of node IDs. If heads is			'heads' and 'common' are both lists of node IDs. If heads is
	not supplied, uses all of the revlog's heads. If common is not			not supplied, uses all of the revlog's heads. If common is not
	supplied, uses nullid."""			supplied, uses nullid."""
	if common is None:			if common is None:
	common = [nullid]			common = [sha1nodeconstants.nullid]
	if heads is None:			if heads is None:
	heads = self.heads()			heads = self.heads()

	common = [self.rev(n) for n in common]			common = [self.rev(n) for n in common]
	heads = [self.rev(n) for n in heads]			heads = [self.rev(n) for n in heads]

	inc = self.incrementalmissingrevs(common=common)			inc = self.incrementalmissingrevs(common=common)
	return [self.node(r) for r in inc.missingancestors(heads)]			return [self.node(r) for r in inc.missingancestors(heads)]
	extra=None,			extra=None,
	p1copies=None,			p1copies=None,
	p2copies=None,			p2copies=None,
	filesadded=None,			filesadded=None,
	filesremoved=None,			filesremoved=None,
	):			):
	parents = []			parents = []
	hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2)			hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2)
	if p1 != nullid:			if p1 != sha1nodeconstants.nullid:
	parents.append(hp1)			parents.append(hp1)
	if p2 and p2 != nullid:			if p2 and p2 != sha1nodeconstants.nullid:
	parents.append(hp2)			parents.append(hp2)
	assert date is not None			assert date is not None
	timestamp, tz = date			timestamp, tz = date
	sig = pygit2.Signature(			sig = pygit2.Signature(
	encoding.unifromlocal(stringutil.person(user)),			encoding.unifromlocal(stringutil.person(user)),
	encoding.unifromlocal(stringutil.email(user)),			encoding.unifromlocal(stringutil.email(user)),
	int(timestamp),			int(timestamp),
	-int(tz // 60),			-int(tz // 60),

	class manifestlog(baselog):			class manifestlog(baselog):
	nodeconstants = sha1nodeconstants			nodeconstants = sha1nodeconstants

	def __getitem__(self, node):			def __getitem__(self, node):
	return self.get(b'', node)			return self.get(b'', node)

	def get(self, relpath, node):			def get(self, relpath, node):
	if node == nullid:			if node == sha1nodeconstants.nullid:
	# TODO: this should almost certainly be a memgittreemanifestctx			# TODO: this should almost certainly be a memgittreemanifestctx
	return manifest.memtreemanifestctx(self, relpath)			return manifest.memtreemanifestctx(self, relpath)
	commit = self.gitrepo[gitutil.togitnode(node)]			commit = self.gitrepo[gitutil.togitnode(node)]
	t = commit.tree			t = commit.tree
	if relpath:			if relpath:
	parts = relpath.split(b'/')			parts = relpath.split(b'/')
	for p in parts:			for p in parts:
	te = t[p]			te = t[p]
	t = self.gitrepo[te.id]			t = self.gitrepo[te.id]
	return gitmanifest.gittreemanifestctx(self.gitrepo, t)			return gitmanifest.gittreemanifestctx(self.gitrepo, t)


	@interfaceutil.implementer(repository.ifilestorage)			@interfaceutil.implementer(repository.ifilestorage)
	class filelog(baselog):			class filelog(baselog):
	def __init__(self, gr, db, path):			def __init__(self, gr, db, path):
	super(filelog, self).__init__(gr, db)			super(filelog, self).__init__(gr, db)
	assert isinstance(path, bytes)			assert isinstance(path, bytes)
	self.path = path			self.path = path
				self.nullid = sha1nodeconstants.nullid

	def read(self, node):			def read(self, node):
	if node == nullid:			if node == sha1nodeconstants.nullid:
	return b''			return b''
	return self.gitrepo[gitutil.togitnode(node)].data			return self.gitrepo[gitutil.togitnode(node)].data

	def lookup(self, node):			def lookup(self, node):
	if len(node) not in (20, 40):			if len(node) not in (20, 40):
	node = int(node)			node = int(node)
	if isinstance(node, int):			if isinstance(node, int):
	assert False, b'todo revnums for nodes'			assert False, b'todo revnums for nodes'

hgext/git/gitutil.py

	"""utilities to assist in working with pygit2"""			"""utilities to assist in working with pygit2"""
	from __future__ import absolute_import			from __future__ import absolute_import

	from mercurial.node import bin, hex, nullid			from mercurial.node import bin, hex, sha1nodeconstants

	from mercurial import pycompat			from mercurial import pycompat

	pygit2_module = None			pygit2_module = None


	def get_pygit2():			def get_pygit2():
	global pygit2_module			global pygit2_module
	def fromgitnode(n):			def fromgitnode(n):
	"""Opposite of togitnode."""			"""Opposite of togitnode."""
	assert len(n) == 40			assert len(n) == 40
	if pycompat.ispy3:			if pycompat.ispy3:
	return bin(n.encode('ascii'))			return bin(n.encode('ascii'))
	return bin(n)			return bin(n)


	nullgit = togitnode(nullid)			nullgit = togitnode(sha1nodeconstants.nullid)

hgext/git/index.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import os			import os
	import sqlite3			import sqlite3

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import sha1nodeconstants
	nullhex,
	nullid,
	)

	from mercurial import (			from mercurial import (
	encoding,			encoding,
	error,			error,
	pycompat,			pycompat,
	)			)

	from . import gitutil			from . import gitutil
	if prog is not None:			if prog is not None:
	prog.complete()			prog.complete()
	prog = progress_factory(b'commits')			prog = progress_factory(b'commits')
	# This walker is sure to visit all the revisions in history, but			# This walker is sure to visit all the revisions in history, but
	# only once.			# only once.
	for pos, commit in enumerate(walker):			for pos, commit in enumerate(walker):
	if prog is not None:			if prog is not None:
	prog.update(pos)			prog.update(pos)
	p1 = p2 = nullhex			p1 = p2 = sha1nodeconstants.nullhex
	if len(commit.parents) > 2:			if len(commit.parents) > 2:
	raise error.ProgrammingError(			raise error.ProgrammingError(
	(			(
	b"git support can't handle octopus merges, "			b"git support can't handle octopus merges, "
	b"found a commit with %d parents :("			b"found a commit with %d parents :("
	)			)
	% len(commit.parents)			% len(commit.parents)
	)			)
	if p1 is not None:			if p1 is not None:
	patchgen = gitrepo.diff(p1, commit.id.hex, flags=_DIFF_FLAGS)			patchgen = gitrepo.diff(p1, commit.id.hex, flags=_DIFF_FLAGS)
	else:			else:
	patchgen = commit.tree.diff_to_tree(			patchgen = commit.tree.diff_to_tree(
	swap=True, flags=_DIFF_FLAGS			swap=True, flags=_DIFF_FLAGS
	)			)
	new_files = (p.delta.new_file for p in patchgen)			new_files = (p.delta.new_file for p in patchgen)
	files = {			files = {
	nf.path: nf.id.hex for nf in new_files if nf.id.raw != nullid			nf.path: nf.id.hex
				for nf in new_files
				if nf.id.raw != sha1nodeconstants.nullid
	}			}
	for p, n in files.items():			for p, n in files.items():
	# We intentionally set NULLs for any file parentage			# We intentionally set NULLs for any file parentage
	# information so it'll get demand-computed later. We			# information so it'll get demand-computed later. We
	# used to do it right here, and it was _very_ slow.			# used to do it right here, and it was _very_ slow.
	db.execute(			db.execute(
	'INSERT INTO changedfiles ('			'INSERT INTO changedfiles ('
	'node, filename, filenode, p1node, p1filenode, p2node, '			'node, filename, filenode, p1node, p1filenode, p2node, '

hgext/gpg.py

	# Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org>			# Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	'''commands to sign and verify changesets'''			'''commands to sign and verify changesets'''

	from __future__ import absolute_import			from __future__ import absolute_import

	import binascii			import binascii
	import os			import os

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from mercurial import (			from mercurial import (
	cmdutil,			cmdutil,
	error,			error,
	help,			help,
	match,			match,
	pycompat,			pycompat,

	date = opts.get(b'date')			date = opts.get(b'date')
	if date:			if date:
	opts[b'date'] = dateutil.parsedate(date)			opts[b'date'] = dateutil.parsedate(date)

	if revs:			if revs:
	nodes = [repo.lookup(n) for n in revs]			nodes = [repo.lookup(n) for n in revs]
	else:			else:
	nodes = [node for node in repo.dirstate.parents() if node != nullid]			nodes = [
				node for node in repo.dirstate.parents() if node != repo.nullid
				]
	if len(nodes) > 1:			if len(nodes) > 1:
	raise error.Abort(			raise error.Abort(
	_(b'uncommitted merge - please provide a specific revision')			_(b'uncommitted merge - please provide a specific revision')
	)			)
	if not nodes:			if not nodes:
	nodes = [repo.changelog.tip()]			nodes = [repo.changelog.tip()]

	for n in nodes:			for n in nodes:

hgext/hgk.py

	'''			'''

	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	nullid,
	nullrev,			nullrev,
	short,			short,
	)			)
	from mercurial import (			from mercurial import (
	commands,			commands,
	obsolete,			obsolete,
	patch,			patch,
	pycompat,			pycompat,
	def __difftree(repo, node1, node2, files=None):			def __difftree(repo, node1, node2, files=None):
	assert node2 is not None			assert node2 is not None
	if files is None:			if files is None:
	files = []			files = []
	mmap = repo[node1].manifest()			mmap = repo[node1].manifest()
	mmap2 = repo[node2].manifest()			mmap2 = repo[node2].manifest()
	m = scmutil.match(repo[node1], files)			m = scmutil.match(repo[node1], files)
	st = repo.status(node1, node2, m)			st = repo.status(node1, node2, m)
	empty = short(nullid)			empty = short(repo.nullid)

	for f in st.modified:			for f in st.modified:
	# TODO get file permissions			# TODO get file permissions
	ui.writenoi18n(			ui.writenoi18n(
	b":100664 100664 %s %s M\t%s\t%s\n"			b":100664 100664 %s %s M\t%s\t%s\n"
	% (short(mmap[f]), short(mmap2[f]), f, f)			% (short(mmap[f]), short(mmap2[f]), f, f)
	)			)
	for f in st.added:			for f in st.added:
	if i not in repo:			if i not in repo:
	continue			continue
	n = repo.changelog.node(i)			n = repo.changelog.node(i)
	mask = is_reachable(want_sha1, reachable, n)			mask = is_reachable(want_sha1, reachable, n)
	if mask:			if mask:
	parentstr = b""			parentstr = b""
	if parents:			if parents:
	pp = repo.changelog.parents(n)			pp = repo.changelog.parents(n)
	if pp[0] != nullid:			if pp[0] != repo.nullid:
	parentstr += b" " + short(pp[0])			parentstr += b" " + short(pp[0])
	if pp[1] != nullid:			if pp[1] != repo.nullid:
	parentstr += b" " + short(pp[1])			parentstr += b" " + short(pp[1])
	if not full:			if not full:
	ui.write(b"%s%s\n" % (short(n), parentstr))			ui.write(b"%s%s\n" % (short(n), parentstr))
	elif full == b"commit":			elif full == b"commit":
	ui.write(b"%s%s\n" % (short(n), parentstr))			ui.write(b"%s%s\n" % (short(n), parentstr))
	catcommit(ui, repo, n, b' ', ctx)			catcommit(ui, repo, n, b' ', ctx)
	else:			else:
	(p1, p2) = repo.changelog.parents(n)			(p1, p2) = repo.changelog.parents(n)

hgext/journal.py

	import errno			import errno
	import os			import os
	import weakref			import weakref

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	)			)

	from mercurial import (			from mercurial import (
	bookmarks,			bookmarks,
	cmdutil,			cmdutil,
	dispatch,			dispatch,
	encoding,			encoding,
	error,			error,


	def recorddirstateparents(dirstate, old, new):			def recorddirstateparents(dirstate, old, new):
	"""Records all dirstate parent changes in the journal."""			"""Records all dirstate parent changes in the journal."""
	old = list(old)			old = list(old)
	new = list(new)			new = list(new)
	if util.safehasattr(dirstate, 'journalstorage'):			if util.safehasattr(dirstate, 'journalstorage'):
	# only record two hashes if there was a merge			# only record two hashes if there was a merge
	oldhashes = old[:1] if old[1] == nullid else old			oldhashes = old[:1] if old[1] == dirstate._nodeconstants.nullid else old
	newhashes = new[:1] if new[1] == nullid else new			newhashes = new[:1] if new[1] == dirstate._nodeconstants.nullid else new
	dirstate.journalstorage.record(			dirstate.journalstorage.record(
	wdirparenttype, b'.', oldhashes, newhashes			wdirparenttype, b'.', oldhashes, newhashes
	)			)


	# hooks to record bookmark changes (both local and remote)			# hooks to record bookmark changes (both local and remote)
	def recordbookmarks(orig, store, fp):			def recordbookmarks(orig, store, fp):
	"""Records all bookmark changes in the journal."""			"""Records all bookmark changes in the journal."""
	repo = store._repo			repo = store._repo
	if util.safehasattr(repo, 'journal'):			if util.safehasattr(repo, 'journal'):
	oldmarks = bookmarks.bmstore(repo)			oldmarks = bookmarks.bmstore(repo)
	for mark, value in pycompat.iteritems(store):			for mark, value in pycompat.iteritems(store):
	oldvalue = oldmarks.get(mark, nullid)			oldvalue = oldmarks.get(mark, repo.nullid)
	if value != oldvalue:			if value != oldvalue:
	repo.journal.record(bookmarktype, mark, oldvalue, value)			repo.journal.record(bookmarktype, mark, oldvalue, value)
	return orig(store, fp)			return orig(store, fp)


	# shared repository support			# shared repository support
	def _readsharedfeatures(repo):			def _readsharedfeatures(repo):
	"""A set of shared features for this repository"""			"""A set of shared features for this repository"""

hgext/largefiles/basestore.py

	# Copyright 2009-2010 Gregory P. Ward			# Copyright 2009-2010 Gregory P. Ward
	# Copyright 2009-2010 Intelerad Medical Systems Incorporated			# Copyright 2009-2010 Intelerad Medical Systems Incorporated
	# Copyright 2010-2011 Fog Creek Software			# Copyright 2010-2011 Fog Creek Software
	# Copyright 2010-2011 Unity Technologies			# Copyright 2010-2011 Unity Technologies
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	'''base class for store implementations and store-related utility code'''			'''base class for store implementations and store-related utility code'''
	from __future__ import absolute_import			from __future__ import absolute_import

	from mercurial.i18n import _			from mercurial.i18n import _

	from mercurial import node, util			from mercurial.node import short
				from mercurial import util
	from mercurial.utils import (			from mercurial.utils import (
	urlutil,			urlutil,
	)			)

	from . import lfutil			from . import lfutil


	class StoreError(Exception):			class StoreError(Exception):

	self.ui.status(			self.ui.status(
	_(b'searching %d changesets for largefiles\n') % len(revs)			_(b'searching %d changesets for largefiles\n') % len(revs)
	)			)
	verified = set() # set of (filename, filenode) tuples			verified = set() # set of (filename, filenode) tuples
	filestocheck = [] # list of (cset, filename, expectedhash)			filestocheck = [] # list of (cset, filename, expectedhash)
	for rev in revs:			for rev in revs:
	cctx = self.repo[rev]			cctx = self.repo[rev]
	cset = b"%d:%s" % (cctx.rev(), node.short(cctx.node()))			cset = b"%d:%s" % (cctx.rev(), short(cctx.node()))

	for standin in cctx:			for standin in cctx:
	filename = lfutil.splitstandin(standin)			filename = lfutil.splitstandin(standin)
	if filename:			if filename:
	fctx = cctx[standin]			fctx = cctx[standin]
	key = (filename, fctx.filenode())			key = (filename, fctx.filenode())
	if key not in verified:			if key not in verified:
	verified.add(key)			verified.add(key)

hgext/largefiles/lfcommands.py

	import errno			import errno
	import os			import os
	import shutil			import shutil

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	)			)

	from mercurial import (			from mercurial import (
	cmdutil,			cmdutil,
	context,			context,
	error,			error,
	exthelper,			exthelper,
	hg,			hg,
	# Get a list of all changesets in the source. The easy way to do this			# Get a list of all changesets in the source. The easy way to do this
	# is to simply walk the changelog, using changelog.nodesbetween().			# is to simply walk the changelog, using changelog.nodesbetween().
	# Take a look at mercurial/revlog.py:639 for more details.			# Take a look at mercurial/revlog.py:639 for more details.
	# Use a generator instead of a list to decrease memory usage			# Use a generator instead of a list to decrease memory usage
	ctxs = (			ctxs = (
	rsrc[ctx]			rsrc[ctx]
	for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0]			for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0]
	)			)
	revmap = {nullid: nullid}			revmap = {rsrc.nullid: rdst.nullid}
	if tolfile:			if tolfile:
	# Lock destination to prevent modification while it is converted to.			# Lock destination to prevent modification while it is converted to.
	# Don't need to lock src because we are just reading from its			# Don't need to lock src because we are just reading from its
	# history which can't change.			# history which can't change.
	dstwlock = rdst.wlock()			dstwlock = rdst.wlock()
	dstlock = rdst.lock()			dstlock = rdst.lock()

	lfiles = set()			lfiles = set()
	lfutil.copyalltostore(rdst, ret)			lfutil.copyalltostore(rdst, ret)
	rdst.setparents(ret)			rdst.setparents(ret)
	revmap[ctx.node()] = rdst.changelog.tip()			revmap[ctx.node()] = rdst.changelog.tip()


	# Generate list of changed files			# Generate list of changed files
	def _getchangedfiles(ctx, parents):			def _getchangedfiles(ctx, parents):
	files = set(ctx.files())			files = set(ctx.files())
	if nullid not in parents:			if ctx.repo().nullid not in parents:
	mc = ctx.manifest()			mc = ctx.manifest()
	for pctx in ctx.parents():			for pctx in ctx.parents():
	for fn in pctx.manifest().diff(mc):			for fn in pctx.manifest().diff(mc):
	files.add(fn)			files.add(fn)
	return files			return files


	# Convert src parents to dst parents			# Convert src parents to dst parents
	def _convertparents(ctx, revmap):			def _convertparents(ctx, revmap):
	parents = []			parents = []
	for p in ctx.parents():			for p in ctx.parents():
	parents.append(revmap[p.node()])			parents.append(revmap[p.node()])
	while len(parents) < 2:			while len(parents) < 2:
	parents.append(nullid)			parents.append(ctx.repo().nullid)
	return parents			return parents


	# Get memfilectx for a normal file			# Get memfilectx for a normal file
	def _getnormalcontext(repo, ctx, f, revmap):			def _getnormalcontext(repo, ctx, f, revmap):
	try:			try:
	fctx = ctx.filectx(f)			fctx = ctx.filectx(f)
	except error.LookupError:			except error.LookupError:

hgext/largefiles/lfutil.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import contextlib			import contextlib
	import copy			import copy
	import os			import os
	import stat			import stat

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import hex
	hex,
	nullid,
	)
	from mercurial.pycompat import open			from mercurial.pycompat import open

	from mercurial import (			from mercurial import (
	dirstate,			dirstate,
	encoding,			encoding,
	error,			error,
	httpconnection,			httpconnection,
	match as matchmod,			match as matchmod,
	makeprogress = repo.ui.makeprogress			makeprogress = repo.ui.makeprogress
	with makeprogress(			with makeprogress(
	_(b'finding outgoing largefiles'),			_(b'finding outgoing largefiles'),
	unit=_(b'revisions'),			unit=_(b'revisions'),
	total=len(missing),			total=len(missing),
	) as progress:			) as progress:
	for i, n in enumerate(missing):			for i, n in enumerate(missing):
	progress.update(i)			progress.update(i)
	parents = [p for p in repo[n].parents() if p != nullid]			parents = [p for p in repo[n].parents() if p != repo.nullid]

	with lfstatus(repo, value=False):			with lfstatus(repo, value=False):
	ctx = repo[n]			ctx = repo[n]

	files = set(ctx.files())			files = set(ctx.files())
	if len(parents) == 2:			if len(parents) == 2:
	mc = ctx.manifest()			mc = ctx.manifest()
	mp1 = ctx.p1().manifest()			mp1 = ctx.p1().manifest()

hgext/lfs/wrapper.py

	# wrapper.py - methods wrapping core mercurial logic			# wrapper.py - methods wrapping core mercurial logic
	#			#
	# Copyright 2017 Facebook, Inc.			# Copyright 2017 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import hashlib			import hashlib

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import bin, hex, nullid, short			from mercurial.node import bin, hex, short
	from mercurial.pycompat import (			from mercurial.pycompat import (
	getattr,			getattr,
	setattr,			setattr,
	)			)

	from mercurial import (			from mercurial import (
	bundle2,			bundle2,
	changegroup,			changegroup,
	def _islfs(rlog, node=None, rev=None):			def _islfs(rlog, node=None, rev=None):
	if rev is None:			if rev is None:
	if node is None:			if node is None:
	# both None - likely working copy content where node is not ready			# both None - likely working copy content where node is not ready
	return False			return False
	rev = rlog.rev(node)			rev = rlog.rev(node)
	else:			else:
	node = rlog.node(rev)			node = rlog.node(rev)
	if node == nullid:			if node == rlog.nullid:
	return False			return False
	flags = rlog.flags(rev)			flags = rlog.flags(rev)
	return bool(flags & revlog.REVIDX_EXTSTORED)			return bool(flags & revlog.REVIDX_EXTSTORED)


	# Wrapping may also be applied by remotefilelog			# Wrapping may also be applied by remotefilelog
	def filelogaddrevision(			def filelogaddrevision(
	orig,			orig,

hgext/mq.py

	import os			import os
	import re			import re
	import shutil			import shutil
	import sys			import sys
	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	)			)
	from mercurial.pycompat import (			from mercurial.pycompat import (
	delattr,			delattr,
	getattr,			getattr,
	open,			open,
	)			)
	In some case where mq get himself in being the parent of a merge the			In some case where mq get himself in being the parent of a merge the
	appropriate parent may be p2.			appropriate parent may be p2.
	(eg: an in progress merge started with mq disabled)			(eg: an in progress merge started with mq disabled)

	If no parent are managed by mq, p1 is returned.			If no parent are managed by mq, p1 is returned.
	"""			"""
	if rev is None:			if rev is None:
	(p1, p2) = repo.dirstate.parents()			(p1, p2) = repo.dirstate.parents()
	if p2 == nullid:			if p2 == repo.nullid:
	return p1			return p1
	if not self.applied:			if not self.applied:
	return None			return None
	return self.applied[-1].node			return self.applied[-1].node
	p1, p2 = repo.changelog.parents(rev)			p1, p2 = repo.changelog.parents(rev)
	if p2 != nullid and p2 in [x.node for x in self.applied]:			if p2 != repo.nullid and p2 in [x.node for x in self.applied]:
	return p2			return p2
	return p1			return p1

	def mergepatch(self, repo, mergeq, series, diffopts):			def mergepatch(self, repo, mergeq, series, diffopts):
	if not self.applied:			if not self.applied:
	# each of the patches merged in will have two parents. This			# each of the patches merged in will have two parents. This
	# can confuse the qrefresh, qdiff, and strip code because it			# can confuse the qrefresh, qdiff, and strip code because it
	# needs to know which parent is actually in the patch queue.			# needs to know which parent is actually in the patch queue.
	):			):
	self.checkkeepchanges(keepchanges, force)			self.checkkeepchanges(keepchanges, force)
	diffopts = self.diffopts()			diffopts = self.diffopts()
	with repo.wlock():			with repo.wlock():
	heads = []			heads = []
	for hs in repo.branchmap().iterheads():			for hs in repo.branchmap().iterheads():
	heads.extend(hs)			heads.extend(hs)
	if not heads:			if not heads:
	heads = [nullid]			heads = [repo.nullid]
	if repo.dirstate.p1() not in heads and not exact:			if repo.dirstate.p1() not in heads and not exact:
	self.ui.status(_(b"(working directory not at a head)\n"))			self.ui.status(_(b"(working directory not at a head)\n"))

	if not self.series:			if not self.series:
	self.ui.warn(_(b'no patches in series\n'))			self.ui.warn(_(b'no patches in series\n'))
	return 0			return 0

	# Suppose our series file is: A B C and the current 'top'			# Suppose our series file is: A B C and the current 'top'
	with repo.dirstate.parentchange():			with repo.dirstate.parentchange():
	for f in a:			for f in a:
	repo.wvfs.unlinkpath(f, ignoremissing=True)			repo.wvfs.unlinkpath(f, ignoremissing=True)
	repo.dirstate.drop(f)			repo.dirstate.drop(f)
	for f in m + r:			for f in m + r:
	fctx = ctx[f]			fctx = ctx[f]
	repo.wwrite(f, fctx.data(), fctx.flags())			repo.wwrite(f, fctx.data(), fctx.flags())
	repo.dirstate.normal(f)			repo.dirstate.normal(f)
	repo.setparents(qp, nullid)			repo.setparents(qp, repo.nullid)
	for patch in reversed(self.applied[start:end]):			for patch in reversed(self.applied[start:end]):
	self.ui.status(_(b"popping %s\n") % patch.name)			self.ui.status(_(b"popping %s\n") % patch.name)
	del self.applied[start:end]			del self.applied[start:end]
	strip(self.ui, repo, [rev], update=False, backup=False)			strip(self.ui, repo, [rev], update=False, backup=False)
	for s, state in repo[b'.'].substate.items():			for s, state in repo[b'.'].substate.items():
	repo[b'.'].sub(s).get(state)			repo[b'.'].sub(s).get(state)
	if self.applied:			if self.applied:
	self.ui.write(_(b"now at: %s\n") % self.applied[-1].name)			self.ui.write(_(b"now at: %s\n") % self.applied[-1].name)

hgext/narrow/narrowbundle2.py

	# narrowbundle2.py - bundle2 extensions for narrow repository support			# narrowbundle2.py - bundle2 extensions for narrow repository support
	#			#
	# Copyright 2017 Google, Inc.			# Copyright 2017 Google, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import errno			import errno
	import struct			import struct

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import nullid
	from mercurial import (			from mercurial import (
	bundle2,			bundle2,
	changegroup,			changegroup,
	error,			error,
	exchange,			exchange,
	localrepo,			localrepo,
	narrowspec,			narrowspec,
	repair,			repair,
	):			):
	match = narrowspec.match(repo.root, include=include, exclude=exclude)			match = narrowspec.match(repo.root, include=include, exclude=exclude)
	if depth is not None:			if depth is not None:
	depth = int(depth)			depth = int(depth)
	if depth < 1:			if depth < 1:
	raise error.Abort(_(b'depth must be positive, got %d') % depth)			raise error.Abort(_(b'depth must be positive, got %d') % depth)

	heads = set(heads or repo.heads())			heads = set(heads or repo.heads())
	common = set(common or [nullid])			common = set(common or [repo.nullid])

	visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis(			visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis(
	repo, common, heads, set(), match, depth=depth			repo, common, heads, set(), match, depth=depth
	)			)

	repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes))			repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes))
	if visitnodes:			if visitnodes:
	packer = changegroup.getbundler(			packer = changegroup.getbundler(
	bundler,			bundler,
	repo,			repo,
	oldmatch,			oldmatch,
	newmatch,			newmatch,
	version,			version,
	common,			common,
	known,			known,
	):			):
	common = set(common or [nullid])			common = set(common or [repo.nullid])
	# Steps:			# Steps:
	# 1. Send kill for "$known & ::common"			# 1. Send kill for "$known & ::common"
	#			#
	# 2. Send changegroup for ::common			# 2. Send changegroup for ::common
	#			#
	# 3. Proceed.			# 3. Proceed.
	#			#
	# In the future, we can send kills for only the specific			# In the future, we can send kills for only the specific

hgext/narrow/narrowcommands.py

	# narrowcommands.py - command modifications for narrowhg extension			# narrowcommands.py - command modifications for narrowhg extension
	#			#
	# Copyright 2017 Google, Inc.			# Copyright 2017 Google, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import itertools			import itertools
	import os			import os

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from mercurial import (			from mercurial import (
	bundle2,			bundle2,
	cmdutil,			cmdutil,
	commands,			commands,
	discovery,			discovery,
	encoding,			encoding,
	if exclude:			if exclude:
	kwargs[b'excludepats'] = exclude			kwargs[b'excludepats'] = exclude
	# calculate known nodes only in ellipses cases because in non-ellipses cases			# calculate known nodes only in ellipses cases because in non-ellipses cases
	# we have all the nodes			# we have all the nodes
	if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities():			if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities():
	kwargs[b'known'] = [			kwargs[b'known'] = [
	hex(ctx.node())			hex(ctx.node())
	for ctx in repo.set(b'::%ln', pullop.common)			for ctx in repo.set(b'::%ln', pullop.common)
	if ctx.node() != nullid			if ctx.node() != repo.nullid
	]			]
	if not kwargs[b'known']:			if not kwargs[b'known']:
	# Mercurial serializes an empty list as '' and deserializes it as			# Mercurial serializes an empty list as '' and deserializes it as
	# [''], so delete it instead to avoid handling the empty string on			# [''], so delete it instead to avoid handling the empty string on
	# the server.			# the server.
	del kwargs[b'known']			del kwargs[b'known']


	overrides = {(b'devel', b'all-warnings'): False}			overrides = {(b'devel', b'all-warnings'): False}

	common = commoninc[0]			common = commoninc[0]
	with ui.uninterruptible():			with ui.uninterruptible():
	if ellipsesremote:			if ellipsesremote:
	ds = repo.dirstate			ds = repo.dirstate
	p1, p2 = ds.p1(), ds.p2()			p1, p2 = ds.p1(), ds.p2()
	with ds.parentchange():			with ds.parentchange():
	ds.setparents(nullid, nullid)			ds.setparents(repo.nullid, repo.nullid)
	if isoldellipses:			if isoldellipses:
	with wrappedextraprepare:			with wrappedextraprepare:
	exchange.pull(repo, remote, heads=common)			exchange.pull(repo, remote, heads=common)
	else:			else:
	known = []			known = []
	if ellipsesremote:			if ellipsesremote:
	known = [			known = [
	ctx.node()			ctx.node()
	for ctx in repo.set(b'::%ln', common)			for ctx in repo.set(b'::%ln', common)
	if ctx.node() != nullid			if ctx.node() != repo.nullid
	]			]
	with remote.commandexecutor() as e:			with remote.commandexecutor() as e:
	bundle = e.callcommand(			bundle = e.callcommand(
	b'narrow_widen',			b'narrow_widen',
	{			{
	b'oldincludes': oldincludes,			b'oldincludes': oldincludes,
	b'oldexcludes': oldexcludes,			b'oldexcludes': oldexcludes,
	b'newincludes': newincludes,			b'newincludes': newincludes,

hgext/phabricator.py

	import hashlib			import hashlib
	import itertools			import itertools
	import json			import json
	import mimetypes			import mimetypes
	import operator			import operator
	import re			import re
	import time			import time

	from mercurial.node import bin, nullid, short			from mercurial.node import bin, short
	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.pycompat import getattr			from mercurial.pycompat import getattr
	from mercurial.thirdparty import attr			from mercurial.thirdparty import attr
	from mercurial import (			from mercurial import (
	cmdutil,			cmdutil,
	context,			context,
	copies,			copies,
	encoding,			encoding,

	# Ignore if precursors (Phabricator and local repo) do not overlap,			# Ignore if precursors (Phabricator and local repo) do not overlap,
	# and force is not set (when commit message says nothing)			# and force is not set (when commit message says nothing)
	if not force and not phprecset:			if not force and not phprecset:
	tagname = b'D%d' % drev			tagname = b'D%d' % drev
	tags.tag(			tags.tag(
	repo,			repo,
	tagname,			tagname,
	nullid,			repo.nullid,
	message=None,			message=None,
	user=None,			user=None,
	date=None,			date=None,
	local=True,			local=True,
	)			)
	unfi.ui.warn(			unfi.ui.warn(
	_(			_(
	b'D%d: local tag removed - does not match '			b'D%d: local tag removed - does not match '
	)			)

	# Remove local tags since it's no longer necessary			# Remove local tags since it's no longer necessary
	tagname = b'D%d' % drevid			tagname = b'D%d' % drevid
	if tagname in repo.tags():			if tagname in repo.tags():
	tags.tag(			tags.tag(
	repo,			repo,
	tagname,			tagname,
	nullid,			repo.nullid,
	message=None,			message=None,
	user=None,			user=None,
	date=None,			date=None,
	local=True,			local=True,
	)			)
	elif fold:			elif fold:
	# When folding multiple commits into one review with			# When folding multiple commits into one review with
	# --fold, track even the commits that weren't amended, so			# --fold, track even the commits that weren't amended, so

hgext/remotefilelog/contentstore.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import threading			import threading

	from mercurial.node import hex, nullid			from mercurial.node import (
				hex,
				sha1nodeconstants,
				)
	from mercurial.pycompat import getattr			from mercurial.pycompat import getattr
	from mercurial import (			from mercurial import (
	mdiff,			mdiff,
	pycompat,			pycompat,
	revlog,			revlog,
	)			)
	from . import (			from . import (
	basestore,			basestore,
	"""Fetches the full text revision contents of the given name+node pair.			"""Fetches the full text revision contents of the given name+node pair.
	If the full text doesn't exist, throws a KeyError.			If the full text doesn't exist, throws a KeyError.

	Under the hood, this uses getdeltachain() across all the stores to build			Under the hood, this uses getdeltachain() across all the stores to build
	up a full chain to produce the full text.			up a full chain to produce the full text.
	"""			"""
	chain = self.getdeltachain(name, node)			chain = self.getdeltachain(name, node)

	if chain[-1][ChainIndicies.BASENODE] != nullid:			if chain[-1][ChainIndicies.BASENODE] != sha1nodeconstants.nullid:
	# If we didn't receive a full chain, throw			# If we didn't receive a full chain, throw
	raise KeyError((name, hex(node)))			raise KeyError((name, hex(node)))

	# The last entry in the chain is a full text, so we start our delta			# The last entry in the chain is a full text, so we start our delta
	# applies with that.			# applies with that.
	fulltext = chain.pop()[ChainIndicies.DATA]			fulltext = chain.pop()[ChainIndicies.DATA]

	text = fulltext			text = fulltext
	Returns an ordered list of:			Returns an ordered list of:

	[(name, node, deltabasename, deltabasenode, deltacontent),...]			[(name, node, deltabasename, deltabasenode, deltacontent),...]

	where the chain is terminated by a full text entry with a nullid			where the chain is terminated by a full text entry with a nullid
	deltabasenode.			deltabasenode.
	"""			"""
	chain = self._getpartialchain(name, node)			chain = self._getpartialchain(name, node)
	while chain[-1][ChainIndicies.BASENODE] != nullid:			while chain[-1][ChainIndicies.BASENODE] != sha1nodeconstants.nullid:
	x, x, deltabasename, deltabasenode, x = chain[-1]			x, x, deltabasename, deltabasenode, x = chain[-1]
	try:			try:
	morechain = self._getpartialchain(deltabasename, deltabasenode)			morechain = self._getpartialchain(deltabasename, deltabasenode)
	chain.extend(morechain)			chain.extend(morechain)
	except KeyError:			except KeyError:
	# If we allow incomplete chains, don't throw.			# If we allow incomplete chains, don't throw.
	if not self.allowincomplete:			if not self.allowincomplete:
	raise			raise
	copyrev = copyfrom = None			copyrev = copyfrom = None
	revision = shallowutil.createrevlogtext(content, copyfrom, copyrev)			revision = shallowutil.createrevlogtext(content, copyfrom, copyrev)
	return revision			return revision

	def getdelta(self, name, node):			def getdelta(self, name, node):
	# Since remotefilelog content stores only contain full texts, just			# Since remotefilelog content stores only contain full texts, just
	# return that.			# return that.
	revision = self.get(name, node)			revision = self.get(name, node)
	return revision, name, nullid, self.getmeta(name, node)			return (
				revision,
				name,
				sha1nodeconstants.nullid,
				self.getmeta(name, node),
				)

	def getdeltachain(self, name, node):			def getdeltachain(self, name, node):
	# Since remotefilelog content stores just contain full texts, we return			# Since remotefilelog content stores just contain full texts, we return
	# a fake delta chain that just consists of a single full text revision.			# a fake delta chain that just consists of a single full text revision.
	# The nullid in the deltabasenode slot indicates that the revision is a			# The nullid in the deltabasenode slot indicates that the revision is a
	# fulltext.			# fulltext.
	revision = self.get(name, node)			revision = self.get(name, node)
	return [(name, node, None, nullid, revision)]			return [(name, node, None, sha1nodeconstants.nullid, revision)]

	def getmeta(self, name, node):			def getmeta(self, name, node):
	self._sanitizemetacache()			self._sanitizemetacache()
	if node != self._threaddata.metacache[0]:			if node != self._threaddata.metacache[0]:
	data = self._getdata(name, node)			data = self._getdata(name, node)
	offset, size, flags = shallowutil.parsesizeflags(data)			offset, size, flags = shallowutil.parsesizeflags(data)
	self._updatemetacache(node, size, flags)			self._updatemetacache(node, size, flags)
	return self._threaddata.metacache[1]			return self._threaddata.metacache[1]
	def get(self, name, node):			def get(self, name, node):
	self._fileservice.prefetch(			self._fileservice.prefetch(
	[(name, hex(node))], force=True, fetchdata=True			[(name, hex(node))], force=True, fetchdata=True
	)			)
	return self._shared.get(name, node)			return self._shared.get(name, node)

	def getdelta(self, name, node):			def getdelta(self, name, node):
	revision = self.get(name, node)			revision = self.get(name, node)
	return revision, name, nullid, self._shared.getmeta(name, node)			return (
				revision,
				name,
				sha1nodeconstants.nullid,
				self._shared.getmeta(name, node),
				)

	def getdeltachain(self, name, node):			def getdeltachain(self, name, node):
	# Since our remote content stores just contain full texts, we return a			# Since our remote content stores just contain full texts, we return a
	# fake delta chain that just consists of a single full text revision.			# fake delta chain that just consists of a single full text revision.
	# The nullid in the deltabasenode slot indicates that the revision is a			# The nullid in the deltabasenode slot indicates that the revision is a
	# fulltext.			# fulltext.
	revision = self.get(name, node)			revision = self.get(name, node)
	return [(name, node, None, nullid, revision)]			return [(name, node, None, sha1nodeconstants.nullid, revision)]

	def getmeta(self, name, node):			def getmeta(self, name, node):
	self._fileservice.prefetch(			self._fileservice.prefetch(
	[(name, hex(node))], force=True, fetchdata=True			[(name, hex(node))], force=True, fetchdata=True
	)			)
	return self._shared.getmeta(name, node)			return self._shared.getmeta(name, node)

	def add(self, name, node, data):			def add(self, name, node, data):
	self._cl = revlog.revlog(self._svfs, b'00changelog.i')			self._cl = revlog.revlog(self._svfs, b'00changelog.i')
	self._repackstartlinkrev = 0			self._repackstartlinkrev = 0

	def get(self, name, node):			def get(self, name, node):
	return self._revlog(name).rawdata(node)			return self._revlog(name).rawdata(node)

	def getdelta(self, name, node):			def getdelta(self, name, node):
	revision = self.get(name, node)			revision = self.get(name, node)
	return revision, name, nullid, self.getmeta(name, node)			return revision, name, self._cl.nullid, self.getmeta(name, node)

	def getdeltachain(self, name, node):			def getdeltachain(self, name, node):
	revision = self.get(name, node)			revision = self.get(name, node)
	return [(name, node, None, nullid, revision)]			return [(name, node, None, self._cl.nullid, revision)]

	def getmeta(self, name, node):			def getmeta(self, name, node):
	rl = self._revlog(name)			rl = self._revlog(name)
	rev = rl.rev(node)			rev = rl.rev(node)
	return {			return {
	constants.METAKEYFLAG: rl.flags(rev),			constants.METAKEYFLAG: rl.flags(rev),
	constants.METAKEYSIZE: rl.rawsize(rev),			constants.METAKEYSIZE: rl.rawsize(rev),
	}			}

	def getancestors(self, name, node, known=None):			def getancestors(self, name, node, known=None):
	if known is None:			if known is None:
	known = set()			known = set()
	if node in known:			if node in known:
	return []			return []

	rl = self._revlog(name)			rl = self._revlog(name)
	ancestors = {}			ancestors = {}
	missing = {node}			missing = {node}
	for ancrev in rl.ancestors([rl.rev(node)], inclusive=True):			for ancrev in rl.ancestors([rl.rev(node)], inclusive=True):
	ancnode = rl.node(ancrev)			ancnode = rl.node(ancrev)
	missing.discard(ancnode)			missing.discard(ancnode)

	p1, p2 = rl.parents(ancnode)			p1, p2 = rl.parents(ancnode)
	if p1 != nullid and p1 not in known:			if p1 != self._cl.nullid and p1 not in known:
	missing.add(p1)			missing.add(p1)
	if p2 != nullid and p2 not in known:			if p2 != self._cl.nullid and p2 not in known:
	missing.add(p2)			missing.add(p2)

	linknode = self._cl.node(rl.linkrev(ancrev))			linknode = self._cl.node(rl.linkrev(ancrev))
	ancestors[rl.node(ancrev)] = (p1, p2, linknode, b'')			ancestors[rl.node(ancrev)] = (p1, p2, linknode, b'')
	if not missing:			if not missing:
	break			break
	return ancestors			return ancestors

hgext/remotefilelog/datapack.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import struct			import struct
	import zlib			import zlib

	from mercurial.node import hex, nullid			from mercurial.node import (
				hex,
				sha1nodeconstants,
				)
	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial import (			from mercurial import (
	pycompat,			pycompat,
	util,			util,
	)			)
	from . import (			from . import (
	basepack,			basepack,
	constants,			constants,
	def createindex(self, nodelocations, indexoffset):			def createindex(self, nodelocations, indexoffset):
	entries = sorted(			entries = sorted(
	(n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries)			(n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries)
	)			)

	rawindex = b''			rawindex = b''
	fmt = self.INDEXFORMAT			fmt = self.INDEXFORMAT
	for node, deltabase, offset, size in entries:			for node, deltabase, offset, size in entries:
	if deltabase == nullid:			if deltabase == sha1nodeconstants.nullid:
	deltabaselocation = FULLTEXTINDEXMARK			deltabaselocation = FULLTEXTINDEXMARK
	else:			else:
	# Instead of storing the deltabase node in the index, let's			# Instead of storing the deltabase node in the index, let's
	# store a pointer directly to the index entry for the deltabase.			# store a pointer directly to the index entry for the deltabase.
	deltabaselocation = nodelocations.get(			deltabaselocation = nodelocations.get(
	deltabase, NOBASEINDEXMARK			deltabase, NOBASEINDEXMARK
	)			)

	entry = struct.pack(fmt, node, deltabaselocation, offset, size)			entry = struct.pack(fmt, node, deltabaselocation, offset, size)
	rawindex += entry			rawindex += entry

	return rawindex			return rawindex

hgext/remotefilelog/debugcommands.py

	# debugcommands.py - debug logic for remotefilelog			# debugcommands.py - debug logic for remotefilelog
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os
	import zlib			import zlib

	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,			sha1nodeconstants,
	short,			short,
	)			)
	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.pycompat import open			from mercurial.pycompat import open
	from mercurial import (			from mercurial import (
	error,			error,
	filelog,			filelog,
	lock as lockmod,			lock as lockmod,
	queue = [firstnode]			queue = [firstnode]
	while queue:			while queue:
	node = queue.pop(0)			node = queue.pop(0)
	p1, p2, linknode, copyfrom = mapping[node]			p1, p2, linknode, copyfrom = mapping[node]
	ui.status(			ui.status(
	_(b"%s => %s %s %s %s\n")			_(b"%s => %s %s %s %s\n")
	% (short(node), short(p1), short(p2), short(linknode), copyfrom)			% (short(node), short(p1), short(p2), short(linknode), copyfrom)
	)			)
	if p1 != nullid:			if p1 != sha1nodeconstants.nullid:
	queue.append(p1)			queue.append(p1)
	if p2 != nullid:			if p2 != sha1nodeconstants.nullid:
	queue.append(p2)			queue.append(p2)


	def buildtemprevlog(repo, file):			def buildtemprevlog(repo, file):
	# get filename key			# get filename key
	filekey = hex(hashutil.sha1(file).digest())			filekey = hex(hashutil.sha1(file).digest())
	filedir = os.path.join(repo.path, b'store/data', filekey)			filedir = os.path.join(repo.path, b'store/data', filekey)

	if generaldelta:			if generaldelta:
	base = r.deltaparent(i)			base = r.deltaparent(i)
	else:			else:
	base = r.chainbase(i)			base = r.chainbase(i)
	if format == 0:			if format == 0:
	try:			try:
	pp = r.parents(node)			pp = r.parents(node)
	except Exception:			except Exception:
	pp = [nullid, nullid]			pp = [repo.nullid, repo.nullid]
	ui.write(			ui.write(
	b"% 6d % 9d % 7d % 6d % 7d %s %s %s\n"			b"% 6d % 9d % 7d % 6d % 7d %s %s %s\n"
	% (			% (
	i,			i,
	r.start(i),			r.start(i),
	r.length(i),			r.length(i),
	base,			base,
	r.linkrev(i),			r.linkrev(i),

	r = buildtemprevlog(repo, os.path.basename(file_)[:-2])			r = buildtemprevlog(repo, os.path.basename(file_)[:-2])

	ui.writenoi18n(b"digraph G {\n")			ui.writenoi18n(b"digraph G {\n")
	for i in r:			for i in r:
	node = r.node(i)			node = r.node(i)
	pp = r.parents(node)			pp = r.parents(node)
	ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))			ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))
	if pp[1] != nullid:			if pp[1] != repo.nullid:
	ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))			ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))
	ui.write(b"}\n")			ui.write(b"}\n")


	def verifyremotefilelog(ui, path, **opts):			def verifyremotefilelog(ui, path, **opts):
	decompress = opts.get('decompress')			decompress = opts.get('decompress')

	for root, dirs, files in os.walk(path):			for root, dirs, files in os.walk(path):
	for file in files:			for file in files:
	if file == b"repos":			if file == b"repos":
	continue			continue
	filepath = os.path.join(root, file)			filepath = os.path.join(root, file)
	size, firstnode, mapping = parsefileblob(filepath, decompress)			size, firstnode, mapping = parsefileblob(filepath, decompress)
	for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping):			for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping):
	if linknode == nullid:			if linknode == sha1nodeconstants.nullid:
	actualpath = os.path.relpath(root, path)			actualpath = os.path.relpath(root, path)
	key = fileserverclient.getcachekey(			key = fileserverclient.getcachekey(
	b"reponame", actualpath, file			b"reponame", actualpath, file
	)			)
	ui.status(			ui.status(
	b"%s %s\n" % (key, os.path.relpath(filepath, path))			b"%s %s\n" % (key, os.path.relpath(filepath, path))
	)			)

	- There must be no cycles			- There must be no cycles
	"""			"""
	failures = 0			failures = 0
	for node in nodes:			for node in nodes:
	seen = set()			seen = set()
	current = node			current = node
	deltabase = bases[current]			deltabase = bases[current]

	while deltabase != nullid:			while deltabase != sha1nodeconstants.nullid:
	if deltabase not in nodes:			if deltabase not in nodes:
	ui.warn(			ui.warn(
	(			(
	b"Bad entry: %s has an unknown deltabase (%s)\n"			b"Bad entry: %s has an unknown deltabase (%s)\n"
	% (short(node), short(deltabase))			% (short(node), short(deltabase))
	)			)
	)			)
	failures += 1			failures += 1
	failures += 1			failures += 1
	break			break

	current = deltabase			current = deltabase
	seen.add(current)			seen.add(current)
	deltabase = bases[current]			deltabase = bases[current]
	# Since ``node`` begins a valid chain, reset/memoize its base to nullid			# Since ``node`` begins a valid chain, reset/memoize its base to nullid
	# so we don't traverse it again.			# so we don't traverse it again.
	bases[node] = nullid			bases[node] = sha1nodeconstants.nullid
	return failures			return failures


	def dumpdeltachain(ui, deltachain, **opts):			def dumpdeltachain(ui, deltachain, **opts):
	hashformatter = hex			hashformatter = hex
	hashlen = 40			hashlen = 40

	lastfilename = None			lastfilename = None

hgext/remotefilelog/fileserverclient.py

	# fileserverclient.py - client for communicating with the cache process			# fileserverclient.py - client for communicating with the cache process
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import io			import io
	import os			import os
	import threading			import threading
	import time			import time
	import zlib			import zlib

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import bin, hex, nullid			from mercurial.node import bin, hex
	from mercurial import (			from mercurial import (
	error,			error,
	pycompat,			pycompat,
	revlog,			revlog,
	sshpeer,			sshpeer,
	util,			util,
	wireprotov1peer,			wireprotov1peer,
	)			)
	missingids = set()			missingids = set()
	if fetchdata:			if fetchdata:
	missingids.update(datastore.getmissing(idstocheck))			missingids.update(datastore.getmissing(idstocheck))
	if fetchhistory:			if fetchhistory:
	missingids.update(historystore.getmissing(idstocheck))			missingids.update(historystore.getmissing(idstocheck))

	# partition missing nodes into nullid and not-nullid so we can			# partition missing nodes into nullid and not-nullid so we can
	# warn about this filtering potentially shadowing bugs.			# warn about this filtering potentially shadowing bugs.
	nullids = len([None for unused, id in missingids if id == nullid])			nullids = len(
				[None for unused, id in missingids if id == self.repo.nullid]
				)
	if nullids:			if nullids:
	missingids = [(f, id) for f, id in missingids if id != nullid]			missingids = [
				(f, id) for f, id in missingids if id != self.repo.nullid
				]
	repo.ui.develwarn(			repo.ui.develwarn(
	(			(
	b'remotefilelog not fetching %d null revs'			b'remotefilelog not fetching %d null revs'
	b' - this is likely hiding bugs' % nullids			b' - this is likely hiding bugs' % nullids
	),			),
	config=b'remotefilelog-ext',			config=b'remotefilelog-ext',
	)			)
	if missingids:			if missingids:

hgext/remotefilelog/historypack.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import struct			import struct

	from mercurial.node import hex, nullid			from mercurial.node import (
				hex,
				sha1nodeconstants,
				)
	from mercurial import (			from mercurial import (
	pycompat,			pycompat,
	util,			util,
	)			)
	from mercurial.utils import hashutil			from mercurial.utils import hashutil
	from . import (			from . import (
	basepack,			basepack,
	constants,			constants,
	if copyfrom:			if copyfrom:
	o += len(copyfrom)			o += len(copyfrom)

	ancnode = entry[ANC_NODE]			ancnode = entry[ANC_NODE]
	if ancnode in pending:			if ancnode in pending:
	pending.remove(ancnode)			pending.remove(ancnode)
	p1node = entry[ANC_P1NODE]			p1node = entry[ANC_P1NODE]
	p2node = entry[ANC_P2NODE]			p2node = entry[ANC_P2NODE]
	if p1node != nullid and p1node not in known:			if p1node != sha1nodeconstants.nullid and p1node not in known:
	pending.add(p1node)			pending.add(p1node)
	if p2node != nullid and p2node not in known:			if p2node != sha1nodeconstants.nullid and p2node not in known:
	pending.add(p2node)			pending.add(p2node)

	yield (ancnode, p1node, p2node, entry[ANC_LINKNODE], copyfrom)			yield (ancnode, p1node, p2node, entry[ANC_LINKNODE], copyfrom)

	def _readentry(self, offset):			def _readentry(self, offset):
	data = self._data			data = self._data
	entry = struct.unpack(			entry = struct.unpack(
	PACKFORMAT, data[offset : offset + PACKENTRYLENGTH]			PACKFORMAT, data[offset : offset + PACKENTRYLENGTH]
	sectionstart = self.packfp.tell()			sectionstart = self.packfp.tell()

	# Write the file section content			# Write the file section content
	entrymap = {e[0]: e for e in entries}			entrymap = {e[0]: e for e in entries}

	def parentfunc(node):			def parentfunc(node):
	x, p1, p2, x, x, x = entrymap[node]			x, p1, p2, x, x, x = entrymap[node]
	parents = []			parents = []
	if p1 != nullid:			if p1 != sha1nodeconstants.nullid:
	parents.append(p1)			parents.append(p1)
	if p2 != nullid:			if p2 != sha1nodeconstants.nullid:
	parents.append(p2)			parents.append(p2)
	return parents			return parents

	sortednodes = list(			sortednodes = list(
	reversed(			reversed(
	shallowutil.sortnodes((e[0] for e in entries), parentfunc)			shallowutil.sortnodes((e[0] for e in entries), parentfunc)
	)			)
	)			)

hgext/remotefilelog/metadatastore.py

	from __future__ import absolute_import			from __future__ import absolute_import

	from mercurial.node import hex, nullid			from mercurial.node import (
				hex,
				sha1nodeconstants,
				)
	from . import (			from . import (
	basestore,			basestore,
	shallowutil,			shallowutil,
	)			)


	class unionmetadatastore(basestore.baseunionstore):			class unionmetadatastore(basestore.baseunionstore):
	def __init__(self, args, *kwargs):			def __init__(self, args, *kwargs):
	if (name, node) in seen:			if (name, node) in seen:
	continue			continue
	seen.add((name, node))			seen.add((name, node))
	value = ancestors.get(node)			value = ancestors.get(node)
	if not value:			if not value:
	missing.append((name, node))			missing.append((name, node))
	continue			continue
	p1, p2, linknode, copyfrom = value			p1, p2, linknode, copyfrom = value
	if p1 != nullid and p1 not in known:			if p1 != sha1nodeconstants.nullid and p1 not in known:
	queue.append((copyfrom or curname, p1))			queue.append((copyfrom or curname, p1))
	if p2 != nullid and p2 not in known:			if p2 != sha1nodeconstants.nullid and p2 not in known:
	queue.append((curname, p2))			queue.append((curname, p2))
	return missing			return missing

	missing = [(name, node)]			missing = [(name, node)]
	while missing:			while missing:
	curname, curnode = missing.pop()			curname, curnode = missing.pop()
	try:			try:
	ancestors.update(			ancestors.update(

hgext/remotefilelog/remotefilectx.py

	# remotefilectx.py - filectx/workingfilectx implementations for remotefilelog			# remotefilectx.py - filectx/workingfilectx implementations for remotefilelog
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import time			import time

	from mercurial.node import bin, hex, nullid, nullrev			from mercurial.node import bin, hex, nullrev
	from mercurial import (			from mercurial import (
	ancestor,			ancestor,
	context,			context,
	error,			error,
	phases,			phases,
	util,			util,
	)			)
	from . import shallowutil			from . import shallowutil
	path,			path,
	changeid=None,			changeid=None,
	fileid=None,			fileid=None,
	filelog=None,			filelog=None,
	changectx=None,			changectx=None,
	ancestormap=None,			ancestormap=None,
	):			):
	if fileid == nullrev:			if fileid == nullrev:
	fileid = nullid			fileid = repo.nullid
	if fileid and len(fileid) == 40:			if fileid and len(fileid) == 40:
	fileid = bin(fileid)			fileid = bin(fileid)
	super(remotefilectx, self).__init__(			super(remotefilectx, self).__init__(
	repo, path, changeid, fileid, filelog, changectx			repo, path, changeid, fileid, filelog, changectx
	)			)
	self._ancestormap = ancestormap			self._ancestormap = ancestormap

	def size(self):			def size(self):
	changeid=changeid,			changeid=changeid,
	)			)

	def linkrev(self):			def linkrev(self):
	return self._linkrev			return self._linkrev

	@propertycache			@propertycache
	def _linkrev(self):			def _linkrev(self):
	if self._filenode == nullid:			if self._filenode == self._repo.nullid:
	return nullrev			return nullrev

	ancestormap = self.ancestormap()			ancestormap = self.ancestormap()
	p1, p2, linknode, copyfrom = ancestormap[self._filenode]			p1, p2, linknode, copyfrom = ancestormap[self._filenode]
	rev = self._repo.changelog.index.get_rev(linknode)			rev = self._repo.changelog.index.get_rev(linknode)
	if rev is not None:			if rev is not None:
	return rev			return rev

	return self._ancestormap			return self._ancestormap

	def parents(self):			def parents(self):
	repo = self._repo			repo = self._repo
	ancestormap = self.ancestormap()			ancestormap = self.ancestormap()

	p1, p2, linknode, copyfrom = ancestormap[self._filenode]			p1, p2, linknode, copyfrom = ancestormap[self._filenode]
	results = []			results = []
	if p1 != nullid:			if p1 != repo.nullid:
	path = copyfrom or self._path			path = copyfrom or self._path
	flog = repo.file(path)			flog = repo.file(path)
	p1ctx = remotefilectx(			p1ctx = remotefilectx(
	repo, path, fileid=p1, filelog=flog, ancestormap=ancestormap			repo, path, fileid=p1, filelog=flog, ancestormap=ancestormap
	)			)
	p1ctx._descendantrev = self.rev()			p1ctx._descendantrev = self.rev()
	results.append(p1ctx)			results.append(p1ctx)

	if p2 != nullid:			if p2 != repo.nullid:
	path = self._path			path = self._path
	flog = repo.file(path)			flog = repo.file(path)
	p2ctx = remotefilectx(			p2ctx = remotefilectx(
	repo, path, fileid=p2, filelog=flog, ancestormap=ancestormap			repo, path, fileid=p2, filelog=flog, ancestormap=ancestormap
	)			)
	p2ctx._descendantrev = self.rev()			p2ctx._descendantrev = self.rev()
	results.append(p2ctx)			results.append(p2ctx)

	if not self._ancestormap:			if not self._ancestormap:
	path = self._path			path = self._path
	pcl = self._changectx._parents			pcl = self._changectx._parents
	renamed = self.renamed()			renamed = self.renamed()

	if renamed:			if renamed:
	p1 = renamed			p1 = renamed
	else:			else:
	p1 = (path, pcl[0]._manifest.get(path, nullid))			p1 = (path, pcl[0]._manifest.get(path, self._repo.nullid))

	p2 = (path, nullid)			p2 = (path, self._repo.nullid)
	if len(pcl) > 1:			if len(pcl) > 1:
	p2 = (path, pcl[1]._manifest.get(path, nullid))			p2 = (path, pcl[1]._manifest.get(path, self._repo.nullid))

	m = {}			m = {}
	if p1[1] != nullid:			if p1[1] != self._repo.nullid:
	p1ctx = self._repo.filectx(p1[0], fileid=p1[1])			p1ctx = self._repo.filectx(p1[0], fileid=p1[1])
	m.update(p1ctx.filelog().ancestormap(p1[1]))			m.update(p1ctx.filelog().ancestormap(p1[1]))

	if p2[1] != nullid:			if p2[1] != self._repo.nullid:
	p2ctx = self._repo.filectx(p2[0], fileid=p2[1])			p2ctx = self._repo.filectx(p2[0], fileid=p2[1])
	m.update(p2ctx.filelog().ancestormap(p2[1]))			m.update(p2ctx.filelog().ancestormap(p2[1]))

	copyfrom = b''			copyfrom = b''
	if renamed:			if renamed:
	copyfrom = renamed[0]			copyfrom = renamed[0]
	m[None] = (p1[1], p2[1], nullid, copyfrom)			m[None] = (p1[1], p2[1], self._repo.nullid, copyfrom)
	self._ancestormap = m			self._ancestormap = m

	return self._ancestormap			return self._ancestormap

hgext/remotefilelog/remotefilelog.py

	# remotefilelog.py - filelog implementation where filelog history is stored			# remotefilelog.py - filelog implementation where filelog history is stored
	# remotely			# remotely
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import os			import os

	from mercurial.node import (			from mercurial.node import bin
	bin,
	nullid,
	wdirfilenodeids,
	wdirid,
	)
	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial import (			from mercurial import (
	ancestor,			ancestor,
	error,			error,
	mdiff,			mdiff,
	pycompat,			pycompat,
	revlog,			revlog,
	util,			util,
	realp1 = bin(meta[b'copyrev'])			realp1 = bin(meta[b'copyrev'])

	data += b"%s%s%s%s%s\0" % (node, realp1, p2, linknode, copyfrom)			data += b"%s%s%s%s%s\0" % (node, realp1, p2, linknode, copyfrom)

	visited = set()			visited = set()

	pancestors = {}			pancestors = {}
	queue = []			queue = []
	if realp1 != nullid:			if realp1 != self.repo.nullid:
	p1flog = self			p1flog = self
	if copyfrom:			if copyfrom:
	p1flog = remotefilelog(self.opener, copyfrom, self.repo)			p1flog = remotefilelog(self.opener, copyfrom, self.repo)

	pancestors.update(p1flog.ancestormap(realp1))			pancestors.update(p1flog.ancestormap(realp1))
	queue.append(realp1)			queue.append(realp1)
	visited.add(realp1)			visited.add(realp1)
	if p2 != nullid:			if p2 != self.repo.nullid:
	pancestors.update(self.ancestormap(p2))			pancestors.update(self.ancestormap(p2))
	queue.append(p2)			queue.append(p2)
	visited.add(p2)			visited.add(p2)

	ancestortext = b""			ancestortext = b""

	# add the ancestors in topological order			# add the ancestors in topological order
	while queue:			while queue:
	c = queue.pop(0)			c = queue.pop(0)
	pa1, pa2, ancestorlinknode, pacopyfrom = pancestors[c]			pa1, pa2, ancestorlinknode, pacopyfrom = pancestors[c]

	pacopyfrom = pacopyfrom or b''			pacopyfrom = pacopyfrom or b''
	ancestortext += b"%s%s%s%s%s\0" % (			ancestortext += b"%s%s%s%s%s\0" % (
	c,			c,
	pa1,			pa1,
	pa2,			pa2,
	ancestorlinknode,			ancestorlinknode,
	pacopyfrom,			pacopyfrom,
	)			)

	if pa1 != nullid and pa1 not in visited:			if pa1 != self.repo.nullid and pa1 not in visited:
	queue.append(pa1)			queue.append(pa1)
	visited.add(pa1)			visited.add(pa1)
	if pa2 != nullid and pa2 not in visited:			if pa2 != self.repo.nullid and pa2 not in visited:
	queue.append(pa2)			queue.append(pa2)
	visited.add(pa2)			visited.add(pa2)

	data += ancestortext			data += ancestortext

	return data			return data

	def addrevision(			def addrevision(
	rawsize = size			rawsize = size

	def cmp(self, node, text):			def cmp(self, node, text):
	"""compare text with a given file revision			"""compare text with a given file revision

	returns True if text is different than what is stored.			returns True if text is different than what is stored.
	"""			"""

	if node == nullid:			if node == self.repo.nullid:
	return True			return True

	nodetext = self.read(node)			nodetext = self.read(node)
	return nodetext != text			return nodetext != text

	def __nonzero__(self):			def __nonzero__(self):
	return True			return True

	if isinstance(node, int):			if isinstance(node, int):
	raise error.ProgrammingError(			raise error.ProgrammingError(
	b'remotefilelog does not accept integer rev for flags'			b'remotefilelog does not accept integer rev for flags'
	)			)
	store = self.repo.contentstore			store = self.repo.contentstore
	return store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0)			return store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0)

	def parents(self, node):			def parents(self, node):
	if node == nullid:			if node == self.repo.nullid:
	return nullid, nullid			return self.repo.nullid, self.repo.nullid

	ancestormap = self.repo.metadatastore.getancestors(self.filename, node)			ancestormap = self.repo.metadatastore.getancestors(self.filename, node)
	p1, p2, linknode, copyfrom = ancestormap[node]			p1, p2, linknode, copyfrom = ancestormap[node]
	if copyfrom:			if copyfrom:
	p1 = nullid			p1 = self.repo.nullid

	return p1, p2			return p1, p2

	def parentrevs(self, rev):			def parentrevs(self, rev):
	# TODO(augie): this is a node and should be a rev, but for now			# TODO(augie): this is a node and should be a rev, but for now
	# nothing in core seems to actually break.			# nothing in core seems to actually break.
	return self.parents(rev)			return self.parents(rev)

	del nodesorder, revisiondata, assumehaveparentrevisions, deltaprevious			del nodesorder, revisiondata, assumehaveparentrevisions, deltaprevious
	del deltamode			del deltamode
	prevnode = None			prevnode = None
	for node in nodes:			for node in nodes:
	p1, p2 = self.parents(node)			p1, p2 = self.parents(node)
	if prevnode is None:			if prevnode is None:
	basenode = prevnode = p1			basenode = prevnode = p1
	if basenode == node:			if basenode == node:
	basenode = nullid			basenode = self.repo.nullid
	if basenode != nullid:			if basenode != self.repo.nullid:
	revision = None			revision = None
	delta = self.revdiff(basenode, node)			delta = self.revdiff(basenode, node)
	else:			else:
	revision = self.rawdata(node)			revision = self.rawdata(node)
	delta = None			delta = None
	yield revlog.revlogrevisiondelta(			yield revlog.revlogrevisiondelta(
	node=node,			node=node,
	p1node=p1,			p1node=p1,
	return flagutil.processflagswrite(self, text, flags)			return flagutil.processflagswrite(self, text, flags)

	def revision(self, node, raw=False):			def revision(self, node, raw=False):
	"""returns the revlog contents at this node.			"""returns the revlog contents at this node.
	this includes the meta data traditionally included in file revlogs.			this includes the meta data traditionally included in file revlogs.
	this is generally only used for bundling and communicating with vanilla			this is generally only used for bundling and communicating with vanilla
	hg clients.			hg clients.
	"""			"""
	if node == nullid:			if node == self.repo.nullid:
	return b""			return b""
	if len(node) != 20:			if len(node) != 20:
	raise error.LookupError(			raise error.LookupError(
	node, self.filename, _(b'invalid revision input')			node, self.filename, _(b'invalid revision input')
	)			)
	if node == wdirid or node in wdirfilenodeids:			if (
				node == self.repo.nodeconstants.wdirid
				or node in self.repo.nodeconstants.wdirfilenodeids
				):
	raise error.WdirUnsupported			raise error.WdirUnsupported

	store = self.repo.contentstore			store = self.repo.contentstore
	rawtext = store.get(self.filename, node)			rawtext = store.get(self.filename, node)
	if raw:			if raw:
	return rawtext			return rawtext
	flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0)			flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0)
	if flags == 0:			if flags == 0:
	pass			pass

	raise error.LookupError(id, self.filename, _(b'no node'))			raise error.LookupError(id, self.filename, _(b'no node'))

	def ancestormap(self, node):			def ancestormap(self, node):
	return self.repo.metadatastore.getancestors(self.filename, node)			return self.repo.metadatastore.getancestors(self.filename, node)

	def ancestor(self, a, b):			def ancestor(self, a, b):
	if a == nullid or b == nullid:			if a == self.repo.nullid or b == self.repo.nullid:
	return nullid			return self.repo.nullid

	revmap, parentfunc = self._buildrevgraph(a, b)			revmap, parentfunc = self._buildrevgraph(a, b)
	nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)}			nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)}

	ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b])			ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b])
	if ancs:			if ancs:
	# choose a consistent winner when there's a tie			# choose a consistent winner when there's a tie
	return min(map(nodemap.__getitem__, ancs))			return min(map(nodemap.__getitem__, ancs))
	return nullid			return self.repo.nullid

	def commonancestorsheads(self, a, b):			def commonancestorsheads(self, a, b):
	"""calculate all the heads of the common ancestors of nodes a and b"""			"""calculate all the heads of the common ancestors of nodes a and b"""

	if a == nullid or b == nullid:			if a == self.repo.nullid or b == self.repo.nullid:
	return nullid			return self.repo.nullid

	revmap, parentfunc = self._buildrevgraph(a, b)			revmap, parentfunc = self._buildrevgraph(a, b)
	nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)}			nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)}

	ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b])			ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b])
	return map(nodemap.__getitem__, ancs)			return map(nodemap.__getitem__, ancs)

	def _buildrevgraph(self, a, b):			def _buildrevgraph(self, a, b):
	"""Builds a numeric revision graph for the given two nodes.			"""Builds a numeric revision graph for the given two nodes.
	Returns a node->rev map and a rev->[revs] parent function.			Returns a node->rev map and a rev->[revs] parent function.
	"""			"""
	amap = self.ancestormap(a)			amap = self.ancestormap(a)
	bmap = self.ancestormap(b)			bmap = self.ancestormap(b)

	# Union the two maps			# Union the two maps
	parentsmap = collections.defaultdict(list)			parentsmap = collections.defaultdict(list)
	allparents = set()			allparents = set()
	for mapping in (amap, bmap):			for mapping in (amap, bmap):
	for node, pdata in pycompat.iteritems(mapping):			for node, pdata in pycompat.iteritems(mapping):
	parents = parentsmap[node]			parents = parentsmap[node]
	p1, p2, linknode, copyfrom = pdata			p1, p2, linknode, copyfrom = pdata
	# Don't follow renames (copyfrom).			# Don't follow renames (copyfrom).
	# remotefilectx.ancestor does that.			# remotefilectx.ancestor does that.
	if p1 != nullid and not copyfrom:			if p1 != self.repo.nullid and not copyfrom:
	parents.append(p1)			parents.append(p1)
	allparents.add(p1)			allparents.add(p1)
	if p2 != nullid:			if p2 != self.repo.nullid:
	parents.append(p2)			parents.append(p2)
	allparents.add(p2)			allparents.add(p2)

	# Breadth first traversal to build linkrev graph			# Breadth first traversal to build linkrev graph
	parentrevs = collections.defaultdict(list)			parentrevs = collections.defaultdict(list)
	revmap = {}			revmap = {}
	queue = collections.deque(			queue = collections.deque(
	((None, n) for n in parentsmap if n not in allparents)			((None, n) for n in parentsmap if n not in allparents)

hgext/remotefilelog/remotefilelogserver.py

	# remotefilelogserver.py - server logic for a remotefilelog server			# remotefilelogserver.py - server logic for a remotefilelog server
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import errno			import errno
	import os			import os
	import stat			import stat
	import time			import time
	import zlib			import zlib

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import bin, hex, nullid			from mercurial.node import bin, hex
	from mercurial.pycompat import open			from mercurial.pycompat import open
	from mercurial import (			from mercurial import (
	changegroup,			changegroup,
	changelog,			changelog,
	context,			context,
	error,			error,
	extensions,			extensions,
	match,			match,

	extensions.wrapfunction(wireprotoserver, b'iscmd', _iscmd)			extensions.wrapfunction(wireprotoserver, b'iscmd', _iscmd)


	def _loadfileblob(repo, cachepath, path, node):			def _loadfileblob(repo, cachepath, path, node):
	filecachepath = os.path.join(cachepath, path, hex(node))			filecachepath = os.path.join(cachepath, path, hex(node))
	if not os.path.exists(filecachepath) or os.path.getsize(filecachepath) == 0:			if not os.path.exists(filecachepath) or os.path.getsize(filecachepath) == 0:
	filectx = repo.filectx(path, fileid=node)			filectx = repo.filectx(path, fileid=node)
	if filectx.node() == nullid:			if filectx.node() == repo.nullid:
	repo.changelog = changelog.changelog(repo.svfs)			repo.changelog = changelog.changelog(repo.svfs)
	filectx = repo.filectx(path, fileid=node)			filectx = repo.filectx(path, fileid=node)

	text = createfileblob(filectx)			text = createfileblob(filectx)
	# TODO configurable compression engines			# TODO configurable compression engines
	text = zlib.compress(text)			text = zlib.compress(text)

	# everything should be user & group read/writable			# everything should be user & group read/writable
	text = f.read()			text = f.read()
	return text			return text


	def getflogheads(repo, proto, path):			def getflogheads(repo, proto, path):
	"""A server api for requesting a filelog's heads"""			"""A server api for requesting a filelog's heads"""
	flog = repo.file(path)			flog = repo.file(path)
	heads = flog.heads()			heads = flog.heads()
	return b'\n'.join((hex(head) for head in heads if head != nullid))			return b'\n'.join((hex(head) for head in heads if head != repo.nullid))


	def getfile(repo, proto, file, node):			def getfile(repo, proto, file, node):
	"""A server api for requesting a particular version of a file. Can be used			"""A server api for requesting a particular version of a file. Can be used
	in batches to request many files at once. The return protocol is:			in batches to request many files at once. The return protocol is:
	<errorcode>\0<data/errormsg> where <errorcode> is 0 for success or			<errorcode>\0<data/errormsg> where <errorcode> is 0 for success or
	non-zero for an error.			non-zero for an error.

	data is a compressed blob with revlog flag and ancestors information. See			data is a compressed blob with revlog flag and ancestors information. See
	createfileblob for its content.			createfileblob for its content.
	"""			"""
	if shallowutil.isenabled(repo):			if shallowutil.isenabled(repo):
	return b'1\0' + _(b'cannot fetch remote files from shallow repo')			return b'1\0' + _(b'cannot fetch remote files from shallow repo')
	cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")			cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")
	if not cachepath:			if not cachepath:
	cachepath = os.path.join(repo.path, b"remotefilelogcache")			cachepath = os.path.join(repo.path, b"remotefilelogcache")
	node = bin(node.strip())			node = bin(node.strip())
	if node == nullid:			if node == repo.nullid:
	return b'0\0'			return b'0\0'
	return b'0\0' + _loadfileblob(repo, cachepath, file, node)			return b'0\0' + _loadfileblob(repo, cachepath, file, node)


	def getfiles(repo, proto):			def getfiles(repo, proto):
	"""A server api for requesting particular versions of particular files."""			"""A server api for requesting particular versions of particular files."""
	if shallowutil.isenabled(repo):			if shallowutil.isenabled(repo):
	raise error.Abort(_(b'cannot fetch remote files from shallow repo'))			raise error.Abort(_(b'cannot fetch remote files from shallow repo'))
	if not isinstance(proto, _sshv1server):			if not isinstance(proto, _sshv1server):
	raise error.Abort(_(b'cannot fetch remote files over non-ssh protocol'))			raise error.Abort(_(b'cannot fetch remote files over non-ssh protocol'))

	def streamer():			def streamer():
	fin = proto._fin			fin = proto._fin

	cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")			cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")
	if not cachepath:			if not cachepath:
	cachepath = os.path.join(repo.path, b"remotefilelogcache")			cachepath = os.path.join(repo.path, b"remotefilelogcache")

	while True:			while True:
	request = fin.readline()[:-1]			request = fin.readline()[:-1]
	if not request:			if not request:
	break			break

	node = bin(request[:40])			node = bin(request[:40])
	if node == nullid:			if node == repo.nullid:
	yield b'0\n'			yield b'0\n'
	continue			continue

	path = request[40:]			path = request[40:]

	text = _loadfileblob(repo, cachepath, path, node)			text = _loadfileblob(repo, cachepath, path, node)

	yield b'%d\n%s' % (len(text), text)			yield b'%d\n%s' % (len(text), text)

	try:			try:
	repo.forcelinkrev = True			repo.forcelinkrev = True
	ancestors.extend([f for f in filectx.ancestors()])			ancestors.extend([f for f in filectx.ancestors()])

	ancestortext = b""			ancestortext = b""
	for ancestorctx in ancestors:			for ancestorctx in ancestors:
	parents = ancestorctx.parents()			parents = ancestorctx.parents()
	p1 = nullid			p1 = repo.nullid
	p2 = nullid			p2 = repo.nullid
	if len(parents) > 0:			if len(parents) > 0:
	p1 = parents[0].filenode()			p1 = parents[0].filenode()
	if len(parents) > 1:			if len(parents) > 1:
	p2 = parents[1].filenode()			p2 = parents[1].filenode()

	copyname = b""			copyname = b""
	rename = ancestorctx.renamed()			rename = ancestorctx.renamed()
	if rename:			if rename:

hgext/remotefilelog/repack.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os
	import time			import time

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import short
	nullid,
	short,
	)
	from mercurial import (			from mercurial import (
	encoding,			encoding,
	error,			error,
	lock as lockmod,			lock as lockmod,
	mdiff,			mdiff,
	policy,			policy,
	pycompat,			pycompat,
	scmutil,			scmutil,
	ui.debug(			ui.debug(
	b"%s: orphan chain: %s\n"			b"%s: orphan chain: %s\n"
	% (filename, b", ".join([short(s) for s in orphans]))			% (filename, b", ".join([short(s) for s in orphans]))
	)			)

	# Create one contiguous chain and reassign deltabases.			# Create one contiguous chain and reassign deltabases.
	for i, node in enumerate(orphans):			for i, node in enumerate(orphans):
	if i == 0:			if i == 0:
	deltabases[node] = (nullid, 0)			deltabases[node] = (self.repo.nullid, 0)
	else:			else:
	parent = orphans[i - 1]			parent = orphans[i - 1]
	deltabases[node] = (parent, deltabases[parent][1] + 1)			deltabases[node] = (parent, deltabases[parent][1] + 1)
	nodes = [n for n in nodes if n not in orphans]			nodes = [n for n in nodes if n not in orphans]
	nodes += orphans			nodes += orphans
	return nodes			return nodes

	def repackdata(self, ledger, target):			def repackdata(self, ledger, target):
	)			)
	for i, node in enumerate(orderednodes):			for i, node in enumerate(orderednodes):
	processprogress.update(i)			processprogress.update(i)
	# Find delta base			# Find delta base
	# TODO: allow delta'ing against most recent descendant instead			# TODO: allow delta'ing against most recent descendant instead
	# of immediate child			# of immediate child
	deltatuple = deltabases.get(node, None)			deltatuple = deltabases.get(node, None)
	if deltatuple is None:			if deltatuple is None:
	deltabase, chainlen = nullid, 0			deltabase, chainlen = self.repo.nullid, 0
	deltabases[node] = (nullid, 0)			deltabases[node] = (self.repo.nullid, 0)
	nobase.add(node)			nobase.add(node)
	else:			else:
	deltabase, chainlen = deltatuple			deltabase, chainlen = deltatuple
	referenced.add(deltabase)			referenced.add(deltabase)

	# Use available ancestor information to inform our delta choices			# Use available ancestor information to inform our delta choices
	ancestorinfo = ancestors.get(node)			ancestorinfo = ancestors.get(node)
	if ancestorinfo:			if ancestorinfo:
	p1, p2, linknode, copyfrom = ancestorinfo			p1, p2, linknode, copyfrom = ancestorinfo

	# The presence of copyfrom means we're at a point where the			# The presence of copyfrom means we're at a point where the
	# file was copied from elsewhere. So don't attempt to do any			# file was copied from elsewhere. So don't attempt to do any
	# deltas with the other file.			# deltas with the other file.
	if copyfrom:			if copyfrom:
	p1 = nullid			p1 = self.repo.nullid

	if chainlen < maxchainlen:			if chainlen < maxchainlen:
	# Record this child as the delta base for its parents.			# Record this child as the delta base for its parents.
	# This may be non optimal, since the parents may have			# This may be non optimal, since the parents may have
	# many children, and this will only choose the last one.			# many children, and this will only choose the last one.
	# TODO: record all children and try all deltas to find			# TODO: record all children and try all deltas to find
	# best			# best
	if p1 != nullid:			if p1 != self.repo.nullid:
	deltabases[p1] = (node, chainlen + 1)			deltabases[p1] = (node, chainlen + 1)
	if p2 != nullid:			if p2 != self.repo.nullid:
	deltabases[p2] = (node, chainlen + 1)			deltabases[p2] = (node, chainlen + 1)

	# experimental config: repack.chainorphansbysize			# experimental config: repack.chainorphansbysize
	if ui.configbool(b'repack', b'chainorphansbysize'):			if ui.configbool(b'repack', b'chainorphansbysize'):
	orphans = nobase - referenced			orphans = nobase - referenced
	orderednodes = self._chainorphans(			orderednodes = self._chainorphans(
	ui, filename, orderednodes, orphans, deltabases			ui, filename, orderednodes, orphans, deltabases
	)			)

	# Compute deltas and write to the pack			# Compute deltas and write to the pack
	for i, node in enumerate(orderednodes):			for i, node in enumerate(orderednodes):
	deltabase, chainlen = deltabases[node]			deltabase, chainlen = deltabases[node]
	# Compute delta			# Compute delta
	# TODO: Optimize the deltachain fetching. Since we're			# TODO: Optimize the deltachain fetching. Since we're
	# iterating over the different version of the file, we may			# iterating over the different version of the file, we may
	# be fetching the same deltachain over and over again.			# be fetching the same deltachain over and over again.
	if deltabase != nullid:			if deltabase != self.repo.nullid:
	deltaentry = self.data.getdelta(filename, node)			deltaentry = self.data.getdelta(filename, node)
	delta, deltabasename, origdeltabase, meta = deltaentry			delta, deltabasename, origdeltabase, meta = deltaentry
	size = meta.get(constants.METAKEYSIZE)			size = meta.get(constants.METAKEYSIZE)
	if (			if (
	deltabasename != filename			deltabasename != filename
	or origdeltabase != deltabase			or origdeltabase != deltabase
	or size is None			or size is None
	):			):
	# Usually this happens if the file was copied to another file,			# Usually this happens if the file was copied to another file,
	# then the copy was deleted, then reintroduced without copy			# then the copy was deleted, then reintroduced without copy
	# metadata. The original add and the new add have the same hash			# metadata. The original add and the new add have the same hash
	# since the content is identical and the parents are null.			# since the content is identical and the parents are null.
	if node in dontprocess and node not in entries:			if node in dontprocess and node not in entries:
	# If copyfrom == filename, it means the copy history			# If copyfrom == filename, it means the copy history
	# went to come other file, then came back to this one, so we			# went to come other file, then came back to this one, so we
	# should continue processing it.			# should continue processing it.
	if p1 != nullid and copyfrom != filename:			if p1 != self.repo.nullid and copyfrom != filename:
	dontprocess.add(p1)			dontprocess.add(p1)
	if p2 != nullid:			if p2 != self.repo.nullid:
	dontprocess.add(p2)			dontprocess.add(p2)
	continue			continue

	if copyfrom:			if copyfrom:
	dontprocess.add(p1)			dontprocess.add(p1)

	target.add(filename, node, p1, p2, linknode, copyfrom)			target.add(filename, node, p1, p2, linknode, copyfrom)

	if node in entries:			if node in entries:
	entries[node].historyrepacked = True			entries[node].historyrepacked = True

	progress.increment()			progress.increment()

	progress.complete()			progress.complete()
	target.close(ledger=ledger)			target.close(ledger=ledger)

	def _toposort(self, ancestors):			def _toposort(self, ancestors):
	def parentfunc(node):			def parentfunc(node):
	p1, p2, linknode, copyfrom = ancestors[node]			p1, p2, linknode, copyfrom = ancestors[node]
	parents = []			parents = []
	if p1 != nullid:			if p1 != self.repo.nullid:
	parents.append(p1)			parents.append(p1)
	if p2 != nullid:			if p2 != self.repo.nullid:
	parents.append(p2)			parents.append(p2)
	return parents			return parents

	sortednodes = shallowutil.sortnodes(ancestors.keys(), parentfunc)			sortednodes = shallowutil.sortnodes(ancestors.keys(), parentfunc)
	return sortednodes			return sortednodes


	class repackledger(object):			class repackledger(object):

hgext/remotefilelog/shallowbundle.py

	# shallowbundle.py - bundle10 implementation for use with shallow repositories			# shallowbundle.py - bundle10 implementation for use with shallow repositories
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import bin, hex, nullid			from mercurial.node import bin, hex
	from mercurial import (			from mercurial import (
	bundlerepo,			bundlerepo,
	changegroup,			changegroup,
	error,			error,
	match,			match,
	mdiff,			mdiff,
	pycompat,			pycompat,
	)			)
	for fnode in missing:			for fnode in missing:
	fctx = repo.filectx(rlog.filename, fileid=fnode)			fctx = repo.filectx(rlog.filename, fileid=fnode)
	if fctx.linkrev() not in commonrevs:			if fctx.linkrev() not in commonrevs:
	results.append(fnode)			results.append(fnode)
	return results			return results

	def nodechunk(self, revlog, node, prevnode, linknode):			def nodechunk(self, revlog, node, prevnode, linknode):
	prefix = b''			prefix = b''
	if prevnode == nullid:			if prevnode == revlog.nullid:
	delta = revlog.rawdata(node)			delta = revlog.rawdata(node)
	prefix = mdiff.trivialdiffheader(len(delta))			prefix = mdiff.trivialdiffheader(len(delta))
	else:			else:
	# Actually uses remotefilelog.revdiff which works on nodes, not revs			# Actually uses remotefilelog.revdiff which works on nodes, not revs
	delta = revlog.revdiff(prevnode, node)			delta = revlog.revdiff(prevnode, node)
	p1, p2 = revlog.parents(node)			p1, p2 = revlog.parents(node)
	flags = revlog.flags(node)			flags = revlog.flags(node)
	meta = self.builddeltaheader(node, p1, p2, prevnode, linknode, flags)			meta = self.builddeltaheader(node, p1, p2, prevnode, linknode, flags)
	visited.add(f)			visited.add(f)

	if chain is None:			if chain is None:
	raise error.Abort(_(b"received file revlog group is empty"))			raise error.Abort(_(b"received file revlog group is empty"))

	processed = set()			processed = set()

	def available(f, node, depf, depnode):			def available(f, node, depf, depnode):
	if depnode != nullid and (depf, depnode) not in processed:			if depnode != repo.nullid and (depf, depnode) not in processed:
	if not (depf, depnode) in revisiondatas:			if not (depf, depnode) in revisiondatas:
	# It's not in the changegroup, assume it's already			# It's not in the changegroup, assume it's already
	# in the repo			# in the repo
	return True			return True
	# re-add self to queue			# re-add self to queue
	queue.insert(0, (f, node))			queue.insert(0, (f, node))
	# add dependency in front			# add dependency in front
	queue.insert(0, (depf, depnode))			queue.insert(0, (depf, depnode))
	return False			return False
	return True			return True

	skipcount = 0			skipcount = 0

	# Prefetch the non-bundled revisions that we will need			# Prefetch the non-bundled revisions that we will need
	prefetchfiles = []			prefetchfiles = []
	for f, node in queue:			for f, node in queue:
	revisiondata = revisiondatas[(f, node)]			revisiondata = revisiondatas[(f, node)]
	# revisiondata: (node, p1, p2, cs, deltabase, delta, flags)			# revisiondata: (node, p1, p2, cs, deltabase, delta, flags)
	dependents = [revisiondata[1], revisiondata[2], revisiondata[4]]			dependents = [revisiondata[1], revisiondata[2], revisiondata[4]]

	for dependent in dependents:			for dependent in dependents:
	if dependent == nullid or (f, dependent) in revisiondatas:			if dependent == repo.nullid or (f, dependent) in revisiondatas:
	continue			continue
	prefetchfiles.append((f, hex(dependent)))			prefetchfiles.append((f, hex(dependent)))

	repo.fileservice.prefetch(prefetchfiles)			repo.fileservice.prefetch(prefetchfiles)

	# Apply the revisions in topological order such that a revision			# Apply the revisions in topological order such that a revision
	# is only written once it's deltabase and parents have been written.			# is only written once it's deltabase and parents have been written.
	while queue:			while queue:
	meta, text = shallowutil.parsemeta(text)			meta, text = shallowutil.parsemeta(text)
	if b'copy' in meta:			if b'copy' in meta:
	copyfrom = meta[b'copy']			copyfrom = meta[b'copy']
	copynode = bin(meta[b'copyrev'])			copynode = bin(meta[b'copyrev'])
	if not available(f, node, copyfrom, copynode):			if not available(f, node, copyfrom, copynode):
	continue			continue

	for p in [p1, p2]:			for p in [p1, p2]:
	if p != nullid:			if p != repo.nullid:
	if not available(f, node, f, p):			if not available(f, node, f, p):
	continue			continue

	fl.add(text, meta, trp, linknode, p1, p2)			fl.add(text, meta, trp, linknode, p1, p2)
	processed.add((f, node))			processed.add((f, node))
	skipcount = 0			skipcount = 0

	progress.complete()			progress.complete()

	return len(revisiondatas), newfiles			return len(revisiondatas), newfiles

hgext/remotefilelog/shallowrepo.py

	# shallowrepo.py - shallow repository that uses remote filelogs			# shallowrepo.py - shallow repository that uses remote filelogs
	#			#
	# Copyright 2013 Facebook, Inc.			# Copyright 2013 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import hex, nullid, nullrev			from mercurial.node import hex, nullrev
	from mercurial import (			from mercurial import (
	encoding,			encoding,
	error,			error,
	localrepo,			localrepo,
	match,			match,
	pycompat,			pycompat,
	scmutil,			scmutil,
	sparse,			sparse,
	# some contexts already have manifest nodes, they don't need any			# some contexts already have manifest nodes, they don't need any
	# prefetching (for example if we're just editing a commit message			# prefetching (for example if we're just editing a commit message
	# we can reuse manifest			# we can reuse manifest
	if not ctx.manifestnode():			if not ctx.manifestnode():
	# prefetch files that will likely be compared			# prefetch files that will likely be compared
	m1 = ctx.p1().manifest()			m1 = ctx.p1().manifest()
	files = []			files = []
	for f in ctx.modified() + ctx.added():			for f in ctx.modified() + ctx.added():
	fparent1 = m1.get(f, nullid)			fparent1 = m1.get(f, self.nullid)
	if fparent1 != nullid:			if fparent1 != self.nullid:
	files.append((f, hex(fparent1)))			files.append((f, hex(fparent1)))
	self.fileservice.prefetch(files)			self.fileservice.prefetch(files)
	return super(shallowrepository, self).commitctx(			return super(shallowrepository, self).commitctx(
	ctx, error=error, origctx=origctx			ctx, error=error, origctx=origctx
	)			)

	def backgroundprefetch(			def backgroundprefetch(
	self, revs, base=None, repack=False, pats=None, opts=None			self, revs, base=None, repack=False, pats=None, opts=None

hgext/sqlitestore.py


	import sqlite3			import sqlite3
	import struct			import struct
	import threading			import threading
	import zlib			import zlib

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	nullid,
	nullrev,			nullrev,
	sha1nodeconstants,			sha1nodeconstants,
	short,			short,
	)			)
	from mercurial.thirdparty import attr			from mercurial.thirdparty import attr
	from mercurial import (			from mercurial import (
	ancestor,			ancestor,
	dagop,			dagop,
	rid, rev, node, p1rev, p2rev, linkrev, flags = row			rid, rev, node, p1rev, p2rev, linkrev, flags = row

	if i != rev:			if i != rev:
	raise SQLiteStoreError(			raise SQLiteStoreError(
	_(b'sqlite database has inconsistent revision numbers')			_(b'sqlite database has inconsistent revision numbers')
	)			)

	if p1rev == nullrev:			if p1rev == nullrev:
	p1node = nullid			p1node = sha1nodeconstants.nullid
	else:			else:
	p1node = self._revtonode[p1rev]			p1node = self._revtonode[p1rev]

	if p2rev == nullrev:			if p2rev == nullrev:
	p2node = nullid			p2node = sha1nodeconstants.nullid
	else:			else:
	p2node = self._revtonode[p2rev]			p2node = self._revtonode[p2rev]

	entry = revisionentry(			entry = revisionentry(
	rid=rid,			rid=rid,
	rev=rev,			rev=rev,
	node=node,			node=node,
	p1rev=p1rev,			p1rev=p1rev,

	def __len__(self):			def __len__(self):
	return len(self._revisions)			return len(self._revisions)

	def __iter__(self):			def __iter__(self):
	return iter(pycompat.xrange(len(self._revisions)))			return iter(pycompat.xrange(len(self._revisions)))

	def hasnode(self, node):			def hasnode(self, node):
	if node == nullid:			if node == sha1nodeconstants.nullid:
	return False			return False

	return node in self._nodetorev			return node in self._nodetorev

	def revs(self, start=0, stop=None):			def revs(self, start=0, stop=None):
	return storageutil.iterrevs(			return storageutil.iterrevs(
	len(self._revisions), start=start, stop=stop			len(self._revisions), start=start, stop=stop
	)			)

	def parents(self, node):			def parents(self, node):
	if node == nullid:			if node == sha1nodeconstants.nullid:
	return nullid, nullid			return sha1nodeconstants.nullid, sha1nodeconstants.nullid

	if node not in self._revisions:			if node not in self._revisions:
	raise error.LookupError(node, self._path, _(b'no node'))			raise error.LookupError(node, self._path, _(b'no node'))

	entry = self._revisions[node]			entry = self._revisions[node]
	return entry.p1node, entry.p2node			return entry.p1node, entry.p2node

	def parentrevs(self, rev):			def parentrevs(self, rev):
	if rev == nullrev:			if rev == nullrev:
	return nullrev, nullrev			return nullrev, nullrev

	if rev not in self._revtonode:			if rev not in self._revtonode:
	raise IndexError(rev)			raise IndexError(rev)

	entry = self._revisions[self._revtonode[rev]]			entry = self._revisions[self._revtonode[rev]]
	return entry.p1rev, entry.p2rev			return entry.p1rev, entry.p2rev

	def rev(self, node):			def rev(self, node):
	if node == nullid:			if node == sha1nodeconstants.nullid:
	return nullrev			return nullrev

	if node not in self._nodetorev:			if node not in self._nodetorev:
	raise error.LookupError(node, self._path, _(b'no node'))			raise error.LookupError(node, self._path, _(b'no node'))

	return self._nodetorev[node]			return self._nodetorev[node]

	def node(self, rev):			def node(self, rev):
	if rev == nullrev:			if rev == nullrev:
	return nullid			return sha1nodeconstants.nullid

	if rev not in self._revtonode:			if rev not in self._revtonode:
	raise IndexError(rev)			raise IndexError(rev)

	return self._revtonode[rev]			return self._revtonode[rev]

	def lookup(self, node):			def lookup(self, node):
	return storageutil.fileidlookup(self, node, self._path)			return storageutil.fileidlookup(self, node, self._path)
	def descendants(self, revs):			def descendants(self, revs):
	# TODO we could implement this using a recursive SQL query, which			# TODO we could implement this using a recursive SQL query, which
	# might be faster.			# might be faster.
	return dagop.descendantrevs(revs, self.revs, self.parentrevs)			return dagop.descendantrevs(revs, self.revs, self.parentrevs)

	def heads(self, start=None, stop=None):			def heads(self, start=None, stop=None):
	if start is None and stop is None:			if start is None and stop is None:
	if not len(self):			if not len(self):
	return [nullid]			return [sha1nodeconstants.nullid]

	startrev = self.rev(start) if start is not None else nullrev			startrev = self.rev(start) if start is not None else nullrev
	stoprevs = {self.rev(n) for n in stop or []}			stoprevs = {self.rev(n) for n in stop or []}

	revs = dagop.headrevssubset(			revs = dagop.headrevssubset(
	self.revs, self.parentrevs, startrev=startrev, stoprevs=stoprevs			self.revs, self.parentrevs, startrev=startrev, stoprevs=stoprevs
	)			)

	node = self._revtonode[rev]			node = self._revtonode[rev]

	if self.renamed(node):			if self.renamed(node):
	return len(self.read(node))			return len(self.read(node))

	return len(self.revision(node))			return len(self.revision(node))

	def revision(self, node, raw=False, _verifyhash=True):			def revision(self, node, raw=False, _verifyhash=True):
	if node in (nullid, nullrev):			if node in (sha1nodeconstants.nullid, nullrev):
	return b''			return b''

	if isinstance(node, int):			if isinstance(node, int):
	node = self.node(node)			node = self.node(node)

	if node not in self._nodetorev:			if node not in self._nodetorev:
	raise error.LookupError(node, self._path, _(b'no node'))			raise error.LookupError(node, self._path, _(b'no node'))

	deltamode=repository.CG_DELTAMODE_STD,			deltamode=repository.CG_DELTAMODE_STD,
	sidedata_helpers=None,			sidedata_helpers=None,
	):			):
	if nodesorder not in (b'nodes', b'storage', b'linear', None):			if nodesorder not in (b'nodes', b'storage', b'linear', None):
	raise error.ProgrammingError(			raise error.ProgrammingError(
	b'unhandled value for nodesorder: %s' % nodesorder			b'unhandled value for nodesorder: %s' % nodesorder
	)			)

	nodes = [n for n in nodes if n != nullid]			nodes = [n for n in nodes if n != sha1nodeconstants.nullid]

	if not nodes:			if not nodes:
	return			return

	# TODO perform in a single query.			# TODO perform in a single query.
	res = self._db.execute(			res = self._db.execute(
	'SELECT revnum, deltaid FROM fileindex '			'SELECT revnum, deltaid FROM fileindex '
	'WHERE pathid=? '			'WHERE pathid=? '

	if wireflags & repository.REVISION_FLAG_CENSORED:			if wireflags & repository.REVISION_FLAG_CENSORED:
	storeflags \|= FLAG_CENSORED			storeflags \|= FLAG_CENSORED

	if wireflags & ~repository.REVISION_FLAG_CENSORED:			if wireflags & ~repository.REVISION_FLAG_CENSORED:
	raise SQLiteStoreError(b'unhandled revision flag')			raise SQLiteStoreError(b'unhandled revision flag')

	if maybemissingparents:			if maybemissingparents:
	if p1 != nullid and not self.hasnode(p1):			if p1 != sha1nodeconstants.nullid and not self.hasnode(p1):
	p1 = nullid			p1 = sha1nodeconstants.nullid
	storeflags \|= FLAG_MISSING_P1			storeflags \|= FLAG_MISSING_P1

	if p2 != nullid and not self.hasnode(p2):			if p2 != sha1nodeconstants.nullid and not self.hasnode(p2):
	p2 = nullid			p2 = sha1nodeconstants.nullid
	storeflags \|= FLAG_MISSING_P2			storeflags \|= FLAG_MISSING_P2

	baserev = self.rev(deltabase)			baserev = self.rev(deltabase)

	# If base is censored, delta must be full replacement in a single			# If base is censored, delta must be full replacement in a single
	# patch operation.			# patch operation.
	if baserev != nullrev and self.iscensored(baserev):			if baserev != nullrev and self.iscensored(baserev):
	hlen = struct.calcsize(b'>lll')			hlen = struct.calcsize(b'>lll')
	storeflags \|= FLAG_CENSORED			storeflags \|= FLAG_CENSORED

	linkrev = linkmapper(linknode)			linkrev = linkmapper(linknode)

	if node in self._revisions:			if node in self._revisions:
	# Possibly reset parents to make them proper.			# Possibly reset parents to make them proper.
	entry = self._revisions[node]			entry = self._revisions[node]

	if entry.flags & FLAG_MISSING_P1 and p1 != nullid:			if (
				entry.flags & FLAG_MISSING_P1
				and p1 != sha1nodeconstants.nullid
				):
	entry.p1node = p1			entry.p1node = p1
	entry.p1rev = self._nodetorev[p1]			entry.p1rev = self._nodetorev[p1]
	entry.flags &= ~FLAG_MISSING_P1			entry.flags &= ~FLAG_MISSING_P1

	self._db.execute(			self._db.execute(
	'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?',			'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?',
	(self._nodetorev[p1], entry.flags, entry.rid),			(self._nodetorev[p1], entry.flags, entry.rid),
	)			)

	if entry.flags & FLAG_MISSING_P2 and p2 != nullid:			if (
				entry.flags & FLAG_MISSING_P2
				and p2 != sha1nodeconstants.nullid
				):
	entry.p2node = p2			entry.p2node = p2
	entry.p2rev = self._nodetorev[p2]			entry.p2rev = self._nodetorev[p2]
	entry.flags &= ~FLAG_MISSING_P2			entry.flags &= ~FLAG_MISSING_P2

	self._db.execute(			self._db.execute(
	'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?',			'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?',
	(self._nodetorev[p1], entry.flags, entry.rid),			(self._nodetorev[p1], entry.flags, entry.rid),
	)			)

	if duplicaterevisioncb:			if duplicaterevisioncb:
	duplicaterevisioncb(self, self.rev(node))			duplicaterevisioncb(self, self.rev(node))
	empty = False			empty = False
	continue			continue

	if deltabase == nullid:			if deltabase == sha1nodeconstants.nullid:
	text = mdiff.patch(b'', delta)			text = mdiff.patch(b'', delta)
	storedelta = None			storedelta = None
	else:			else:
	text = None			text = None
	storedelta = (deltabase, delta)			storedelta = (deltabase, delta)

	rev = self._addrawrevision(			rev = self._addrawrevision(
	node,			node,

	if isinstance(deltabase, int):			if isinstance(deltabase, int):
	deltabase = self.node(deltabase)			deltabase = self.node(deltabase)

	else:			else:
	assert revisiondata is not None			assert revisiondata is not None
	deltabase = p1			deltabase = p1

	if deltabase == nullid:			if deltabase == sha1nodeconstants.nullid:
	delta = revisiondata			delta = revisiondata
	else:			else:
	delta = mdiff.textdiff(			delta = mdiff.textdiff(
	self.revision(self.rev(deltabase)), revisiondata			self.revision(self.rev(deltabase)), revisiondata
	)			)

	# File index stores a pointer to its delta and the parent delta.			# File index stores a pointer to its delta and the parent delta.
	# The parent delta is stored via a pointer to the fileindex PK.			# The parent delta is stored via a pointer to the fileindex PK.
	if deltabase == nullid:			if deltabase == sha1nodeconstants.nullid:
	baseid = None			baseid = None
	else:			else:
	baseid = self._revisions[deltabase].rid			baseid = self._revisions[deltabase].rid

	# Deltas are stored with a hash of their content. This allows			# Deltas are stored with a hash of their content. This allows
	# us to de-duplicate. The table is configured to ignore conflicts			# us to de-duplicate. The table is configured to ignore conflicts
	# and it is faster to just insert and silently noop than to look			# and it is faster to just insert and silently noop than to look
	# first.			# first.
	if len(deltablob) >= len(delta):			if len(deltablob) >= len(delta):
	deltablob = delta			deltablob = delta
	compression = COMPRESSION_NONE			compression = COMPRESSION_NONE

	deltaid = insertdelta(self._db, compression, deltahash, deltablob)			deltaid = insertdelta(self._db, compression, deltahash, deltablob)

	rev = len(self)			rev = len(self)

	if p1 == nullid:			if p1 == sha1nodeconstants.nullid:
	p1rev = nullrev			p1rev = nullrev
	else:			else:
	p1rev = self._nodetorev[p1]			p1rev = self._nodetorev[p1]

	if p2 == nullid:			if p2 == sha1nodeconstants.nullid:
	p2rev = nullrev			p2rev = nullrev
	else:			else:
	p2rev = self._nodetorev[p2]			p2rev = self._nodetorev[p2]

	rid = self._db.execute(			rid = self._db.execute(
	'INSERT INTO fileindex ('			'INSERT INTO fileindex ('
	' pathid, revnum, node, p1rev, p2rev, linkrev, flags, '			' pathid, revnum, node, p1rev, p2rev, linkrev, flags, '
	' deltaid, deltabaseid) '			' deltaid, deltabaseid) '

hgext/transplant.py


	import os			import os

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.pycompat import open			from mercurial.pycompat import open
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from mercurial import (			from mercurial import (
	bundlerepo,			bundlerepo,
	cmdutil,			cmdutil,
	error,			error,
	exchange,			exchange,
	hg,			hg,
	if list:			if list:
	del list[list.index(transplant)]			del list[list.index(transplant)]
	self.dirty = True			self.dirty = True


	class transplanter(object):			class transplanter(object):
	def __init__(self, ui, repo, opts):			def __init__(self, ui, repo, opts):
	self.ui = ui			self.ui = ui
				self.repo = repo
	self.path = repo.vfs.join(b'transplant')			self.path = repo.vfs.join(b'transplant')
	self.opener = vfsmod.vfs(self.path)			self.opener = vfsmod.vfs(self.path)
	self.transplants = transplants(			self.transplants = transplants(
	self.path, b'transplants', opener=self.opener			self.path, b'transplants', opener=self.opener
	)			)

	def getcommiteditor():			def getcommiteditor():
	editform = cmdutil.mergeeditform(repo[None], b'transplant')			editform = cmdutil.mergeeditform(repo[None], b'transplant')
	# pulling all the merge revs at once would mean we			# pulling all the merge revs at once would mean we
	# couldn't transplant after the latest even if			# couldn't transplant after the latest even if
	# transplants before them fail.			# transplants before them fail.
	domerge = True			domerge = True
	if not hasnode(repo, node):			if not hasnode(repo, node):
	exchange.pull(repo, source.peer(), heads=[node])			exchange.pull(repo, source.peer(), heads=[node])

	skipmerge = False			skipmerge = False
	if parents[1] != nullid:			if parents[1] != repo.nullid:
	if not opts.get(b'parent'):			if not opts.get(b'parent'):
	self.ui.note(			self.ui.note(
	_(b'skipping merge changeset %d:%s\n')			_(b'skipping merge changeset %d:%s\n')
	% (rev, short(node))			% (rev, short(node))
	)			)
	skipmerge = True			skipmerge = True
	else:			else:
	parent = source.lookup(opts[b'parent'])			parent = source.lookup(opts[b'parent'])
	series.write(b'# Merges\n')			series.write(b'# Merges\n')
	for m in merges:			for m in merges:
	series.write(hex(m) + b'\n')			series.write(hex(m) + b'\n')
	series.close()			series.close()

	def parselog(self, fp):			def parselog(self, fp):
	parents = []			parents = []
	message = []			message = []
	node = nullid			node = self.repo.nullid
	inmsg = False			inmsg = False
	user = None			user = None
	date = None			date = None
	for line in fp.read().splitlines():			for line in fp.read().splitlines():
	if inmsg:			if inmsg:
	message.append(line)			message.append(line)
	elif line.startswith(b'# User '):			elif line.startswith(b'# User '):
	user = line[7:]			user = line[7:]
	absdst = os.path.join(self.path, b'journal')			absdst = os.path.join(self.path, b'journal')
	if os.path.exists(absdst):			if os.path.exists(absdst):
	os.unlink(absdst)			os.unlink(absdst)

	def transplantfilter(self, repo, source, root):			def transplantfilter(self, repo, source, root):
	def matchfn(node):			def matchfn(node):
	if self.applied(repo, node, root):			if self.applied(repo, node, root):
	return False			return False
	if source.changelog.parents(node)[1] != nullid:			if source.changelog.parents(node)[1] != repo.nullid:
	return False			return False
	extra = source.changelog.read(node)[5]			extra = source.changelog.read(node)[5]
	cnode = extra.get(b'transplant_source')			cnode = extra.get(b'transplant_source')
	if cnode and self.applied(repo, cnode, root):			if cnode and self.applied(repo, cnode, root):
	return False			return False
	return True			return True

	return matchfn			return matchfn
	opts[b'log'] = ui.config(b'transplant', b'log')			opts[b'log'] = ui.config(b'transplant', b'log')
	if not opts.get(b'filter'):			if not opts.get(b'filter'):
	# deprecated config: transplant.filter			# deprecated config: transplant.filter
	opts[b'filter'] = ui.config(b'transplant', b'filter')			opts[b'filter'] = ui.config(b'transplant', b'filter')

	tp = transplanter(ui, repo, opts)			tp = transplanter(ui, repo, opts)

	p1 = repo.dirstate.p1()			p1 = repo.dirstate.p1()
	if len(repo) > 0 and p1 == nullid:			if len(repo) > 0 and p1 == repo.nullid:
	raise error.Abort(_(b'no revision checked out'))			raise error.Abort(_(b'no revision checked out'))
	if opts.get(b'continue'):			if opts.get(b'continue'):
	if not tp.canresume():			if not tp.canresume():
	raise error.StateError(_(b'no transplant to continue'))			raise error.StateError(_(b'no transplant to continue'))
	elif opts.get(b'stop'):			elif opts.get(b'stop'):
	if not tp.canresume():			if not tp.canresume():
	raise error.StateError(_(b'no interrupted transplant found'))			raise error.StateError(_(b'no interrupted transplant found'))
	return tp.stop(ui, repo)			return tp.stop(ui, repo)

hgext/uncommit.py

	files to their uncommitted state. This means that files modified, added or			files to their uncommitted state. This means that files modified, added or
	removed in the changeset will be left unchanged, and so will remain modified,			removed in the changeset will be left unchanged, and so will remain modified,
	added and removed in the working directory.			added and removed in the working directory.
	"""			"""

	from __future__ import absolute_import			from __future__ import absolute_import

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import nullid

	from mercurial import (			from mercurial import (
	cmdutil,			cmdutil,
	commands,			commands,
	context,			context,
	copies as copiesmod,			copies as copiesmod,
	error,			error,
	obsutil,			obsutil,
	message = ctx.description()			message = ctx.description()
	if not user:			if not user:
	user = ctx.user()			user = ctx.user()
	if not date:			if not date:
	date = ctx.date()			date = ctx.date()

	new = context.memctx(			new = context.memctx(
	repo,			repo,
	parents=[base.node(), nullid],			parents=[base.node(), repo.nullid],
	text=message,			text=message,
	files=files,			files=files,
	filectxfn=filectxfn,			filectxfn=filectxfn,
	user=user,			user=user,
	date=date,			date=date,
	extra=ctx.extra(),			extra=ctx.extra(),
	)			)
	return repo.commitctx(new)			return repo.commitctx(new)

mercurial/bookmarks.py

	import errno			import errno
	import struct			import struct

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	short,			short,
	wdirid,
	)			)
	from .pycompat import getattr			from .pycompat import getattr
	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	obsutil,			obsutil,
	pycompat,			pycompat,
	scmutil,			scmutil,
	:bookmark-length: an unsigned short,			:bookmark-length: an unsigned short,
	:bookmark-name: the name of the bookmark (of length <bookmark-length>)			:bookmark-name: the name of the bookmark (of length <bookmark-length>)

	wdirid (all bits set) will be used as a special value for "missing"			wdirid (all bits set) will be used as a special value for "missing"
	"""			"""
	binarydata = []			binarydata = []
	for book, node in bookmarks:			for book, node in bookmarks:
	if not node: # None or ''			if not node: # None or ''
	node = wdirid			node = repo.nodeconstants.wdirid
	binarydata.append(_binaryentry.pack(node, len(book)))			binarydata.append(_binaryentry.pack(node, len(book)))
	binarydata.append(book)			binarydata.append(book)
	return b''.join(binarydata)			return b''.join(binarydata)


	def binarydecode(repo, stream):			def binarydecode(repo, stream):
	"""decode a binary stream into an '(bookmark, node)' iterable			"""decode a binary stream into an '(bookmark, node)' iterable

	if entry:			if entry:
	raise error.Abort(_(b'bad bookmark stream'))			raise error.Abort(_(b'bad bookmark stream'))
	break			break
	node, length = _binaryentry.unpack(entry)			node, length = _binaryentry.unpack(entry)
	bookmark = stream.read(length)			bookmark = stream.read(length)
	if len(bookmark) < length:			if len(bookmark) < length:
	if entry:			if entry:
	raise error.Abort(_(b'bad bookmark stream'))			raise error.Abort(_(b'bad bookmark stream'))
	if node == wdirid:			if node == repo.nodeconstants.wdirid:
	node = None			node = None
	books.append((bookmark, node))			books.append((bookmark, node))
	return books			return books


	def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()):			def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()):
	ui.debug(b"checking for updated bookmarks\n")			ui.debug(b"checking for updated bookmarks\n")
	localmarks = repo._bookmarks			localmarks = repo._bookmarks

mercurial/branchmap.py

	# branchmap.py - logic to computes, maintain and stores branchmap for local repo			# branchmap.py - logic to computes, maintain and stores branchmap for local repo
	#			#
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import struct			import struct

	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)
	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	pycompat,			pycompat,
	scmutil,			scmutil,
	util,			util,
	This field can be used to avoid changelog reads when determining if a			This field can be used to avoid changelog reads when determining if a
	branch head closes a branch or not.			branch head closes a branch or not.
	"""			"""

	def __init__(			def __init__(
	self,			self,
	repo,			repo,
	entries=(),			entries=(),
	tipnode=nullid,			tipnode=None,
	tiprev=nullrev,			tiprev=nullrev,
	filteredhash=None,			filteredhash=None,
	closednodes=None,			closednodes=None,
	hasnode=None,			hasnode=None,
	):			):
	# type: (localrepo.localrepository, Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None			# type: (localrepo.localrepository, Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None
	"""hasnode is a function which can be used to verify whether changelog			"""hasnode is a function which can be used to verify whether changelog
	has a given node or not. If it's not provided, we assume that every node			has a given node or not. If it's not provided, we assume that every node
	we have exists in changelog"""			we have exists in changelog"""
	self._repo = repo			self._repo = repo
				if tipnode is None:
				self.tipnode = repo.nullid
				else:
	self.tipnode = tipnode			self.tipnode = tipnode
	self.tiprev = tiprev			self.tiprev = tiprev
	self.filteredhash = filteredhash			self.filteredhash = filteredhash
	# closednodes is a set of nodes that close their branch. If the branch			# closednodes is a set of nodes that close their branch. If the branch
	# cache has been updated, it may contain nodes that are no longer			# cache has been updated, it may contain nodes that are no longer
	# heads.			# heads.
	if closednodes is None:			if closednodes is None:
	self._closednodes = set()			self._closednodes = set()
	else:			else:
	ntiprev = tiprev			ntiprev = tiprev

	if ntiprev > self.tiprev:			if ntiprev > self.tiprev:
	self.tiprev = ntiprev			self.tiprev = ntiprev
	self.tipnode = cl.node(ntiprev)			self.tipnode = cl.node(ntiprev)

	if not self.validfor(repo):			if not self.validfor(repo):
	# cache key are not valid anymore			# cache key are not valid anymore
	self.tipnode = nullid			self.tipnode = repo.nullid
	self.tiprev = nullrev			self.tiprev = nullrev
	for heads in self.iterheads():			for heads in self.iterheads():
	tiprev = max(cl.rev(node) for node in heads)			tiprev = max(cl.rev(node) for node in heads)
	if tiprev > self.tiprev:			if tiprev > self.tiprev:
	self.tipnode = cl.node(tiprev)			self.tipnode = cl.node(tiprev)
	self.tiprev = tiprev			self.tiprev = tiprev
	self.filteredhash = scmutil.filteredhash(repo, self.tiprev)			self.filteredhash = scmutil.filteredhash(repo, self.tiprev)

mercurial/bundle2.py

	import re			import re
	import string			import string
	import struct			import struct
	import sys			import sys

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from . import (			from . import (
	bookmarks,			bookmarks,
	changegroup,			changegroup,
	encoding,			encoding,
	error,			error,
	obsolete,			obsolete,
	packer = changegroup.getbundler(			packer = changegroup.getbundler(
	cgversion,			cgversion,
	repo,			repo,
	oldmatcher=oldmatcher,			oldmatcher=oldmatcher,
	matcher=newmatcher,			matcher=newmatcher,
	fullnodes=commonnodes,			fullnodes=commonnodes,
	)			)
	cgdata = packer.generate(			cgdata = packer.generate(
	{nullid},			{repo.nullid},
	list(commonnodes),			list(commonnodes),
	False,			False,
	b'narrow_widen',			b'narrow_widen',
	changelog=False,			changelog=False,
	)			)

	part = bundler.newpart(b'changegroup', data=cgdata)			part = bundler.newpart(b'changegroup', data=cgdata)
	part.addparam(b'version', cgversion)			part.addparam(b'version', cgversion)
	if scmutil.istreemanifest(repo):			if scmutil.istreemanifest(repo):
	part.addparam(b'treemanifest', b'1')			part.addparam(b'treemanifest', b'1')
	if b'exp-sidedata-flag' in repo.requirements:			if b'exp-sidedata-flag' in repo.requirements:
	part.addparam(b'exp-sidedata', b'1')			part.addparam(b'exp-sidedata', b'1')
	wanted = format_remote_wanted_sidedata(repo)			wanted = format_remote_wanted_sidedata(repo)
	part.addparam(b'exp-wanted-sidedata', wanted)			part.addparam(b'exp-wanted-sidedata', wanted)

	return bundler			return bundler

mercurial/bundlerepo.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os
	import shutil			import shutil

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)

	from . import (			from . import (
	bundle2,			bundle2,
	changegroup,			changegroup,
	changelog,			changelog,
	cmdutil,			cmdutil,

	def peer(self):			def peer(self):
	return bundlepeer(self)			return bundlepeer(self)

	def getcwd(self):			def getcwd(self):
	return encoding.getcwd() # always outside the repo			return encoding.getcwd() # always outside the repo

	# Check if parents exist in localrepo before setting			# Check if parents exist in localrepo before setting
	def setparents(self, p1, p2=nullid):			def setparents(self, p1, p2=None):
				if p2 is None:
				p2 = self.nullid
	p1rev = self.changelog.rev(p1)			p1rev = self.changelog.rev(p1)
	p2rev = self.changelog.rev(p2)			p2rev = self.changelog.rev(p2)
	msg = _(b"setting parent to node %s that only exists in the bundle\n")			msg = _(b"setting parent to node %s that only exists in the bundle\n")
	if self.changelog.repotiprev < p1rev:			if self.changelog.repotiprev < p1rev:
	self.ui.warn(msg % hex(p1))			self.ui.warn(msg % hex(p1))
	if self.changelog.repotiprev < p2rev:			if self.changelog.repotiprev < p2rev:
	self.ui.warn(msg % hex(p2))			self.ui.warn(msg % hex(p2))
	return super(bundlerepository, self).setparents(p1, p2)			return super(bundlerepository, self).setparents(p1, p2)

mercurial/changegroup.py

	import collections			import collections
	import os			import os
	import struct			import struct
	import weakref			import weakref

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	)			)
	from .pycompat import open			from .pycompat import open

	from . import (			from . import (
	error,			error,
	match as matchmod,			match as matchmod,
	# The captured revision delta may be encoded as a delta against			# The captured revision delta may be encoded as a delta against
	# a base revision or as a full revision. The changegroup format			# a base revision or as a full revision. The changegroup format
	# requires that everything on the wire be deltas. So for full			# requires that everything on the wire be deltas. So for full
	# revisions, we need to invent a header that says to rewrite			# revisions, we need to invent a header that says to rewrite
	# data.			# data.

	if delta.delta is not None:			if delta.delta is not None:
	prefix, data = b'', delta.delta			prefix, data = b'', delta.delta
	elif delta.basenode == nullid:			elif delta.basenode == repo.nullid:
	data = delta.revision			data = delta.revision
	prefix = mdiff.trivialdiffheader(len(data))			prefix = mdiff.trivialdiffheader(len(data))
	else:			else:
	data = delta.revision			data = delta.revision
	prefix = mdiff.replacediffheader(delta.baserevisionsize, len(data))			prefix = mdiff.replacediffheader(delta.baserevisionsize, len(data))

	meta = headerfn(delta)			meta = headerfn(delta)

mercurial/changelog.py

	# changelog.py - changelog class for mercurial			# changelog.py - changelog class for mercurial
	#			#
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	)			)
	from .thirdparty import attr			from .thirdparty import attr

	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	metadata,			metadata,
	pycompat,			pycompat,
	'_text',			'_text',
	'_sidedata',			'_sidedata',
	'_cpsd',			'_cpsd',
	'_changes',			'_changes',
	)			)

	def __new__(cls, cl, text, sidedata, cpsd):			def __new__(cls, cl, text, sidedata, cpsd):
	if not text:			if not text:
	return _changelogrevision(extra=_defaultextra, manifest=nullid)			return _changelogrevision(extra=_defaultextra, manifest=cl.nullid)

	self = super(changelogrevision, cls).__new__(cls)			self = super(changelogrevision, cls).__new__(cls)
	# We could return here and implement the following as an __init__.			# We could return here and implement the following as an __init__.
	# But doing it here is equivalent and saves an extra function call.			# But doing it here is equivalent and saves an extra function call.

	# format used:			# format used:
	# nodeid\n : manifest node in ascii			# nodeid\n : manifest node in ascii
	# user\n : user, no \n or \r allowed			# user\n : user, no \n or \r allowed

mercurial/cmdutil.py

	import copy as copymod			import copy as copymod
	import errno			import errno
	import os			import os
	import re			import re

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	)			)
	from .pycompat import (			from .pycompat import (
	getattr,			getattr,
	open,			open,
	setattr,			setattr,
	)			)
	"""enforce the precondition that working directory must be clean.			"""enforce the precondition that working directory must be clean.

	'merge' can be set to false if a pending uncommitted merge should be			'merge' can be set to false if a pending uncommitted merge should be
	ignored (such as when 'update --check' runs).			ignored (such as when 'update --check' runs).

	'hint' is the usual hint given to Abort exception.			'hint' is the usual hint given to Abort exception.
	"""			"""

	if merge and repo.dirstate.p2() != nullid:			if merge and repo.dirstate.p2() != repo.nullid:
	raise error.StateError(_(b'outstanding uncommitted merge'), hint=hint)			raise error.StateError(_(b'outstanding uncommitted merge'), hint=hint)
	st = repo.status()			st = repo.status()
	if st.modified or st.added or st.removed or st.deleted:			if st.modified or st.added or st.removed or st.deleted:
	raise error.StateError(_(b'uncommitted changes'), hint=hint)			raise error.StateError(_(b'uncommitted changes'), hint=hint)
	ctx = repo[None]			ctx = repo[None]
	for s in sorted(ctx.substate):			for s in sorted(ctx.substate):
	ctx.sub(s).bailifchanged(hint=hint)			ctx.sub(s).bailifchanged(hint=hint)

	parents = [p.node() for p in ctx.parents() if p]			parents = [p.node() for p in ctx.parents() if p]
	branch = ctx.branch()			branch = ctx.branch()
	if switch_parent:			if switch_parent:
	parents.reverse()			parents.reverse()

	if parents:			if parents:
	prev = parents[0]			prev = parents[0]
	else:			else:
	prev = nullid			prev = repo.nullid

	fm.context(ctx=ctx)			fm.context(ctx=ctx)
	fm.plain(b'# HG changeset patch\n')			fm.plain(b'# HG changeset patch\n')
	fm.write(b'user', b'# User %s\n', ctx.user())			fm.write(b'user', b'# User %s\n', ctx.user())
	fm.plain(b'# Date %d %d\n' % ctx.date())			fm.plain(b'# Date %d %d\n' % ctx.date())
	fm.write(b'date', b'# %s\n', fm.formatdate(ctx.date()))			fm.write(b'date', b'# %s\n', fm.formatdate(ctx.date()))
	fm.condwrite(			fm.condwrite(
	branch and branch != b'default', b'branch', b'# Branch %s\n', branch			branch and branch != b'default', b'branch', b'# Branch %s\n', branch

	commitphase = None			commitphase = None
	if opts.get(b'secret'):			if opts.get(b'secret'):
	commitphase = phases.secret			commitphase = phases.secret
	newid = repo.commitctx(new)			newid = repo.commitctx(new)
	ms.reset()			ms.reset()

	# Reroute the working copy parent to the new changeset			# Reroute the working copy parent to the new changeset
	repo.setparents(newid, nullid)			repo.setparents(newid, repo.nullid)

	# Fixing the dirstate because localrepo.commitctx does not update			# Fixing the dirstate because localrepo.commitctx does not update
	# it. This is rather convenient because we did not need to update			# it. This is rather convenient because we did not need to update
	# the dirstate for all the files in the new commit which commitctx			# the dirstate for all the files in the new commit which commitctx
	# could have done if it updated the dirstate. Now, we can			# could have done if it updated the dirstate. Now, we can
	# selectively update the dirstate only for the amended files.			# selectively update the dirstate only for the amended files.
	dirstate = repo.dirstate			dirstate = repo.dirstate


	# We need to wait for some post-processing to update this set			# We need to wait for some post-processing to update this set
	# before making the distinction. The dirstate will be used for			# before making the distinction. The dirstate will be used for
	# that purpose.			# that purpose.
	dsadded = added			dsadded = added

	# in case of merge, files that are actually added can be reported as			# in case of merge, files that are actually added can be reported as
	# modified, we need to post process the result			# modified, we need to post process the result
	if p2 != nullid:			if p2 != repo.nullid:
	mergeadd = set(dsmodified)			mergeadd = set(dsmodified)
	for path in dsmodified:			for path in dsmodified:
	if path in mf:			if path in mf:
	mergeadd.remove(path)			mergeadd.remove(path)
	dsadded \|= mergeadd			dsadded \|= mergeadd
	dsmodified -= mergeadd			dsmodified -= mergeadd

	# if f is a rename, update `names` to also revert the source			# if f is a rename, update `names` to also revert the source
	prntstatusmsg(b'drop', f)			prntstatusmsg(b'drop', f)
	repo.dirstate.remove(f)			repo.dirstate.remove(f)

	normal = None			normal = None
	if node == parent:			if node == parent:
	# We're reverting to our parent. If possible, we'd like status			# We're reverting to our parent. If possible, we'd like status
	# to report the file as clean. We have to use normallookup for			# to report the file as clean. We have to use normallookup for
	# merges to avoid losing information about merged/dirty files.			# merges to avoid losing information about merged/dirty files.
	if p2 != nullid:			if p2 != repo.nullid:
	normal = repo.dirstate.normallookup			normal = repo.dirstate.normallookup
	else:			else:
	normal = repo.dirstate.normal			normal = repo.dirstate.normal

	newlyaddedandmodifiedfiles = set()			newlyaddedandmodifiedfiles = set()
	if interactive:			if interactive:
	# Prompt the user for changes to revert			# Prompt the user for changes to revert
	torevert = [f for f in actions[b'revert'][0] if f not in excluded_files]			torevert = [f for f in actions[b'revert'][0] if f not in excluded_files]
	for f in actions[b'add'][0]:			for f in actions[b'add'][0]:
	# Don't checkout modified files, they are already created by the diff			# Don't checkout modified files, they are already created by the diff
	if f not in newlyaddedandmodifiedfiles:			if f not in newlyaddedandmodifiedfiles:
	prntstatusmsg(b'add', f)			prntstatusmsg(b'add', f)
	checkout(f)			checkout(f)
	repo.dirstate.add(f)			repo.dirstate.add(f)

	normal = repo.dirstate.normallookup			normal = repo.dirstate.normallookup
	if node == parent and p2 == nullid:			if node == parent and p2 == repo.nullid:
	normal = repo.dirstate.normal			normal = repo.dirstate.normal
	for f in actions[b'undelete'][0]:			for f in actions[b'undelete'][0]:
	if interactive:			if interactive:
	choice = repo.ui.promptchoice(			choice = repo.ui.promptchoice(
	_(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f			_(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f
	)			)
	if choice == 0:			if choice == 0:
	prntstatusmsg(b'undelete', f)			prntstatusmsg(b'undelete', f)

mercurial/commands.py

This file is larger than 256 KB, so syntax highlighting is disabled by default.

	import errno			import errno
	import os			import os
	import re			import re
	import sys			import sys

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	wdirhex,
	wdirrev,			wdirrev,
	)			)
	from .pycompat import open			from .pycompat import open
	from . import (			from . import (
	archival,			archival,
	bookmarks,			bookmarks,
	bundle2,			bundle2,
	bundlecaches,			bundlecaches,

	def formatrev(rev):			def formatrev(rev):
	if rev == wdirrev:			if rev == wdirrev:
	return b'%d+' % ctx.p1().rev()			return b'%d+' % ctx.p1().rev()
	else:			else:
	return b'%d ' % rev			return b'%d ' % rev

	def formathex(h):			def formathex(h):
	if h == wdirhex:			if h == repo.nodeconstants.wdirhex:
	return b'%s+' % shorthex(hex(ctx.p1().node()))			return b'%s+' % shorthex(hex(ctx.p1().node()))
	else:			else:
	return b'%s ' % shorthex(h)			return b'%s ' % shorthex(h)

	else:			else:
	formatrev = b'%d'.__mod__			formatrev = b'%d'.__mod__
	formathex = shorthex			formathex = shorthex


	op1, op2 = repo.dirstate.parents()			op1, op2 = repo.dirstate.parents()
	if not repo.changelog.isancestor(node, op1):			if not repo.changelog.isancestor(node, op1):
	raise error.InputError(			raise error.InputError(
	_(b'cannot backout change that is not an ancestor')			_(b'cannot backout change that is not an ancestor')
	)			)

	p1, p2 = repo.changelog.parents(node)			p1, p2 = repo.changelog.parents(node)
	if p1 == nullid:			if p1 == repo.nullid:
	raise error.InputError(_(b'cannot backout a change with no parents'))			raise error.InputError(_(b'cannot backout a change with no parents'))
	if p2 != nullid:			if p2 != repo.nullid:
	if not opts.get(b'parent'):			if not opts.get(b'parent'):
	raise error.InputError(_(b'cannot backout a merge changeset'))			raise error.InputError(_(b'cannot backout a merge changeset'))
	p = repo.lookup(opts[b'parent'])			p = repo.lookup(opts[b'parent'])
	if p not in (p1, p2):			if p not in (p1, p2):
	raise error.InputError(			raise error.InputError(
	_(b'%s is not a parent of %s') % (short(p), short(node))			_(b'%s is not a parent of %s') % (short(p), short(node))
	)			)
	parent = p			parent = p
	raise error.StateError(			raise error.StateError(
	_(			_(
	b'current bisect revision is unknown - '			b'current bisect revision is unknown - '
	b'start a new bisect to fix'			b'start a new bisect to fix'
	)			)
	)			)
	else:			else:
	node, p2 = repo.dirstate.parents()			node, p2 = repo.dirstate.parents()
	if p2 != nullid:			if p2 != repo.nullid:
	raise error.StateError(_(b'current bisect revision is a merge'))			raise error.StateError(_(b'current bisect revision is a merge'))
	if rev:			if rev:
	if not nodes:			if not nodes:
	raise error.Abort(_(b'empty revision set'))			raise error.Abort(_(b'empty revision set'))
	node = repo[nodes[-1]].node()			node = repo[nodes[-1]].node()
	with hbisect.restore_state(repo, state, node):			with hbisect.restore_state(repo, state, node):
	while changesets:			while changesets:
	# update state			# update state
	will check out a clean copy of the original merge parent, losing			will check out a clean copy of the original merge parent, losing
	all changes.			all changes.

	Returns 0 on success, 1 if there are unresolved files.			Returns 0 on success, 1 if there are unresolved files.
	"""			"""

	opts = pycompat.byteskwargs(opts)			opts = pycompat.byteskwargs(opts)
	abort = opts.get(b'abort')			abort = opts.get(b'abort')
	if abort and repo.dirstate.p2() == nullid:			if abort and repo.dirstate.p2() == repo.nullid:
	cmdutil.wrongtooltocontinue(repo, _(b'merge'))			cmdutil.wrongtooltocontinue(repo, _(b'merge'))
	cmdutil.check_incompatible_arguments(opts, b'abort', [b'rev', b'preview'])			cmdutil.check_incompatible_arguments(opts, b'abort', [b'rev', b'preview'])
	if abort:			if abort:
	state = cmdutil.getunfinishedstate(repo)			state = cmdutil.getunfinishedstate(repo)
	if state and state._opname != b'merge':			if state and state._opname != b'merge':
	raise error.StateError(			raise error.StateError(
	_(b'cannot abort merge with %s in progress') % (state._opname),			_(b'cannot abort merge with %s in progress') % (state._opname),
	hint=state.hint(),			hint=state.hint(),
	for fn in filenodes:			for fn in filenodes:
	fctx = repo.filectx(file_, fileid=fn)			fctx = repo.filectx(file_, fileid=fn)
	p.append(fctx.node())			p.append(fctx.node())
	else:			else:
	p = [cp.node() for cp in ctx.parents()]			p = [cp.node() for cp in ctx.parents()]

	displayer = logcmdutil.changesetdisplayer(ui, repo, opts)			displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
	for n in p:			for n in p:
	if n != nullid:			if n != repo.nullid:
	displayer.show(repo[n])			displayer.show(repo[n])
	displayer.close()			displayer.close()


	@command(			@command(
	b'paths',			b'paths',
	formatteropts,			formatteropts,
	_(b'[NAME]'),			_(b'[NAME]'),
	fm.data(path=f)			fm.data(path=f)
	fm.plain(b'%s\n' % uipathfn(f), label=label)			fm.plain(b'%s\n' % uipathfn(f), label=label)
	fm.end()			fm.end()
	return 0			return 0

	with repo.wlock():			with repo.wlock():
	ms = mergestatemod.mergestate.read(repo)			ms = mergestatemod.mergestate.read(repo)

	if not (ms.active() or repo.dirstate.p2() != nullid):			if not (ms.active() or repo.dirstate.p2() != repo.nullid):
	raise error.StateError(			raise error.StateError(
	_(b'resolve command not applicable when not merging')			_(b'resolve command not applicable when not merging')
	)			)

	wctx = repo[None]			wctx = repo[None]
	m = scmutil.match(wctx, pats, opts)			m = scmutil.match(wctx, pats, opts)
	ret = 0			ret = 0
	didwork = False			didwork = False
	a = repo.wjoin(f)			a = repo.wjoin(f)
	try:			try:
	util.rename(a + b".resolve", scmutil.backuppath(ui, repo, f))			util.rename(a + b".resolve", scmutil.backuppath(ui, repo, f))
	except OSError as inst:			except OSError as inst:
	if inst.errno != errno.ENOENT:			if inst.errno != errno.ENOENT:
	raise			raise

	ms.commit()			ms.commit()
	branchmerge = repo.dirstate.p2() != nullid			branchmerge = repo.dirstate.p2() != repo.nullid
	mergestatemod.recordupdates(repo, ms.actions(), branchmerge, None)			mergestatemod.recordupdates(repo, ms.actions(), branchmerge, None)

	if not didwork and pats:			if not didwork and pats:
	hint = None			hint = None
	if not any([p for p in pats if p.find(b':') >= 0]):			if not any([p for p in pats if p.find(b':') >= 0]):
	pats = [b'path:%s' % p for p in pats]			pats = [b'path:%s' % p for p in pats]
	m = scmutil.match(wctx, pats, opts)			m = scmutil.match(wctx, pats, opts)
	for f in ms:			for f in ms:
	"""			"""

	opts = pycompat.byteskwargs(opts)			opts = pycompat.byteskwargs(opts)
	if opts.get(b"date"):			if opts.get(b"date"):
	cmdutil.check_incompatible_arguments(opts, b'date', [b'rev'])			cmdutil.check_incompatible_arguments(opts, b'date', [b'rev'])
	opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"])			opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"])

	parent, p2 = repo.dirstate.parents()			parent, p2 = repo.dirstate.parents()
	if not opts.get(b'rev') and p2 != nullid:			if not opts.get(b'rev') and p2 != repo.nullid:
	# revert after merge is a trap for new users (issue2915)			# revert after merge is a trap for new users (issue2915)
	raise error.InputError(			raise error.InputError(
	_(b'uncommitted merge with no revision specified'),			_(b'uncommitted merge with no revision specified'),
	hint=_(b"use 'hg update' or see 'hg help revert'"),			hint=_(b"use 'hg update' or see 'hg help revert'"),
	)			)

	rev = opts.get(b'rev')			rev = opts.get(b'rev')
	if rev:			if rev:
	repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')			repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
	ctx = scmutil.revsingle(repo, rev)			ctx = scmutil.revsingle(repo, rev)

	if not (			if not (
	pats			pats
	or opts.get(b'include')			or opts.get(b'include')
	or opts.get(b'exclude')			or opts.get(b'exclude')
	or opts.get(b'all')			or opts.get(b'all')
	or opts.get(b'interactive')			or opts.get(b'interactive')
	):			):
	msg = _(b"no files or directories specified")			msg = _(b"no files or directories specified")
	if p2 != nullid:			if p2 != repo.nullid:
	hint = _(			hint = _(
	b"uncommitted merge, use --all to discard all changes,"			b"uncommitted merge, use --all to discard all changes,"
	b" or 'hg update -C .' to abort the merge"			b" or 'hg update -C .' to abort the merge"
	)			)
	raise error.InputError(msg, hint=hint)			raise error.InputError(msg, hint=hint)
	dirty = any(repo.status())			dirty = any(repo.status())
	node = ctx.node()			node = ctx.node()
	if node != parent:			if node != parent:
	if opts.get(b'local'):			if opts.get(b'local'):
	expectedtype = b'local'			expectedtype = b'local'
	else:			else:
	expectedtype = b'global'			expectedtype = b'global'

	for n in names:			for n in names:
	if repo.tagtype(n) == b'global':			if repo.tagtype(n) == b'global':
	alltags = tagsmod.findglobaltags(ui, repo)			alltags = tagsmod.findglobaltags(ui, repo)
	if alltags[n][0] == nullid:			if alltags[n][0] == repo.nullid:
	raise error.InputError(			raise error.InputError(
	_(b"tag '%s' is already removed") % n			_(b"tag '%s' is already removed") % n
	)			)
	if not repo.tagtype(n):			if not repo.tagtype(n):
	raise error.InputError(_(b"tag '%s' does not exist") % n)			raise error.InputError(_(b"tag '%s' does not exist") % n)
	if repo.tagtype(n) != expectedtype:			if repo.tagtype(n) != expectedtype:
	if expectedtype == b'global':			if expectedtype == b'global':
	raise error.InputError(			raise error.InputError(
	elif not opts.get(b'force'):			elif not opts.get(b'force'):
	for n in names:			for n in names:
	if n in repo.tags():			if n in repo.tags():
	raise error.InputError(			raise error.InputError(
	_(b"tag '%s' already exists (use -f to force)") % n			_(b"tag '%s' already exists (use -f to force)") % n
	)			)
	if not opts.get(b'local'):			if not opts.get(b'local'):
	p1, p2 = repo.dirstate.parents()			p1, p2 = repo.dirstate.parents()
	if p2 != nullid:			if p2 != repo.nullid:
	raise error.StateError(_(b'uncommitted merge'))			raise error.StateError(_(b'uncommitted merge'))
	bheads = repo.branchheads()			bheads = repo.branchheads()
	if not opts.get(b'force') and bheads and p1 not in bheads:			if not opts.get(b'force') and bheads and p1 not in bheads:
	raise error.InputError(			raise error.InputError(
	_(			_(
	b'working directory is not at a branch head '			b'working directory is not at a branch head '
	b'(use -f to force)'			b'(use -f to force)'
	)			)

mercurial/commit.py

	# commit.py - fonction to perform commit			# commit.py - fonction to perform commit
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import errno			import errno

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)

	from . import (			from . import (
	context,			context,
	mergestate,			mergestate,
	metadata,			metadata,
	phases,			phases,

	output: (filenode, touched)			output: (filenode, touched)

	filenode: the filenode that should be used by this changeset			filenode: the filenode that should be used by this changeset
	touched: one of: None (mean untouched), 'added' or 'modified'			touched: one of: None (mean untouched), 'added' or 'modified'
	"""			"""

	fname = fctx.path()			fname = fctx.path()
	fparent1 = manifest1.get(fname, nullid)			fparent1 = manifest1.get(fname, repo.nullid)
	fparent2 = manifest2.get(fname, nullid)			fparent2 = manifest2.get(fname, repo.nullid)
	touched = None			touched = None
	if fparent1 == fparent2 == nullid:			if fparent1 == fparent2 == repo.nullid:
	touched = 'added'			touched = 'added'

	if isinstance(fctx, context.filectx):			if isinstance(fctx, context.filectx):
	# This block fast path most comparisons which are usually done. It			# This block fast path most comparisons which are usually done. It
	# assumes that bare filectx is used and no merge happened, hence no			# assumes that bare filectx is used and no merge happened, hence no
	# need to create a new file revision in this case.			# need to create a new file revision in this case.
	node = fctx.filenode()			node = fctx.filenode()
	if node in [fparent1, fparent2]:			if node in [fparent1, fparent2]:
	repo.ui.debug(b'reusing %s filelog entry\n' % fname)			repo.ui.debug(b'reusing %s filelog entry\n' % fname)
	if (			if (
	fparent1 != nullid and manifest1.flags(fname) != fctx.flags()			fparent1 != repo.nullid
				and manifest1.flags(fname) != fctx.flags()
	) or (			) or (
	fparent2 != nullid and manifest2.flags(fname) != fctx.flags()			fparent2 != repo.nullid
				and manifest2.flags(fname) != fctx.flags()
	):			):
	touched = 'modified'			touched = 'modified'
	return node, touched			return node, touched

	flog = repo.file(fname)			flog = repo.file(fname)
	meta = {}			meta = {}
	cfname = fctx.copysource()			cfname = fctx.copysource()
	fnode = None			fnode = None
	# \ / merging rev3 and rev4 should use bar@rev2			# \ / merging rev3 and rev4 should use bar@rev2
	# \- 2 --- 4 as the merge base			# \- 2 --- 4 as the merge base
	#			#

	cnode = manifest1.get(cfname)			cnode = manifest1.get(cfname)
	newfparent = fparent2			newfparent = fparent2

	if manifest2: # branch merge			if manifest2: # branch merge
	if fparent2 == nullid or cnode is None: # copied on remote side			if (
				fparent2 == repo.nullid or cnode is None
				): # copied on remote side
	if cfname in manifest2:			if cfname in manifest2:
	cnode = manifest2[cfname]			cnode = manifest2[cfname]
	newfparent = fparent1			newfparent = fparent1

	# Here, we used to search backwards through history to try to find			# Here, we used to search backwards through history to try to find
	# where the file copy came from if the source of a copy was not in			# where the file copy came from if the source of a copy was not in
	# the parent directory. However, this doesn't actually make sense to			# the parent directory. However, this doesn't actually make sense to
	# do (what does a copy from something not in your working copy even			# do (what does a copy from something not in your working copy even
	# mean?) and it causes bugs (eg, issue4476). Instead, we will warn			# mean?) and it causes bugs (eg, issue4476). Instead, we will warn
	# the user that copy information was dropped, so if they didn't			# the user that copy information was dropped, so if they didn't
	# expect this outcome it can be fixed, but this is the correct			# expect this outcome it can be fixed, but this is the correct
	# behavior in this circumstance.			# behavior in this circumstance.

	if cnode:			if cnode:
	repo.ui.debug(b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode)))			repo.ui.debug(b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode)))
	if includecopymeta:			if includecopymeta:
	meta[b"copy"] = cfname			meta[b"copy"] = cfname
	meta[b"copyrev"] = hex(cnode)			meta[b"copyrev"] = hex(cnode)
	fparent1, fparent2 = nullid, newfparent			fparent1, fparent2 = repo.nullid, newfparent
	else:			else:
	repo.ui.warn(			repo.ui.warn(
	_(			_(
	b"warning: can't find ancestor for '%s' "			b"warning: can't find ancestor for '%s' "
	b"copied from '%s'!\n"			b"copied from '%s'!\n"
	)			)
	% (fname, cfname)			% (fname, cfname)
	)			)

	elif fparent1 == nullid:			elif fparent1 == repo.nullid:
	fparent1, fparent2 = fparent2, nullid			fparent1, fparent2 = fparent2, repo.nullid
	elif fparent2 != nullid:			elif fparent2 != repo.nullid:
	if ms.active() and ms.extras(fname).get(b'filenode-source') == b'other':			if ms.active() and ms.extras(fname).get(b'filenode-source') == b'other':
	fparent1, fparent2 = fparent2, nullid			fparent1, fparent2 = fparent2, repo.nullid
	elif ms.active() and ms.extras(fname).get(b'merged') != b'yes':			elif ms.active() and ms.extras(fname).get(b'merged') != b'yes':
	fparent1, fparent2 = fparent1, nullid			fparent1, fparent2 = fparent1, repo.nullid
	# is one parent an ancestor of the other?			# is one parent an ancestor of the other?
	else:			else:
	fparentancestors = flog.commonancestorsheads(fparent1, fparent2)			fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
	if fparent1 in fparentancestors:			if fparent1 in fparentancestors:
	fparent1, fparent2 = fparent2, nullid			fparent1, fparent2 = fparent2, repo.nullid
	elif fparent2 in fparentancestors:			elif fparent2 in fparentancestors:
	fparent2 = nullid			fparent2 = repo.nullid

	force_new_node = False			force_new_node = False
	# The file might have been deleted by merge code and user explicitly choose			# The file might have been deleted by merge code and user explicitly choose
	# to revert the file and keep it. The other case can be where there is			# to revert the file and keep it. The other case can be where there is
	# change-delete or delete-change conflict and user explicitly choose to keep			# change-delete or delete-change conflict and user explicitly choose to keep
	# the file. The goal is to create a new filenode for users explicit choices			# the file. The goal is to create a new filenode for users explicit choices
	if (			if (
	repo.ui.configbool(b'experimental', b'merge-track-salvaged')			repo.ui.configbool(b'experimental', b'merge-track-salvaged')
	and ms.active()			and ms.active()
	and ms.extras(fname).get(b'merge-removal-candidate') == b'yes'			and ms.extras(fname).get(b'merge-removal-candidate') == b'yes'
	):			):
	force_new_node = True			force_new_node = True
	# is the file changed?			# is the file changed?
	text = fctx.data()			text = fctx.data()
	if fparent2 != nullid or meta or flog.cmp(fparent1, text) or force_new_node:			if (
				fparent2 != repo.nullid
				or meta
				or flog.cmp(fparent1, text)
				or force_new_node
				):
	if touched is None: # do not overwrite added			if touched is None: # do not overwrite added
	if fparent2 == nullid:			if fparent2 == repo.nullid:
	touched = 'modified'			touched = 'modified'
	else:			else:
	touched = 'merged'			touched = 'merged'
	fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)			fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)
	# are just the flags changed during merge?			# are just the flags changed during merge?
	elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():			elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
	touched = 'modified'			touched = 'modified'
	fnode = fparent1			fnode = fparent1

mercurial/context.py

	# context.py - changeset and file context objects for mercurial			# context.py - changeset and file context objects for mercurial
	#			#
	# Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import errno			import errno
	import filecmp			import filecmp
	import os			import os
	import stat			import stat

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	addednodeid,
	hex,			hex,
	modifiednodeid,
	nullid,
	nullrev,			nullrev,
	short,			short,
	wdirfilenodeids,
	wdirhex,
	)			)
	from .pycompat import (			from .pycompat import (
	getattr,			getattr,
	open,			open,
	)			)
	from . import (			from . import (
	dagop,			dagop,
	encoding,			encoding,
	continue			continue
	(node1, flag1), (node2, flag2) = value			(node1, flag1), (node2, flag2) = value
	if node1 is None:			if node1 is None:
	added.append(fn)			added.append(fn)
	elif node2 is None:			elif node2 is None:
	removed.append(fn)			removed.append(fn)
	elif flag1 != flag2:			elif flag1 != flag2:
	modified.append(fn)			modified.append(fn)
	elif node2 not in wdirfilenodeids:			elif node2 not in self._repo.nodeconstants.wdirfilenodeids:
	# When comparing files between two commits, we save time by			# When comparing files between two commits, we save time by
	# not comparing the file contents when the nodeids differ.			# not comparing the file contents when the nodeids differ.
	# Note that this means we incorrectly report a reverted change			# Note that this means we incorrectly report a reverted change
	# to a file as a modification.			# to a file as a modification.
	modified.append(fn)			modified.append(fn)
	elif self[fn].cmp(other[fn]):			elif self[fn].cmp(other[fn]):
	modified.append(fn)			modified.append(fn)
	else:			else:
	merge.preferancestor configuration before falling back to the			merge.preferancestor configuration before falling back to the
	revlog ancestor."""			revlog ancestor."""
	# deal with workingctxs			# deal with workingctxs
	n2 = c2._node			n2 = c2._node
	if n2 is None:			if n2 is None:
	n2 = c2._parents[0]._node			n2 = c2._parents[0]._node
	cahs = self._repo.changelog.commonancestorsheads(self._node, n2)			cahs = self._repo.changelog.commonancestorsheads(self._node, n2)
	if not cahs:			if not cahs:
	anc = nullid			anc = self._repo.nodeconstants.nullid
	elif len(cahs) == 1:			elif len(cahs) == 1:
	anc = cahs[0]			anc = cahs[0]
	else:			else:
	# experimental config: merge.preferancestor			# experimental config: merge.preferancestor
	for r in self._repo.ui.configlist(b'merge', b'preferancestor'):			for r in self._repo.ui.configlist(b'merge', b'preferancestor'):
	try:			try:
	ctx = scmutil.revsymbol(self._repo, r)			ctx = scmutil.revsymbol(self._repo, r)
	except error.RepoLookupError:			except error.RepoLookupError:
	fctx._descendantrev = self._descendantrev			fctx._descendantrev = self._descendantrev
	fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)			fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
	return fctx			return fctx

	def parents(self):			def parents(self):
	_path = self._path			_path = self._path
	fl = self._filelog			fl = self._filelog
	parents = self._filelog.parents(self._filenode)			parents = self._filelog.parents(self._filenode)
	pl = [(_path, node, fl) for node in parents if node != nullid]			pl = [
				(_path, node, fl)
				for node in parents
				if node != self._repo.nodeconstants.nullid
				]

	r = fl.renamed(self._filenode)			r = fl.renamed(self._filenode)
	if r:			if r:
	# - In the simple rename case, both parent are nullid, pl is empty.			# - In the simple rename case, both parent are nullid, pl is empty.
	# - In case of merge, only one of the parent is null id and should			# - In case of merge, only one of the parent is null id and should
	# be replaced with the rename information. This parent is -always-			# be replaced with the rename information. This parent is -always-
	# the first one.			# the first one.
	#			#
	for f in d:			for f in d:
	if d[f] != b'r':			if d[f] != b'r':
	yield f			yield f

	def __contains__(self, key):			def __contains__(self, key):
	return self._repo.dirstate[key] not in b"?r"			return self._repo.dirstate[key] not in b"?r"

	def hex(self):			def hex(self):
	return wdirhex			return self._repo.nodeconstants.wdirhex

	@propertycache			@propertycache
	def _parents(self):			def _parents(self):
	p = self._repo.dirstate.parents()			p = self._repo.dirstate.parents()
	if p[1] == nullid:			if p[1] == self._repo.nodeconstants.nullid:
	p = p[:-1]			p = p[:-1]
	# use unfiltered repo to delay/avoid loading obsmarkers			# use unfiltered repo to delay/avoid loading obsmarkers
	unfi = self._repo.unfiltered()			unfi = self._repo.unfiltered()
	return [			return [
	changectx(			changectx(
	self._repo, unfi.changelog.rev(n), n, maybe_filtered=False			self._repo, unfi.changelog.rev(n), n, maybe_filtered=False
	)			)
	for n in p			for n in p
	]			]

	def setparents(self, p1node, p2node=nullid):			def setparents(self, p1node, p2node=None):
				if p2node is None:
				p2node = self._repo.nodeconstants.nullid
	dirstate = self._repo.dirstate			dirstate = self._repo.dirstate
	with dirstate.parentchange():			with dirstate.parentchange():
	copies = dirstate.setparents(p1node, p2node)			copies = dirstate.setparents(p1node, p2node)
	pctx = self._repo[p1node]			pctx = self._repo[p1node]
	if copies:			if copies:
	# Adjust copy records, the dirstate cannot do it, it			# Adjust copy records, the dirstate cannot do it, it
	# requires access to parents manifests. Preserve them			# requires access to parents manifests. Preserve them
	# only for entries added to first parent.			# only for entries added to first parent.
	for f in copies:			for f in copies:
	if f not in pctx and copies[f] in pctx:			if f not in pctx and copies[f] in pctx:
	dirstate.copy(copies[f], f)			dirstate.copy(copies[f], f)
	if p2node == nullid:			if p2node == self._repo.nodeconstants.nullid:
	for f, s in sorted(dirstate.copies().items()):			for f, s in sorted(dirstate.copies().items()):
	if f not in pctx and s not in pctx:			if f not in pctx and s not in pctx:
	dirstate.copy(None, f)			dirstate.copy(None, f)

	def _fileinfo(self, path):			def _fileinfo(self, path):
	# populate __dict__['_manifest'] as workingctx has no _manifestdelta			# populate __dict__['_manifest'] as workingctx has no _manifestdelta
	self._manifest			self._manifest
	return super(workingctx, self)._fileinfo(path)			return super(workingctx, self)._fileinfo(path)
	def _buildstatusmanifest(self, status):			def _buildstatusmanifest(self, status):
	"""Builds a manifest that includes the given status results."""			"""Builds a manifest that includes the given status results."""
	parents = self.parents()			parents = self.parents()

	man = parents[0].manifest().copy()			man = parents[0].manifest().copy()

	ff = self._flagfunc			ff = self._flagfunc
	for i, l in (			for i, l in (
	(addednodeid, status.added),			(self._repo.nodeconstants.addednodeid, status.added),
	(modifiednodeid, status.modified),			(self._repo.nodeconstants.modifiednodeid, status.modified),
	):			):
	for f in l:			for f in l:
	man[f] = i			man[f] = i
	try:			try:
	man.setflag(f, ff(f))			man.setflag(f, ff(f))
	except OSError:			except OSError:
	pass			pass

	def linkrev(self):			def linkrev(self):
	# linked to self._changectx no matter if file is modified or not			# linked to self._changectx no matter if file is modified or not
	return self.rev()			return self.rev()

	def renamed(self):			def renamed(self):
	path = self.copysource()			path = self.copysource()
	if not path:			if not path:
	return None			return None
	return path, self._changectx._parents[0]._manifest.get(path, nullid)			return (
				path,
				self._changectx._parents[0]._manifest.get(
				path, self._repo.nodeconstants.nullid
				),
				)

	def parents(self):			def parents(self):
	'''return parent filectxs, following copies if necessary'''			'''return parent filectxs, following copies if necessary'''

	def filenode(ctx, path):			def filenode(ctx, path):
	return ctx._manifest.get(path, nullid)			return ctx._manifest.get(path, self._repo.nodeconstants.nullid)

	path = self._path			path = self._path
	fl = self._filelog			fl = self._filelog
	pcl = self._changectx._parents			pcl = self._changectx._parents
	renamed = self.renamed()			renamed = self.renamed()

	if renamed:			if renamed:
	pl = [renamed + (None,)]			pl = [renamed + (None,)]
	else:			else:
	pl = [(path, filenode(pcl[0], path), fl)]			pl = [(path, filenode(pcl[0], path), fl)]

	for pc in pcl[1:]:			for pc in pcl[1:]:
	pl.append((path, filenode(pc, path), fl))			pl.append((path, filenode(pc, path), fl))

	return [			return [
	self._parentfilectx(p, fileid=n, filelog=l)			self._parentfilectx(p, fileid=n, filelog=l)
	for p, n, l in pl			for p, n, l in pl
	if n != nullid			if n != self._repo.nodeconstants.nullid
	]			]

	def children(self):			def children(self):
	return []			return []


	class workingfilectx(committablefilectx):			class workingfilectx(committablefilectx):
	"""A workingfilectx object makes access to data related to a particular			"""A workingfilectx object makes access to data related to a particular
	def setbase(self, wrappedctx):			def setbase(self, wrappedctx):
	self._wrappedctx = wrappedctx			self._wrappedctx = wrappedctx
	self._parents = [wrappedctx]			self._parents = [wrappedctx]
	# Drop old manifest cache as it is now out of date.			# Drop old manifest cache as it is now out of date.
	# This is necessary when, e.g., rebasing several nodes with one			# This is necessary when, e.g., rebasing several nodes with one
	# ``overlayworkingctx`` (e.g. with --collapse).			# ``overlayworkingctx`` (e.g. with --collapse).
	util.clearcachedproperty(self, b'_manifest')			util.clearcachedproperty(self, b'_manifest')

	def setparents(self, p1node, p2node=nullid):			def setparents(self, p1node, p2node=None):
				if p2node is None:
				p2node = self._repo.nodeconstants.nullid
	assert p1node == self._wrappedctx.node()			assert p1node == self._wrappedctx.node()
	self._parents = [self._wrappedctx, self._repo.unfiltered()[p2node]]			self._parents = [self._wrappedctx, self._repo.unfiltered()[p2node]]

	def data(self, path):			def data(self, path):
	if self.isdirty(path):			if self.isdirty(path):
	if self._cache[path][b'exists']:			if self._cache[path][b'exists']:
	if self._cache[path][b'data'] is not None:			if self._cache[path][b'data'] is not None:
	return self._cache[path][b'data']			return self._cache[path][b'data']

	@propertycache			@propertycache
	def _manifest(self):			def _manifest(self):
	parents = self.parents()			parents = self.parents()
	man = parents[0].manifest().copy()			man = parents[0].manifest().copy()

	flag = self._flagfunc			flag = self._flagfunc
	for path in self.added():			for path in self.added():
	man[path] = addednodeid			man[path] = self._repo.nodeconstants.addednodeid
	man.setflag(path, flag(path))			man.setflag(path, flag(path))
	for path in self.modified():			for path in self.modified():
	man[path] = modifiednodeid			man[path] = self._repo.nodeconstants.modifiednodeid
	man.setflag(path, flag(path))			man.setflag(path, flag(path))
	for path in self.removed():			for path in self.removed():
	del man[path]			del man[path]
	return man			return man

	@propertycache			@propertycache
	def _flagfunc(self):			def _flagfunc(self):
	def f(path):			def f(path):
	branch=None,			branch=None,
	editor=None,			editor=None,
	):			):
	super(memctx, self).__init__(			super(memctx, self).__init__(
	repo, text, user, date, extra, branch=branch			repo, text, user, date, extra, branch=branch
	)			)
	self._rev = None			self._rev = None
	self._node = None			self._node = None
	parents = [(p or nullid) for p in parents]			parents = [(p or self._repo.nodeconstants.nullid) for p in parents]
	p1, p2 = parents			p1, p2 = parents
	self._parents = [self._repo[p] for p in (p1, p2)]			self._parents = [self._repo[p] for p in (p1, p2)]
	files = sorted(set(files))			files = sorted(set(files))
	self._files = files			self._files = files
	self.substate = {}			self.substate = {}

	if isinstance(filectxfn, patch.filestore):			if isinstance(filectxfn, patch.filestore):
	filectxfn = memfilefrompatch(filectxfn)			filectxfn = memfilefrompatch(filectxfn)
	def _manifest(self):			def _manifest(self):
	"""generate a manifest based on the return values of filectxfn"""			"""generate a manifest based on the return values of filectxfn"""

	# keep this simple for now; just worry about p1			# keep this simple for now; just worry about p1
	pctx = self._parents[0]			pctx = self._parents[0]
	man = pctx.manifest().copy()			man = pctx.manifest().copy()

	for f in self._status.modified:			for f in self._status.modified:
	man[f] = modifiednodeid			man[f] = self._repo.nodeconstants.modifiednodeid

	for f in self._status.added:			for f in self._status.added:
	man[f] = addednodeid			man[f] = self._repo.nodeconstants.addednodeid

	for f in self._status.removed:			for f in self._status.removed:
	if f in man:			if f in man:
	del man[f]			del man[f]

	return man			return man

	@propertycache			@propertycache
	parents = parents[:]			parents = parents[:]
	while len(parents) < 2:			while len(parents) < 2:
	parents.append(repo[nullrev])			parents.append(repo[nullrev])
	p1, p2 = self._parents = parents			p1, p2 = self._parents = parents

	# sanity check to ensure that the reused manifest parents are			# sanity check to ensure that the reused manifest parents are
	# manifests of our commit parents			# manifests of our commit parents
	mp1, mp2 = self.manifestctx().parents			mp1, mp2 = self.manifestctx().parents
	if p1 != nullid and p1.manifestnode() != mp1:			if p1 != self._repo.nodeconstants.nullid and p1.manifestnode() != mp1:
	raise RuntimeError(			raise RuntimeError(
	r"can't reuse the manifest: its p1 "			r"can't reuse the manifest: its p1 "
	r"doesn't match the new ctx p1"			r"doesn't match the new ctx p1"
	)			)
	if p2 != nullid and p2.manifestnode() != mp2:			if p2 != self._repo.nodeconstants.nullid and p2.manifestnode() != mp2:
	raise RuntimeError(			raise RuntimeError(
	r"can't reuse the manifest: "			r"can't reuse the manifest: "
	r"its p2 doesn't match the new ctx p2"			r"its p2 doesn't match the new ctx p2"
	)			)

	self._files = originalctx.files()			self._files = originalctx.files()
	self.substate = {}			self.substate = {}

mercurial/copies.py

	# coding: utf8			# coding: utf8
	# copies.py - copy detection for Mercurial			# copies.py - copy detection for Mercurial
	#			#
	# Copyright 2008 Olivia Mackall <olivia@selenic.com>			# Copyright 2008 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import os			import os

	from .i18n import _			from .i18n import _
	from .node import (			from .node import nullrev
	nullid,
	nullrev,
	)

	from . import (			from . import (
	match as matchmod,			match as matchmod,
	pathutil,			pathutil,
	policy,			policy,
	pycompat,			pycompat,
	util,			util,
	)			)

	def ismerged(path):			def ismerged(path):
	if path not in ctx.files():			if path not in ctx.files():
	return False			return False
	fctx = ctx[path]			fctx = ctx[path]
	parents = fctx._filelog.parents(fctx._filenode)			parents = fctx._filelog.parents(fctx._filenode)
	nb_parents = 0			nb_parents = 0
	for n in parents:			for n in parents:
	if n != nullid:			if n != repo.nullid:
	nb_parents += 1			nb_parents += 1
	return nb_parents >= 2			return nb_parents >= 2

	return ismerged			return ismerged

	def revinfo(rev):			def revinfo(rev):
	p1, p2 = parents(rev)			p1, p2 = parents(rev)
	ctx = repo[rev]			ctx = repo[rev]

mercurial/debugcommands.py

	import subprocess			import subprocess
	import sys			import sys
	import time			import time

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	)			)
	from .pycompat import (			from .pycompat import (
	getattr,			getattr,
	open,			open,
	)			)
	from . import (			from . import (
	"""dump an index DAG as a graphviz dot file"""			"""dump an index DAG as a graphviz dot file"""
	opts = pycompat.byteskwargs(opts)			opts = pycompat.byteskwargs(opts)
	r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts)			r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts)
	ui.writenoi18n(b"digraph G {\n")			ui.writenoi18n(b"digraph G {\n")
	for i in r:			for i in r:
	node = r.node(i)			node = r.node(i)
	pp = r.parents(node)			pp = r.parents(node)
	ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))			ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))
	if pp[1] != nullid:			if pp[1] != repo.nullid:
	ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))			ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))
	ui.write(b"}\n")			ui.write(b"}\n")


	@command(b'debugindexstats', [])			@command(b'debugindexstats', [])
	def debugindexstats(ui, repo):			def debugindexstats(ui, repo):
	"""show stats related to the changelog index"""			"""show stats related to the changelog index"""
	repo.changelog.shortest(nullid, 1)			repo.changelog.shortest(repo.nullid, 1)
	index = repo.changelog.index			index = repo.changelog.index
	if not util.safehasattr(index, b'stats'):			if not util.safehasattr(index, b'stats'):
	raise error.Abort(_(b'debugindexstats only works with native code'))			raise error.Abort(_(b'debugindexstats only works with native code'))
	for k, v in sorted(index.stats().items()):			for k, v in sorted(index.stats().items()):
	ui.write(b'%s: %d\n' % (k, v))			ui.write(b'%s: %d\n' % (k, v))


	@command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True)			@command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True)
	opts = pycompat.byteskwargs(opts)			opts = pycompat.byteskwargs(opts)

	def parsenodeid(s):			def parsenodeid(s):
	try:			try:
	# We do not use revsingle/revrange functions here to accept			# We do not use revsingle/revrange functions here to accept
	# arbitrary node identifiers, possibly not present in the			# arbitrary node identifiers, possibly not present in the
	# local repository.			# local repository.
	n = bin(s)			n = bin(s)
	if len(n) != len(nullid):			if len(n) != repo.nodeconstants.nodelen:
	raise TypeError()			raise TypeError()
	return n			return n
	except TypeError:			except TypeError:
	raise error.InputError(			raise error.InputError(
	b'changeset references must be full hexadecimal '			b'changeset references must be full hexadecimal '
	b'node identifiers'			b'node identifiers'
	)			)

	)			)

	for i in r:			for i in r:
	node = r.node(i)			node = r.node(i)
	if format == 0:			if format == 0:
	try:			try:
	pp = r.parents(node)			pp = r.parents(node)
	except Exception:			except Exception:
	pp = [nullid, nullid]			pp = [repo.nullid, repo.nullid]
	if ui.verbose:			if ui.verbose:
	ui.write(			ui.write(
	b"% 6d % 9d % 7d % 7d %s %s %s\n"			b"% 6d % 9d % 7d % 7d %s %s %s\n"
	% (			% (
	i,			i,
	r.start(i),			r.start(i),
	r.length(i),			r.length(i),
	r.linkrev(i),			r.linkrev(i),

	def display(other, chlist, displayer):			def display(other, chlist, displayer):
	if opts.get(b"newest_first"):			if opts.get(b"newest_first"):
	chlist.reverse()			chlist.reverse()
	count = 0			count = 0
	for n in chlist:			for n in chlist:
	if limit is not None and count >= limit:			if limit is not None and count >= limit:
	break			break
	parents = [True for p in other.changelog.parents(n) if p != nullid]			parents = [
				True for p in other.changelog.parents(n) if p != repo.nullid
				]
	if opts.get(b"no_merges") and len(parents) == 2:			if opts.get(b"no_merges") and len(parents) == 2:
	continue			continue
	count += 1			count += 1
	displayer.show(other[n])			displayer.show(other[n])

	recovernode = opts.get(b"recover")			recovernode = opts.get(b"recover")
	if recovernode:			if recovernode:
	if scmutil.isrevsymbol(repo, recovernode):			if scmutil.isrevsymbol(repo, recovernode):

mercurial/dirstate.py

	# dirstate.py - working directory tracking for mercurial			# dirstate.py - working directory tracking for mercurial
	#			#
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import contextlib			import contextlib
	import errno			import errno
	import os			import os
	import stat			import stat

	from .i18n import _			from .i18n import _
	from .node import nullid
	from .pycompat import delattr			from .pycompat import delattr

	from hgdemandimport import tracing			from hgdemandimport import tracing

	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	match as matchmod,			match as matchmod,
	return self._validate(self._pl[0])			return self._validate(self._pl[0])

	def p2(self):			def p2(self):
	return self._validate(self._pl[1])			return self._validate(self._pl[1])

	def branch(self):			def branch(self):
	return encoding.tolocal(self._branch)			return encoding.tolocal(self._branch)

	def setparents(self, p1, p2=nullid):			def setparents(self, p1, p2=None):
	"""Set dirstate parents to p1 and p2.			"""Set dirstate parents to p1 and p2.

	When moving from two parents to one, 'm' merged entries a			When moving from two parents to one, 'm' merged entries a
	adjusted to normal and previous copy records discarded and			adjusted to normal and previous copy records discarded and
	returned by the call.			returned by the call.

	See localrepo.setparents()			See localrepo.setparents()
	"""			"""
				if p2 is None:
				p2 = self._nodeconstants.nullid
	if self._parentwriters == 0:			if self._parentwriters == 0:
	raise ValueError(			raise ValueError(
	b"cannot set dirstate parent outside of "			b"cannot set dirstate parent outside of "
	b"dirstate.parentchange context manager"			b"dirstate.parentchange context manager"
	)			)

	self._dirty = True			self._dirty = True
	oldp2 = self._pl[1]			oldp2 = self._pl[1]
	if self._origpl is None:			if self._origpl is None:
	self._origpl = self._pl			self._origpl = self._pl
	self._map.setparents(p1, p2)			self._map.setparents(p1, p2)
	copies = {}			copies = {}
	if oldp2 != nullid and p2 == nullid:			if (
				oldp2 != self._nodeconstants.nullid
				and p2 == self._nodeconstants.nullid
				):
	candidatefiles = self._map.nonnormalset.union(			candidatefiles = self._map.nonnormalset.union(
	self._map.otherparentset			self._map.otherparentset
	)			)
	for f in candidatefiles:			for f in candidatefiles:
	s = self._map.get(f)			s = self._map.get(f)
	if s is None:			if s is None:
	continue			continue

	if mtime > self._lastnormaltime:			if mtime > self._lastnormaltime:
	# Remember the most recent modification timeslot for status(),			# Remember the most recent modification timeslot for status(),
	# to make sure we won't miss future size-preserving file content			# to make sure we won't miss future size-preserving file content
	# modifications that happen within the same timeslot.			# modifications that happen within the same timeslot.
	self._lastnormaltime = mtime			self._lastnormaltime = mtime

	def normallookup(self, f):			def normallookup(self, f):
	'''Mark a file normal, but possibly dirty.'''			'''Mark a file normal, but possibly dirty.'''
	if self._pl[1] != nullid:			if self._pl[1] != self._nodeconstants.nullid:
	# if there is a merge going on and the file was either			# if there is a merge going on and the file was either
	# in state 'm' (-1) or coming from other parent (-2) before			# in state 'm' (-1) or coming from other parent (-2) before
	# being removed, restore that state.			# being removed, restore that state.
	entry = self._map.get(f)			entry = self._map.get(f)
	if entry is not None:			if entry is not None:
	if entry[0] == b'r' and entry[2] in (-1, -2):			if entry[0] == b'r' and entry[2] in (-1, -2):
	source = self._map.copymap.get(f)			source = self._map.copymap.get(f)
	if entry[2] == -1:			if entry[2] == -1:
	self.merge(f)			self.merge(f)
	elif entry[2] == -2:			elif entry[2] == -2:
	self.otherparent(f)			self.otherparent(f)
	if source:			if source:
	self.copy(source, f)			self.copy(source, f)
	return			return
	if entry[0] == b'm' or entry[0] == b'n' and entry[2] == -2:			if entry[0] == b'm' or entry[0] == b'n' and entry[2] == -2:
	return			return
	self._addpath(f, b'n', 0, -1, -1)			self._addpath(f, b'n', 0, -1, -1)
	self._map.copymap.pop(f, None)			self._map.copymap.pop(f, None)

	def otherparent(self, f):			def otherparent(self, f):
	'''Mark as coming from the other parent, always dirty.'''			'''Mark as coming from the other parent, always dirty.'''
	if self._pl[1] == nullid:			if self._pl[1] == self._nodeconstants.nullid:
	raise error.Abort(			raise error.Abort(
	_(b"setting %r to other parent only allowed in merges") % f			_(b"setting %r to other parent only allowed in merges") % f
	)			)
	if f in self and self[f] == b'n':			if f in self and self[f] == b'n':
	# merge-like			# merge-like
	self._addpath(f, b'm', 0, -2, -1)			self._addpath(f, b'm', 0, -2, -1)
	else:			else:
	# add-like			# add-like
	self._addpath(f, b'n', 0, -2, -1)			self._addpath(f, b'n', 0, -2, -1)
	self._map.copymap.pop(f, None)			self._map.copymap.pop(f, None)

	def add(self, f):			def add(self, f):
	'''Mark a file added.'''			'''Mark a file added.'''
	self._addpath(f, b'a', 0, -1, -1)			self._addpath(f, b'a', 0, -1, -1)
	self._map.copymap.pop(f, None)			self._map.copymap.pop(f, None)

	def remove(self, f):			def remove(self, f):
	'''Mark a file removed.'''			'''Mark a file removed.'''
	self._dirty = True			self._dirty = True
	oldstate = self[f]			oldstate = self[f]
	size = 0			size = 0
	if self._pl[1] != nullid:			if self._pl[1] != self._nodeconstants.nullid:
	entry = self._map.get(f)			entry = self._map.get(f)
	if entry is not None:			if entry is not None:
	# backup the previous state			# backup the previous state
	if entry[0] == b'm': # merge			if entry[0] == b'm': # merge
	size = -1			size = -1
	elif entry[0] == b'n' and entry[2] == -2: # other parent			elif entry[0] == b'n' and entry[2] == -2: # other parent
	size = -2			size = -2
	self._map.otherparentset.add(f)			self._map.otherparentset.add(f)
	self._updatedfiles.add(f)			self._updatedfiles.add(f)
	self._map.removefile(f, oldstate, size)			self._map.removefile(f, oldstate, size)
	if size == 0:			if size == 0:
	self._map.copymap.pop(f, None)			self._map.copymap.pop(f, None)

	def merge(self, f):			def merge(self, f):
	'''Mark a file merged.'''			'''Mark a file merged.'''
	if self._pl[1] == nullid:			if self._pl[1] == self._nodeconstants.nullid:
	return self.normallookup(f)			return self.normallookup(f)
	return self.otherparent(f)			return self.otherparent(f)

	def drop(self, f):			def drop(self, f):
	'''Drop a file from the dirstate'''			'''Drop a file from the dirstate'''
	oldstate = self[f]			oldstate = self[f]
	if self._map.dropfile(f, oldstate):			if self._map.dropfile(f, oldstate):
	self._dirty = True			self._dirty = True
	to_drop.append(f)			to_drop.append(f)
	else:			else:
	changedfilesset = set(changedfiles)			changedfilesset = set(changedfiles)
	to_lookup = changedfilesset & set(allfiles)			to_lookup = changedfilesset & set(allfiles)
	to_drop = changedfilesset - to_lookup			to_drop = changedfilesset - to_lookup

	if self._origpl is None:			if self._origpl is None:
	self._origpl = self._pl			self._origpl = self._pl
	self._map.setparents(parent, nullid)			self._map.setparents(parent, self._nodeconstants.nullid)

	for f in to_lookup:			for f in to_lookup:
	self.normallookup(f)			self.normallookup(f)
	for f in to_drop:			for f in to_drop:
	self.drop(f)			self.drop(f)

	self._dirty = True			self._dirty = True

	def copymap(self):			def copymap(self):
	self.copymap = {}			self.copymap = {}
	self._map			self._map
	return self.copymap			return self.copymap

	def clear(self):			def clear(self):
	self._map.clear()			self._map.clear()
	self.copymap.clear()			self.copymap.clear()
	self.setparents(nullid, nullid)			self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
	util.clearcachedproperty(self, b"_dirs")			util.clearcachedproperty(self, b"_dirs")
	util.clearcachedproperty(self, b"_alldirs")			util.clearcachedproperty(self, b"_alldirs")
	util.clearcachedproperty(self, b"filefoldmap")			util.clearcachedproperty(self, b"filefoldmap")
	util.clearcachedproperty(self, b"dirfoldmap")			util.clearcachedproperty(self, b"dirfoldmap")
	util.clearcachedproperty(self, b"nonnormalset")			util.clearcachedproperty(self, b"nonnormalset")
	util.clearcachedproperty(self, b"otherparentset")			util.clearcachedproperty(self, b"otherparentset")

	def items(self):			def items(self):

	l = len(st)			l = len(st)
	if l == self._nodelen * 2:			if l == self._nodelen * 2:
	self._parents = (			self._parents = (
	st[: self._nodelen],			st[: self._nodelen],
	st[self._nodelen : 2 * self._nodelen],			st[self._nodelen : 2 * self._nodelen],
	)			)
	elif l == 0:			elif l == 0:
	self._parents = (nullid, nullid)			self._parents = (
				self._nodeconstants.nullid,
				self._nodeconstants.nullid,
				)
	else:			else:
	raise error.Abort(			raise error.Abort(
	_(b'working directory state appears damaged!')			_(b'working directory state appears damaged!')
	)			)

	return self._parents			return self._parents

	def setparents(self, p1, p2):			def setparents(self, p1, p2):
	return self._rustmap.copymap()			return self._rustmap.copymap()

	def preload(self):			def preload(self):
	self._rustmap			self._rustmap

	def clear(self):			def clear(self):
	self._rustmap.clear()			self._rustmap.clear()
	self._inner_rustmap.clear()			self._inner_rustmap.clear()
	self.setparents(nullid, nullid)			self.setparents(
				self._nodeconstants.nullid, self._nodeconstants.nullid
				)
	util.clearcachedproperty(self, b"_dirs")			util.clearcachedproperty(self, b"_dirs")
	util.clearcachedproperty(self, b"_alldirs")			util.clearcachedproperty(self, b"_alldirs")
	util.clearcachedproperty(self, b"dirfoldmap")			util.clearcachedproperty(self, b"dirfoldmap")

	def items(self):			def items(self):
	return self._rustmap.items()			return self._rustmap.items()

	def keys(self):			def keys(self):

mercurial/discovery.py

	# discovery.py - protocol changeset discovery functions			# discovery.py - protocol changeset discovery functions
	#			#
	# Copyright 2010 Olivia Mackall <olivia@selenic.com>			# Copyright 2010 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import functools			import functools

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	short,			short,
	)			)

	from . import (			from . import (
	bookmarks,			bookmarks,
	branchmap,			branchmap,
	error,			error,
	phases,			phases,
	# at least one of them must not be set			# at least one of them must not be set
	assert None in (commonheads, missingroots)			assert None in (commonheads, missingroots)
	cl = repo.changelog			cl = repo.changelog
	if ancestorsof is None:			if ancestorsof is None:
	ancestorsof = cl.heads()			ancestorsof = cl.heads()
	if missingroots:			if missingroots:
	discbases = []			discbases = []
	for n in missingroots:			for n in missingroots:
	discbases.extend([p for p in cl.parents(n) if p != nullid])			discbases.extend([p for p in cl.parents(n) if p != repo.nullid])
	# TODO remove call to nodesbetween.			# TODO remove call to nodesbetween.
	# TODO populate attributes on outgoing instance instead of setting			# TODO populate attributes on outgoing instance instead of setting
	# discbases.			# discbases.
	csets, roots, heads = cl.nodesbetween(missingroots, ancestorsof)			csets, roots, heads = cl.nodesbetween(missingroots, ancestorsof)
	included = set(csets)			included = set(csets)
	ancestorsof = heads			ancestorsof = heads
	commonheads = [n for n in discbases if n not in included]			commonheads = [n for n in discbases if n not in included]
	elif not commonheads:			elif not commonheads:
	commonheads = [nullid]			commonheads = [repo.nullid]
	self.commonheads = commonheads			self.commonheads = commonheads
	self.ancestorsof = ancestorsof			self.ancestorsof = ancestorsof
	self._revlog = cl			self._revlog = cl
	self._common = None			self._common = None
	self._missing = None			self._missing = None
	self.excluded = []			self.excluded = []

	def _computecommonmissing(self):			def _computecommonmissing(self):
	inc = bool(pushop.incoming)			inc = bool(pushop.incoming)

	# Check for each named branch if we're creating new remote heads.			# Check for each named branch if we're creating new remote heads.
	# To be a remote head after push, node must be either:			# To be a remote head after push, node must be either:
	# - unknown locally			# - unknown locally
	# - a local outgoing head descended from update			# - a local outgoing head descended from update
	# - a remote head that's known locally and not			# - a remote head that's known locally and not
	# ancestral to an outgoing head			# ancestral to an outgoing head
	if remoteheads == [nullid]:			if remoteheads == [repo.nullid]:
	# remote is empty, nothing to check.			# remote is empty, nothing to check.
	return			return

	if remote.capable(b'branchmap'):			if remote.capable(b'branchmap'):
	headssum = _headssummary(pushop)			headssum = _headssummary(pushop)
	else:			else:
	headssum = _oldheadssummary(repo, remoteheads, outgoing, inc)			headssum = _oldheadssummary(repo, remoteheads, outgoing, inc)
	pushop.pushbranchmap = headssum			pushop.pushbranchmap = headssum

mercurial/exchange.py

	# exchange.py - utility to exchange data between repos.			# exchange.py - utility to exchange data between repos.
	#			#
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import weakref			import weakref

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)
	from . import (			from . import (
	bookmarks as bookmod,			bookmarks as bookmod,
	bundle2,			bundle2,
	bundlecaches,			bundlecaches,
	changegroup,			changegroup,
	discovery,			discovery,

	Returns a discovery.outgoing object.			Returns a discovery.outgoing object.
	"""			"""
	cl = repo.changelog			cl = repo.changelog
	if common:			if common:
	hasnode = cl.hasnode			hasnode = cl.hasnode
	common = [n for n in common if hasnode(n)]			common = [n for n in common if hasnode(n)]
	else:			else:
	common = [nullid]			common = [repo.nullid]
	if not heads:			if not heads:
	heads = cl.heads()			heads = cl.heads()
	return discovery.outgoing(repo, common, heads)			return discovery.outgoing(repo, common, heads)


	def _checkpublish(pushop):			def _checkpublish(pushop):
	repo = pushop.repo			repo = pushop.repo
	ui = repo.ui			ui = repo.ui
	# If this is a full pull / clone and the server supports the clone bundles			# If this is a full pull / clone and the server supports the clone bundles
	# feature, tell the server whether we attempted a clone bundle. The			# feature, tell the server whether we attempted a clone bundle. The
	# presence of this flag indicates the client supports clone bundles. This			# presence of this flag indicates the client supports clone bundles. This
	# will enable the server to treat clients that support clone bundles			# will enable the server to treat clients that support clone bundles
	# differently from those that don't.			# differently from those that don't.
	if (			if (
	pullop.remote.capable(b'clonebundles')			pullop.remote.capable(b'clonebundles')
	and pullop.heads is None			and pullop.heads is None
	and list(pullop.common) == [nullid]			and list(pullop.common) == [pullop.repo.nullid]
	):			):
	kwargs[b'cbattempted'] = pullop.clonebundleattempted			kwargs[b'cbattempted'] = pullop.clonebundleattempted

	if streaming:			if streaming:
	pullop.repo.ui.status(_(b'streaming all changes\n'))			pullop.repo.ui.status(_(b'streaming all changes\n'))
	elif not pullop.fetch:			elif not pullop.fetch:
	pullop.repo.ui.status(_(b"no changes found\n"))			pullop.repo.ui.status(_(b"no changes found\n"))
	pullop.cgresult = 0			pullop.cgresult = 0
	else:			else:
	if pullop.heads is None and list(pullop.common) == [nullid]:			if pullop.heads is None and list(pullop.common) == [pullop.repo.nullid]:
	pullop.repo.ui.status(_(b"requesting all changes\n"))			pullop.repo.ui.status(_(b"requesting all changes\n"))
	if obsolete.isenabled(pullop.repo, obsolete.exchangeopt):			if obsolete.isenabled(pullop.repo, obsolete.exchangeopt):
	remoteversions = bundle2.obsmarkersversion(pullop.remotebundle2caps)			remoteversions = bundle2.obsmarkersversion(pullop.remotebundle2caps)
	if obsolete.commonversion(remoteversions) is not None:			if obsolete.commonversion(remoteversions) is not None:
	kwargs[b'obsmarkers'] = True			kwargs[b'obsmarkers'] = True
	pullop.stepsdone.add(b'obsmarkers')			pullop.stepsdone.add(b'obsmarkers')
	_pullbundle2extraprepare(pullop, kwargs)			_pullbundle2extraprepare(pullop, kwargs)

	if b'changegroup' in pullop.stepsdone:			if b'changegroup' in pullop.stepsdone:
	return			return
	pullop.stepsdone.add(b'changegroup')			pullop.stepsdone.add(b'changegroup')
	if not pullop.fetch:			if not pullop.fetch:
	pullop.repo.ui.status(_(b"no changes found\n"))			pullop.repo.ui.status(_(b"no changes found\n"))
	pullop.cgresult = 0			pullop.cgresult = 0
	return			return
	tr = pullop.gettransaction()			tr = pullop.gettransaction()
	if pullop.heads is None and list(pullop.common) == [nullid]:			if pullop.heads is None and list(pullop.common) == [pullop.repo.nullid]:
	pullop.repo.ui.status(_(b"requesting all changes\n"))			pullop.repo.ui.status(_(b"requesting all changes\n"))
	elif pullop.heads is None and pullop.remote.capable(b'changegroupsubset'):			elif pullop.heads is None and pullop.remote.capable(b'changegroupsubset'):
	# issue1320, avoid a race if remote changed after discovery			# issue1320, avoid a race if remote changed after discovery
	pullop.heads = pullop.rheads			pullop.heads = pullop.rheads

	if pullop.remote.capable(b'getbundle'):			if pullop.remote.capable(b'getbundle'):
	# TODO: get bundlecaps from remote			# TODO: get bundlecaps from remote
	cg = pullop.remote.getbundle(			cg = pullop.remote.getbundle(

mercurial/exchangev2.py

	# exchangev2.py - repository exchange for wire protocol version 2			# exchangev2.py - repository exchange for wire protocol version 2
	#			#
	# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>			# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import weakref			import weakref

	from .i18n import _			from .i18n import _
	from .node import (			from .node import short
	nullid,
	short,
	)
	from . import (			from . import (
	bookmarks,			bookmarks,
	error,			error,
	mdiff,			mdiff,
	narrowspec,			narrowspec,
	phases,			phases,
	pycompat,			pycompat,
	requirements as requirementsmod,			requirements as requirementsmod,
	if fetch and remoteheads:			if fetch and remoteheads:
	has_node = repo.unfiltered().changelog.index.has_node			has_node = repo.unfiltered().changelog.index.has_node

	common \|= {head for head in remoteheads if has_node(head)}			common \|= {head for head in remoteheads if has_node(head)}

	if set(remoteheads).issubset(common):			if set(remoteheads).issubset(common):
	fetch = []			fetch = []

	common.discard(nullid)			common.discard(repo.nullid)

	return common, fetch, remoteheads			return common, fetch, remoteheads


	def _fetchchangesets(repo, tr, remote, common, fetch, remoteheads):			def _fetchchangesets(repo, tr, remote, common, fetch, remoteheads):
	# TODO consider adding a step here where we obtain the DAG shape first			# TODO consider adding a step here where we obtain the DAG shape first
	# (or ask the server to slice changesets into chunks for us) so that			# (or ask the server to slice changesets into chunks for us) so that
	# we can perform multiple fetches in batches. This will facilitate			# we can perform multiple fetches in batches. This will facilitate

	yield (			yield (
	node,			node,
	cset[b'parents'][0],			cset[b'parents'][0],
	cset[b'parents'][1],			cset[b'parents'][1],
	# Linknode is always itself for changesets.			# Linknode is always itself for changesets.
	cset[b'node'],			cset[b'node'],
	# We always send full revisions. So delta base is not set.			# We always send full revisions. So delta base is not set.
	nullid,			repo.nullid,
	mdiff.trivialdiffheader(len(data)) + data,			mdiff.trivialdiffheader(len(data)) + data,
	# Flags not yet supported.			# Flags not yet supported.
	0,			0,
	# Sidedata not yet supported			# Sidedata not yet supported
	{},			{},
	)			)

	cl.addgroup(			cl.addgroup(

	for field, size in manifest.get(b'fieldsfollowing', []):			for field, size in manifest.get(b'fieldsfollowing', []):
	extrafields[field] = next(objs)			extrafields[field] = next(objs)

	if b'delta' in extrafields:			if b'delta' in extrafields:
	basenode = manifest[b'deltabasenode']			basenode = manifest[b'deltabasenode']
	delta = extrafields[b'delta']			delta = extrafields[b'delta']
	elif b'revision' in extrafields:			elif b'revision' in extrafields:
	basenode = nullid			basenode = repo.nullid
	revision = extrafields[b'revision']			revision = extrafields[b'revision']
	delta = mdiff.trivialdiffheader(len(revision)) + revision			delta = mdiff.trivialdiffheader(len(revision)) + revision
	else:			else:
	continue			continue

	yield (			yield (
	node,			node,
	manifest[b'parents'][0],			manifest[b'parents'][0],

	for field, size in filerevision.get(b'fieldsfollowing', []):			for field, size in filerevision.get(b'fieldsfollowing', []):
	extrafields[field] = next(objs)			extrafields[field] = next(objs)

	if b'delta' in extrafields:			if b'delta' in extrafields:
	basenode = filerevision[b'deltabasenode']			basenode = filerevision[b'deltabasenode']
	delta = extrafields[b'delta']			delta = extrafields[b'delta']
	elif b'revision' in extrafields:			elif b'revision' in extrafields:
	basenode = nullid			basenode = repo.nullid
	revision = extrafields[b'revision']			revision = extrafields[b'revision']
	delta = mdiff.trivialdiffheader(len(revision)) + revision			delta = mdiff.trivialdiffheader(len(revision)) + revision
	else:			else:
	continue			continue

	yield (			yield (
	node,			node,
	filerevision[b'parents'][0],			filerevision[b'parents'][0],

	for field, size in filerevision.get(b'fieldsfollowing', []):			for field, size in filerevision.get(b'fieldsfollowing', []):
	extrafields[field] = next(objs)			extrafields[field] = next(objs)

	if b'delta' in extrafields:			if b'delta' in extrafields:
	basenode = filerevision[b'deltabasenode']			basenode = filerevision[b'deltabasenode']
	delta = extrafields[b'delta']			delta = extrafields[b'delta']
	elif b'revision' in extrafields:			elif b'revision' in extrafields:
	basenode = nullid			basenode = repo.nullid
	revision = extrafields[b'revision']			revision = extrafields[b'revision']
	delta = mdiff.trivialdiffheader(len(revision)) + revision			delta = mdiff.trivialdiffheader(len(revision)) + revision
	else:			else:
	continue			continue

	if b'linknode' in filerevision:			if b'linknode' in filerevision:
	linknode = filerevision[b'linknode']			linknode = filerevision[b'linknode']
	else:			else:

mercurial/filelog.py

	# filelog.py - file history class for mercurial			# filelog.py - file history class for mercurial
	#			#
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	from .i18n import _			from .i18n import _
	from .node import (			from .node import nullrev
	nullid,
	nullrev,
	)
	from . import (			from . import (
	error,			error,
	revlog,			revlog,
	)			)
	from .interfaces import (			from .interfaces import (
	repository,			repository,
	util as interfaceutil,			util as interfaceutil,
	)			)

	def __len__(self):			def __len__(self):
	return len(self._revlog)			return len(self._revlog)

	def __iter__(self):			def __iter__(self):
	return self._revlog.__iter__()			return self._revlog.__iter__()

	def hasnode(self, node):			def hasnode(self, node):
	if node in (nullid, nullrev):			if node in (self.nullid, nullrev):
	return False			return False

	try:			try:
	self._revlog.rev(node)			self._revlog.rev(node)
	return True			return True
	except (TypeError, ValueError, IndexError, error.LookupError):			except (TypeError, ValueError, IndexError, error.LookupError):
	return False			return False

mercurial/filemerge.py

	import contextlib			import contextlib
	import os			import os
	import re			import re
	import shutil			import shutil

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from .pycompat import (			from .pycompat import (
	getattr,			getattr,
	open,			open,
	)			)

	from . import (			from . import (

	def size(self):			def size(self):
	return None			return None

	def data(self):			def data(self):
	return None			return None

	def filenode(self):			def filenode(self):
	return nullid			return self._ctx.repo().nullid

	_customcmp = True			_customcmp = True

	def cmp(self, fctx):			def cmp(self, fctx):
	"""compare with other file context			"""compare with other file context

	returns True if different from fctx.			returns True if different from fctx.
	"""			"""

mercurial/hg.py

	import errno			import errno
	import os			import os
	import shutil			import shutil
	import stat			import stat

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullhex,			sha1nodeconstants,
	nullid,
	short,			short,
	)			)
	from .pycompat import getattr			from .pycompat import getattr

	from . import (			from . import (
	bookmarks,			bookmarks,
	bundlerepo,			bundlerepo,
	cacheutil,			cacheutil,
	with srcpeer.commandexecutor() as e:			with srcpeer.commandexecutor() as e:
	rootnode = e.callcommand(			rootnode = e.callcommand(
	b'lookup',			b'lookup',
	{			{
	b'key': b'0',			b'key': b'0',
	},			},
	).result()			).result()

	if rootnode != nullid:			if rootnode != sha1nodeconstants.nullid:
	sharepath = os.path.join(sharepool, hex(rootnode))			sharepath = os.path.join(sharepool, hex(rootnode))
	else:			else:
	ui.status(			ui.status(
	_(			_(
	b'(not using pooled storage: '			b'(not using pooled storage: '
	b'remote appears to be empty)\n'			b'remote appears to be empty)\n'
	)			)
	)			)

	dstcachedir = os.path.join(destpath, b'cache')			dstcachedir = os.path.join(destpath, b'cache')
	for cache in cacheutil.cachetocopy(srcrepo):			for cache in cacheutil.cachetocopy(srcrepo):
	_copycache(srcrepo, dstcachedir, cache)			_copycache(srcrepo, dstcachedir, cache)

	# we need to re-init the repo after manually copying the data			# we need to re-init the repo after manually copying the data
	# into it			# into it
	destpeer = peer(srcrepo, peeropts, dest)			destpeer = peer(srcrepo, peeropts, dest)
	srcrepo.hook(b'outgoing', source=b'clone', node=nullhex)			srcrepo.hook(
				b'outgoing', source=b'clone', node=srcrepo.nodeconstants.nullhex
				)
	else:			else:
	try:			try:
	# only pass ui when no srcrepo			# only pass ui when no srcrepo
	destpeer = peer(			destpeer = peer(
	srcrepo or ui,			srcrepo or ui,
	peeropts,			peeropts,
	dest,			dest,
	create=True,			create=True,
	def display(other, chlist, displayer):			def display(other, chlist, displayer):
	limit = logcmdutil.getlimit(opts)			limit = logcmdutil.getlimit(opts)
	if opts.get(b'newest_first'):			if opts.get(b'newest_first'):
	chlist.reverse()			chlist.reverse()
	count = 0			count = 0
	for n in chlist:			for n in chlist:
	if limit is not None and count >= limit:			if limit is not None and count >= limit:
	break			break
	parents = [p for p in other.changelog.parents(n) if p != nullid]			parents = [
				p for p in other.changelog.parents(n) if p != repo.nullid
				]
	if opts.get(b'no_merges') and len(parents) == 2:			if opts.get(b'no_merges') and len(parents) == 2:
	continue			continue
	count += 1			count += 1
	displayer.show(other[n])			displayer.show(other[n])

	return _incoming(			return _incoming(
	display, subreporecurse, ui, repo, source, opts, subpath=subpath			display, subreporecurse, ui, repo, source, opts, subpath=subpath
	)			)
	yield r			yield r
	return			return

	count = 0			count = 0
	cl = repo.changelog			cl = repo.changelog
	for n in revs:			for n in revs:
	if limit is not None and count >= limit:			if limit is not None and count >= limit:
	break			break
	parents = [p for p in cl.parents(n) if p != nullid]			parents = [p for p in cl.parents(n) if p != repo.nullid]
	if no_merges and len(parents) == 2:			if no_merges and len(parents) == 2:
	continue			continue
	count += 1			count += 1
	yield n			yield n


	def outgoing(ui, repo, dests, opts, subpath=None):			def outgoing(ui, repo, dests, opts, subpath=None):
	if opts.get(b'graph'):			if opts.get(b'graph'):

mercurial/hgweb/webutil.py

	# hgweb/webutil.py - utility library for the web interface.			# hgweb/webutil.py - utility library for the web interface.
	#			#
	# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>			# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import copy			import copy
	import difflib			import difflib
	import os			import os
	import re			import re

	from ..i18n import _			from ..i18n import _
	from ..node import hex, nullid, short			from ..node import hex, short
	from ..pycompat import setattr			from ..pycompat import setattr

	from .common import (			from .common import (
	ErrorResponse,			ErrorResponse,
	HTTP_BAD_REQUEST,			HTTP_BAD_REQUEST,
	HTTP_NOT_FOUND,			HTTP_NOT_FOUND,
	paritygen,			paritygen,
	)			)
	if util.safehasattr(s, b'path'):			if util.safehasattr(s, b'path'):
	d[b'file'] = s.path()			d[b'file'] = s.path()
	yield d			yield d


	def _siblings(siblings=None, hiderev=None):			def _siblings(siblings=None, hiderev=None):
	if siblings is None:			if siblings is None:
	siblings = []			siblings = []
	siblings = [s for s in siblings if s.node() != nullid]			siblings = [s for s in siblings if s.node() != s.repo().nullid]
	if len(siblings) == 1 and siblings[0].rev() == hiderev:			if len(siblings) == 1 and siblings[0].rev() == hiderev:
	siblings = []			siblings = []
	return templateutil.mappinggenerator(_ctxsgen, args=(siblings,))			return templateutil.mappinggenerator(_ctxsgen, args=(siblings,))


	def difffeatureopts(req, ui, section):			def difffeatureopts(req, ui, section):
	diffopts = diffutil.difffeatureopts(			diffopts = diffutil.difffeatureopts(
	ui, untrusted=True, section=section, whitespace=True			ui, untrusted=True, section=section, whitespace=True
	return templateutil.hybridlist(branches, name=b'name')			return templateutil.hybridlist(branches, name=b'name')


	def _nodenamesgen(context, f, node, name):			def _nodenamesgen(context, f, node, name):
	for t in f(node):			for t in f(node):
	yield {name: t}			yield {name: t}


	def showtag(repo, t1, node=nullid):			def showtag(repo, t1, node=None):
				if node is None:
				node = repo.nullid
	args = (repo.nodetags, node, b'tag')			args = (repo.nodetags, node, b'tag')
	return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)			return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)


	def showbookmark(repo, t1, node=nullid):			def showbookmark(repo, t1, node=None):
				if node is None:
				node = repo.nullid
	args = (repo.nodebookmarks, node, b'bookmark')			args = (repo.nodebookmarks, node, b'bookmark')
	return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)			return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)


	def branchentries(repo, stripecount, limit=0):			def branchentries(repo, stripecount, limit=0):
	tips = []			tips = []
	heads = repo.heads()			heads = repo.heads()
	parity = paritygen(stripecount)			parity = paritygen(stripecount)

mercurial/interfaces/dirstate.py

	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	import contextlib			import contextlib

	from .. import node as nodemod

	from . import util as interfaceutil			from . import util as interfaceutil


	class idirstate(interfaceutil.Interface):			class idirstate(interfaceutil.Interface):
	def __init__(opener, ui, root, validate, sparsematchfn, nodeconstants):			def __init__(opener, ui, root, validate, sparsematchfn, nodeconstants):
	"""Create a new dirstate object.			"""Create a new dirstate object.

	opener is an open()-like callable that can be used to open the			opener is an open()-like callable that can be used to open the
	pass			pass

	def p2():			def p2():
	pass			pass

	def branch():			def branch():
	pass			pass

	def setparents(p1, p2=nodemod.nullid):			def setparents(p1, p2=None):
	"""Set dirstate parents to p1 and p2.			"""Set dirstate parents to p1 and p2.

	When moving from two parents to one, 'm' merged entries a			When moving from two parents to one, 'm' merged entries a
	adjusted to normal and previous copy records discarded and			adjusted to normal and previous copy records discarded and
	returned by the call.			returned by the call.

	See localrepo.setparents()			See localrepo.setparents()
	"""			"""

mercurial/localrepo.py

	import sys			import sys
	import time			import time
	import weakref			import weakref

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	sha1nodeconstants,			sha1nodeconstants,
	short,			short,
	)			)
	from .pycompat import (			from .pycompat import (
	delattr,			delattr,
	getattr,			getattr,
	)			)
	return node			return node
	except error.LookupError:			except error.LookupError:
	if not self._dirstatevalidatewarned:			if not self._dirstatevalidatewarned:
	self._dirstatevalidatewarned = True			self._dirstatevalidatewarned = True
	self.ui.warn(			self.ui.warn(
	_(b"warning: ignoring unknown working parent %s!\n")			_(b"warning: ignoring unknown working parent %s!\n")
	% short(node)			% short(node)
	)			)
	return nullid			return self.nullid

	@storecache(narrowspec.FILENAME)			@storecache(narrowspec.FILENAME)
	def narrowpats(self):			def narrowpats(self):
	"""matcher patterns for this repository's narrowspec			"""matcher patterns for this repository's narrowspec

	A tuple of (includes, excludes).			A tuple of (includes, excludes).
	"""			"""
	return narrowspec.load(self)			return narrowspec.load(self)

	def setnarrowpats(self, newincludes, newexcludes):			def setnarrowpats(self, newincludes, newexcludes):
	narrowspec.save(self, newincludes, newexcludes)			narrowspec.save(self, newincludes, newexcludes)
	self.invalidate(clearfilecache=True)			self.invalidate(clearfilecache=True)

	@unfilteredpropertycache			@unfilteredpropertycache
	def _quick_access_changeid_null(self):			def _quick_access_changeid_null(self):
	return {			return {
	b'null': (nullrev, nullid),			b'null': (nullrev, self.nodeconstants.nullid),
	nullrev: (nullrev, nullid),			nullrev: (nullrev, self.nodeconstants.nullid),
	nullid: (nullrev, nullid),			self.nullid: (nullrev, self.nullid),
	}			}

	@unfilteredpropertycache			@unfilteredpropertycache
	def _quick_access_changeid_wc(self):			def _quick_access_changeid_wc(self):
	# also fast path access to the working copy parents			# also fast path access to the working copy parents
	# however, only do it for filter that ensure wc is visible.			# however, only do it for filter that ensure wc is visible.
	quick = self._quick_access_changeid_null.copy()			quick = self._quick_access_changeid_null.copy()
	cl = self.unfiltered().changelog			cl = self.unfiltered().changelog
	for node in self.dirstate.parents():			for node in self.dirstate.parents():
	if node == nullid:			if node == self.nullid:
	continue			continue
	rev = cl.index.get_rev(node)			rev = cl.index.get_rev(node)
	if rev is None:			if rev is None:
	# unknown working copy parent case:			# unknown working copy parent case:
	#			#
	# skip the fast path and let higher code deal with it			# skip the fast path and let higher code deal with it
	continue			continue
	pair = (rev, node)			pair = (rev, node)
	quick[rev] = pair			quick[rev] = pair
	quick[node] = pair			quick[node] = pair
	# also add the parents of the parents			# also add the parents of the parents
	for r in cl.parentrevs(rev):			for r in cl.parentrevs(rev):
	if r == nullrev:			if r == nullrev:
	continue			continue
	n = cl.node(r)			n = cl.node(r)
	pair = (r, n)			pair = (r, n)
	quick[r] = pair			quick[r] = pair
	quick[n] = pair			quick[n] = pair
	p1node = self.dirstate.p1()			p1node = self.dirstate.p1()
	if p1node != nullid:			if p1node != self.nullid:
	quick[b'.'] = quick[p1node]			quick[b'.'] = quick[p1node]
	return quick			return quick

	@unfilteredmethod			@unfilteredmethod
	def _quick_access_changeid_invalidate(self):			def _quick_access_changeid_invalidate(self):
	if '_quick_access_changeid_wc' in vars(self):			if '_quick_access_changeid_wc' in vars(self):
	del self.__dict__['_quick_access_changeid_wc']			del self.__dict__['_quick_access_changeid_wc']

	tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)			tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)

	# Build the return dicts. Have to re-encode tag names because			# Build the return dicts. Have to re-encode tag names because
	# the tags module always uses UTF-8 (in order not to lose info			# the tags module always uses UTF-8 (in order not to lose info
	# writing to the cache), but the rest of Mercurial wants them in			# writing to the cache), but the rest of Mercurial wants them in
	# local encoding.			# local encoding.
	tags = {}			tags = {}
	for (name, (node, hist)) in pycompat.iteritems(alltags):			for (name, (node, hist)) in pycompat.iteritems(alltags):
	if node != nullid:			if node != self.nullid:
	tags[encoding.tolocal(name)] = node			tags[encoding.tolocal(name)] = node
	tags[b'tip'] = self.changelog.tip()			tags[b'tip'] = self.changelog.tip()
	tagtypes = {			tagtypes = {
	encoding.tolocal(name): value			encoding.tolocal(name): value
	for (name, value) in pycompat.iteritems(tagtypes)			for (name, value) in pycompat.iteritems(tagtypes)
	}			}
	return (tags, tagtypes)			return (tags, tagtypes)

	'''the type of shared repository (None if not shared)'''			'''the type of shared repository (None if not shared)'''
	if self.sharedpath != self.path:			if self.sharedpath != self.path:
	return b'store'			return b'store'
	return None			return None

	def wjoin(self, f, *insidef):			def wjoin(self, f, *insidef):
	return self.vfs.reljoin(self.root, f, *insidef)			return self.vfs.reljoin(self.root, f, *insidef)

	def setparents(self, p1, p2=nullid):			def setparents(self, p1, p2=None):
				if p2 is None:
				p2 = self.nullid
	self[None].setparents(p1, p2)			self[None].setparents(p1, p2)
	self._quick_access_changeid_invalidate()			self._quick_access_changeid_invalidate()

	def filectx(self, path, changeid=None, fileid=None, changectx=None):			def filectx(self, path, changeid=None, fileid=None, changectx=None):
	"""changeid must be a changeset revision, if specified.			"""changeid must be a changeset revision, if specified.
	fileid can be a file revision or node."""			fileid can be a file revision or node."""
	return context.filectx(			return context.filectx(
	self, path, changeid, fileid, changectx=changectx			self, path, changeid, fileid, changectx=changectx
	_(b'committing subrepository %s\n')			_(b'committing subrepository %s\n')
	% uipathfn(subrepoutil.subrelpath(sub))			% uipathfn(subrepoutil.subrelpath(sub))
	)			)
	sr = sub.commit(cctx._text, user, date)			sr = sub.commit(cctx._text, user, date)
	newstate[s] = (newstate[s][0], sr)			newstate[s] = (newstate[s][0], sr)
	subrepoutil.writestate(self, newstate)			subrepoutil.writestate(self, newstate)

	p1, p2 = self.dirstate.parents()			p1, p2 = self.dirstate.parents()
	hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or b'')			hookp1, hookp2 = hex(p1), (p2 != self.nullid and hex(p2) or b'')
	try:			try:
	self.hook(			self.hook(
	b"precommit", throw=True, parent1=hookp1, parent2=hookp2			b"precommit", throw=True, parent1=hookp1, parent2=hookp2
	)			)
	with self.transaction(b'commit'):			with self.transaction(b'commit'):
	ret = self.commitctx(cctx, True)			ret = self.commitctx(cctx, True)
	# update bookmarks, dirstate and mergestate			# update bookmarks, dirstate and mergestate
	bookmarks.update(self, [p1, p2], ret)			bookmarks.update(self, [p1, p2], ret)
	def branches(self, nodes):			def branches(self, nodes):
	if not nodes:			if not nodes:
	nodes = [self.changelog.tip()]			nodes = [self.changelog.tip()]
	b = []			b = []
	for n in nodes:			for n in nodes:
	t = n			t = n
	while True:			while True:
	p = self.changelog.parents(n)			p = self.changelog.parents(n)
	if p[1] != nullid or p[0] == nullid:			if p[1] != self.nullid or p[0] == self.nullid:
	b.append((t, n, p[0], p[1]))			b.append((t, n, p[0], p[1]))
	break			break
	n = p[0]			n = p[0]
	return b			return b

	def between(self, pairs):			def between(self, pairs):
	r = []			r = []

	for top, bottom in pairs:			for top, bottom in pairs:
	n, l, i = top, [], 0			n, l, i = top, [], 0
	f = 1			f = 1

	while n != bottom and n != nullid:			while n != bottom and n != self.nullid:
	p = self.changelog.parents(n)[0]			p = self.changelog.parents(n)[0]
	if i == f:			if i == f:
	l.append(n)			l.append(n)
	f = f * 2			f = f * 2
	n = p			n = p
	i += 1			i += 1

	r.append(l)			r.append(l)

mercurial/logcmdutil.py

	# logcmdutil.py - utility for log-like commands			# logcmdutil.py - utility for log-like commands
	#			#
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import itertools			import itertools
	import os			import os
	import posixpath			import posixpath

	from .i18n import _			from .i18n import _
	from .node import (			from .node import nullrev, wdirrev
	nullid,
	nullrev,
	wdirid,
	wdirrev,
	)

	from .thirdparty import attr			from .thirdparty import attr

	from . import (			from . import (
	dagop,			dagop,
	error,			error,
	formatter,			formatter,
	graphmod,			graphmod,
	label = b'log.parent changeset.%s' % pctx.phasestr()			label = b'log.parent changeset.%s' % pctx.phasestr()
	self.ui.write(			self.ui.write(
	columns[b'parent'] % scmutil.formatchangeid(pctx), label=label			columns[b'parent'] % scmutil.formatchangeid(pctx), label=label
	)			)

	if self.ui.debugflag:			if self.ui.debugflag:
	mnode = ctx.manifestnode()			mnode = ctx.manifestnode()
	if mnode is None:			if mnode is None:
	mnode = wdirid			mnode = self.repo.nodeconstants.wdirid
	mrev = wdirrev			mrev = wdirrev
	else:			else:
	mrev = self.repo.manifestlog.rev(mnode)			mrev = self.repo.manifestlog.rev(mnode)
	self.ui.write(			self.ui.write(
	columns[b'manifest']			columns[b'manifest']
	% scmutil.formatrevnode(self.ui, mrev, mnode),			% scmutil.formatrevnode(self.ui, mrev, mnode),
	label=b'ui.debug log.manifest',			label=b'ui.debug log.manifest',
	)			)
	bookmarks=fm.formatlist(ctx.bookmarks(), name=b'bookmark'),			bookmarks=fm.formatlist(ctx.bookmarks(), name=b'bookmark'),
	tags=fm.formatlist(ctx.tags(), name=b'tag'),			tags=fm.formatlist(ctx.tags(), name=b'tag'),
	parents=fm.formatlist(			parents=fm.formatlist(
	[fm.hexfunc(c.node()) for c in ctx.parents()], name=b'node'			[fm.hexfunc(c.node()) for c in ctx.parents()], name=b'node'
	),			),
	)			)

	if self.ui.debugflag or b'manifest' in datahint:			if self.ui.debugflag or b'manifest' in datahint:
	fm.data(manifest=fm.hexfunc(ctx.manifestnode() or wdirid))			fm.data(
				manifest=fm.hexfunc(
				ctx.manifestnode() or self.repo.nodeconstants.wdirid
				)
				)
	if self.ui.debugflag or b'extra' in datahint:			if self.ui.debugflag or b'extra' in datahint:
	fm.data(extra=fm.formatdict(ctx.extra()))			fm.data(extra=fm.formatdict(ctx.extra()))

	if (			if (
	self.ui.debugflag			self.ui.debugflag
	or b'modified' in datahint			or b'modified' in datahint
	or b'added' in datahint			or b'added' in datahint
	or b'removed' in datahint			or b'removed' in datahint
	expr = None			expr = None
	return expr			return expr


	def _initialrevs(repo, wopts):			def _initialrevs(repo, wopts):
	"""Return the initial set of revisions to be filtered or followed"""			"""Return the initial set of revisions to be filtered or followed"""
	if wopts.revspec:			if wopts.revspec:
	revs = scmutil.revrange(repo, wopts.revspec)			revs = scmutil.revrange(repo, wopts.revspec)
	elif wopts.follow and repo.dirstate.p1() == nullid:			elif wopts.follow and repo.dirstate.p1() == repo.nullid:
	revs = smartset.baseset()			revs = smartset.baseset()
	elif wopts.follow:			elif wopts.follow:
	revs = repo.revs(b'.')			revs = repo.revs(b'.')
	else:			else:
	revs = smartset.spanset(repo)			revs = smartset.spanset(repo)
	revs.reverse()			revs.reverse()
	return revs			return revs

mercurial/manifest.py

	import itertools			import itertools
	import struct			import struct
	import weakref			import weakref

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)
	from .pycompat import getattr			from .pycompat import getattr
	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	match as matchmod,			match as matchmod,
	mdiff,			mdiff,
	_noop = lambda s: None			_noop = lambda s: None


	@interfaceutil.implementer(repository.imanifestdict)			@interfaceutil.implementer(repository.imanifestdict)
	class treemanifest(object):			class treemanifest(object):
	def __init__(self, nodeconstants, dir=b'', text=b''):			def __init__(self, nodeconstants, dir=b'', text=b''):
	self._dir = dir			self._dir = dir
	self.nodeconstants = nodeconstants			self.nodeconstants = nodeconstants
	self._node = nullid			self._node = self.nodeconstants.nullid
	self._loadfunc = _noop			self._loadfunc = _noop
	self._copyfunc = _noop			self._copyfunc = _noop
	self._dirty = False			self._dirty = False
	self._dirs = {}			self._dirs = {}
	self._lazydirs = {}			self._lazydirs = {}
	# Using _lazymanifest here is a little slower than plain old dicts			# Using _lazymanifest here is a little slower than plain old dicts
	self._files = {}			self._files = {}
	self._flags = {}			self._flags = {}
	visit = self._loadchildrensetlazy(visit)			visit = self._loadchildrensetlazy(visit)
	if visit == b'this' or visit == b'all':			if visit == b'this' or visit == b'all':
	visit = None			visit = None
	for d, subm in pycompat.iteritems(self._dirs):			for d, subm in pycompat.iteritems(self._dirs):
	if visit and d[:-1] not in visit:			if visit and d[:-1] not in visit:
	continue			continue
	subp1 = getnode(m1, d)			subp1 = getnode(m1, d)
	subp2 = getnode(m2, d)			subp2 = getnode(m2, d)
	if subp1 == nullid:			if subp1 == self.nodeconstants.nullid:
	subp1, subp2 = subp2, subp1			subp1, subp2 = subp2, subp1
	writesubtree(subm, subp1, subp2, match)			writesubtree(subm, subp1, subp2, match)

	def walksubtrees(self, matcher=None):			def walksubtrees(self, matcher=None):
	"""Returns an iterator of the subtrees of this manifest, including this			"""Returns an iterator of the subtrees of this manifest, including this
	manifest itself.			manifest itself.

	If `matcher` is provided, it only returns subtrees that match.			If `matcher` is provided, it only returns subtrees that match.
	# Side-effect is LookupError is raised if node doesn't exist.			# Side-effect is LookupError is raised if node doesn't exist.
	self._rootstore.rev(node)			self._rootstore.rev(node)

	if self._treemanifests:			if self._treemanifests:
	m = treemanifestctx(self, b'', node)			m = treemanifestctx(self, b'', node)
	else:			else:
	m = manifestctx(self, node)			m = manifestctx(self, node)

	if node != nullid:			if node != self.nodeconstants.nullid:
	mancache = self._dirmancache.get(tree)			mancache = self._dirmancache.get(tree)
	if not mancache:			if not mancache:
	mancache = util.lrucachedict(self._cachesize)			mancache = util.lrucachedict(self._cachesize)
	self._dirmancache[tree] = mancache			self._dirmancache[tree] = mancache
	mancache[node] = m			mancache[node] = m
	return m			return m

	def getstorage(self, tree):			def getstorage(self, tree):
	return memmf			return memmf

	@propertycache			@propertycache
	def parents(self):			def parents(self):
	return self._storage().parents(self._node)			return self._storage().parents(self._node)

	def read(self):			def read(self):
	if self._data is None:			if self._data is None:
	if self._node == nullid:			if self._node == self._manifestlog.nodeconstants.nullid:
	self._data = manifestdict()			self._data = manifestdict()
	else:			else:
	store = self._storage()			store = self._storage()
	if self._node in store.fulltextcache:			if self._node in store.fulltextcache:
	text = pycompat.bytestr(store.fulltextcache[self._node])			text = pycompat.bytestr(store.fulltextcache[self._node])
	else:			else:
	text = store.revision(self._node)			text = store.revision(self._node)
	arraytext = bytearray(text)			arraytext = bytearray(text)
	return excludedmanifestrevlog(			return excludedmanifestrevlog(
	self._manifestlog.nodeconstants, self._dir			self._manifestlog.nodeconstants, self._dir
	)			)
	return self._manifestlog.getstorage(self._dir)			return self._manifestlog.getstorage(self._dir)

	def read(self):			def read(self):
	if self._data is None:			if self._data is None:
	store = self._storage()			store = self._storage()
	if self._node == nullid:			if self._node == self._manifestlog.nodeconstants.nullid:
	self._data = treemanifest(self._manifestlog.nodeconstants)			self._data = treemanifest(self._manifestlog.nodeconstants)
	# TODO accessing non-public API			# TODO accessing non-public API
	elif store._treeondisk:			elif store._treeondisk:
	m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)			m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)

	def gettext():			def gettext():
	return store.revision(self._node)			return store.revision(self._node)

mercurial/merge.py

	# merge.py - directory-level update/merge handling for Mercurial			# merge.py - directory-level update/merge handling for Mercurial
	#			#
	# Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import errno			import errno
	import stat			import stat
	import struct			import struct

	from .i18n import _			from .i18n import _
	from .node import (			from .node import nullrev
	addednodeid,
	modifiednodeid,
	nullid,
	nullrev,
	)
	from .thirdparty import attr			from .thirdparty import attr
	from .utils import stringutil			from .utils import stringutil
	from . import (			from . import (
	copies,			copies,
	encoding,			encoding,
	error,			error,
	filemerge,			filemerge,
	match as matchmod,			match as matchmod,
	copied2 = set(branch_copies2.copy.values())			copied2 = set(branch_copies2.copy.values())
	copied2.update(branch_copies2.movewithdir.values())			copied2.update(branch_copies2.movewithdir.values())

	if b'.hgsubstate' in m1 and wctx.rev() is None:			if b'.hgsubstate' in m1 and wctx.rev() is None:
	# Check whether sub state is modified, and overwrite the manifest			# Check whether sub state is modified, and overwrite the manifest
	# to flag the change. If wctx is a committed revision, we shouldn't			# to flag the change. If wctx is a committed revision, we shouldn't
	# care for the dirty state of the working directory.			# care for the dirty state of the working directory.
	if any(wctx.sub(s).dirty() for s in wctx.substate):			if any(wctx.sub(s).dirty() for s in wctx.substate):
	m1[b'.hgsubstate'] = modifiednodeid			m1[b'.hgsubstate'] = repo.nodeconstants.modifiednodeid

	# Don't use m2-vs-ma optimization if:			# Don't use m2-vs-ma optimization if:
	# - ma is the same as m1 or m2, which we're just going to diff again later			# - ma is the same as m1 or m2, which we're just going to diff again later
	# - The caller specifically asks for a full diff, which is useful during bid			# - The caller specifically asks for a full diff, which is useful during bid
	# merge.			# merge.
	# - we are tracking salvaged files specifically hence should process all			# - we are tracking salvaged files specifically hence should process all
	# files			# files
	if (			if (
	mergestatemod.ACTION_CHANGED_DELETED,			mergestatemod.ACTION_CHANGED_DELETED,
	(f, None, f, False, pa.node()),			(f, None, f, False, pa.node()),
	b'prompt changed/deleted',			b'prompt changed/deleted',
	)			)
	if branchmerge:			if branchmerge:
	mresult.addcommitinfo(			mresult.addcommitinfo(
	f, b'merge-removal-candidate', b'yes'			f, b'merge-removal-candidate', b'yes'
	)			)
	elif n1 == addednodeid:			elif n1 == repo.nodeconstants.addednodeid:
	# This file was locally added. We should forget it instead of			# This file was locally added. We should forget it instead of
	# deleting it.			# deleting it.
	mresult.addfile(			mresult.addfile(
	f,			f,
	mergestatemod.ACTION_FORGET,			mergestatemod.ACTION_FORGET,
	None,			None,
	b'remote deleted',			b'remote deleted',
	)			)
	# itself because a) fsmonitor may have already printed a warning			# itself because a) fsmonitor may have already printed a warning
	# b) we only care about the config state here.			# b) we only care about the config state here.
	except KeyError:			except KeyError:
	fsmonitorenabled = False			fsmonitorenabled = False

	if (			if (
	fsmonitorwarning			fsmonitorwarning
	and not fsmonitorenabled			and not fsmonitorenabled
	and p1node == nullid			and p1node == repo.nullid
	and num_gets >= fsmonitorthreshold			and num_gets >= fsmonitorthreshold
	and pycompat.sysplatform.startswith((b'linux', b'darwin'))			and pycompat.sysplatform.startswith((b'linux', b'darwin'))
	):			):
	repo.ui.warn(			repo.ui.warn(
	_(			_(
	b'(warning: large working directory being used without '			b'(warning: large working directory being used without '
	b'fsmonitor enabled; enable fsmonitor to improve performance; '			b'fsmonitor enabled; enable fsmonitor to improve performance; '
	b'see "hg help -e fsmonitor")\n'			b'see "hg help -e fsmonitor")\n'
	pl = wc.parents()			pl = wc.parents()
	p1 = pl[0]			p1 = pl[0]
	p2 = repo[node]			p2 = repo[node]
	if ancestor is not None:			if ancestor is not None:
	pas = [repo[ancestor]]			pas = [repo[ancestor]]
	else:			else:
	if repo.ui.configlist(b'merge', b'preferancestor') == [b'*']:			if repo.ui.configlist(b'merge', b'preferancestor') == [b'*']:
	cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node())			cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node())
	pas = [repo[anc] for anc in (sorted(cahs) or [nullid])]			pas = [repo[anc] for anc in (sorted(cahs) or [repo.nullid])]
	else:			else:
	pas = [p1.ancestor(p2, warn=branchmerge)]			pas = [p1.ancestor(p2, warn=branchmerge)]

	fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2)			fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2)

	overwrite = force and not branchmerge			overwrite = force and not branchmerge
	### check phase			### check phase
	if not overwrite:			if not overwrite:
	)			)
	% f			% f
	)			)
	for nf in sorted(fl):			for nf in sorted(fl):
	repo.ui.warn(b" %s\n" % nf)			repo.ui.warn(b" %s\n" % nf)

	### apply phase			### apply phase
	if not branchmerge: # just jump to the new rev			if not branchmerge: # just jump to the new rev
	fp1, fp2, xp1, xp2 = fp2, nullid, xp2, b''			fp1, fp2, xp1, xp2 = fp2, repo.nullid, xp2, b''
	# If we're doing a partial update, we need to skip updating			# If we're doing a partial update, we need to skip updating
	# the dirstate.			# the dirstate.
	always = matcher is None or matcher.always()			always = matcher is None or matcher.always()
	updatedirstate = updatedirstate and always and not wc.isinmemory()			updatedirstate = updatedirstate and always and not wc.isinmemory()
	if updatedirstate:			if updatedirstate:
	repo.hook(b'preupdate', throw=True, parent1=xp1, parent2=xp2)			repo.hook(b'preupdate', throw=True, parent1=xp1, parent2=xp2)
	# note that we're in the middle of an update			# note that we're in the middle of an update
	repo.vfs.write(b'updatestate', p2.hex())			repo.vfs.write(b'updatestate', p2.hex())
	mergeancestor=mergeancestor,			mergeancestor=mergeancestor,
	labels=labels,			labels=labels,
	wc=wctx,			wc=wctx,
	)			)

	if keepconflictparent and stats.unresolvedcount:			if keepconflictparent and stats.unresolvedcount:
	pother = ctx.node()			pother = ctx.node()
	else:			else:
	pother = nullid			pother = repo.nullid
	parents = ctx.parents()			parents = ctx.parents()
	if keepparent and len(parents) == 2 and base in parents:			if keepparent and len(parents) == 2 and base in parents:
	parents.remove(base)			parents.remove(base)
	pother = parents[0].node()			pother = parents[0].node()
	# Never set both parents equal to each other			# Never set both parents equal to each other
	if pother == pctx.node():			if pother == pctx.node():
	pother = nullid			pother = repo.nullid

	if wctx.isinmemory():			if wctx.isinmemory():
	wctx.setparents(pctx.node(), pother)			wctx.setparents(pctx.node(), pother)
	# fix up dirstate for copies and renames			# fix up dirstate for copies and renames
	copies.graftcopies(wctx, ctx, base)			copies.graftcopies(wctx, ctx, base)
	else:			else:
	with repo.dirstate.parentchange():			with repo.dirstate.parentchange():
	repo.setparents(pctx.node(), pother)			repo.setparents(pctx.node(), pother)

mercurial/mergestate.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import errno			import errno
	import shutil			import shutil
	import struct			import struct

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullhex,
	nullrev,			nullrev,
	)			)
	from . import (			from . import (
	error,			error,
	filemerge,			filemerge,
	pycompat,			pycompat,
	util,			util,
	)			)
	from .utils import hashutil			from .utils import hashutil

	_pack = struct.pack			_pack = struct.pack
	_unpack = struct.unpack			_unpack = struct.unpack


	def _droponode(data):			def _droponode(data):
	# used for compatibility for v1			# used for compatibility for v1
	bits = data.split(b'\0')			bits = data.split(b'\0')
	bits = bits[:-2] + bits[-1:]			bits = bits[:-2] + bits[-1:]
	return b'\0'.join(bits)			return b'\0'.join(bits)


	def _filectxorabsent(hexnode, ctx, f):			def _filectxorabsent(hexnode, ctx, f):
	if hexnode == nullhex:			if hexnode == ctx.repo().nodeconstants.nullhex:
	return filemerge.absentfilectx(ctx, f)			return filemerge.absentfilectx(ctx, f)
	else:			else:
	return ctx[f]			return ctx[f]


	# Merge state record types. See ``mergestate`` docs for more.			# Merge state record types. See ``mergestate`` docs for more.

	####			####
	fcl: file context for local,			fcl: file context for local,
	fco: file context for remote,			fco: file context for remote,
	fca: file context for ancestors,			fca: file context for ancestors,
	fd: file path of the resulting merge.			fd: file path of the resulting merge.

	note: also write the local version to the `.hg/merge` directory.			note: also write the local version to the `.hg/merge` directory.
	"""			"""
	if fcl.isabsent():			if fcl.isabsent():
	localkey = nullhex			localkey = self._repo.nodeconstants.nullhex
	else:			else:
	localkey = mergestate.getlocalkey(fcl.path())			localkey = mergestate.getlocalkey(fcl.path())
	self._make_backup(fcl, localkey)			self._make_backup(fcl, localkey)
	self._state[fd] = [			self._state[fd] = [
	MERGE_RECORD_UNRESOLVED,			MERGE_RECORD_UNRESOLVED,
	localkey,			localkey,
	fcl.path(),			fcl.path(),
	fca.path(),			fca.path(),
	b'without common ancestor - keeping local flags\n'			b'without common ancestor - keeping local flags\n'
	)			)
	% afile			% afile
	)			)
	elif flags == fla:			elif flags == fla:
	flags = flo			flags = flo
	if preresolve:			if preresolve:
	# restore local			# restore local
	if localkey != nullhex:			if localkey != self._repo.nodeconstants.nullhex:
	self._restore_backup(wctx[dfile], localkey, flags)			self._restore_backup(wctx[dfile], localkey, flags)
	else:			else:
	wctx[dfile].remove(ignoremissing=True)			wctx[dfile].remove(ignoremissing=True)
	complete, merge_ret, deleted = filemerge.premerge(			complete, merge_ret, deleted = filemerge.premerge(
	self._repo,			self._repo,
	wctx,			wctx,
	self._local,			self._local,
	lfile,			lfile,
	MERGE_RECORD_UNRESOLVED_PATH,			MERGE_RECORD_UNRESOLVED_PATH,
	MERGE_RECORD_RESOLVED_PATH,			MERGE_RECORD_RESOLVED_PATH,
	):			):
	# Path conflicts. These are stored in 'P' records. The current			# Path conflicts. These are stored in 'P' records. The current
	# resolution state ('pu' or 'pr') is stored within the record.			# resolution state ('pu' or 'pr') is stored within the record.
	records.append(			records.append(
	(RECORD_PATH_CONFLICT, b'\0'.join([filename] + v))			(RECORD_PATH_CONFLICT, b'\0'.join([filename] + v))
	)			)
	elif v[1] == nullhex or v[6] == nullhex:			elif (
				v[1] == self._repo.nodeconstants.nullhex
				or v[6] == self._repo.nodeconstants.nullhex
				):
	# Change/Delete or Delete/Change conflicts. These are stored in			# Change/Delete or Delete/Change conflicts. These are stored in
	# 'C' records. v[1] is the local file, and is nullhex when the			# 'C' records. v[1] is the local file, and is nullhex when the
	# file is deleted locally ('dc'). v[6] is the remote file, and			# file is deleted locally ('dc'). v[6] is the remote file, and
	# is nullhex when the file is deleted remotely ('cd').			# is nullhex when the file is deleted remotely ('cd').
	records.append(			records.append(
	(RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v))			(RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v))
	)			)
	else:			else:

mercurial/metadata.py

	# coding: utf-8			# coding: utf-8
	# metadata.py -- code related to various metadata computation and access.			# metadata.py -- code related to various metadata computation and access.
	#			#
	# Copyright 2019 Google, Inc <martinvonz@google.com>			# Copyright 2019 Google, Inc <martinvonz@google.com>
	# Copyright 2020 Pierre-Yves David <pierre-yves.david@octobus.net>			# Copyright 2020 Pierre-Yves David <pierre-yves.david@octobus.net>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	import multiprocessing			import multiprocessing
	import struct			import struct

	from .node import (			from .node import nullrev
	nullid,
	nullrev,
	)
	from . import (			from . import (
	error,			error,
	pycompat,			pycompat,
	requirements as requirementsmod,			requirements as requirementsmod,
	util,			util,
	)			)

	from .revlogutils import (			from .revlogutils import (
	"""return the list of files merged in a changeset"""			"""return the list of files merged in a changeset"""
	merged = []			merged = []
	if len(ctx.parents()) < 2:			if len(ctx.parents()) < 2:
	return merged			return merged
	for f in ctx.files():			for f in ctx.files():
	if f in ctx:			if f in ctx:
	fctx = ctx[f]			fctx = ctx[f]
	parents = fctx._filelog.parents(fctx._filenode)			parents = fctx._filelog.parents(fctx._filenode)
	if parents[1] != nullid:			if parents[1] != ctx.repo().nullid:
	merged.append(f)			merged.append(f)
	return merged			return merged


	def computechangesetcopies(ctx):			def computechangesetcopies(ctx):
	"""return the copies data for a changeset			"""return the copies data for a changeset

	The copies data are returned as a pair of dictionnary (p1copies, p2copies).			The copies data are returned as a pair of dictionnary (p1copies, p2copies).

mercurial/obsolete.py


	"""			"""
	from __future__ import absolute_import			from __future__ import absolute_import

	import errno			import errno
	import struct			import struct

	from .i18n import _			from .i18n import _
				from .node import (
				bin,
				hex,
				)
	from .pycompat import getattr			from .pycompat import getattr
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	)			)
	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	obsutil,			obsutil,
	phases,			phases,
	policy,			policy,
	pycompat,			pycompat,
	def _addchildren(children, markers):			def _addchildren(children, markers):
	for mark in markers:			for mark in markers:
	parents = mark[5]			parents = mark[5]
	if parents is not None:			if parents is not None:
	for p in parents:			for p in parents:
	children.setdefault(p, set()).add(mark)			children.setdefault(p, set()).add(mark)


	def _checkinvalidmarkers(markers):			def _checkinvalidmarkers(repo, markers):
	"""search for marker with invalid data and raise error if needed			"""search for marker with invalid data and raise error if needed

	Exist as a separated function to allow the evolve extension for a more			Exist as a separated function to allow the evolve extension for a more
	subtle handling.			subtle handling.
	"""			"""
	for mark in markers:			for mark in markers:
	if nullid in mark[1]:			if repo.nullid in mark[1]:
	raise error.Abort(			raise error.Abort(
	_(			_(
	b'bad obsolescence marker detected: '			b'bad obsolescence marker detected: '
	b'invalid successors nullid'			b'invalid successors nullid'
	)			)
	)			)



	@propertycache			@propertycache
	def _all(self):			def _all(self):
	data = self._data			data = self._data
	if not data:			if not data:
	return []			return []
	self._version, markers = _readmarkers(data)			self._version, markers = _readmarkers(data)
	markers = list(markers)			markers = list(markers)
	_checkinvalidmarkers(markers)			_checkinvalidmarkers(self.repo, markers)
	return markers			return markers

	@propertycache			@propertycache
	def successors(self):			def successors(self):
	successors = {}			successors = {}
	_addsuccessors(successors, self._all)			_addsuccessors(successors, self._all)
	return successors			return successors

	self._data = self._data + rawdata			self._data = self._data + rawdata
	self._all.extend(markers)			self._all.extend(markers)
	if self._cached('successors'):			if self._cached('successors'):
	_addsuccessors(self.successors, markers)			_addsuccessors(self.successors, markers)
	if self._cached('predecessors'):			if self._cached('predecessors'):
	_addpredecessors(self.predecessors, markers)			_addpredecessors(self.predecessors, markers)
	if self._cached('children'):			if self._cached('children'):
	_addchildren(self.children, markers)			_addchildren(self.children, markers)
	_checkinvalidmarkers(markers)			_checkinvalidmarkers(self.repo, markers)

	def relevantmarkers(self, nodes):			def relevantmarkers(self, nodes):
	"""return a set of all obsolescence markers relevant to a set of nodes.			"""return a set of all obsolescence markers relevant to a set of nodes.

	"relevant" to a set of nodes mean:			"relevant" to a set of nodes mean:

	- marker that use this changeset as successor			- marker that use this changeset as successor
	- prune marker of direct children on this changeset			- prune marker of direct children on this changeset

mercurial/patch.py

	import os			import os
	import re			import re
	import shutil			import shutil
	import zlib			import zlib

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullhex,			sha1nodeconstants,
	short,			short,
	)			)
	from .pycompat import open			from .pycompat import open
	from . import (			from . import (
	copies,			copies,
	diffhelper,			diffhelper,
	diffutil,			diffutil,
	encoding,			encoding,
	opts: user passed options			opts: user passed options

	It exists as a separate function so that extensions like extdiff can wrap			It exists as a separate function so that extensions like extdiff can wrap
	it and use the file content directly.			it and use the file content directly.
	"""			"""

	ctx1, fctx1, path1, flag1, content1, date1 = data1			ctx1, fctx1, path1, flag1, content1, date1 = data1
	ctx2, fctx2, path2, flag2, content2, date2 = data2			ctx2, fctx2, path2, flag2, content2, date2 = data2
	index1 = _gitindex(content1) if path1 in ctx1 else nullhex			index1 = _gitindex(content1) if path1 in ctx1 else sha1nodeconstants.nullhex
	index2 = _gitindex(content2) if path2 in ctx2 else nullhex			index2 = _gitindex(content2) if path2 in ctx2 else sha1nodeconstants.nullhex
	if binary and opts.git and not opts.nobinary:			if binary and opts.git and not opts.nobinary:
	text = mdiff.b85diff(content1, content2)			text = mdiff.b85diff(content1, content2)
	if text:			if text:
	header.append(b'index %s..%s' % (index1, index2))			header.append(b'index %s..%s' % (index1, index2))
	hunks = ((None, [text]),)			hunks = ((None, [text]),)
	else:			else:
	if opts.git and opts.index > 0:			if opts.git and opts.index > 0:
	flag = flag1			flag = flag1

mercurial/phases.py


	import errno			import errno
	import struct			import struct

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	wdirrev,			wdirrev,
	)			)
	from .pycompat import (			from .pycompat import (
	getattr,			getattr,
	setattr,			setattr,
	)			)
	draftroots = []			draftroots = []
	has_node = repo.changelog.index.has_node # to filter unknown nodes			has_node = repo.changelog.index.has_node # to filter unknown nodes
	for nhex, phase in pycompat.iteritems(roots):			for nhex, phase in pycompat.iteritems(roots):
	if nhex == b'publishing': # ignore data related to publish option			if nhex == b'publishing': # ignore data related to publish option
	continue			continue
	node = bin(nhex)			node = bin(nhex)
	phase = int(phase)			phase = int(phase)
	if phase == public:			if phase == public:
	if node != nullid:			if node != repo.nullid:
	repo.ui.warn(			repo.ui.warn(
	_(			_(
	b'ignoring inconsistent public root'			b'ignoring inconsistent public root'
	b' from remote: %s\n'			b' from remote: %s\n'
	)			)
	% nhex			% nhex
	)			)
	elif phase == draft:			elif phase == draft:
	# phases > dagop > patch > copies > scmutil > obsolete > obsutil > phases			# phases > dagop > patch > copies > scmutil > obsolete > obsutil > phases
	from . import dagop			from . import dagop

	repo = repo.unfiltered()			repo = repo.unfiltered()
	cl = repo.changelog			cl = repo.changelog
	rev = cl.index.get_rev			rev = cl.index.get_rev
	if not roots:			if not roots:
	return heads			return heads
	if not heads or heads == [nullid]:			if not heads or heads == [repo.nullid]:
	return []			return []
	# The logic operated on revisions, convert arguments early for convenience			# The logic operated on revisions, convert arguments early for convenience
	new_heads = {rev(n) for n in heads if n != nullid}			new_heads = {rev(n) for n in heads if n != repo.nullid}
	roots = [rev(n) for n in roots]			roots = [rev(n) for n in roots]
	# compute the area we need to remove			# compute the area we need to remove
	affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads)			affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads)
	# heads in the area are no longer heads			# heads in the area are no longer heads
	new_heads.difference_update(affected_zone)			new_heads.difference_update(affected_zone)
	# revisions in the area have children outside of it,			# revisions in the area have children outside of it,
	# They might be new heads			# They might be new heads
	candidates = repo.revs(			candidates = repo.revs(

mercurial/pure/parsers.py

	# parsers.py - Python implementation of parsers.c			# parsers.py - Python implementation of parsers.c
	#			#
	# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others			# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import struct			import struct
	import zlib			import zlib

	from ..node import nullid, nullrev			from ..node import (
				nullrev,
				sha1nodeconstants,
				)
	from .. import (			from .. import (
	pycompat,			pycompat,
	util,			util,
	)			)

	from ..revlogutils import nodemap as nodemaputil			from ..revlogutils import nodemap as nodemaputil
	from ..revlogutils import constants as revlog_constants			from ..revlogutils import constants as revlog_constants

	class BaseIndexObject(object):			class BaseIndexObject(object):
	# Format of an index entry according to Python's `struct` language			# Format of an index entry according to Python's `struct` language
	index_format = revlog_constants.INDEX_ENTRY_V1			index_format = revlog_constants.INDEX_ENTRY_V1
	# Size of a C unsigned long long int, platform independent			# Size of a C unsigned long long int, platform independent
	big_int_size = struct.calcsize(b'>Q')			big_int_size = struct.calcsize(b'>Q')
	# Size of a C long int, platform independent			# Size of a C long int, platform independent
	int_size = struct.calcsize(b'>i')			int_size = struct.calcsize(b'>i')
	# An empty index entry, used as a default value to be overridden, or nullrev			# An empty index entry, used as a default value to be overridden, or nullrev
	null_item = (0, 0, 0, -1, -1, -1, -1, nullid)			null_item = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid)

	@util.propertycache			@util.propertycache
	def entry_size(self):			def entry_size(self):
	return self.index_format.size			return self.index_format.size

	@property			@property
	def nodemap(self):			def nodemap(self):
	msg = b"index.nodemap is deprecated, use index.[has_node\|rev\|get_rev]"			msg = b"index.nodemap is deprecated, use index.[has_node\|rev\|get_rev]"
	util.nouideprecwarn(msg, b'5.3', stacklevel=2)			util.nouideprecwarn(msg, b'5.3', stacklevel=2)
	return self._nodemap			return self._nodemap

	@util.propertycache			@util.propertycache
	def _nodemap(self):			def _nodemap(self):
	nodemap = nodemaputil.NodeMap({nullid: nullrev})			nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
	for r in range(0, len(self)):			for r in range(0, len(self)):
	n = self[r][7]			n = self[r][7]
	nodemap[n] = r			nodemap[n] = r
	return nodemap			return nodemap

	def has_node(self, node):			def has_node(self, node):
	"""return True if the node exist in the index"""			"""return True if the node exist in the index"""
	return node in self._nodemap			return node in self._nodemap
	cls = IndexObject2 if revlogv2 else IndexObject			cls = IndexObject2 if revlogv2 else IndexObject
	return cls(data), None			return cls(data), None
	cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject			cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject
	return cls(data, inline), (0, data)			return cls(data, inline), (0, data)


	class Index2Mixin(object):			class Index2Mixin(object):
	index_format = revlog_constants.INDEX_ENTRY_V2			index_format = revlog_constants.INDEX_ENTRY_V2
	null_item = (0, 0, 0, -1, -1, -1, -1, nullid, 0, 0)			null_item = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid, 0, 0)

	def replace_sidedata_info(self, i, sidedata_offset, sidedata_length):			def replace_sidedata_info(self, i, sidedata_offset, sidedata_length):
	"""			"""
	Replace an existing index entry's sidedata offset and length with new			Replace an existing index entry's sidedata offset and length with new
	ones.			ones.
	This cannot be used outside of the context of sidedata rewriting,			This cannot be used outside of the context of sidedata rewriting,
	inside the transaction that creates the revision `i`.			inside the transaction that creates the revision `i`.
	"""			"""

mercurial/revlog.py

	import os			import os
	import struct			import struct
	import zlib			import zlib

	# import stuff from node for others to import from revlog			# import stuff from node for others to import from revlog
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullhex,
	nullid,
	nullrev,			nullrev,
	sha1nodeconstants,			sha1nodeconstants,
	short,			short,
	wdirfilenodeids,
	wdirhex,
	wdirid,
	wdirrev,			wdirrev,
	)			)
	from .i18n import _			from .i18n import _
	from .pycompat import getattr			from .pycompat import getattr
	from .revlogutils.constants import (			from .revlogutils.constants import (
	FLAG_GENERALDELTA,			FLAG_GENERALDELTA,
	FLAG_INLINE_DATA,			FLAG_INLINE_DATA,
	INDEX_ENTRY_V0,			INDEX_ENTRY_V0,
	@property			@property
	def nodemap(self):			def nodemap(self):
	msg = b"index.nodemap is deprecated, use index.[has_node\|rev\|get_rev]"			msg = b"index.nodemap is deprecated, use index.[has_node\|rev\|get_rev]"
	util.nouideprecwarn(msg, b'5.3', stacklevel=2)			util.nouideprecwarn(msg, b'5.3', stacklevel=2)
	return self._nodemap			return self._nodemap

	@util.propertycache			@util.propertycache
	def _nodemap(self):			def _nodemap(self):
	nodemap = nodemaputil.NodeMap({nullid: nullrev})			nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
	for r in range(0, len(self)):			for r in range(0, len(self)):
	n = self[r][7]			n = self[r][7]
	nodemap[n] = r			nodemap[n] = r
	return nodemap			return nodemap

	def has_node(self, node):			def has_node(self, node):
	"""return True if the node exist in the index"""			"""return True if the node exist in the index"""
	return node in self._nodemap			return node in self._nodemap
	del self._nodemap[self[r][7]]			del self._nodemap[self[r][7]]
	super(revlogoldindex, self).__delitem__(i)			super(revlogoldindex, self).__delitem__(i)

	def clearcaches(self):			def clearcaches(self):
	self.__dict__.pop('_nodemap', None)			self.__dict__.pop('_nodemap', None)

	def __getitem__(self, i):			def __getitem__(self, i):
	if i == -1:			if i == -1:
	return (0, 0, 0, -1, -1, -1, -1, nullid)			return (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid)
	return list.__getitem__(self, i)			return list.__getitem__(self, i)


	class revlogoldio(object):			class revlogoldio(object):
	def parseindex(self, data, inline):			def parseindex(self, data, inline):
	s = INDEX_ENTRY_V0.size			s = INDEX_ENTRY_V0.size
	index = []			index = []
	nodemap = nodemaputil.NodeMap({nullid: nullrev})			nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
	n = off = 0			n = off = 0
	l = len(data)			l = len(data)
	while off + s <= l:			while off + s <= l:
	cur = data[off : off + s]			cur = data[off : off + s]
	off += s			off += s
	e = INDEX_ENTRY_V0.unpack(cur)			e = INDEX_ENTRY_V0.unpack(cur)
	# transform to revlogv1 format			# transform to revlogv1 format
	e2 = (			e2 = (

	def rev(self, node):			def rev(self, node):
	try:			try:
	return self.index.rev(node)			return self.index.rev(node)
	except TypeError:			except TypeError:
	raise			raise
	except error.RevlogError:			except error.RevlogError:
	# parsers.c radix tree lookup failed			# parsers.c radix tree lookup failed
	if node == wdirid or node in wdirfilenodeids:			if (
				node == self.nodeconstants.wdirid
				or node in self.nodeconstants.wdirfilenodeids
				):
	raise error.WdirUnsupported			raise error.WdirUnsupported
	raise error.LookupError(node, self.indexfile, _(b'no node'))			raise error.LookupError(node, self.indexfile, _(b'no node'))

	# Accessors for index entries.			# Accessors for index entries.

	# First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes			# First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
	# are flags.			# are flags.
	def start(self, rev):			def start(self, rev):

	def end(self, rev):			def end(self, rev):
	return self.start(rev) + self.length(rev)			return self.start(rev) + self.length(rev)

	def parents(self, node):			def parents(self, node):
	i = self.index			i = self.index
	d = i[self.rev(node)]			d = i[self.rev(node)]
	# inline node() to avoid function call overhead			# inline node() to avoid function call overhead
	if d[5] == nullid:			if d[5] == self.nullid:
	return i[d[6]][7], i[d[5]][7]			return i[d[6]][7], i[d[5]][7]
	else:			else:
	return i[d[5]][7], i[d[6]][7]			return i[d[5]][7], i[d[6]][7]

	def chainlen(self, rev):			def chainlen(self, rev):
	return self._chaininfo(rev)[0]			return self._chaininfo(rev)[0]

	def _chaininfo(self, rev):			def _chaininfo(self, rev):

	The list is sorted by revision number, meaning it is			The list is sorted by revision number, meaning it is
	topologically sorted.			topologically sorted.

	'heads' and 'common' are both lists of node IDs. If heads is			'heads' and 'common' are both lists of node IDs. If heads is
	not supplied, uses all of the revlog's heads. If common is not			not supplied, uses all of the revlog's heads. If common is not
	supplied, uses nullid."""			supplied, uses nullid."""
	if common is None:			if common is None:
	common = [nullid]			common = [self.nullid]
	if heads is None:			if heads is None:
	heads = self.heads()			heads = self.heads()

	common = [self.rev(n) for n in common]			common = [self.rev(n) for n in common]
	heads = [self.rev(n) for n in heads]			heads = [self.rev(n) for n in heads]

	# we want the ancestors, but inclusive			# we want the ancestors, but inclusive
	class lazyset(object):			class lazyset(object):

	The list is sorted by revision number, meaning it is			The list is sorted by revision number, meaning it is
	topologically sorted.			topologically sorted.

	'heads' and 'common' are both lists of node IDs. If heads is			'heads' and 'common' are both lists of node IDs. If heads is
	not supplied, uses all of the revlog's heads. If common is not			not supplied, uses all of the revlog's heads. If common is not
	supplied, uses nullid."""			supplied, uses nullid."""
	if common is None:			if common is None:
	common = [nullid]			common = [self.nullid]
	if heads is None:			if heads is None:
	heads = self.heads()			heads = self.heads()

	common = [self.rev(n) for n in common]			common = [self.rev(n) for n in common]
	heads = [self.rev(n) for n in heads]			heads = [self.rev(n) for n in heads]

	inc = self.incrementalmissingrevs(common=common)			inc = self.incrementalmissingrevs(common=common)
	return [self.node(r) for r in inc.missingancestors(heads)]			return [self.node(r) for r in inc.missingancestors(heads)]
	unspecified, uses list of all of the revlog's heads."""			unspecified, uses list of all of the revlog's heads."""
	nonodes = ([], [], [])			nonodes = ([], [], [])
	if roots is not None:			if roots is not None:
	roots = list(roots)			roots = list(roots)
	if not roots:			if not roots:
	return nonodes			return nonodes
	lowestrev = min([self.rev(n) for n in roots])			lowestrev = min([self.rev(n) for n in roots])
	else:			else:
	roots = [nullid] # Everybody's a descendant of nullid			roots = [self.nullid] # Everybody's a descendant of nullid
	lowestrev = nullrev			lowestrev = nullrev
	if (lowestrev == nullrev) and (heads is None):			if (lowestrev == nullrev) and (heads is None):
	# We want _all_ the nodes!			# We want _all_ the nodes!
	return ([self.node(r) for r in self], [nullid], list(self.heads()))			return (
				[self.node(r) for r in self],
				[self.nullid],
				list(self.heads()),
				)
	if heads is None:			if heads is None:
	# All nodes are ancestors, so the latest ancestor is the last			# All nodes are ancestors, so the latest ancestor is the last
	# node.			# node.
	highestrev = len(self) - 1			highestrev = len(self) - 1
	# Set ancestors to None to signal that every node is an ancestor.			# Set ancestors to None to signal that every node is an ancestor.
	ancestors = None			ancestors = None
	# Set heads to an empty dictionary for later discovery of heads			# Set heads to an empty dictionary for later discovery of heads
	heads = {}			heads = {}
	# Start at the top and keep marking parents until we're done.			# Start at the top and keep marking parents until we're done.
	nodestotag = set(heads)			nodestotag = set(heads)
	# Remember where the top was so we can use it as a limit later.			# Remember where the top was so we can use it as a limit later.
	highestrev = max([self.rev(n) for n in nodestotag])			highestrev = max([self.rev(n) for n in nodestotag])
	while nodestotag:			while nodestotag:
	# grab a node to tag			# grab a node to tag
	n = nodestotag.pop()			n = nodestotag.pop()
	# Never tag nullid			# Never tag nullid
	if n == nullid:			if n == self.nullid:
	continue			continue
	# A node's revision number represents its place in a			# A node's revision number represents its place in a
	# topologically sorted list of nodes.			# topologically sorted list of nodes.
	r = self.rev(n)			r = self.rev(n)
	if r >= lowestrev:			if r >= lowestrev:
	if n not in ancestors:			if n not in ancestors:
	# If we are possibly a descendant of one of the roots			# If we are possibly a descendant of one of the roots
	# and we haven't already been marked as an ancestor			# and we haven't already been marked as an ancestor
	ancestors.add(n) # Mark as ancestor			ancestors.add(n) # Mark as ancestor
	# Add non-nullid parents to list of nodes to tag.			# Add non-nullid parents to list of nodes to tag.
	nodestotag.update(			nodestotag.update(
	[p for p in self.parents(n) if p != nullid]			[p for p in self.parents(n) if p != self.nullid]
	)			)
	elif n in heads: # We've seen it before, is it a fake head?			elif n in heads: # We've seen it before, is it a fake head?
	# So it is, real heads should not be the ancestors of			# So it is, real heads should not be the ancestors of
	# any other heads.			# any other heads.
	heads.pop(n)			heads.pop(n)
	if not ancestors:			if not ancestors:
	return nonodes			return nonodes
	# Now that we have our set of ancestors, we want to remove any			# Now that we have our set of ancestors, we want to remove any
	lowestrev = min([self.rev(root) for root in roots])			lowestrev = min([self.rev(root) for root in roots])
	else:			else:
	# No more roots? Return empty list			# No more roots? Return empty list
	return nonodes			return nonodes
	else:			else:
	# We are descending from nullid, and don't need to care about			# We are descending from nullid, and don't need to care about
	# any other roots.			# any other roots.
	lowestrev = nullrev			lowestrev = nullrev
	roots = [nullid]			roots = [self.nullid]
	# Transform our roots list into a set.			# Transform our roots list into a set.
	descendants = set(roots)			descendants = set(roots)
	# Also, keep the original roots so we can filter out roots that aren't			# Also, keep the original roots so we can filter out roots that aren't
	# 'real' roots (i.e. are descended from other roots).			# 'real' roots (i.e. are descended from other roots).
	roots = descendants.copy()			roots = descendants.copy()
	# Our topologically sorted list of output nodes.			# Our topologically sorted list of output nodes.
	orderedout = []			orderedout = []
	# Don't start at nullid since we don't want nullid in our output list,			# Don't start at nullid since we don't want nullid in our output list,

	if start is specified, only heads that are descendants of			if start is specified, only heads that are descendants of
	start will be returned			start will be returned
	if stop is specified, it will consider all the revs from stop			if stop is specified, it will consider all the revs from stop
	as if they had no children			as if they had no children
	"""			"""
	if start is None and stop is None:			if start is None and stop is None:
	if not len(self):			if not len(self):
	return [nullid]			return [self.nullid]
	return [self.node(r) for r in self.headrevs()]			return [self.node(r) for r in self.headrevs()]

	if start is None:			if start is None:
	start = nullrev			start = nullrev
	else:			else:
	start = self.rev(start)			start = self.rev(start)

	stoprevs = {self.rev(n) for n in stop or []}			stoprevs = {self.rev(n) for n in stop or []}
	a, b = self.rev(a), self.rev(b)			a, b = self.rev(a), self.rev(b)
	try:			try:
	ancs = self.index.ancestors(a, b)			ancs = self.index.ancestors(a, b)
	except (AttributeError, OverflowError):			except (AttributeError, OverflowError):
	ancs = ancestor.ancestors(self.parentrevs, a, b)			ancs = ancestor.ancestors(self.parentrevs, a, b)
	if ancs:			if ancs:
	# choose a consistent winner when there's a tie			# choose a consistent winner when there's a tie
	return min(map(self.node, ancs))			return min(map(self.node, ancs))
	return nullid			return self.nullid

	def _match(self, id):			def _match(self, id):
	if isinstance(id, int):			if isinstance(id, int):
	# rev			# rev
	return self.node(id)			return self.node(id)
	if len(id) == 20:			if len(id) == 20:
	# possibly a binary node			# possibly a binary node
	# odds of a binary node being all hex in ASCII are 1 in 10**25			# odds of a binary node being all hex in ASCII are 1 in 10**25
	node = bin(id)			node = bin(id)
	self.rev(node)			self.rev(node)
	return node			return node
	except (TypeError, error.LookupError):			except (TypeError, error.LookupError):
	pass			pass

	def _partialmatch(self, id):			def _partialmatch(self, id):
	# we don't care wdirfilenodeids as they should be always full hash			# we don't care wdirfilenodeids as they should be always full hash
	maybewdir = wdirhex.startswith(id)			maybewdir = self.nodeconstants.wdirhex.startswith(id)
	try:			try:
	partial = self.index.partialmatch(id)			partial = self.index.partialmatch(id)
	if partial and self.hasnode(partial):			if partial and self.hasnode(partial):
	if maybewdir:			if maybewdir:
	# single 'ff...' match in radix tree, ambiguous with wdir			# single 'ff...' match in radix tree, ambiguous with wdir
	raise error.RevlogError			raise error.RevlogError
	return partial			return partial
	if maybewdir:			if maybewdir:
	try:			try:
	# hex(node)[:...]			# hex(node)[:...]
	l = len(id) // 2 # grab an even number of digits			l = len(id) // 2 # grab an even number of digits
	prefix = bin(id[: l * 2])			prefix = bin(id[: l * 2])
	nl = [e[7] for e in self.index if e[7].startswith(prefix)]			nl = [e[7] for e in self.index if e[7].startswith(prefix)]
	nl = [			nl = [
	n for n in nl if hex(n).startswith(id) and self.hasnode(n)			n for n in nl if hex(n).startswith(id) and self.hasnode(n)
	]			]
	if nullhex.startswith(id):			if self.nodeconstants.nullhex.startswith(id):
	nl.append(nullid)			nl.append(self.nullid)
	if len(nl) > 0:			if len(nl) > 0:
	if len(nl) == 1 and not maybewdir:			if len(nl) == 1 and not maybewdir:
	self._pcache[id] = nl[0]			self._pcache[id] = nl[0]
	return nl[0]			return nl[0]
	raise error.AmbiguousPrefixLookupError(			raise error.AmbiguousPrefixLookupError(
	id, self.indexfile, _(b'ambiguous identifier')			id, self.indexfile, _(b'ambiguous identifier')
	)			)
	if maybewdir:			if maybewdir:
	if not maybewdir(prefix):			if not maybewdir(prefix):
	return prefix			return prefix

	if not getattr(self, 'filteredrevs', None):			if not getattr(self, 'filteredrevs', None):
	try:			try:
	length = max(self.index.shortest(node), minlength)			length = max(self.index.shortest(node), minlength)
	return disambiguate(hexnode, length)			return disambiguate(hexnode, length)
	except error.RevlogError:			except error.RevlogError:
	if node != wdirid:			if node != self.nodeconstants.wdirid:
	raise error.LookupError(node, self.indexfile, _(b'no node'))			raise error.LookupError(node, self.indexfile, _(b'no node'))
	except AttributeError:			except AttributeError:
	# Fall through to pure code			# Fall through to pure code
	pass			pass

	if node == wdirid:			if node == self.nodeconstants.wdirid:
	for length in range(minlength, len(hexnode) + 1):			for length in range(minlength, len(hexnode) + 1):
	prefix = hexnode[:length]			prefix = hexnode[:length]
	if isvalid(prefix):			if isvalid(prefix):
	return prefix			return prefix

	for length in range(minlength, len(hexnode) + 1):			for length in range(minlength, len(hexnode) + 1):
	prefix = hexnode[:length]			prefix = hexnode[:length]
	if isvalid(prefix):			if isvalid(prefix):
	if isinstance(nodeorrev, int):			if isinstance(nodeorrev, int):
	rev = nodeorrev			rev = nodeorrev
	node = self.node(rev)			node = self.node(rev)
	else:			else:
	node = nodeorrev			node = nodeorrev
	rev = None			rev = None

	# fast path the special `nullid` rev			# fast path the special `nullid` rev
	if node == nullid:			if node == self.nullid:
	return b"", {}			return b"", {}

	# ``rawtext`` is the text as stored inside the revlog. Might be the			# ``rawtext`` is the text as stored inside the revlog. Might be the
	# revision or might need to be processed to retrieve the revision.			# revision or might need to be processed to retrieve the revision.
	rev, rawtext, validated = self._rawtext(node, rev, _df=_df)			rev, rawtext, validated = self._rawtext(node, rev, _df=_df)

	if self.version & 0xFFFF == REVLOGV2:			if self.version & 0xFFFF == REVLOGV2:
	if rev is None:			if rev is None:

	if "deltacomputer" is not provided or None, a defaultdeltacomputer will			if "deltacomputer" is not provided or None, a defaultdeltacomputer will
	be used.			be used.

	invariants:			invariants:
	- rawtext is optional (can be None); if not set, cachedelta must be set.			- rawtext is optional (can be None); if not set, cachedelta must be set.
	if both are set, they must correspond to each other.			if both are set, they must correspond to each other.
	"""			"""
	if node == nullid:			if node == self.nullid:
	raise error.RevlogError(			raise error.RevlogError(
	_(b"%s: attempt to add null revision") % self.indexfile			_(b"%s: attempt to add null revision") % self.indexfile
	)			)
	if node == wdirid or node in wdirfilenodeids:			if (
				node == self.nodeconstants.wdirid
				or node in self.nodeconstants.wdirfilenodeids
				):
	raise error.RevlogError(			raise error.RevlogError(
	_(b"%s: attempt to add wdir revision") % self.indexfile			_(b"%s: attempt to add wdir revision") % self.indexfile
	)			)

	if self._inline:			if self._inline:
	fh = ifh			fh = ifh
	else:			else:
	fh = dfh			fh = dfh

mercurial/scmutil.py

	import re			import re
	import subprocess			import subprocess
	import weakref			import weakref

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	wdirid,
	wdirrev,			wdirrev,
	)			)
	from .pycompat import getattr			from .pycompat import getattr
	from .thirdparty import attr			from .thirdparty import attr
	from . import (			from . import (
	copies as copiesmod,			copies as copiesmod,
	encoding,			encoding,
	error,			error,
	newdirs.append(d)			newdirs.append(d)
	dirs[:] = newdirs			dirs[:] = newdirs


	def binnode(ctx):			def binnode(ctx):
	"""Return binary node id for a given basectx"""			"""Return binary node id for a given basectx"""
	node = ctx.node()			node = ctx.node()
	if node is None:			if node is None:
	return wdirid			return ctx.repo().nodeconstants.wdirid
	return node			return node


	def intrev(ctx):			def intrev(ctx):
	"""Return integer for a given basectx that can be used in comparison or			"""Return integer for a given basectx that can be used in comparison or
	arithmetic operation"""			arithmetic operation"""
	rev = ctx.rev()			rev = ctx.rev()
	if rev is None:			if rev is None:
	for rep in replacements:			for rep in replacements:
	allreplaced.extend(rep)			allreplaced.extend(rep)
	roots = list(			roots = list(
	unfi.set(b'max((::%n) - %ln)', oldnode, allreplaced)			unfi.set(b'max((::%n) - %ln)', oldnode, allreplaced)
	)			)
	if roots:			if roots:
	newnode = roots[0].node()			newnode = roots[0].node()
	else:			else:
	newnode = nullid			newnode = repo.nullid
	else:			else:
	newnode = newnodes[0]			newnode = newnodes[0]
	moves[oldnode] = newnode			moves[oldnode] = newnode

	allnewnodes = [n for ns in replacements.values() for n in ns]			allnewnodes = [n for ns in replacements.values() for n in ns]
	toretract = {}			toretract = {}
	toadvance = {}			toadvance = {}
	if fixphase:			if fixphase:

	A matcher can be provided as an optimization. It is probably a bug to pass			A matcher can be provided as an optimization. It is probably a bug to pass
	a matcher that doesn't match all the differences between the parent of the			a matcher that doesn't match all the differences between the parent of the
	working copy and newctx.			working copy and newctx.
	"""			"""
	oldctx = repo[b'.']			oldctx = repo[b'.']
	ds = repo.dirstate			ds = repo.dirstate
	copies = dict(ds.copies())			copies = dict(ds.copies())
	ds.setparents(newctx.node(), nullid)			ds.setparents(newctx.node(), repo.nullid)
	s = newctx.status(oldctx, match=match)			s = newctx.status(oldctx, match=match)
	for f in s.modified:			for f in s.modified:
	if ds[f] == b'r':			if ds[f] == b'r':
	# modified + removed -> removed			# modified + removed -> removed
	continue			continue
	ds.normallookup(f)			ds.normallookup(f)

	for f in s.added:			for f in s.added:

mercurial/setdiscovery.py

	"""			"""

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import random			import random

	from .i18n import _			from .i18n import _
	from .node import (			from .node import nullrev
	nullid,
	nullrev,
	)
	from . import (			from . import (
	error,			error,
	policy,			policy,
	util,			util,
	)			)


	def _updatesample(revs, heads, sample, parentfn, quicksamplesize=0):			def _updatesample(revs, heads, sample, parentfn, quicksamplesize=0):
	)			)

	srvheadhashes, yesno = fheads.result(), fknown.result()			srvheadhashes, yesno = fheads.result(), fknown.result()

	if audit is not None:			if audit is not None:
	audit[b'total-roundtrips'] = 1			audit[b'total-roundtrips'] = 1

	if cl.tiprev() == nullrev:			if cl.tiprev() == nullrev:
	if srvheadhashes != [nullid]:			if srvheadhashes != [cl.nullid]:
	return [nullid], True, srvheadhashes			return [cl.nullid], True, srvheadhashes
	return [nullid], False, []			return [cl.nullid], False, []
	else:			else:
	# we still need the remote head for the function return			# we still need the remote head for the function return
	with remote.commandexecutor() as e:			with remote.commandexecutor() as e:
	fheads = e.callcommand(b'heads', {})			fheads = e.callcommand(b'heads', {})
	srvheadhashes = fheads.result()			srvheadhashes = fheads.result()

	# start actual discovery (we note this before the next "if" for			# start actual discovery (we note this before the next "if" for
	# compatibility reasons)			# compatibility reasons)
	ui.status(_(b"searching for changes\n"))			ui.status(_(b"searching for changes\n"))

	knownsrvheads = [] # revnos of remote heads that are known locally			knownsrvheads = [] # revnos of remote heads that are known locally
	for node in srvheadhashes:			for node in srvheadhashes:
	if node == nullid:			if node == cl.nullid:
	continue			continue

	try:			try:
	knownsrvheads.append(clrev(node))			knownsrvheads.append(clrev(node))
	# Catches unknown and filtered nodes.			# Catches unknown and filtered nodes.
	except error.LookupError:			except error.LookupError:
	continue			continue

	b' %d roundtrips in %.4fs\n'			b' %d roundtrips in %.4fs\n'
	)			)
	missing = set(result) - set(knownsrvheads)			missing = set(result) - set(knownsrvheads)
	ui.log(b'discovery', msg, len(result), len(missing), roundtrips, elapsed)			ui.log(b'discovery', msg, len(result), len(missing), roundtrips, elapsed)

	if audit is not None:			if audit is not None:
	audit[b'total-roundtrips'] = roundtrips			audit[b'total-roundtrips'] = roundtrips

	if not result and srvheadhashes != [nullid]:			if not result and srvheadhashes != [cl.nullid]:
	if abortwhenunrelated:			if abortwhenunrelated:
	raise error.Abort(_(b"repository is unrelated"))			raise error.Abort(_(b"repository is unrelated"))
	else:			else:
	ui.warn(_(b"warning: repository is unrelated\n"))			ui.warn(_(b"warning: repository is unrelated\n"))
	return (			return (
	{nullid},			{cl.nullid},
	True,			True,
	srvheadhashes,			srvheadhashes,
	)			)

	anyincoming = srvheadhashes != [nullid]			anyincoming = srvheadhashes != [cl.nullid]
	result = {clnode(r) for r in result}			result = {clnode(r) for r in result}
	return result, anyincoming, srvheadhashes			return result, anyincoming, srvheadhashes

mercurial/shelve.py

	import errno			import errno
	import itertools			import itertools
	import stat			import stat

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)
	from . import (			from . import (
	bookmarks,			bookmarks,
	bundle2,			bundle2,
	changegroup,			changegroup,
	cmdutil,			cmdutil,
	discovery,			discovery,
	_(b"unresolved conflicts, can't continue"),			_(b"unresolved conflicts, can't continue"),
	hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"),			hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"),
	)			)

	shelvectx = repo[state.parents[1]]			shelvectx = repo[state.parents[1]]
	pendingctx = state.pendingctx			pendingctx = state.pendingctx

	with repo.dirstate.parentchange():			with repo.dirstate.parentchange():
	repo.setparents(state.pendingctx.node(), nullid)			repo.setparents(state.pendingctx.node(), repo.nullid)
	repo.dirstate.write(repo.currenttransaction())			repo.dirstate.write(repo.currenttransaction())

	targetphase = phases.internal			targetphase = phases.internal
	if not phases.supportinternal(repo):			if not phases.supportinternal(repo):
	targetphase = phases.secret			targetphase = phases.secret
	overrides = {(b'phases', b'new-commit'): targetphase}			overrides = {(b'phases', b'new-commit'): targetphase}
	with repo.ui.configoverride(overrides, b'unshelve'):			with repo.ui.configoverride(overrides, b'unshelve'):
	with repo.dirstate.parentchange():			with repo.dirstate.parentchange():
	repo.setparents(state.parents[0], nullid)			repo.setparents(state.parents[0], repo.nullid)
	newnode, ispartialunshelve = _createunshelvectx(			newnode, ispartialunshelve = _createunshelvectx(
	ui, repo, shelvectx, basename, interactive, opts			ui, repo, shelvectx, basename, interactive, opts
	)			)

	if newnode is None:			if newnode is None:
	shelvectx = state.pendingctx			shelvectx = state.pendingctx
	msg = _(			msg = _(
	b'note: unshelved changes already existed '			b'note: unshelved changes already existed '
	branchtorestore,			branchtorestore,
	opts.get(b'keep'),			opts.get(b'keep'),
	activebookmark,			activebookmark,
	interactive,			interactive,
	)			)
	raise error.ConflictResolutionRequired(b'unshelve')			raise error.ConflictResolutionRequired(b'unshelve')

	with repo.dirstate.parentchange():			with repo.dirstate.parentchange():
	repo.setparents(tmpwctx.node(), nullid)			repo.setparents(tmpwctx.node(), repo.nullid)
	newnode, ispartialunshelve = _createunshelvectx(			newnode, ispartialunshelve = _createunshelvectx(
	ui, repo, shelvectx, basename, interactive, opts			ui, repo, shelvectx, basename, interactive, opts
	)			)

	if newnode is None:			if newnode is None:
	shelvectx = tmpwctx			shelvectx = tmpwctx
	msg = _(			msg = _(
	b'note: unshelved changes already existed '			b'note: unshelved changes already existed '

mercurial/sparse.py

	# sparse.py - functionality for sparse checkouts			# sparse.py - functionality for sparse checkouts
	#			#
	# Copyright 2014 Facebook, Inc.			# Copyright 2014 Facebook, Inc.
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os

	from .i18n import _			from .i18n import _
	from .node import (			from .node import hex
	hex,
	nullid,
	)
	from . import (			from . import (
	error,			error,
	match as matchmod,			match as matchmod,
	merge as mergemod,			merge as mergemod,
	mergestate as mergestatemod,			mergestate as mergestatemod,
	pathutil,			pathutil,
	pycompat,			pycompat,
	requirements,			requirements,
	"""Determine the active sparse config rules.			"""Determine the active sparse config rules.

	Rules are constructed by reading the current sparse config and bringing in			Rules are constructed by reading the current sparse config and bringing in
	referenced profiles from parents of the working directory.			referenced profiles from parents of the working directory.
	"""			"""
	revs = [			revs = [
	repo.changelog.rev(node)			repo.changelog.rev(node)
	for node in repo.dirstate.parents()			for node in repo.dirstate.parents()
	if node != nullid			if node != repo.nullid
	]			]

	allincludes = set()			allincludes = set()
	allexcludes = set()			allexcludes = set()
	allprofiles = set()			allprofiles = set()

	for rev in revs:			for rev in revs:
	includes, excludes, profiles = patternsforrev(repo, rev)			includes, excludes, profiles = patternsforrev(repo, rev)
	# If sparse isn't enabled, sparse matcher matches everything.			# If sparse isn't enabled, sparse matcher matches everything.
	if not enabled:			if not enabled:
	return matchmod.always()			return matchmod.always()

	if not revs or revs == [None]:			if not revs or revs == [None]:
	revs = [			revs = [
	repo.changelog.rev(node)			repo.changelog.rev(node)
	for node in repo.dirstate.parents()			for node in repo.dirstate.parents()
	if node != nullid			if node != repo.nullid
	]			]

	signature = configsignature(repo, includetemp=includetemp)			signature = configsignature(repo, includetemp=includetemp)

	key = b'%s %s' % (signature, b' '.join(map(pycompat.bytestr, revs)))			key = b'%s %s' % (signature, b' '.join(map(pycompat.bytestr, revs)))

	result = repo._sparsematchercache.get(key)			result = repo._sparsematchercache.get(key)
	if result:			if result:

mercurial/strip.py

	from __future__ import absolute_import			from __future__ import absolute_import

	from .i18n import _			from .i18n import _
	from .pycompat import getattr			from .pycompat import getattr
	from .node import nullid
	from . import (			from . import (
	bookmarks as bookmarksmod,			bookmarks as bookmarksmod,
	cmdutil,			cmdutil,
	error,			error,
	hg,			hg,
	lock as lockmod,			lock as lockmod,
	mergestate as mergestatemod,			mergestate as mergestatemod,
	pycompat,			pycompat,


	def _findupdatetarget(repo, nodes):			def _findupdatetarget(repo, nodes):
	unode, p2 = repo.changelog.parents(nodes[0])			unode, p2 = repo.changelog.parents(nodes[0])
	currentbranch = repo[None].branch()			currentbranch = repo[None].branch()

	if (			if (
	util.safehasattr(repo, b'mq')			util.safehasattr(repo, b'mq')
	and p2 != nullid			and p2 != repo.nullid
	and p2 in [x.node for x in repo.mq.applied]			and p2 in [x.node for x in repo.mq.applied]
	):			):
	unode = p2			unode = p2
	elif currentbranch != repo[unode].branch():			elif currentbranch != repo[unode].branch():
	pwdir = b'parents(wdir())'			pwdir = b'parents(wdir())'
	revset = b'max(((parents(%ln::%r) + %r) - %ln::%r) and branch(%s))'			revset = b'max(((parents(%ln::%r) + %r) - %ln::%r) and branch(%s))'
	branchtarget = repo.revs(			branchtarget = repo.revs(
	revset, nodes, pwdir, pwdir, nodes, pwdir, currentbranch			revset, nodes, pwdir, pwdir, nodes, pwdir, currentbranch

	descendants = set(cl.descendants(revs))			descendants = set(cl.descendants(revs))
	strippedrevs = revs.union(descendants)			strippedrevs = revs.union(descendants)
	roots = revs.difference(descendants)			roots = revs.difference(descendants)

	# if one of the wdir parent is stripped we'll need			# if one of the wdir parent is stripped we'll need
	# to update away to an earlier revision			# to update away to an earlier revision
	update = any(			update = any(
	p != nullid and cl.rev(p) in strippedrevs			p != repo.nullid and cl.rev(p) in strippedrevs
	for p in repo.dirstate.parents()			for p in repo.dirstate.parents()
	)			)

	rootnodes = {cl.node(r) for r in roots}			rootnodes = {cl.node(r) for r in roots}

	q = getattr(repo, 'mq', None)			q = getattr(repo, 'mq', None)
	if q is not None and q.applied:			if q is not None and q.applied:
	# refresh queue state if we're about to strip			# refresh queue state if we're about to strip

mercurial/subrepo.py

	import sys			import sys
	import tarfile			import tarfile
	import xml.dom.minidom			import xml.dom.minidom

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	short,			short,
	)			)
	from . import (			from . import (
	cmdutil,			cmdutil,
	encoding,			encoding,
	error,			error,
	exchange,			exchange,
	logcmdutil,			logcmdutil,
	def phase(self, state):			def phase(self, state):
	return self._repo[state or b'.'].phase()			return self._repo[state or b'.'].phase()

	@annotatesubrepoerror			@annotatesubrepoerror
	def remove(self):			def remove(self):
	# we can't fully delete the repository as it may contain			# we can't fully delete the repository as it may contain
	# local-only history			# local-only history
	self.ui.note(_(b'removing subrepo %s\n') % subrelpath(self))			self.ui.note(_(b'removing subrepo %s\n') % subrelpath(self))
	hg.clean(self._repo, nullid, False)			hg.clean(self._repo, self._repo.nullid, False)

	def _get(self, state):			def _get(self, state):
	source, revision, kind = state			source, revision, kind = state
	parentrepo = self._repo._subparent			parentrepo = self._repo._subparent

	if revision in self._repo.unfiltered():			if revision in self._repo.unfiltered():
	# Allow shared subrepos tracked at null to setup the sharedpath			# Allow shared subrepos tracked at null to setup the sharedpath
	if len(self._repo) != 0 or not parentrepo.shared():			if len(self._repo) != 0 or not parentrepo.shared():

mercurial/tagmerge.py

	# merged tags file			# merged tags file
	# - sort the "tag blocks" according to their associated number line			# - sort the "tag blocks" according to their associated number line
	# - put blocks whose nodes come all from p2 first			# - put blocks whose nodes come all from p2 first
	# - write the tag blocks in the sorted order			# - write the tag blocks in the sorted order

	from __future__ import absolute_import			from __future__ import absolute_import

	from .i18n import _			from .i18n import _
	from .node import (
	nullhex,
	)
	from . import (			from . import (
	tags as tagsmod,			tags as tagsmod,
	util,			util,
	)			)


	def readtagsformerge(ui, repo, lines, fn=b'', keeplinenums=False):			def readtagsformerge(ui, repo, lines, fn=b'', keeplinenums=False):
	"""read the .hgtags file into a structure that is suitable for merging			"""read the .hgtags file into a structure that is suitable for merging
	# recover the list of "lost tags" (i.e. those that were found on the base			# recover the list of "lost tags" (i.e. those that were found on the base
	# revision but not on one of the revisions being merged)			# revision but not on one of the revisions being merged)
	basetagset = set(basetags)			basetagset = set(basetags)
	for n, pntags in enumerate((p1tags, p2tags)):			for n, pntags in enumerate((p1tags, p2tags)):
	pntagset = set(pntags)			pntagset = set(pntags)
	pnlosttagset = basetagset - pntagset			pnlosttagset = basetagset - pntagset
	for t in pnlosttagset:			for t in pnlosttagset:
	pntags[t] = basetags[t]			pntags[t] = basetags[t]
	if pntags[t][-1][0] != nullhex:			if pntags[t][-1][0] != repo.nodeconstants.nullhex:
	pntags[t].append([nullhex, None])			pntags[t].append([repo.nodeconstants.nullhex, None])

	conflictedtags = [] # for reporting purposes			conflictedtags = [] # for reporting purposes
	mergedtags = util.sortdict(p1tags)			mergedtags = util.sortdict(p1tags)
	# sortdict does not implement iteritems()			# sortdict does not implement iteritems()
	for tname, p2nodes in p2tags.items():			for tname, p2nodes in p2tags.items():
	if tname not in mergedtags:			if tname not in mergedtags:
	mergedtags[tname] = p2nodes			mergedtags[tname] = p2nodes
	continue			continue

mercurial/tags.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import errno			import errno
	import io			import io

	from .node import (			from .node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	short,			short,
	)			)
	from .i18n import _			from .i18n import _
	from . import (			from . import (
	encoding,			encoding,
	error,			error,
	match as matchmod,			match as matchmod,
	unfi = repo.unfiltered()			unfi = repo.unfiltered()
	tonode = unfi.changelog.node			tonode = unfi.changelog.node
	nodes = [tonode(r) for r in revs]			nodes = [tonode(r) for r in revs]
	fnodes = _getfnodes(ui, repo, nodes)			fnodes = _getfnodes(ui, repo, nodes)
	fnodes = _filterfnodes(fnodes, nodes)			fnodes = _filterfnodes(fnodes, nodes)
	return fnodes			return fnodes


	def _nulltonone(value):			def _nulltonone(repo, value):
	"""convert nullid to None			"""convert nullid to None

	For tag value, nullid means "deleted". This small utility function helps			For tag value, nullid means "deleted". This small utility function helps
	translating that to None."""			translating that to None."""
	if value == nullid:			if value == repo.nullid:
	return None			return None
	return value			return value


	def difftags(ui, repo, oldfnodes, newfnodes):			def difftags(ui, repo, oldfnodes, newfnodes):
	"""list differences between tags expressed in two set of file-nodes			"""list differences between tags expressed in two set of file-nodes

	The list contains entries in the form: (tagname, oldvalue, new value).			The list contains entries in the form: (tagname, oldvalue, new value).
	None is used to expressed missing value:			None is used to expressed missing value:
	('foo', None, 'abcd') is a new tag,			('foo', None, 'abcd') is a new tag,
	('bar', 'ef01', None) is a deletion,			('bar', 'ef01', None) is a deletion,
	('baz', 'abcd', 'ef01') is a tag movement.			('baz', 'abcd', 'ef01') is a tag movement.
	"""			"""
	if oldfnodes == newfnodes:			if oldfnodes == newfnodes:
	return []			return []
	oldtags = _tagsfromfnodes(ui, repo, oldfnodes)			oldtags = _tagsfromfnodes(ui, repo, oldfnodes)
	newtags = _tagsfromfnodes(ui, repo, newfnodes)			newtags = _tagsfromfnodes(ui, repo, newfnodes)

	# list of (tag, old, new): None means missing			# list of (tag, old, new): None means missing
	entries = []			entries = []
	for tag, (new, __) in newtags.items():			for tag, (new, __) in newtags.items():
	new = _nulltonone(new)			new = _nulltonone(repo, new)
	old, __ = oldtags.pop(tag, (None, None))			old, __ = oldtags.pop(tag, (None, None))
	old = _nulltonone(old)			old = _nulltonone(repo, old)
	if old != new:			if old != new:
	entries.append((tag, old, new))			entries.append((tag, old, new))
	# handle deleted tags			# handle deleted tags
	for tag, (old, __) in oldtags.items():			for tag, (old, __) in oldtags.items():
	old = _nulltonone(old)			old = _nulltonone(repo, old)
	if old is not None:			if old is not None:
	entries.append((tag, old, None))			entries.append((tag, old, None))
	entries.sort()			entries.sort()
	return entries			return entries


	def writediff(fp, difflist):			def writediff(fp, difflist):
	"""write tags diff information to a file.			"""write tags diff information to a file.
	if cachefile:			if cachefile:
	cachefile.close() # ignore rest of file			cachefile.close() # ignore rest of file

	valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev))			valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev))

	repoheads = repo.heads()			repoheads = repo.heads()
	# Case 2 (uncommon): empty repo; get out quickly and don't bother			# Case 2 (uncommon): empty repo; get out quickly and don't bother
	# writing an empty cache.			# writing an empty cache.
	if repoheads == [nullid]:			if repoheads == [repo.nullid]:
	return ([], {}, valid, {}, False)			return ([], {}, valid, {}, False)

	# Case 3 (uncommon): cache file missing or empty.			# Case 3 (uncommon): cache file missing or empty.

	# Case 4 (uncommon): tip rev decreased. This should only happen			# Case 4 (uncommon): tip rev decreased. This should only happen
	# when we're called from localrepository.destroyed(). Refresh the			# when we're called from localrepository.destroyed(). Refresh the
	# cache so future invocations will not see disappeared heads in the			# cache so future invocations will not see disappeared heads in the
	# cache.			# cache.
	starttime = util.timer()			starttime = util.timer()
	fnodescache = hgtagsfnodescache(repo.unfiltered())			fnodescache = hgtagsfnodescache(repo.unfiltered())
	cachefnode = {}			cachefnode = {}
	validated_fnodes = set()			validated_fnodes = set()
	unknown_entries = set()			unknown_entries = set()
	for node in nodes:			for node in nodes:
	fnode = fnodescache.getfnode(node)			fnode = fnodescache.getfnode(node)
	flog = repo.file(b'.hgtags')			flog = repo.file(b'.hgtags')
	if fnode != nullid:			if fnode != repo.nullid:
	if fnode not in validated_fnodes:			if fnode not in validated_fnodes:
	if flog.hasnode(fnode):			if flog.hasnode(fnode):
	validated_fnodes.add(fnode)			validated_fnodes.add(fnode)
	else:			else:
	unknown_entries.add(node)			unknown_entries.add(node)
	cachefnode[node] = fnode			cachefnode[node] = fnode

	if unknown_entries:			if unknown_entries:
	fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries)			fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries)
	for node, fnode in pycompat.iteritems(fixed_nodemap):			for node, fnode in pycompat.iteritems(fixed_nodemap):
	if fnode != nullid:			if fnode != repo.nullid:
	cachefnode[node] = fnode			cachefnode[node] = fnode

	fnodescache.write()			fnodescache.write()

	duration = util.timer() - starttime			duration = util.timer() - starttime
	ui.log(			ui.log(
	b'tagscache',			b'tagscache',
	b'%d/%d cache hits/lookups in %0.4f seconds\n',			b'%d/%d cache hits/lookups in %0.4f seconds\n',
	fp.write(b'\n')			fp.write(b'\n')
	for name in names:			for name in names:
	if munge:			if munge:
	m = munge(name)			m = munge(name)
	else:			else:
	m = name			m = name

	if repo._tagscache.tagtypes and name in repo._tagscache.tagtypes:			if repo._tagscache.tagtypes and name in repo._tagscache.tagtypes:
	old = repo.tags().get(name, nullid)			old = repo.tags().get(name, repo.nullid)
	fp.write(b'%s %s\n' % (hex(old), m))			fp.write(b'%s %s\n' % (hex(old), m))
	fp.write(b'%s %s\n' % (hex(node), m))			fp.write(b'%s %s\n' % (hex(node), m))
	fp.close()			fp.close()

	prevtags = b''			prevtags = b''
	if local:			if local:
	try:			try:
	fp = repo.vfs(b'localtags', b'r+')			fp = repo.vfs(b'localtags', b'r+')
	Otherwise, the filenode will be computed and returned unless			Otherwise, the filenode will be computed and returned unless
	"computemissing" is False. In that case, None will be returned if			"computemissing" is False. In that case, None will be returned if
	the entry is missing or False if the entry is invalid without			the entry is missing or False if the entry is invalid without
	any potentially expensive computation being performed.			any potentially expensive computation being performed.

	If an .hgtags does not exist at the specified revision, nullid is			If an .hgtags does not exist at the specified revision, nullid is
	returned.			returned.
	"""			"""
	if node == nullid:			if node == self._repo.nullid:
	return nullid			return node

	ctx = self._repo[node]			ctx = self._repo[node]
	rev = ctx.rev()			rev = ctx.rev()

	self.lookupcount += 1			self.lookupcount += 1

	offset = rev * _fnodesrecsize			offset = rev * _fnodesrecsize
	record = b'%s' % self._raw[offset : offset + _fnodesrecsize]			record = b'%s' % self._raw[offset : offset + _fnodesrecsize]
	if fnode is None:			if fnode is None:
	fnode = p1fnode			fnode = p1fnode
	if fnode is None:			if fnode is None:
	# Populate missing entry.			# Populate missing entry.
	try:			try:
	fnode = ctx.filenode(b'.hgtags')			fnode = ctx.filenode(b'.hgtags')
	except error.LookupError:			except error.LookupError:
	# No .hgtags file on this revision.			# No .hgtags file on this revision.
	fnode = nullid			fnode = self._repo.nullid
	return fnode			return fnode

	def setfnode(self, node, fnode):			def setfnode(self, node, fnode):
	"""Set the .hgtags filenode for a given changeset."""			"""Set the .hgtags filenode for a given changeset."""
	assert len(fnode) == 20			assert len(fnode) == 20
	ctx = self._repo[node]			ctx = self._repo[node]

	# Do a lookup first to avoid writing if nothing has changed.			# Do a lookup first to avoid writing if nothing has changed.

mercurial/templatefuncs.py

	# templatefuncs.py - common template functions			# templatefuncs.py - common template functions
	#			#
	# Copyright 2005, 2006 Olivia Mackall <olivia@selenic.com>			# Copyright 2005, 2006 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import re			import re

	from .i18n import _			from .i18n import _
	from .node import (			from .node import bin
	bin,
	wdirid,
	)
	from . import (			from . import (
	color,			color,
	dagop,			dagop,
	diffutil,			diffutil,
	encoding,			encoding,
	error,			error,
	minirst,			minirst,
	obsutil,			obsutil,
	try:			try:
	node = bin(hexnode)			node = bin(hexnode)
	except TypeError:			except TypeError:
	return hexnode			return hexnode
	else:			else:
	try:			try:
	node = scmutil.resolvehexnodeidprefix(repo, hexnode)			node = scmutil.resolvehexnodeidprefix(repo, hexnode)
	except error.WdirUnsupported:			except error.WdirUnsupported:
	node = wdirid			node = repo.nodeconstants.wdirid
	except error.LookupError:			except error.LookupError:
	return hexnode			return hexnode
	if not node:			if not node:
	return hexnode			return hexnode
	cache = context.resource(mapping, b'cache')			cache = context.resource(mapping, b'cache')
	try:			try:
	return scmutil.shortesthexnodeidprefix(repo, node, minlength, cache)			return scmutil.shortesthexnodeidprefix(repo, node, minlength, cache)
	except error.RepoLookupError:			except error.RepoLookupError:

mercurial/templatekw.py

	# templatekw.py - common changeset template keywords			# templatekw.py - common changeset template keywords
	#			#
	# Copyright 2005-2009 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2009 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	from .i18n import _			from .i18n import _
	from .node import (			from .node import (
	hex,			hex,
	nullid,
	wdirid,
	wdirrev,			wdirrev,
	)			)

	from . import (			from . import (
	diffutil,			diffutil,
	encoding,			encoding,
	error,			error,
	hbisect,			hbisect,


	def getgraphnode(repo, ctx, cache):			def getgraphnode(repo, ctx, cache):
	return getgraphnodecurrent(repo, ctx, cache) or getgraphnodesymbol(ctx)			return getgraphnodecurrent(repo, ctx, cache) or getgraphnodesymbol(ctx)


	def getgraphnodecurrent(repo, ctx, cache):			def getgraphnodecurrent(repo, ctx, cache):
	wpnodes = repo.dirstate.parents()			wpnodes = repo.dirstate.parents()
	if wpnodes[1] == nullid:			if wpnodes[1] == repo.nullid:
	wpnodes = wpnodes[:1]			wpnodes = wpnodes[:1]
	if ctx.node() in wpnodes:			if ctx.node() in wpnodes:
	return b'@'			return b'@'
	else:			else:
	merge_nodes = cache.get(b'merge_nodes')			merge_nodes = cache.get(b'merge_nodes')
	if merge_nodes is None:			if merge_nodes is None:
	from . import mergestate as mergestatemod			from . import mergestate as mergestatemod



	@templatekeyword(b'manifest', requires={b'repo', b'ctx'})			@templatekeyword(b'manifest', requires={b'repo', b'ctx'})
	def showmanifest(context, mapping):			def showmanifest(context, mapping):
	repo = context.resource(mapping, b'repo')			repo = context.resource(mapping, b'repo')
	ctx = context.resource(mapping, b'ctx')			ctx = context.resource(mapping, b'ctx')
	mnode = ctx.manifestnode()			mnode = ctx.manifestnode()
	if mnode is None:			if mnode is None:
	mnode = wdirid			mnode = repo.nodeconstants.wdirid
	mrev = wdirrev			mrev = wdirrev
				mhex = repo.nodeconstants.wdirhex
	else:			else:
	mrev = repo.manifestlog.rev(mnode)			mrev = repo.manifestlog.rev(mnode)
	mhex = hex(mnode)			mhex = hex(mnode)
	mapping = context.overlaymap(mapping, {b'rev': mrev, b'node': mhex})			mapping = context.overlaymap(mapping, {b'rev': mrev, b'node': mhex})
	f = context.process(b'manifest', mapping)			f = context.process(b'manifest', mapping)
	return templateutil.hybriditem(			return templateutil.hybriditem(
	f, None, f, lambda x: {b'rev': mrev, b'node': mhex}			f, None, f, lambda x: {b'rev': mrev, b'node': mhex}
	)			)


	@templatekeyword(b'obsfate', requires={b'ui', b'repo', b'ctx'})			@templatekeyword(b'obsfate', requires={b'ui', b'repo', b'ctx'})

mercurial/testing/storage.py

	# storage.py - Testing of storage primitives.			# storage.py - Testing of storage primitives.
	#			#
	# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>			# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import unittest			import unittest

	from ..node import (			from ..node import (
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)
	from ..pycompat import getattr			from ..pycompat import getattr
	from .. import (			from .. import (
	error,			error,
	mdiff,			mdiff,
	)			)
	from ..interfaces import repository			from ..interfaces import repository

	gen = iter(f)			gen = iter(f)
	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	self.assertFalse(f.hasnode(None))			self.assertFalse(f.hasnode(None))
	self.assertFalse(f.hasnode(0))			self.assertFalse(f.hasnode(0))
	self.assertFalse(f.hasnode(nullrev))			self.assertFalse(f.hasnode(nullrev))
	self.assertFalse(f.hasnode(nullid))			self.assertFalse(f.hasnode(f.nullid))
	self.assertFalse(f.hasnode(b'0'))			self.assertFalse(f.hasnode(b'0'))
	self.assertFalse(f.hasnode(b'a' * 20))			self.assertFalse(f.hasnode(b'a' * 20))

	# revs() should evaluate to an empty list.			# revs() should evaluate to an empty list.
	self.assertEqual(list(f.revs()), [])			self.assertEqual(list(f.revs()), [])

	revs = iter(f.revs())			revs = iter(f.revs())
	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(revs)			next(revs)

	self.assertEqual(list(f.revs(start=20)), [])			self.assertEqual(list(f.revs(start=20)), [])

	# parents() and parentrevs() work with nullid/nullrev.			# parents() and parentrevs() work with f.nullid/nullrev.
	self.assertEqual(f.parents(nullid), (nullid, nullid))			self.assertEqual(f.parents(f.nullid), (f.nullid, f.nullid))
	self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev))			self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev))

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.parents(b'\x01' * 20)			f.parents(b'\x01' * 20)

	for i in range(-5, 5):			for i in range(-5, 5):
	if i == nullrev:			if i == nullrev:
	continue			continue

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.parentrevs(i)			f.parentrevs(i)

	# nullid/nullrev lookup always works.			# f.nullid/nullrev lookup always works.
	self.assertEqual(f.rev(nullid), nullrev)			self.assertEqual(f.rev(f.nullid), nullrev)
	self.assertEqual(f.node(nullrev), nullid)			self.assertEqual(f.node(nullrev), f.nullid)

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.rev(b'\x01' * 20)			f.rev(b'\x01' * 20)

	for i in range(-5, 5):			for i in range(-5, 5):
	if i == nullrev:			if i == nullrev:
	continue			continue

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.node(i)			f.node(i)

	self.assertEqual(f.lookup(nullid), nullid)			self.assertEqual(f.lookup(f.nullid), f.nullid)
	self.assertEqual(f.lookup(nullrev), nullid)			self.assertEqual(f.lookup(nullrev), f.nullid)
	self.assertEqual(f.lookup(hex(nullid)), nullid)			self.assertEqual(f.lookup(hex(f.nullid)), f.nullid)
	self.assertEqual(f.lookup(b'%d' % nullrev), nullid)			self.assertEqual(f.lookup(b'%d' % nullrev), f.nullid)

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.lookup(b'badvalue')			f.lookup(b'badvalue')

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.lookup(hex(nullid)[0:12])			f.lookup(hex(f.nullid)[0:12])

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.lookup(b'-2')			f.lookup(b'-2')

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.lookup(b'0')			f.lookup(b'0')

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):

	for i in range(-5, 5):			for i in range(-5, 5):
	if i == nullrev:			if i == nullrev:
	continue			continue

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.iscensored(i)			f.iscensored(i)

	self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), [])			self.assertEqual(list(f.commonancestorsheads(f.nullid, f.nullid)), [])

	with self.assertRaises(ValueError):			with self.assertRaises(ValueError):
	self.assertEqual(list(f.descendants([])), [])			self.assertEqual(list(f.descendants([])), [])

	self.assertEqual(list(f.descendants([nullrev])), [])			self.assertEqual(list(f.descendants([nullrev])), [])

	self.assertEqual(f.heads(), [nullid])			self.assertEqual(f.heads(), [f.nullid])
	self.assertEqual(f.heads(nullid), [nullid])			self.assertEqual(f.heads(f.nullid), [f.nullid])
	self.assertEqual(f.heads(None, [nullid]), [nullid])			self.assertEqual(f.heads(None, [f.nullid]), [f.nullid])
	self.assertEqual(f.heads(nullid, [nullid]), [nullid])			self.assertEqual(f.heads(f.nullid, [f.nullid]), [f.nullid])

	self.assertEqual(f.children(nullid), [])			self.assertEqual(f.children(f.nullid), [])

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.children(b'\x01' * 20)			f.children(b'\x01' * 20)

	def testsinglerevision(self):			def testsinglerevision(self):
	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node = f.add(b'initial', None, tr, 0, nullid, nullid)			node = f.add(b'initial', None, tr, 0, f.nullid, f.nullid)

	self.assertEqual(len(f), 1)			self.assertEqual(len(f), 1)
	self.assertEqual(list(f), [0])			self.assertEqual(list(f), [0])

	gen = iter(f)			gen = iter(f)
	self.assertEqual(next(gen), 0)			self.assertEqual(next(gen), 0)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	self.assertTrue(f.hasnode(node))			self.assertTrue(f.hasnode(node))
	self.assertFalse(f.hasnode(hex(node)))			self.assertFalse(f.hasnode(hex(node)))
	self.assertFalse(f.hasnode(nullrev))			self.assertFalse(f.hasnode(nullrev))
	self.assertFalse(f.hasnode(nullid))			self.assertFalse(f.hasnode(f.nullid))
	self.assertFalse(f.hasnode(node[0:12]))			self.assertFalse(f.hasnode(node[0:12]))
	self.assertFalse(f.hasnode(hex(node)[0:20]))			self.assertFalse(f.hasnode(hex(node)[0:20]))

	self.assertEqual(list(f.revs()), [0])			self.assertEqual(list(f.revs()), [0])
	self.assertEqual(list(f.revs(start=1)), [])			self.assertEqual(list(f.revs(start=1)), [])
	self.assertEqual(list(f.revs(start=0)), [0])			self.assertEqual(list(f.revs(start=0)), [0])
	self.assertEqual(list(f.revs(stop=0)), [0])			self.assertEqual(list(f.revs(stop=0)), [0])
	self.assertEqual(list(f.revs(stop=1)), [0])			self.assertEqual(list(f.revs(stop=1)), [0])
	self.assertEqual(list(f.revs(1, 1)), [])			self.assertEqual(list(f.revs(1, 1)), [])
	# TODO buggy			# TODO buggy
	self.assertEqual(list(f.revs(1, 0)), [1, 0])			self.assertEqual(list(f.revs(1, 0)), [1, 0])
	self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])			self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])

	self.assertEqual(f.parents(node), (nullid, nullid))			self.assertEqual(f.parents(node), (f.nullid, f.nullid))
	self.assertEqual(f.parentrevs(0), (nullrev, nullrev))			self.assertEqual(f.parentrevs(0), (nullrev, nullrev))

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.parents(b'\x01' * 20)			f.parents(b'\x01' * 20)

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.parentrevs(1)			f.parentrevs(1)

	self.assertEqual(f.rev(node), 0)			self.assertEqual(f.rev(node), 0)

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.rev(b'\x01' * 20)			f.rev(b'\x01' * 20)

	self.assertEqual(f.node(0), node)			self.assertEqual(f.node(0), node)

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.node(1)			f.node(1)

	self.assertEqual(f.lookup(node), node)			self.assertEqual(f.lookup(node), node)
	self.assertEqual(f.lookup(0), node)			self.assertEqual(f.lookup(0), node)
	self.assertEqual(f.lookup(-1), nullid)			self.assertEqual(f.lookup(-1), f.nullid)
	self.assertEqual(f.lookup(b'0'), node)			self.assertEqual(f.lookup(b'0'), node)
	self.assertEqual(f.lookup(hex(node)), node)			self.assertEqual(f.lookup(hex(node)), node)

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.lookup(hex(node)[0:12])			f.lookup(hex(node)[0:12])

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.lookup(-2)			f.lookup(-2)

	def testmultiplerevisions(self):			def testmultiplerevisions(self):
	fulltext0 = b'x' * 1024			fulltext0 = b'x' * 1024
	fulltext1 = fulltext0 + b'y'			fulltext1 = fulltext0 + b'y'
	fulltext2 = b'y' + fulltext0 + b'z'			fulltext2 = b'y' + fulltext0 + b'z'

	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(fulltext1, None, tr, 1, node0, nullid)			node1 = f.add(fulltext1, None, tr, 1, node0, f.nullid)
	node2 = f.add(fulltext2, None, tr, 3, node1, nullid)			node2 = f.add(fulltext2, None, tr, 3, node1, f.nullid)

	self.assertEqual(len(f), 3)			self.assertEqual(len(f), 3)
	self.assertEqual(list(f), [0, 1, 2])			self.assertEqual(list(f), [0, 1, 2])

	gen = iter(f)			gen = iter(f)
	self.assertEqual(next(gen), 0)			self.assertEqual(next(gen), 0)
	self.assertEqual(next(gen), 1)			self.assertEqual(next(gen), 1)
	self.assertEqual(next(gen), 2)			self.assertEqual(next(gen), 2)
	self.assertEqual(list(f.revs(stop=1)), [0, 1])			self.assertEqual(list(f.revs(stop=1)), [0, 1])
	self.assertEqual(list(f.revs(stop=2)), [0, 1, 2])			self.assertEqual(list(f.revs(stop=2)), [0, 1, 2])
	self.assertEqual(list(f.revs(stop=3)), [0, 1, 2])			self.assertEqual(list(f.revs(stop=3)), [0, 1, 2])
	self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])			self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
	self.assertEqual(list(f.revs(2, 1)), [2, 1])			self.assertEqual(list(f.revs(2, 1)), [2, 1])
	# TODO this is wrong			# TODO this is wrong
	self.assertEqual(list(f.revs(3, 2)), [3, 2])			self.assertEqual(list(f.revs(3, 2)), [3, 2])

	self.assertEqual(f.parents(node0), (nullid, nullid))			self.assertEqual(f.parents(node0), (f.nullid, f.nullid))
	self.assertEqual(f.parents(node1), (node0, nullid))			self.assertEqual(f.parents(node1), (node0, f.nullid))
	self.assertEqual(f.parents(node2), (node1, nullid))			self.assertEqual(f.parents(node2), (node1, f.nullid))

	self.assertEqual(f.parentrevs(0), (nullrev, nullrev))			self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
	self.assertEqual(f.parentrevs(1), (0, nullrev))			self.assertEqual(f.parentrevs(1), (0, nullrev))
	self.assertEqual(f.parentrevs(2), (1, nullrev))			self.assertEqual(f.parentrevs(2), (1, nullrev))

	self.assertEqual(f.rev(node0), 0)			self.assertEqual(f.rev(node0), 0)
	self.assertEqual(f.rev(node1), 1)			self.assertEqual(f.rev(node1), 1)
	self.assertEqual(f.rev(node2), 2)			self.assertEqual(f.rev(node2), 2)

	self.assertFalse(f.iscensored(0))			self.assertFalse(f.iscensored(0))
	self.assertFalse(f.iscensored(1))			self.assertFalse(f.iscensored(1))
	self.assertFalse(f.iscensored(2))			self.assertFalse(f.iscensored(2))

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.iscensored(3)			f.iscensored(3)

	self.assertEqual(f.commonancestorsheads(node1, nullid), [])			self.assertEqual(f.commonancestorsheads(node1, f.nullid), [])
	self.assertEqual(f.commonancestorsheads(node1, node0), [node0])			self.assertEqual(f.commonancestorsheads(node1, node0), [node0])
	self.assertEqual(f.commonancestorsheads(node1, node1), [node1])			self.assertEqual(f.commonancestorsheads(node1, node1), [node1])
	self.assertEqual(f.commonancestorsheads(node0, node1), [node0])			self.assertEqual(f.commonancestorsheads(node0, node1), [node0])
	self.assertEqual(f.commonancestorsheads(node1, node2), [node1])			self.assertEqual(f.commonancestorsheads(node1, node2), [node1])
	self.assertEqual(f.commonancestorsheads(node2, node1), [node1])			self.assertEqual(f.commonancestorsheads(node2, node1), [node1])

	self.assertEqual(list(f.descendants([0])), [1, 2])			self.assertEqual(list(f.descendants([0])), [1, 2])
	self.assertEqual(list(f.descendants([1])), [2])			self.assertEqual(list(f.descendants([1])), [2])
	self.assertEqual(f.children(node0), [node1])			self.assertEqual(f.children(node0), [node1])
	self.assertEqual(f.children(node1), [node2])			self.assertEqual(f.children(node1), [node2])
	self.assertEqual(f.children(node2), [])			self.assertEqual(f.children(node2), [])

	def testmultipleheads(self):			def testmultipleheads(self):
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'0', None, tr, 0, nullid, nullid)			node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(b'1', None, tr, 1, node0, nullid)			node1 = f.add(b'1', None, tr, 1, node0, f.nullid)
	node2 = f.add(b'2', None, tr, 2, node1, nullid)			node2 = f.add(b'2', None, tr, 2, node1, f.nullid)
	node3 = f.add(b'3', None, tr, 3, node0, nullid)			node3 = f.add(b'3', None, tr, 3, node0, f.nullid)
	node4 = f.add(b'4', None, tr, 4, node3, nullid)			node4 = f.add(b'4', None, tr, 4, node3, f.nullid)
	node5 = f.add(b'5', None, tr, 5, node0, nullid)			node5 = f.add(b'5', None, tr, 5, node0, f.nullid)

	self.assertEqual(len(f), 6)			self.assertEqual(len(f), 6)

	self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5])			self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5])
	self.assertEqual(list(f.descendants([1])), [2])			self.assertEqual(list(f.descendants([1])), [2])
	self.assertEqual(list(f.descendants([2])), [])			self.assertEqual(list(f.descendants([2])), [])
	self.assertEqual(list(f.descendants([3])), [4])			self.assertEqual(list(f.descendants([3])), [4])
	self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5])			self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5])

	for i in range(-5, 5):			for i in range(-5, 5):
	if i == nullrev:			if i == nullrev:
	continue			continue

	with self.assertRaises(IndexError):			with self.assertRaises(IndexError):
	f.size(i)			f.size(i)

	self.assertEqual(f.revision(nullid), b'')			self.assertEqual(f.revision(f.nullid), b'')
	self.assertEqual(f.rawdata(nullid), b'')			self.assertEqual(f.rawdata(f.nullid), b'')

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.revision(b'\x01' * 20)			f.revision(b'\x01' * 20)

	self.assertEqual(f.read(nullid), b'')			self.assertEqual(f.read(f.nullid), b'')

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.read(b'\x01' * 20)			f.read(b'\x01' * 20)

	self.assertFalse(f.renamed(nullid))			self.assertFalse(f.renamed(f.nullid))

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.read(b'\x01' * 20)			f.read(b'\x01' * 20)

	self.assertTrue(f.cmp(nullid, b''))			self.assertTrue(f.cmp(f.nullid, b''))
	self.assertTrue(f.cmp(nullid, b'foo'))			self.assertTrue(f.cmp(f.nullid, b'foo'))

	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	f.cmp(b'\x01' * 20, b'irrelevant')			f.cmp(b'\x01' * 20, b'irrelevant')

	# Emitting empty list is an empty generator.			# Emitting empty list is an empty generator.
	gen = f.emitrevisions([])			gen = f.emitrevisions([])
	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# Emitting null node yields nothing.			# Emitting null node yields nothing.
	gen = f.emitrevisions([nullid])			gen = f.emitrevisions([f.nullid])
	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# Requesting unknown node fails.			# Requesting unknown node fails.
	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	list(f.emitrevisions([b'\x01' * 20]))			list(f.emitrevisions([b'\x01' * 20]))

	def testsinglerevision(self):			def testsinglerevision(self):
	fulltext = b'initial'			fulltext = b'initial'

	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node = f.add(fulltext, None, tr, 0, nullid, nullid)			node = f.add(fulltext, None, tr, 0, f.nullid, f.nullid)

	self.assertEqual(f.storageinfo(), {})			self.assertEqual(f.storageinfo(), {})
	self.assertEqual(			self.assertEqual(
	f.storageinfo(revisionscount=True, trackedsize=True),			f.storageinfo(revisionscount=True, trackedsize=True),
	{b'revisionscount': 1, b'trackedsize': len(fulltext)},			{b'revisionscount': 1, b'trackedsize': len(fulltext)},
	)			)

	self.assertEqual(f.size(0), len(fulltext))			self.assertEqual(f.size(0), len(fulltext))
	self.assertFalse(f.cmp(node, fulltext))			self.assertFalse(f.cmp(node, fulltext))
	self.assertTrue(f.cmp(node, fulltext + b'extra'))			self.assertTrue(f.cmp(node, fulltext + b'extra'))

	# Emitting a single revision works.			# Emitting a single revision works.
	gen = f.emitrevisions([node])			gen = f.emitrevisions([node])
	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node)			self.assertEqual(rev.node, node)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertIsNone(rev.delta)			self.assertIsNone(rev.delta)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# Requesting revision data works.			# Requesting revision data works.
	gen = f.emitrevisions([node], revisiondata=True)			gen = f.emitrevisions([node], revisiondata=True)
	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node)			self.assertEqual(rev.node, node)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertEqual(rev.revision, fulltext)			self.assertEqual(rev.revision, fulltext)
	self.assertIsNone(rev.delta)			self.assertIsNone(rev.delta)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# Emitting an unknown node after a known revision results in error.			# Emitting an unknown node after a known revision results in error.
	with self.assertRaises(error.LookupError):			with self.assertRaises(error.LookupError):
	list(f.emitrevisions([node, b'\x01' * 20]))			list(f.emitrevisions([node, b'\x01' * 20]))

	def testmultiplerevisions(self):			def testmultiplerevisions(self):
	fulltext0 = b'x' * 1024			fulltext0 = b'x' * 1024
	fulltext1 = fulltext0 + b'y'			fulltext1 = fulltext0 + b'y'
	fulltext2 = b'y' + fulltext0 + b'z'			fulltext2 = b'y' + fulltext0 + b'z'

	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(fulltext1, None, tr, 1, node0, nullid)			node1 = f.add(fulltext1, None, tr, 1, node0, f.nullid)
	node2 = f.add(fulltext2, None, tr, 3, node1, nullid)			node2 = f.add(fulltext2, None, tr, 3, node1, f.nullid)

	self.assertEqual(f.storageinfo(), {})			self.assertEqual(f.storageinfo(), {})
	self.assertEqual(			self.assertEqual(
	f.storageinfo(revisionscount=True, trackedsize=True),			f.storageinfo(revisionscount=True, trackedsize=True),
	{			{
	b'revisionscount': 3,			b'revisionscount': 3,
	b'trackedsize': len(fulltext0)			b'trackedsize': len(fulltext0)
	+ len(fulltext1)			+ len(fulltext1)
	f.cmp(b'\x01' * 20, b'irrelevant')			f.cmp(b'\x01' * 20, b'irrelevant')

	# Nodes should be emitted in order.			# Nodes should be emitted in order.
	gen = f.emitrevisions([node0, node1, node2], revisiondata=True)			gen = f.emitrevisions([node0, node1, node2], revisiondata=True)

	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node0)			self.assertEqual(rev.node, node0)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertEqual(rev.revision, fulltext0)			self.assertEqual(rev.revision, fulltext0)
	self.assertIsNone(rev.delta)			self.assertIsNone(rev.delta)

	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node1)			self.assertEqual(rev.node, node1)
	self.assertEqual(rev.p1node, node0)			self.assertEqual(rev.p1node, node0)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, node0)			self.assertEqual(rev.basenode, node0)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1,			b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1,
	)			)

	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node2)			self.assertEqual(rev.node, node2)
	self.assertEqual(rev.p1node, node1)			self.assertEqual(rev.p1node, node1)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, node1)			self.assertEqual(rev.basenode, node1)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2,			b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2,
	)			)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# Request not in DAG order is reordered to be in DAG order.			# Request not in DAG order is reordered to be in DAG order.
	gen = f.emitrevisions([node2, node1, node0], revisiondata=True)			gen = f.emitrevisions([node2, node1, node0], revisiondata=True)

	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node0)			self.assertEqual(rev.node, node0)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertEqual(rev.revision, fulltext0)			self.assertEqual(rev.revision, fulltext0)
	self.assertIsNone(rev.delta)			self.assertIsNone(rev.delta)

	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node1)			self.assertEqual(rev.node, node1)
	self.assertEqual(rev.p1node, node0)			self.assertEqual(rev.p1node, node0)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, node0)			self.assertEqual(rev.basenode, node0)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1,			b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1,
	)			)

	rev = next(gen)			rev = next(gen)

	self.assertEqual(rev.node, node2)			self.assertEqual(rev.node, node2)
	self.assertEqual(rev.p1node, node1)			self.assertEqual(rev.p1node, node1)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertIsNone(rev.linknode)			self.assertIsNone(rev.linknode)
	self.assertEqual(rev.basenode, node1)			self.assertEqual(rev.basenode, node1)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2,			b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2,
	)			)
	# nodesorder=nodes forces the order.			# nodesorder=nodes forces the order.
	gen = f.emitrevisions(			gen = f.emitrevisions(
	[node2, node0], nodesorder=b'nodes', revisiondata=True			[node2, node0], nodesorder=b'nodes', revisiondata=True
	)			)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node2)			self.assertEqual(rev.node, node2)
	self.assertEqual(rev.p1node, node1)			self.assertEqual(rev.p1node, node1)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertEqual(rev.revision, fulltext2)			self.assertEqual(rev.revision, fulltext2)
	self.assertIsNone(rev.delta)			self.assertIsNone(rev.delta)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node0)			self.assertEqual(rev.node, node0)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	# Delta behavior is storage dependent, so we can't easily test it.			# Delta behavior is storage dependent, so we can't easily test it.

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# assumehaveparentrevisions=False (the default) won't send a delta for			# assumehaveparentrevisions=False (the default) won't send a delta for
	# the first revision.			# the first revision.
	gen = f.emitrevisions({node2, node1}, revisiondata=True)			gen = f.emitrevisions({node2, node1}, revisiondata=True)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node1)			self.assertEqual(rev.node, node1)
	self.assertEqual(rev.p1node, node0)			self.assertEqual(rev.p1node, node0)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertEqual(rev.revision, fulltext1)			self.assertEqual(rev.revision, fulltext1)
	self.assertIsNone(rev.delta)			self.assertIsNone(rev.delta)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node2)			self.assertEqual(rev.node, node2)
	self.assertEqual(rev.p1node, node1)			self.assertEqual(rev.p1node, node1)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, node1)			self.assertEqual(rev.basenode, node1)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2,			b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2,
	)			)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	# assumehaveparentrevisions=True allows delta against initial revision.			# assumehaveparentrevisions=True allows delta against initial revision.
	gen = f.emitrevisions(			gen = f.emitrevisions(
	[node2, node1], revisiondata=True, assumehaveparentrevisions=True			[node2, node1], revisiondata=True, assumehaveparentrevisions=True
	)			)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node1)			self.assertEqual(rev.node, node1)
	self.assertEqual(rev.p1node, node0)			self.assertEqual(rev.p1node, node0)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, node0)			self.assertEqual(rev.basenode, node0)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1,			b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1,
	)			)

	# forceprevious=True forces a delta against the previous revision.			# forceprevious=True forces a delta against the previous revision.
	# Special case for initial revision.			# Special case for initial revision.
	gen = f.emitrevisions(			gen = f.emitrevisions(
	[node0], revisiondata=True, deltamode=repository.CG_DELTAMODE_PREV			[node0], revisiondata=True, deltamode=repository.CG_DELTAMODE_PREV
	)			)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node0)			self.assertEqual(rev.node, node0)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0,			b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0,
	)			)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	gen = f.emitrevisions(			gen = f.emitrevisions(
	[node0, node2],			[node0, node2],
	revisiondata=True,			revisiondata=True,
	deltamode=repository.CG_DELTAMODE_PREV,			deltamode=repository.CG_DELTAMODE_PREV,
	)			)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node0)			self.assertEqual(rev.node, node0)
	self.assertEqual(rev.p1node, nullid)			self.assertEqual(rev.p1node, f.nullid)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, nullid)			self.assertEqual(rev.basenode, f.nullid)
	self.assertIsNone(rev.baserevisionsize)			self.assertIsNone(rev.baserevisionsize)
	self.assertIsNone(rev.revision)			self.assertIsNone(rev.revision)
	self.assertEqual(			self.assertEqual(
	rev.delta,			rev.delta,
	b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0,			b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0,
	)			)

	rev = next(gen)			rev = next(gen)
	self.assertEqual(rev.node, node2)			self.assertEqual(rev.node, node2)
	self.assertEqual(rev.p1node, node1)			self.assertEqual(rev.p1node, node1)
	self.assertEqual(rev.p2node, nullid)			self.assertEqual(rev.p2node, f.nullid)
	self.assertEqual(rev.basenode, node0)			self.assertEqual(rev.basenode, node0)

	with self.assertRaises(StopIteration):			with self.assertRaises(StopIteration):
	next(gen)			next(gen)

	def testrenamed(self):			def testrenamed(self):
	fulltext0 = b'foo'			fulltext0 = b'foo'
	fulltext1 = b'bar'			fulltext1 = b'bar'
	b'\x01\ncopy: source1\n',			b'\x01\ncopy: source1\n',
	b'copyrev: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n\x01\n',			b'copyrev: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n\x01\n',
	fulltext2,			fulltext2,
	]			]
	)			)

	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(fulltext1, meta1, tr, 1, node0, nullid)			node1 = f.add(fulltext1, meta1, tr, 1, node0, f.nullid)
	node2 = f.add(fulltext2, meta2, tr, 2, nullid, nullid)			node2 = f.add(fulltext2, meta2, tr, 2, f.nullid, f.nullid)

	# Metadata header isn't recognized when parent isn't nullid.			# Metadata header isn't recognized when parent isn't f.nullid.
	self.assertEqual(f.size(1), len(stored1))			self.assertEqual(f.size(1), len(stored1))
	self.assertEqual(f.size(2), len(fulltext2))			self.assertEqual(f.size(2), len(fulltext2))

	self.assertEqual(f.revision(node1), stored1)			self.assertEqual(f.revision(node1), stored1)
	self.assertEqual(f.rawdata(node1), stored1)			self.assertEqual(f.rawdata(node1), stored1)
	self.assertEqual(f.revision(node2), stored2)			self.assertEqual(f.revision(node2), stored2)
	self.assertEqual(f.rawdata(node2), stored2)			self.assertEqual(f.rawdata(node2), stored2)

	b'\x01\ncopy: source0\n',			b'\x01\ncopy: source0\n',
	b'copyrev: %s\n' % (b'b' * 40),			b'copyrev: %s\n' % (b'b' * 40),
	b'\x01\n\x01\nbar',			b'\x01\n\x01\nbar',
	]			]
	)			)

	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, {}, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, {}, tr, 0, f.nullid, f.nullid)
	node1 = f.add(fulltext1, meta1, tr, 1, nullid, nullid)			node1 = f.add(fulltext1, meta1, tr, 1, f.nullid, f.nullid)

	# TODO this is buggy.			# TODO this is buggy.
	self.assertEqual(f.size(0), len(fulltext0) + 4)			self.assertEqual(f.size(0), len(fulltext0) + 4)

	self.assertEqual(f.size(1), len(fulltext1))			self.assertEqual(f.size(1), len(fulltext1))

	self.assertEqual(f.revision(node0), stored0)			self.assertEqual(f.revision(node0), stored0)
	self.assertEqual(f.rawdata(node0), stored0)			self.assertEqual(f.rawdata(node0), stored0)

	def testbadnoderead(self):			def testbadnoderead(self):
	f = self._makefilefn()			f = self._makefilefn()

	fulltext0 = b'foo\n' * 30			fulltext0 = b'foo\n' * 30
	fulltext1 = fulltext0 + b'bar\n'			fulltext1 = fulltext0 + b'bar\n'

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = b'\xaa' * 20			node1 = b'\xaa' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, rawtext=fulltext1			f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
	)			)

	self.assertEqual(len(f), 2)			self.assertEqual(len(f), 2)
	self.assertEqual(f.parents(node1), (node0, nullid))			self.assertEqual(f.parents(node1), (node0, f.nullid))

	# revision() raises since it performs hash verification.			# revision() raises since it performs hash verification.
	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.revision(node1)			f.revision(node1)

	# rawdata() still verifies because there are no special storage			# rawdata() still verifies because there are no special storage
	# settings.			# settings.
	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	# Like above except we test rawdata() first to isolate			# Like above except we test rawdata() first to isolate
	# revision caching behavior.			# revision caching behavior.
	f = self._makefilefn()			f = self._makefilefn()

	fulltext0 = b'foo\n' * 30			fulltext0 = b'foo\n' * 30
	fulltext1 = fulltext0 + b'bar\n'			fulltext1 = fulltext0 + b'bar\n'

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = b'\xaa' * 20			node1 = b'\xaa' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, rawtext=fulltext1			f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
	)			)

	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.rawdata(node1)			f.rawdata(node1)

	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.rawdata(node1)			f.rawdata(node1)

	def testbadnoderevision(self):			def testbadnoderevision(self):
	# Like above except we test read() first to isolate revision caching			# Like above except we test read() first to isolate revision caching
	# behavior.			# behavior.
	f = self._makefilefn()			f = self._makefilefn()

	fulltext0 = b'foo\n' * 30			fulltext0 = b'foo\n' * 30
	fulltext1 = fulltext0 + b'bar\n'			fulltext1 = fulltext0 + b'bar\n'

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = b'\xaa' * 20			node1 = b'\xaa' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, rawtext=fulltext1			f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
	)			)

	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.read(node1)			f.read(node1)

	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.read(node1)			f.read(node1)

	def testbadnodedelta(self):			def testbadnodedelta(self):
	f = self._makefilefn()			f = self._makefilefn()

	fulltext0 = b'foo\n' * 31			fulltext0 = b'foo\n' * 31
	fulltext1 = fulltext0 + b'bar\n'			fulltext1 = fulltext0 + b'bar\n'
	fulltext2 = fulltext1 + b'baz\n'			fulltext2 = fulltext1 + b'baz\n'

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
	node1 = b'\xaa' * 20			node1 = b'\xaa' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, rawtext=fulltext1			f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
	)			)

	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.read(node1)			f.read(node1)

	node2 = storageutil.hashrevisionsha1(fulltext2, node1, nullid)			node2 = storageutil.hashrevisionsha1(fulltext2, node1, f.nullid)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	delta = mdiff.textdiff(fulltext1, fulltext2)			delta = mdiff.textdiff(fulltext1, fulltext2)
	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node2, node1, nullid, 2, delta=(1, delta)			f, tr, node2, node1, f.nullid, 2, delta=(1, delta)
	)			)

	self.assertEqual(len(f), 3)			self.assertEqual(len(f), 3)

	# Assuming a delta is stored, we shouldn't need to validate node1 in			# Assuming a delta is stored, we shouldn't need to validate node1 in
	# order to retrieve node2.			# order to retrieve node2.
	self.assertEqual(f.read(node2), fulltext2)			self.assertEqual(f.read(node2), fulltext2)

	def testcensored(self):			def testcensored(self):
	f = self._makefilefn()			f = self._makefilefn()

	stored1 = storageutil.packmeta(			stored1 = storageutil.packmeta(
	{			{
	b'censored': b'tombstone',			b'censored': b'tombstone',
	},			},
	b'',			b'',
	)			)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'foo', None, tr, 0, nullid, nullid)			node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)

	# The node value doesn't matter since we can't verify it.			# The node value doesn't matter since we can't verify it.
	node1 = b'\xbb' * 20			node1 = b'\xbb' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, stored1, censored=True			f, tr, node1, node0, f.nullid, 1, stored1, censored=True
	)			)

	self.assertTrue(f.iscensored(1))			self.assertTrue(f.iscensored(1))

	with self.assertRaises(error.CensoredNodeError):			with self.assertRaises(error.CensoredNodeError):
	f.revision(1)			f.revision(1)

	with self.assertRaises(error.CensoredNodeError):			with self.assertRaises(error.CensoredNodeError):
	stored1 = storageutil.packmeta(			stored1 = storageutil.packmeta(
	{			{
	b'censored': b'tombstone',			b'censored': b'tombstone',
	},			},
	b'',			b'',
	)			)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'foo', None, tr, 0, nullid, nullid)			node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)

	# The node value doesn't matter since we can't verify it.			# The node value doesn't matter since we can't verify it.
	node1 = b'\xbb' * 20			node1 = b'\xbb' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, stored1, censored=True			f, tr, node1, node0, f.nullid, 1, stored1, censored=True
	)			)

	with self.assertRaises(error.CensoredNodeError):			with self.assertRaises(error.CensoredNodeError):
	f.rawdata(1)			f.rawdata(1)


	class ifilemutationtests(basetestcase):			class ifilemutationtests(basetestcase):
	"""Generic tests for the ifilemutation interface.			"""Generic tests for the ifilemutation interface.

	All file storage backends that support writing should conform to this			All file storage backends that support writing should conform to this
	interface.			interface.

	Use ``makeifilemutationtests()`` to create an instance of this type.			Use ``makeifilemutationtests()`` to create an instance of this type.
	"""			"""

	def testaddnoop(self):			def testaddnoop(self):
	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'foo', None, tr, 0, nullid, nullid)			node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(b'foo', None, tr, 0, nullid, nullid)			node1 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)
	# Varying by linkrev shouldn't impact hash.			# Varying by linkrev shouldn't impact hash.
	node2 = f.add(b'foo', None, tr, 1, nullid, nullid)			node2 = f.add(b'foo', None, tr, 1, f.nullid, f.nullid)

	self.assertEqual(node1, node0)			self.assertEqual(node1, node0)
	self.assertEqual(node2, node0)			self.assertEqual(node2, node0)
	self.assertEqual(len(f), 1)			self.assertEqual(len(f), 1)

	def testaddrevisionbadnode(self):			def testaddrevisionbadnode(self):
	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	# Adding a revision with bad node value fails.			# Adding a revision with bad node value fails.
	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20)			f.addrevision(
				b'foo', tr, 0, f.nullid, f.nullid, node=b'\x01' * 20
				)

	def testaddrevisionunknownflag(self):			def testaddrevisionunknownflag(self):
	f = self._makefilefn()			f = self._makefilefn()
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	for i in range(15, 0, -1):			for i in range(15, 0, -1):
	if (1 << i) & ~repository.REVISION_FLAGS_KNOWN:			if (1 << i) & ~repository.REVISION_FLAGS_KNOWN:
	flags = 1 << i			flags = 1 << i
	break			break

	with self.assertRaises(error.StorageError):			with self.assertRaises(error.StorageError):
	f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags)			f.addrevision(b'foo', tr, 0, f.nullid, f.nullid, flags=flags)

	def testaddgroupsimple(self):			def testaddgroupsimple(self):
	f = self._makefilefn()			f = self._makefilefn()

	callbackargs = []			callbackargs = []

	def cb(args, *kwargs):			def cb(args, *kwargs):
	callbackargs.append((args, kwargs))			callbackargs.append((args, kwargs))
	self.assertEqual(nodes, [])			self.assertEqual(nodes, [])
	self.assertEqual(callbackargs, [])			self.assertEqual(callbackargs, [])
	self.assertEqual(len(f), 0)			self.assertEqual(len(f), 0)

	fulltext0 = b'foo'			fulltext0 = b'foo'
	delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0			delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)			node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)

	f = self._makefilefn()			f = self._makefilefn()

	deltas = [			deltas = [
	(node0, nullid, nullid, nullid, nullid, delta0, 0, {}),			(node0, f.nullid, f.nullid, f.nullid, f.nullid, delta0, 0, {}),
	]			]

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	nodes = []			nodes = []

	def onchangeset(cl, rev):			def onchangeset(cl, rev):
	node = cl.node(rev)			node = cl.node(rev)
	nodes.append(node)			nodes.append(node)
	b'foo',			b'foo',
	b'bar',			b'bar',
	b'x' * 1024,			b'x' * 1024,
	]			]

	nodes = []			nodes = []
	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	for fulltext in fulltexts:			for fulltext in fulltexts:
	nodes.append(f.add(fulltext, None, tr, 0, nullid, nullid))			nodes.append(f.add(fulltext, None, tr, 0, f.nullid, f.nullid))

	f = self._makefilefn()			f = self._makefilefn()
	deltas = []			deltas = []
	for i, fulltext in enumerate(fulltexts):			for i, fulltext in enumerate(fulltexts):
	delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext			delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext

	deltas.append(			deltas.append(
	(nodes[i], nullid, nullid, nullid, nullid, delta, 0, {})			(nodes[i], f.nullid, f.nullid, f.nullid, f.nullid, delta, 0, {})
	)			)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	newnodes = []			newnodes = []

	def onchangeset(cl, rev):			def onchangeset(cl, rev):
	newnodes.append(cl.node(rev))			newnodes.append(cl.node(rev))

	stored1 = storageutil.packmeta(			stored1 = storageutil.packmeta(
	{			{
	b'censored': b'tombstone',			b'censored': b'tombstone',
	},			},
	b'',			b'',
	)			)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid)			node0 = f.add(b'foo\n' * 30, None, tr, 0, f.nullid, f.nullid)

	# The node value doesn't matter since we can't verify it.			# The node value doesn't matter since we can't verify it.
	node1 = b'\xbb' * 20			node1 = b'\xbb' * 20

	self._addrawrevisionfn(			self._addrawrevisionfn(
	f, tr, node1, node0, nullid, 1, stored1, censored=True			f, tr, node1, node0, f.nullid, 1, stored1, censored=True
	)			)

	delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n')			delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n')
	deltas = [			deltas = [
	(b'\xcc' * 20, node1, nullid, b'\x01' * 20, node1, delta, 0, {})			(b'\xcc' * 20, node1, f.nullid, b'\x01' * 20, node1, delta, 0, {})
	]			]

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	with self.assertRaises(error.CensoredBaseError):			with self.assertRaises(error.CensoredBaseError):
	f.addgroup(deltas, lambda x: 0, tr)			f.addgroup(deltas, lambda x: 0, tr)

	def testcensorrevisionbasic(self):			def testcensorrevisionbasic(self):
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid)			node0 = f.add(b'foo\n' * 30, None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, nullid)			node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, f.nullid)
	node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, nullid)			node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, f.nullid)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	f.censorrevision(tr, node1)			f.censorrevision(tr, node1)

	self.assertEqual(len(f), 3)			self.assertEqual(len(f), 3)
	self.assertEqual(list(f.revs()), [0, 1, 2])			self.assertEqual(list(f.revs()), [0, 1, 2])

	self.assertEqual(f.read(node0), b'foo\n' * 30)			self.assertEqual(f.read(node0), b'foo\n' * 30)
	self.assertEqual(f.read(node2), b'foo\n' * 32)			self.assertEqual(f.read(node2), b'foo\n' * 32)

	with self.assertRaises(error.CensoredNodeError):			with self.assertRaises(error.CensoredNodeError):
	f.read(node1)			f.read(node1)

	def testgetstrippointnoparents(self):			def testgetstrippointnoparents(self):
	# N revisions where none have parents.			# N revisions where none have parents.
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	for rev in range(10):			for rev in range(10):
	f.add(b'%d' % rev, None, tr, rev, nullid, nullid)			f.add(b'%d' % rev, None, tr, rev, f.nullid, f.nullid)

	for rev in range(10):			for rev in range(10):
	self.assertEqual(f.getstrippoint(rev), (rev, set()))			self.assertEqual(f.getstrippoint(rev), (rev, set()))

	def testgetstrippointlinear(self):			def testgetstrippointlinear(self):
	# N revisions in a linear chain.			# N revisions in a linear chain.
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	p1 = nullid			p1 = f.nullid

	for rev in range(10):			for rev in range(10):
	f.add(b'%d' % rev, None, tr, rev, p1, nullid)			f.add(b'%d' % rev, None, tr, rev, p1, f.nullid)

	for rev in range(10):			for rev in range(10):
	self.assertEqual(f.getstrippoint(rev), (rev, set()))			self.assertEqual(f.getstrippoint(rev), (rev, set()))

	def testgetstrippointmultipleheads(self):			def testgetstrippointmultipleheads(self):
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'0', None, tr, 0, nullid, nullid)			node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(b'1', None, tr, 1, node0, nullid)			node1 = f.add(b'1', None, tr, 1, node0, f.nullid)
	f.add(b'2', None, tr, 2, node1, nullid)			f.add(b'2', None, tr, 2, node1, f.nullid)
	f.add(b'3', None, tr, 3, node0, nullid)			f.add(b'3', None, tr, 3, node0, f.nullid)
	f.add(b'4', None, tr, 4, node0, nullid)			f.add(b'4', None, tr, 4, node0, f.nullid)

	for rev in range(5):			for rev in range(5):
	self.assertEqual(f.getstrippoint(rev), (rev, set()))			self.assertEqual(f.getstrippoint(rev), (rev, set()))

	def testgetstrippointearlierlinkrevs(self):			def testgetstrippointearlierlinkrevs(self):
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	node0 = f.add(b'0', None, tr, 0, nullid, nullid)			node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid)
	f.add(b'1', None, tr, 10, node0, nullid)			f.add(b'1', None, tr, 10, node0, f.nullid)
	f.add(b'2', None, tr, 5, node0, nullid)			f.add(b'2', None, tr, 5, node0, f.nullid)

	self.assertEqual(f.getstrippoint(0), (0, set()))			self.assertEqual(f.getstrippoint(0), (0, set()))
	self.assertEqual(f.getstrippoint(1), (1, set()))			self.assertEqual(f.getstrippoint(1), (1, set()))
	self.assertEqual(f.getstrippoint(2), (1, set()))			self.assertEqual(f.getstrippoint(2), (1, set()))
	self.assertEqual(f.getstrippoint(3), (1, set()))			self.assertEqual(f.getstrippoint(3), (1, set()))
	self.assertEqual(f.getstrippoint(4), (1, set()))			self.assertEqual(f.getstrippoint(4), (1, set()))
	self.assertEqual(f.getstrippoint(5), (1, set()))			self.assertEqual(f.getstrippoint(5), (1, set()))
	self.assertEqual(f.getstrippoint(6), (1, {2}))			self.assertEqual(f.getstrippoint(6), (1, {2}))
	f.strip(0, tr)			f.strip(0, tr)

	self.assertEqual(len(f), 0)			self.assertEqual(len(f), 0)

	def teststripall(self):			def teststripall(self):
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	p1 = nullid			p1 = f.nullid
	for rev in range(10):			for rev in range(10):
	p1 = f.add(b'%d' % rev, None, tr, rev, p1, nullid)			p1 = f.add(b'%d' % rev, None, tr, rev, p1, f.nullid)

	self.assertEqual(len(f), 10)			self.assertEqual(len(f), 10)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	f.strip(0, tr)			f.strip(0, tr)

	self.assertEqual(len(f), 0)			self.assertEqual(len(f), 0)

	def teststrippartial(self):			def teststrippartial(self):
	f = self._makefilefn()			f = self._makefilefn()

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	f.add(b'0', None, tr, 0, nullid, nullid)			f.add(b'0', None, tr, 0, f.nullid, f.nullid)
	node1 = f.add(b'1', None, tr, 5, nullid, nullid)			node1 = f.add(b'1', None, tr, 5, f.nullid, f.nullid)
	node2 = f.add(b'2', None, tr, 10, nullid, nullid)			node2 = f.add(b'2', None, tr, 10, f.nullid, f.nullid)

	self.assertEqual(len(f), 3)			self.assertEqual(len(f), 3)

	with self._maketransactionfn() as tr:			with self._maketransactionfn() as tr:
	f.strip(11, tr)			f.strip(11, tr)

	self.assertEqual(len(f), 3)			self.assertEqual(len(f), 3)

mercurial/treediscovery.py

	# discovery.py - protocol changeset discovery functions			# discovery.py - protocol changeset discovery functions
	#			#
	# Copyright 2010 Olivia Mackall <olivia@selenic.com>			# Copyright 2010 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections

	from .i18n import _			from .i18n import _
	from .node import (			from .node import short
	nullid,
	short,
	)
	from . import (			from . import (
	error,			error,
	pycompat,			pycompat,
	)			)


	def findcommonincoming(repo, remote, heads=None, force=False, audit=None):			def findcommonincoming(repo, remote, heads=None, force=False, audit=None):
	"""Return a tuple (common, fetch, heads) used to identify the common			"""Return a tuple (common, fetch, heads) used to identify the common

	if not heads:			if not heads:
	with remote.commandexecutor() as e:			with remote.commandexecutor() as e:
	heads = e.callcommand(b'heads', {}).result()			heads = e.callcommand(b'heads', {}).result()

	if audit is not None:			if audit is not None:
	audit[b'total-roundtrips'] = 1			audit[b'total-roundtrips'] = 1

	if repo.changelog.tip() == nullid:			if repo.changelog.tip() == repo.nullid:
	base.add(nullid)			base.add(repo.nullid)
	if heads != [nullid]:			if heads != [repo.nullid]:
	return [nullid], [nullid], list(heads)			return [repo.nullid], [repo.nullid], list(heads)
	return [nullid], [], heads			return [repo.nullid], [], heads

	# assume we're closer to the tip than the root			# assume we're closer to the tip than the root
	# and start by examining the heads			# and start by examining the heads
	repo.ui.status(_(b"searching for changes\n"))			repo.ui.status(_(b"searching for changes\n"))

	unknown = []			unknown = []
	for h in heads:			for h in heads:
	if not knownnode(h):			if not knownnode(h):
	while unknown:			while unknown:
	r = []			r = []
	while unknown:			while unknown:
	n = unknown.popleft()			n = unknown.popleft()
	if n[0] in seen:			if n[0] in seen:
	continue			continue

	repo.ui.debug(b"examining %s:%s\n" % (short(n[0]), short(n[1])))			repo.ui.debug(b"examining %s:%s\n" % (short(n[0]), short(n[1])))
	if n[0] == nullid: # found the end of the branch			if n[0] == repo.nullid: # found the end of the branch
	pass			pass
	elif n in seenbranch:			elif n in seenbranch:
	repo.ui.debug(b"branch already found\n")			repo.ui.debug(b"branch already found\n")
	continue			continue
	elif n[1] and knownnode(n[1]): # do we know the base?			elif n[1] and knownnode(n[1]): # do we know the base?
	repo.ui.debug(			repo.ui.debug(
	b"found incomplete branch %s:%s\n"			b"found incomplete branch %s:%s\n"
	% (short(n[0]), short(n[1]))			% (short(n[0]), short(n[1]))
	search = newsearch			search = newsearch

	# sanity check our fetch list			# sanity check our fetch list
	for f in fetch:			for f in fetch:
	if knownnode(f):			if knownnode(f):
	raise error.RepoError(_(b"already have changeset ") + short(f[:4]))			raise error.RepoError(_(b"already have changeset ") + short(f[:4]))

	base = list(base)			base = list(base)
	if base == [nullid]:			if base == [repo.nullid]:
	if force:			if force:
	repo.ui.warn(_(b"warning: repository is unrelated\n"))			repo.ui.warn(_(b"warning: repository is unrelated\n"))
	else:			else:
	raise error.Abort(_(b"repository is unrelated"))			raise error.Abort(_(b"repository is unrelated"))

	repo.ui.debug(			repo.ui.debug(
	b"found new changesets starting at "			b"found new changesets starting at "
	+ b" ".join([short(f) for f in fetch])			+ b" ".join([short(f) for f in fetch])

mercurial/util.py

	import re as remod			import re as remod
	import shutil			import shutil
	import stat			import stat
	import sys			import sys
	import time			import time
	import traceback			import traceback
	import warnings			import warnings

				from .node import hex
	from .thirdparty import attr			from .thirdparty import attr
	from .pycompat import (			from .pycompat import (
	delattr,			delattr,
	getattr,			getattr,
	open,			open,
	setattr,			setattr,
	)			)
	from .node import hex			from .node import hex

mercurial/utils/storageutil.py

	# storageutil.py - Storage functionality agnostic of backend implementation.			# storageutil.py - Storage functionality agnostic of backend implementation.
	#			#
	# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>			# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import re			import re
	import struct			import struct

	from ..i18n import _			from ..i18n import _
	from ..node import (			from ..node import (
	bin,			bin,
	nullid,
	nullrev,			nullrev,
				sha1nodeconstants,
	)			)
	from .. import (			from .. import (
	dagop,			dagop,
	error,			error,
	mdiff,			mdiff,
	pycompat,			pycompat,
	)			)
	from ..interfaces import repository			from ..interfaces import repository
	from ..revlogutils import sidedata as sidedatamod			from ..revlogutils import sidedata as sidedatamod
	from ..utils import hashutil			from ..utils import hashutil

	_nullhash = hashutil.sha1(nullid)			_nullhash = hashutil.sha1(sha1nodeconstants.nullid)


	def hashrevisionsha1(text, p1, p2):			def hashrevisionsha1(text, p1, p2):
	"""Compute the SHA-1 for revision data and its parents.			"""Compute the SHA-1 for revision data and its parents.

	This hash combines both the current file contents and its history			This hash combines both the current file contents and its history
	in a manner that makes it easy to distinguish nodes with the same			in a manner that makes it easy to distinguish nodes with the same
	content in the revision graph.			content in the revision graph.
	"""			"""
	# As of now, if one of the parent node is null, p2 is null			# As of now, if one of the parent node is null, p2 is null
	if p2 == nullid:			if p2 == sha1nodeconstants.nullid:
	# deep copy of a hash is faster than creating one			# deep copy of a hash is faster than creating one
	s = _nullhash.copy()			s = _nullhash.copy()
	s.update(p1)			s.update(p1)
	else:			else:
	# none of the parent nodes are nullid			# none of the parent nodes are nullid
	if p1 < p2:			if p1 < p2:
	a = p1			a = p1
	b = p2			b = p2


	def filerevisioncopied(store, node):			def filerevisioncopied(store, node):
	"""Resolve file revision copy metadata.			"""Resolve file revision copy metadata.

	Returns ``False`` if the file has no copy metadata. Otherwise a			Returns ``False`` if the file has no copy metadata. Otherwise a
	2-tuple of the source filename and node.			2-tuple of the source filename and node.
	"""			"""
	if store.parents(node)[0] != nullid:			if store.parents(node)[0] != sha1nodeconstants.nullid:
	return False			return False

	meta = parsemeta(store.revision(node))[0]			meta = parsemeta(store.revision(node))[0]

	# copy and copyrev occur in pairs. In rare cases due to old bugs,			# copy and copyrev occur in pairs. In rare cases due to old bugs,
	# one can occur without the other. So ensure both are present to flag			# one can occur without the other. So ensure both are present to flag
	# as a copy.			# as a copy.
	if meta and b'copy' in meta and b'copyrev' in meta:			if meta and b'copy' in meta and b'copyrev' in meta:

mercurial/verify.py

	# verify.py - repository integrity checking for Mercurial			# verify.py - repository integrity checking for Mercurial
	#			#
	# Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os

	from .i18n import _			from .i18n import _
	from .node import (			from .node import short
	nullid,			from .utils import stringutil
	short,
	)
	from .utils import (
	stringutil,
	)

	from . import (			from . import (
	error,			error,
	pycompat,			pycompat,
	revlog,			revlog,
	util,			util,
	)			)

	self._warn(			self._warn(
	_(b" (expected %s)")			_(b" (expected %s)")
	% b" ".join(map(pycompat.bytestr, linkrevs))			% b" ".join(map(pycompat.bytestr, linkrevs))
	)			)
	lr = None # can't be trusted			lr = None # can't be trusted

	try:			try:
	p1, p2 = obj.parents(node)			p1, p2 = obj.parents(node)
	if p1 not in seen and p1 != nullid:			if p1 not in seen and p1 != self.repo.nullid:
	self._err(			self._err(
	lr,			lr,
	_(b"unknown parent 1 %s of %s") % (short(p1), short(node)),			_(b"unknown parent 1 %s of %s") % (short(p1), short(node)),
	f,			f,
	)			)
	if p2 not in seen and p2 != nullid:			if p2 not in seen and p2 != self.repo.nullid:
	self._err(			self._err(
	lr,			lr,
	_(b"unknown parent 2 %s of %s") % (short(p2), short(node)),			_(b"unknown parent 2 %s of %s") % (short(p2), short(node)),
	f,			f,
	)			)
	except Exception as inst:			except Exception as inst:
	self._exc(lr, _(b"checking parents of %s") % short(node), inst, f)			self._exc(lr, _(b"checking parents of %s") % short(node), inst, f)

	)			)
	for i in repo:			for i in repo:
	progress.update(i)			progress.update(i)
	n = cl.node(i)			n = cl.node(i)
	self._checkentry(cl, i, n, seen, [i], b"changelog")			self._checkentry(cl, i, n, seen, [i], b"changelog")

	try:			try:
	changes = cl.read(n)			changes = cl.read(n)
	if changes[0] != nullid:			if changes[0] != self.repo.nullid:
	mflinkrevs.setdefault(changes[0], []).append(i)			mflinkrevs.setdefault(changes[0], []).append(i)
	self.refersmf = True			self.refersmf = True
	for f in changes[3]:			for f in changes[3]:
	if match(f):			if match(f):
	filelinkrevs.setdefault(_normpath(f), []).append(i)			filelinkrevs.setdefault(_normpath(f), []).append(i)
	except Exception as inst:			except Exception as inst:
	self.refersmf = True			self.refersmf = True
	self._exc(i, _(b"unpacking changeset %s") % short(n), inst)			self._exc(i, _(b"unpacking changeset %s") % short(n), inst)
	lr,			lr,
	_(			_(
	b"empty or missing copy source revlog "			b"empty or missing copy source revlog "
	b"%s:%s"			b"%s:%s"
	)			)
	% (rp[0], short(rp[1])),			% (rp[0], short(rp[1])),
	f,			f,
	)			)
	elif rp[1] == nullid:			elif rp[1] == self.repo.nullid:
	ui.note(			ui.note(
	_(			_(
	b"warning: %s@%s: copy source"			b"warning: %s@%s: copy source"
	b" revision is nullid %s:%s\n"			b" revision is nullid %s:%s\n"
	)			)
	% (f, lr, rp[0], short(rp[1]))			% (f, lr, rp[0], short(rp[1]))
	)			)
	else:			else:

mercurial/wireprotov1server.py

	# wireprotov1server.py - Wire protocol version 1 server functionality			# wireprotov1server.py - Wire protocol version 1 server functionality
	#			#
	# Copyright 2005-2010 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2010 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import binascii			import binascii
	import os			import os

	from .i18n import _			from .i18n import _
	from .node import (			from .node import hex
	hex,
	nullid,
	)
	from .pycompat import getattr			from .pycompat import getattr

	from . import (			from . import (
	bundle2,			bundle2,
	bundlecaches,			bundlecaches,
	changegroup as changegroupmod,			changegroup as changegroupmod,
	discovery,			discovery,
	encoding,			encoding,
	if proto.name == b'http-v1':			if proto.name == b'http-v1':
	return wireprototypes.ooberror(bundle2required)			return wireprototypes.ooberror(bundle2required)
	raise error.Abort(bundle2requiredmain, hint=bundle2requiredhint)			raise error.Abort(bundle2requiredmain, hint=bundle2requiredhint)

	try:			try:
	clheads = set(repo.changelog.heads())			clheads = set(repo.changelog.heads())
	heads = set(opts.get(b'heads', set()))			heads = set(opts.get(b'heads', set()))
	common = set(opts.get(b'common', set()))			common = set(opts.get(b'common', set()))
	common.discard(nullid)			common.discard(repo.nullid)
	if (			if (
	repo.ui.configbool(b'server', b'pullbundle')			repo.ui.configbool(b'server', b'pullbundle')
	and b'partial-pull' in proto.getprotocaps()			and b'partial-pull' in proto.getprotocaps()
	):			):
	# Check if a pre-built bundle covers this request.			# Check if a pre-built bundle covers this request.
	bundle = find_pullbundle(repo, proto, opts, clheads, heads, common)			bundle = find_pullbundle(repo, proto, opts, clheads, heads, common)
	if bundle:			if bundle:
	return wireprototypes.streamres(			return wireprototypes.streamres(

mercurial/wireprotov2server.py

	# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>			# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
	# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import collections			import collections
	import contextlib			import contextlib

	from .i18n import _			from .i18n import _
	from .node import (			from .node import hex
	hex,
	nullid,
	)
	from . import (			from . import (
	discovery,			discovery,
	encoding,			encoding,
	error,			error,
	match as matchmod,			match as matchmod,
	narrowspec,			narrowspec,
	pycompat,			pycompat,
	streamclone,			streamclone,
	if not spec[b'heads']:			if not spec[b'heads']:
	raise error.WireprotoCommandError(			raise error.WireprotoCommandError(
	b'heads key in changesetdagrange cannot be empty'			b'heads key in changesetdagrange cannot be empty'
	)			)

	if spec[b'roots']:			if spec[b'roots']:
	common = [n for n in spec[b'roots'] if clhasnode(n)]			common = [n for n in spec[b'roots'] if clhasnode(n)]
	else:			else:
	common = [nullid]			common = [repo.nullid]

	for n in discovery.outgoing(repo, common, spec[b'heads']).missing:			for n in discovery.outgoing(repo, common, spec[b'heads']).missing:
	if n not in seen:			if n not in seen:
	nodes.append(n)			nodes.append(n)
	seen.add(n)			seen.add(n)

	else:			else:
	raise error.WireprotoCommandError(			raise error.WireprotoCommandError(

tests/drawdag.py

	# prune: A, B, C # many to nothing			# prune: A, B, C # many to nothing
	"""			"""
	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	import collections			import collections
	import itertools			import itertools
	import re			import re

	from mercurial.node import nullid
	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial import (			from mercurial import (
	context,			context,
	error,			error,
	obsolete,			obsolete,
	pycompat,			pycompat,
	registrar,			registrar,
	scmutil,			scmutil,
	'changes': scmutil.status([], list(added), [], [], [], [], []),			'changes': scmutil.status([], list(added), [], [], [], [], []),
	'date': b'0 0',			'date': b'0 0',
	'extra': {b'branch': b'default'},			'extra': {b'branch': b'default'},
	}			}
	super(simplecommitctx, self).__init__(repo, name, **opts)			super(simplecommitctx, self).__init__(repo, name, **opts)
	self._added = added			self._added = added
	self._parents = parentctxs			self._parents = parentctxs
	while len(self._parents) < 2:			while len(self._parents) < 2:
	self._parents.append(repo[nullid])			self._parents.append(repo[repo.nullid])

	def filectx(self, key):			def filectx(self, key):
	return simplefilectx(key, self._added[key])			return simplefilectx(key, self._added[key])

	def commit(self):			def commit(self):
	return self._repo.commitctx(self)			return self._repo.commitctx(self)

	def p1copies(self):			def p1copies(self):
	# parse comments to get extra file content instructions			# parse comments to get extra file content instructions
	files = collections.defaultdict(dict) # {(name, path): content}			files = collections.defaultdict(dict) # {(name, path): content}
	comments = list(_getcomments(text))			comments = list(_getcomments(text))
	filere = re.compile(br'^(\w+)/([\w/]+)\s=\s(.*)$', re.M)			filere = re.compile(br'^(\w+)/([\w/]+)\s=\s(.*)$', re.M)
	for name, path, content in filere.findall(b'\n'.join(comments)):			for name, path, content in filere.findall(b'\n'.join(comments)):
	content = content.replace(br'\n', b'\n').replace(br'\1', b'\1')			content = content.replace(br'\n', b'\n').replace(br'\1', b'\1')
	files[name][path] = content			files[name][path] = content

	committed = {None: nullid} # {name: node}			committed = {None: repo.nullid} # {name: node}

	# for leaf nodes, try to find existing nodes in repo			# for leaf nodes, try to find existing nodes in repo
	for name, parents in edges.items():			for name, parents in edges.items():
	if len(parents) == 0:			if len(parents) == 0:
	try:			try:
	committed[name] = scmutil.revsingle(repo, name)			committed[name] = scmutil.revsingle(repo, name)
	except error.RepoLookupError:			except error.RepoLookupError:
	pass			pass

tests/simplestorerepo.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import stat			import stat

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
	)			)
	from mercurial.thirdparty import attr			from mercurial.thirdparty import attr
	from mercurial import (			from mercurial import (
	ancestor,			ancestor,
	bundlerepo,			bundlerepo,
	error,			error,
	extensions,			extensions,
	self._indexbynode.clear()			self._indexbynode.clear()
	self._indexbyrev.clear()			self._indexbyrev.clear()
	self._index = []			self._index = []

	for i, entry in enumerate(self._indexdata):			for i, entry in enumerate(self._indexdata):
	self._indexbynode[entry[b'node']] = entry			self._indexbynode[entry[b'node']] = entry
	self._indexbyrev[i] = entry			self._indexbyrev[i] = entry

	self._indexbynode[nullid] = {			self._indexbynode[self._repo.nullid] = {
	b'node': nullid,			b'node': self._repo.nullid,
	b'p1': nullid,			b'p1': self._repo.nullid,
	b'p2': nullid,			b'p2': self._repo.nullid,
	b'linkrev': nullrev,			b'linkrev': nullrev,
	b'flags': 0,			b'flags': 0,
	}			}

	self._indexbyrev[nullrev] = {			self._indexbyrev[nullrev] = {
	b'node': nullid,			b'node': self._repo.nullid,
	b'p1': nullid,			b'p1': self._repo.nullid,
	b'p2': nullid,			b'p2': self._repo.nullid,
	b'linkrev': nullrev,			b'linkrev': nullrev,
	b'flags': 0,			b'flags': 0,
	}			}

	for i, entry in enumerate(self._indexdata):			for i, entry in enumerate(self._indexdata):
	p1rev, p2rev = self.parentrevs(self.rev(entry[b'node']))			p1rev, p2rev = self.parentrevs(self.rev(entry[b'node']))

	# start, length, rawsize, chainbase, linkrev, p1, p2, node			# start, length, rawsize, chainbase, linkrev, p1, p2, node
	self._index.append(			self._index.append(
	(0, 0, 0, -1, entry[b'linkrev'], p1rev, p2rev, entry[b'node'])			(0, 0, 0, -1, entry[b'linkrev'], p1rev, p2rev, entry[b'node'])
	)			)

	self._index.append((0, 0, 0, -1, -1, -1, -1, nullid))			self._index.append((0, 0, 0, -1, -1, -1, -1, self._repo.nullid))

	def __len__(self):			def __len__(self):
	return len(self._indexdata)			return len(self._indexdata)

	def __iter__(self):			def __iter__(self):
	return iter(range(len(self)))			return iter(range(len(self)))

	def revs(self, start=0, stop=None):			def revs(self, start=0, stop=None):

	def revision(self, nodeorrev, raw=False):			def revision(self, nodeorrev, raw=False):
	if isinstance(nodeorrev, int):			if isinstance(nodeorrev, int):
	node = self.node(nodeorrev)			node = self.node(nodeorrev)
	else:			else:
	node = nodeorrev			node = nodeorrev
	validatenode(node)			validatenode(node)

	if node == nullid:			if node == self._repo.nullid:
	return b''			return b''

	rev = self.rev(node)			rev = self.rev(node)
	flags = self._flags(rev)			flags = self._flags(rev)

	path = b'/'.join([self._storepath, hex(node)])			path = b'/'.join([self._storepath, hex(node)])
	rawtext = self._svfs.read(path)			rawtext = self._svfs.read(path)

	return revision			return revision

	start = revision.index(b'\1\n', 2)			start = revision.index(b'\1\n', 2)
	return revision[start + 2 :]			return revision[start + 2 :]

	def renamed(self, node):			def renamed(self, node):
	validatenode(node)			validatenode(node)

	if self.parents(node)[0] != nullid:			if self.parents(node)[0] != self._repo.nullid:
	return False			return False

	fulltext = self.revision(node)			fulltext = self.revision(node)
	m = storageutil.parsemeta(fulltext)[0]			m = storageutil.parsemeta(fulltext)[0]

	if m and 'copy' in m:			if m and 'copy' in m:
	return m['copy'], bin(m['copyrev'])			return m['copy'], bin(m['copyrev'])

	nodes,			nodes,
	nodesorder=None,			nodesorder=None,
	revisiondata=False,			revisiondata=False,
	assumehaveparentrevisions=False,			assumehaveparentrevisions=False,
	deltamode=repository.CG_DELTAMODE_STD,			deltamode=repository.CG_DELTAMODE_STD,
	sidedata_helpers=None,			sidedata_helpers=None,
	):			):
	# TODO this will probably break on some ordering options.			# TODO this will probably break on some ordering options.
	nodes = [n for n in nodes if n != nullid]			nodes = [n for n in nodes if n != self._repo.nullid]
	if not nodes:			if not nodes:
	return			return
	for delta in storageutil.emitrevisions(			for delta in storageutil.emitrevisions(
	self,			self,
	nodes,			nodes,
	nodesorder,			nodesorder,
	simplestorerevisiondelta,			simplestorerevisiondelta,
	revisiondata=revisiondata,			revisiondata=revisiondata,

	if node in self._indexbynode:			if node in self._indexbynode:
	if duplicaterevisioncb:			if duplicaterevisioncb:
	duplicaterevisioncb(self, self.rev(node))			duplicaterevisioncb(self, self.rev(node))
	empty = False			empty = False
	continue			continue

	# Need to resolve the fulltext from the delta base.			# Need to resolve the fulltext from the delta base.
	if deltabase == nullid:			if deltabase == self._repo.nullid:
	text = mdiff.patch(b'', delta)			text = mdiff.patch(b'', delta)
	else:			else:
	text = mdiff.patch(self.revision(deltabase), delta)			text = mdiff.patch(self.revision(deltabase), delta)

	rev = self._addrawrevision(			rev = self._addrawrevision(
	node, text, transaction, linkrev, p1, p2, flags			node, text, transaction, linkrev, p1, p2, flags
	)			)

	revishead[self.rev(entry[b'p2'])] = False			revishead[self.rev(entry[b'p2'])] = False

	return [rev for rev, ishead in sorted(revishead.items()) if ishead]			return [rev for rev, ishead in sorted(revishead.items()) if ishead]

	def heads(self, start=None, stop=None):			def heads(self, start=None, stop=None):
	# This is copied from revlog.py.			# This is copied from revlog.py.
	if start is None and stop is None:			if start is None and stop is None:
	if not len(self):			if not len(self):
	return [nullid]			return [self._repo.nullid]
	return [self.node(r) for r in self._headrevs()]			return [self.node(r) for r in self._headrevs()]

	if start is None:			if start is None:
	start = nullid			start = self._repo.nullid
	if stop is None:			if stop is None:
	stop = []			stop = []
	stoprevs = {self.rev(n) for n in stop}			stoprevs = {self.rev(n) for n in stop}
	startrev = self.rev(start)			startrev = self.rev(start)
	reachable = {startrev}			reachable = {startrev}
	heads = {startrev}			heads = {startrev}

	parentrevs = self.parentrevs			parentrevs = self.parentrevs

tests/test-annotate.t


	to reproduce the situation with recent Mercurial, this script uses (1)			to reproduce the situation with recent Mercurial, this script uses (1)
	"hg debugsetparents" to merge without ancestor check by "hg merge",			"hg debugsetparents" to merge without ancestor check by "hg merge",
	and (2) the extension to allow filelog merging between the revision			and (2) the extension to allow filelog merging between the revision
	and its ancestor by overriding "repo._filecommit".			and its ancestor by overriding "repo._filecommit".

	$ cat > ../legacyrepo.py <<EOF			$ cat > ../legacyrepo.py <<EOF
	> from __future__ import absolute_import			> from __future__ import absolute_import
	> from mercurial import commit, error, extensions, node			> from mercurial import commit, error, extensions
	> def _filecommit(orig, repo, fctx, manifest1, manifest2,			> def _filecommit(orig, repo, fctx, manifest1, manifest2,
	> linkrev, tr, includecopymeta, ms):			> linkrev, tr, includecopymeta, ms):
	> fname = fctx.path()			> fname = fctx.path()
	> text = fctx.data()			> text = fctx.data()
	> flog = repo.file(fname)			> flog = repo.file(fname)
	> fparent1 = manifest1.get(fname, node.nullid)			> fparent1 = manifest1.get(fname, repo.nullid)
	> fparent2 = manifest2.get(fname, node.nullid)			> fparent2 = manifest2.get(fname, repo.nullid)
	> meta = {}			> meta = {}
	> copy = fctx.copysource()			> copy = fctx.copysource()
	> if copy and copy != fname:			> if copy and copy != fname:
	> raise error.Abort('copying is not supported')			> raise error.Abort('copying is not supported')
	> if fparent2 != node.nullid:			> if fparent2 != repo.nullid:
	> return flog.add(text, meta, tr, linkrev,			> return flog.add(text, meta, tr, linkrev,
	> fparent1, fparent2), 'modified'			> fparent1, fparent2), 'modified'
	> raise error.Abort('only merging is supported')			> raise error.Abort('only merging is supported')
	> def uisetup(ui):			> def uisetup(ui):
	> extensions.wrapfunction(commit, '_filecommit', _filecommit)			> extensions.wrapfunction(commit, '_filecommit', _filecommit)
	> EOF			> EOF

	$ cat > baz <<EOF			$ cat > baz <<EOF

tests/test-commit.t

	description:			description:
	empty commit			empty commit



	verify pathauditor blocks evil filepaths			verify pathauditor blocks evil filepaths
	$ cat > evil-commit.py <<EOF			$ cat > evil-commit.py <<EOF
	> from __future__ import absolute_import			> from __future__ import absolute_import
	> from mercurial import context, hg, node, ui as uimod			> from mercurial import context, hg, ui as uimod
	> notrc = u".h\u200cg".encode('utf-8') + b'/hgrc'			> notrc = u".h\u200cg".encode('utf-8') + b'/hgrc'
	> u = uimod.ui.load()			> u = uimod.ui.load()
	> r = hg.repository(u, b'.')			> r = hg.repository(u, b'.')
	> def filectxfn(repo, memctx, path):			> def filectxfn(repo, memctx, path):
	> return context.memfilectx(repo, memctx, path,			> return context.memfilectx(repo, memctx, path,
	> b'[hooks]\nupdate = echo owned')			> b'[hooks]\nupdate = echo owned')
	> c = context.memctx(r, [r.changelog.tip(), node.nullid],			> c = context.memctx(r, [r.changelog.tip(), r.nullid],
	> b'evil', [notrc], filectxfn, 0)			> b'evil', [notrc], filectxfn, 0)
	> r.commitctx(c)			> r.commitctx(c)
	> EOF			> EOF
	$ "$PYTHON" evil-commit.py			$ "$PYTHON" evil-commit.py
	#if windows			#if windows
	$ hg co --clean tip			$ hg co --clean tip
	abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc)			abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc)
	[255]			[255]
	#else			#else
	$ hg co --clean tip			$ hg co --clean tip
	abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc)			abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc)
	[255]			[255]
	#endif			#endif

	$ hg rollback -f			$ hg rollback -f
	repository tip rolled back to revision 2 (undo commit)			repository tip rolled back to revision 2 (undo commit)
	$ cat > evil-commit.py <<EOF			$ cat > evil-commit.py <<EOF
	> from __future__ import absolute_import			> from __future__ import absolute_import
	> from mercurial import context, hg, node, ui as uimod			> from mercurial import context, hg, ui as uimod
	> notrc = b"HG~1/hgrc"			> notrc = b"HG~1/hgrc"
	> u = uimod.ui.load()			> u = uimod.ui.load()
	> r = hg.repository(u, b'.')			> r = hg.repository(u, b'.')
	> def filectxfn(repo, memctx, path):			> def filectxfn(repo, memctx, path):
	> return context.memfilectx(repo, memctx, path,			> return context.memfilectx(repo, memctx, path,
	> b'[hooks]\nupdate = echo owned')			> b'[hooks]\nupdate = echo owned')
	> c = context.memctx(r, [r[b'tip'].node(), node.nullid],			> c = context.memctx(r, [r[b'tip'].node(), r.nullid],
	> b'evil', [notrc], filectxfn, 0)			> b'evil', [notrc], filectxfn, 0)
	> r.commitctx(c)			> r.commitctx(c)
	> EOF			> EOF
	$ "$PYTHON" evil-commit.py			$ "$PYTHON" evil-commit.py
	$ hg co --clean tip			$ hg co --clean tip
	abort: path contains illegal component: HG~1/hgrc			abort: path contains illegal component: HG~1/hgrc
	[255]			[255]

	$ hg rollback -f			$ hg rollback -f
	repository tip rolled back to revision 2 (undo commit)			repository tip rolled back to revision 2 (undo commit)
	$ cat > evil-commit.py <<EOF			$ cat > evil-commit.py <<EOF
	> from __future__ import absolute_import			> from __future__ import absolute_import
	> from mercurial import context, hg, node, ui as uimod			> from mercurial import context, hg, ui as uimod
	> notrc = b"HG8B6C~2/hgrc"			> notrc = b"HG8B6C~2/hgrc"
	> u = uimod.ui.load()			> u = uimod.ui.load()
	> r = hg.repository(u, b'.')			> r = hg.repository(u, b'.')
	> def filectxfn(repo, memctx, path):			> def filectxfn(repo, memctx, path):
	> return context.memfilectx(repo, memctx, path,			> return context.memfilectx(repo, memctx, path,
	> b'[hooks]\nupdate = echo owned')			> b'[hooks]\nupdate = echo owned')
	> c = context.memctx(r, [r[b'tip'].node(), node.nullid],			> c = context.memctx(r, [r[b'tip'].node(), r.nullid],
	> b'evil', [notrc], filectxfn, 0)			> b'evil', [notrc], filectxfn, 0)
	> r.commitctx(c)			> r.commitctx(c)
	> EOF			> EOF
	$ "$PYTHON" evil-commit.py			$ "$PYTHON" evil-commit.py
	$ hg co --clean tip			$ hg co --clean tip
	abort: path contains illegal component: HG8B6C~2/hgrc			abort: path contains illegal component: HG8B6C~2/hgrc
	[255]			[255]

tests/test-fastannotate-hg.t


	to reproduce the situation with recent Mercurial, this script uses (1)			to reproduce the situation with recent Mercurial, this script uses (1)
	"hg debugsetparents" to merge without ancestor check by "hg merge",			"hg debugsetparents" to merge without ancestor check by "hg merge",
	and (2) the extension to allow filelog merging between the revision			and (2) the extension to allow filelog merging between the revision
	and its ancestor by overriding "repo._filecommit".			and its ancestor by overriding "repo._filecommit".

	$ cat > ../legacyrepo.py <<EOF			$ cat > ../legacyrepo.py <<EOF
	> from __future__ import absolute_import			> from __future__ import absolute_import
	> from mercurial import commit, error, extensions, node			> from mercurial import commit, error, extensions
	> def _filecommit(orig, repo, fctx, manifest1, manifest2,			> def _filecommit(orig, repo, fctx, manifest1, manifest2,
	> linkrev, tr, includecopymeta, ms):			> linkrev, tr, includecopymeta, ms):
	> fname = fctx.path()			> fname = fctx.path()
	> text = fctx.data()			> text = fctx.data()
	> flog = repo.file(fname)			> flog = repo.file(fname)
	> fparent1 = manifest1.get(fname, node.nullid)			> fparent1 = manifest1.get(fname, repo.nullid)
	> fparent2 = manifest2.get(fname, node.nullid)			> fparent2 = manifest2.get(fname, repo.nullid)
	> meta = {}			> meta = {}
	> copy = fctx.copysource()			> copy = fctx.copysource()
	> if copy and copy != fname:			> if copy and copy != fname:
	> raise error.Abort('copying is not supported')			> raise error.Abort('copying is not supported')
	> if fparent2 != node.nullid:			> if fparent2 != repo.nullid:
	> return flog.add(text, meta, tr, linkrev,			> return flog.add(text, meta, tr, linkrev,
	> fparent1, fparent2), 'modified'			> fparent1, fparent2), 'modified'
	> raise error.Abort('only merging is supported')			> raise error.Abort('only merging is supported')
	> def uisetup(ui):			> def uisetup(ui):
	> extensions.wrapfunction(commit, '_filecommit', _filecommit)			> extensions.wrapfunction(commit, '_filecommit', _filecommit)
	> EOF			> EOF

	$ cat > baz <<EOF			$ cat > baz <<EOF

tests/test-filelog.py

	#!/usr/bin/env python3			#!/usr/bin/env python3
	"""			"""
	Tests the behavior of filelog w.r.t. data starting with '\1\n'			Tests the behavior of filelog w.r.t. data starting with '\1\n'
	"""			"""
	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	from mercurial.node import (			from mercurial.node import hex
	hex,
	nullid,
	)
	from mercurial import (			from mercurial import (
	hg,			hg,
	ui as uimod,			ui as uimod,
	)			)

	myui = uimod.ui.load()			myui = uimod.ui.load()
	repo = hg.repository(myui, path=b'.', create=True)			repo = hg.repository(myui, path=b'.', create=True)

	fl = repo.file(b'foobar')			fl = repo.file(b'foobar')


	def addrev(text, renamed=False):			def addrev(text, renamed=False):
	if renamed:			if renamed:
	# data doesn't matter. Just make sure filelog.renamed() returns True			# data doesn't matter. Just make sure filelog.renamed() returns True
	meta = {b'copyrev': hex(nullid), b'copy': b'bar'}			meta = {b'copyrev': hex(repo.nullid), b'copy': b'bar'}
	else:			else:
	meta = {}			meta = {}

	lock = t = None			lock = t = None
	try:			try:
	lock = repo.lock()			lock = repo.lock()
	t = repo.transaction(b'commit')			t = repo.transaction(b'commit')
	node = fl.add(text, meta, t, 0, nullid, nullid)			node = fl.add(text, meta, t, 0, repo.nullid, repo.nullid)
	return node			return node
	finally:			finally:
	if t:			if t:
	t.close()			t.close()
	if lock:			if lock:
	lock.release()			lock.release()

tests/test-parseindex2.py

	"""This unit test primarily tests parsers.parse_index2().			"""This unit test primarily tests parsers.parse_index2().

	It also checks certain aspects of the parsers module as a whole.			It also checks certain aspects of the parsers module as a whole.
	"""			"""

	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	import os			import os
	import struct			import struct
	import subprocess			import subprocess
	import sys			import sys
	import unittest			import unittest

	from mercurial.node import (			from mercurial.node import (
	bin,			bin,
	hex,			hex,
	nullid,
	nullrev,			nullrev,
				sha1nodeconstants,
	)			)
	from mercurial import (			from mercurial import (
	policy,			policy,
	pycompat,			pycompat,
	)			)

	parsers = policy.importmod('parsers')			parsers = policy.importmod('parsers')

	# original python implementation			# original python implementation
	def gettype(q):			def gettype(q):
	return int(q & 0xFFFF)			return int(q & 0xFFFF)


	def offset_type(offset, type):			def offset_type(offset, type):
	return int(int(offset) << 16 \| type)			return int(int(offset) << 16 \| type)


	indexformatng = ">Qiiiiii20s12x"			indexformatng = ">Qiiiiii20s12x"


	def py_parseindex(data, inline):			def py_parseindex(data, inline):
	s = 64			s = 64
	cache = None			cache = None
	index = []			index = []
	nodemap = {nullid: nullrev}			nodemap = {sha1nodeconstants.nullid: nullrev}
	n = off = 0			n = off = 0

	l = len(data) - s			l = len(data) - s
	append = index.append			append = index.append
	if inline:			if inline:
	cache = (0, data)			cache = (0, data)
	while off <= l:			while off <= l:
	e = struct.unpack(indexformatng, data[off : off + s])			e = struct.unpack(indexformatng, data[off : off + s])
	self.assertEqual(want, got) # inline data			self.assertEqual(want, got) # inline data

	want = py_parseindex(data_non_inlined, False)			want = py_parseindex(data_non_inlined, False)
	got = parse_index2(data_non_inlined, False)			got = parse_index2(data_non_inlined, False)
	self.assertEqual(want, got) # no inline data			self.assertEqual(want, got) # no inline data

	ix = parsers.parse_index2(data_inlined, True)[0]			ix = parsers.parse_index2(data_inlined, True)[0]
	for i, r in enumerate(ix):			for i, r in enumerate(ix):
	if r[7] == nullid:			if r[7] == sha1nodeconstants.nullid:
	i = -1			i = -1
	try:			try:
	self.assertEqual(			self.assertEqual(
	ix[r[7]],			ix[r[7]],
	i,			i,
	'Reverse lookup inconsistent for %r' % hex(r[7]),			'Reverse lookup inconsistent for %r' % hex(r[7]),
	)			)
	except TypeError:			except TypeError:
	# pure version doesn't support this			# pure version doesn't support this
	break			break

	def testminusone(self):			def testminusone(self):
	want = (0, 0, 0, -1, -1, -1, -1, nullid)			want = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid)
	index, junk = parsers.parse_index2(data_inlined, True)			index, junk = parsers.parse_index2(data_inlined, True)
	got = index[-1]			got = index[-1]
	self.assertEqual(want, got) # inline data			self.assertEqual(want, got) # inline data

	index, junk = parsers.parse_index2(data_non_inlined, False)			index, junk = parsers.parse_index2(data_non_inlined, False)
	got = index[-1]			got = index[-1]
	self.assertEqual(want, got) # no inline data			self.assertEqual(want, got) # no inline data

tests/test-remotefilelog-datapack.py

	import tempfile			import tempfile
	import time			import time
	import unittest			import unittest

	import silenttestrunner			import silenttestrunner

	# Load the local remotefilelog, not the system one			# Load the local remotefilelog, not the system one
	sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')]			sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')]
	from mercurial.node import nullid			from mercurial.node import sha1nodeconstants
	from mercurial import policy			from mercurial import policy

	if not policy._packageprefs.get(policy.policy, (False, False))[1]:			if not policy._packageprefs.get(policy.policy, (False, False))[1]:
	if __name__ == '__main__':			if __name__ == '__main__':
	msg = "skipped: pure module not available with module policy:"			msg = "skipped: pure module not available with module policy:"
	print(msg, policy.policy, file=sys.stderr)			print(msg, policy.policy, file=sys.stderr)
	sys.exit(80)			sys.exit(80)


	def getFakeHash(self):			def getFakeHash(self):
	return b''.join(			return b''.join(
	pycompat.bytechr(random.randint(0, 255)) for _ in range(20)			pycompat.bytechr(random.randint(0, 255)) for _ in range(20)
	)			)

	def createPack(self, revisions=None, packdir=None):			def createPack(self, revisions=None, packdir=None):
	if revisions is None:			if revisions is None:
	revisions = [(b"filename", self.getFakeHash(), nullid, b"content")]			revisions = [
				(
				b"filename",
				self.getFakeHash(),
				sha1nodeconstants.nullid,
				b"content",
				)
				]

	if packdir is None:			if packdir is None:
	packdir = self.makeTempDir()			packdir = self.makeTempDir()

	packer = datapack.mutabledatapack(uimod.ui(), packdir, version=2)			packer = datapack.mutabledatapack(uimod.ui(), packdir, version=2)

	for args in revisions:			for args in revisions:
	filename, node, base, content = args[0:4]			filename, node, base, content = args[0:4]
	# meta is optional			# meta is optional
	meta = None			meta = None
	if len(args) > 4:			if len(args) > 4:
	meta = args[4]			meta = args[4]
	packer.add(filename, node, base, content, metadata=meta)			packer.add(filename, node, base, content, metadata=meta)

	path = packer.close()			path = packer.close()
	return self.datapackreader(path)			return self.datapackreader(path)

	def _testAddSingle(self, content):			def _testAddSingle(self, content):
	"""Test putting a simple blob into a pack and reading it out."""			"""Test putting a simple blob into a pack and reading it out."""
	filename = b"foo"			filename = b"foo"
	node = self.getHash(content)			node = self.getHash(content)

	revisions = [(filename, node, nullid, content)]			revisions = [(filename, node, sha1nodeconstants.nullid, content)]
	pack = self.createPack(revisions)			pack = self.createPack(revisions)
	if self.paramsavailable:			if self.paramsavailable:
	self.assertEqual(			self.assertEqual(
	pack.params.fanoutprefix, basepack.SMALLFANOUTPREFIX			pack.params.fanoutprefix, basepack.SMALLFANOUTPREFIX
	)			)

	chain = pack.getdeltachain(filename, node)			chain = pack.getdeltachain(filename, node)
	self.assertEqual(content, chain[0][4])			self.assertEqual(content, chain[0][4])

	chain = pack.getdeltachain(filename, node)			chain = pack.getdeltachain(filename, node)
	self.assertEqual(content, chain[0][4])			self.assertEqual(content, chain[0][4])

	def testAddDeltas(self):			def testAddDeltas(self):
	"""Test putting multiple delta blobs into a pack and read the chain."""			"""Test putting multiple delta blobs into a pack and read the chain."""
	revisions = []			revisions = []
	filename = b"foo"			filename = b"foo"
	lastnode = nullid			lastnode = sha1nodeconstants.nullid
	for i in range(10):			for i in range(10):
	content = b"abcdef%d" % i			content = b"abcdef%d" % i
	node = self.getHash(content)			node = self.getHash(content)
	revisions.append((filename, node, lastnode, content))			revisions.append((filename, node, lastnode, content))
	lastnode = node			lastnode = node

	pack = self.createPack(revisions)			pack = self.createPack(revisions)

	blobs = {}			blobs = {}
	random.seed(0)			random.seed(0)
	for i in range(100):			for i in range(100):
	filename = b"filename-%d" % i			filename = b"filename-%d" % i
	filerevs = []			filerevs = []
	for j in range(random.randint(1, 100)):			for j in range(random.randint(1, 100)):
	content = b"content-%d" % j			content = b"content-%d" % j
	node = self.getHash(content)			node = self.getHash(content)
	lastnode = nullid			lastnode = sha1nodeconstants.nullid
	if len(filerevs) > 0:			if len(filerevs) > 0:
	lastnode = filerevs[random.randint(0, len(filerevs) - 1)]			lastnode = filerevs[random.randint(0, len(filerevs) - 1)]
	filerevs.append(node)			filerevs.append(node)
	blobs[(filename, node, lastnode)] = content			blobs[(filename, node, lastnode)] = content
	revisions.append((filename, node, lastnode, content))			revisions.append((filename, node, lastnode, content))

	pack = self.createPack(revisions)			pack = self.createPack(revisions)

	content = b'put-something-here \n' * i			content = b'put-something-here \n' * i
	node = self.getHash(content)			node = self.getHash(content)
	meta = {			meta = {
	constants.METAKEYFLAG: i ** 4,			constants.METAKEYFLAG: i ** 4,
	constants.METAKEYSIZE: len(content),			constants.METAKEYSIZE: len(content),
	b'Z': b'random_string',			b'Z': b'random_string',
	b'_': b'\0' * i,			b'_': b'\0' * i,
	}			}
	revisions.append((filename, node, nullid, content, meta))			revisions.append(
				(filename, node, sha1nodeconstants.nullid, content, meta)
				)
	pack = self.createPack(revisions)			pack = self.createPack(revisions)
	for name, node, x, content, origmeta in revisions:			for name, node, x, content, origmeta in revisions:
	parsedmeta = pack.getmeta(name, node)			parsedmeta = pack.getmeta(name, node)
	# flag == 0 should be optimized out			# flag == 0 should be optimized out
	if origmeta[constants.METAKEYFLAG] == 0:			if origmeta[constants.METAKEYFLAG] == 0:
	del origmeta[constants.METAKEYFLAG]			del origmeta[constants.METAKEYFLAG]
	self.assertEqual(parsedmeta, origmeta)			self.assertEqual(parsedmeta, origmeta)

	def testGetMissing(self):			def testGetMissing(self):
	"""Test the getmissing() api."""			"""Test the getmissing() api."""
	revisions = []			revisions = []
	filename = b"foo"			filename = b"foo"
	lastnode = nullid			lastnode = sha1nodeconstants.nullid
	for i in range(10):			for i in range(10):
	content = b"abcdef%d" % i			content = b"abcdef%d" % i
	node = self.getHash(content)			node = self.getHash(content)
	revisions.append((filename, node, lastnode, content))			revisions.append((filename, node, lastnode, content))
	lastnode = node			lastnode = node

	pack = self.createPack(revisions)			pack = self.createPack(revisions)

	[(b"foo", revisions[0][1]), (b"foo", fakenode)]			[(b"foo", revisions[0][1]), (b"foo", fakenode)]
	)			)
	self.assertEqual(missing, [(b"foo", fakenode)])			self.assertEqual(missing, [(b"foo", fakenode)])

	def testAddThrows(self):			def testAddThrows(self):
	pack = self.createPack()			pack = self.createPack()

	try:			try:
	pack.add(b'filename', nullid, b'contents')			pack.add(b'filename', sha1nodeconstants.nullid, b'contents')
	self.assertTrue(False, "datapack.add should throw")			self.assertTrue(False, "datapack.add should throw")
	except RuntimeError:			except RuntimeError:
	pass			pass

	def testBadVersionThrows(self):			def testBadVersionThrows(self):
	pack = self.createPack()			pack = self.createPack()
	path = pack.path + b'.datapack'			path = pack.path + b'.datapack'
	with open(path, 'rb') as f:			with open(path, 'rb') as f:
	revisions = []			revisions = []
	blobs = {}			blobs = {}
	total = basepack.SMALLFANOUTCUTOFF + 1			total = basepack.SMALLFANOUTCUTOFF + 1
	for i in pycompat.xrange(total):			for i in pycompat.xrange(total):
	filename = b"filename-%d" % i			filename = b"filename-%d" % i
	content = filename			content = filename
	node = self.getHash(content)			node = self.getHash(content)
	blobs[(filename, node)] = content			blobs[(filename, node)] = content
	revisions.append((filename, node, nullid, content))			revisions.append(
				(filename, node, sha1nodeconstants.nullid, content)
				)

	pack = self.createPack(revisions)			pack = self.createPack(revisions)
	if self.paramsavailable:			if self.paramsavailable:
	self.assertEqual(			self.assertEqual(
	pack.params.fanoutprefix, basepack.LARGEFANOUTPREFIX			pack.params.fanoutprefix, basepack.LARGEFANOUTPREFIX
	)			)

	for (filename, node), content in blobs.items():			for (filename, node), content in blobs.items():
	actualcontent = pack.getdeltachain(filename, node)[0][4]			actualcontent = pack.getdeltachain(filename, node)[0][4]
	self.assertEqual(actualcontent, content)			self.assertEqual(actualcontent, content)

	def testPacksCache(self):			def testPacksCache(self):
	"""Test that we remember the most recent packs while fetching the delta			"""Test that we remember the most recent packs while fetching the delta
	chain."""			chain."""

	packdir = self.makeTempDir()			packdir = self.makeTempDir()
	deltachains = []			deltachains = []

	numpacks = 10			numpacks = 10
	revisionsperpack = 100			revisionsperpack = 100

	for i in range(numpacks):			for i in range(numpacks):
	chain = []			chain = []
	revision = (b'%d' % i, self.getFakeHash(), nullid, b"content")			revision = (
				b'%d' % i,
				self.getFakeHash(),
				sha1nodeconstants.nullid,
				b"content",
				)

	for _ in range(revisionsperpack):			for _ in range(revisionsperpack):
	chain.append(revision)			chain.append(revision)
	revision = (			revision = (
	b'%d' % i,			b'%d' % i,
	self.getFakeHash(),			self.getFakeHash(),
	revision[1],			revision[1],
	self.getFakeHash(),			self.getFakeHash(),
	1000000,			1000000,
	]			]
	for packsize in packsizes:			for packsize in packsizes:
	revisions = []			revisions = []
	for i in pycompat.xrange(packsize):			for i in pycompat.xrange(packsize):
	filename = b"filename-%d" % i			filename = b"filename-%d" % i
	content = b"content-%d" % i			content = b"content-%d" % i
	node = self.getHash(content)			node = self.getHash(content)
	revisions.append((filename, node, nullid, content))			revisions.append(
				(filename, node, sha1nodeconstants.nullid, content)
				)

	path = self.createPack(revisions).path			path = self.createPack(revisions).path

	# Perf of large multi-get			# Perf of large multi-get
	import gc			import gc

	gc.disable()			gc.disable()
	pack = self.datapackreader(path)			pack = self.datapackreader(path)

tests/test-remotefilelog-histpack.py

	#!/usr/bin/env python3			#!/usr/bin/env python3
	from __future__ import absolute_import			from __future__ import absolute_import

	import hashlib			import hashlib
	import os			import os
	import random			import random
	import shutil			import shutil
	import stat			import stat
	import struct			import struct
	import sys			import sys
	import tempfile			import tempfile
	import unittest			import unittest

	import silenttestrunner			import silenttestrunner

	from mercurial.node import nullid			from mercurial.node import sha1nodeconstants
	from mercurial import (			from mercurial import (
	pycompat,			pycompat,
	ui as uimod,			ui as uimod,
	)			)

	# Load the local remotefilelog, not the system one			# Load the local remotefilelog, not the system one
	sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')]			sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')]
	from hgext.remotefilelog import (			from hgext.remotefilelog import (
	`revisions` is a list of tuples, where each tuple contains a filanem,			`revisions` is a list of tuples, where each tuple contains a filanem,
	node, p1node, p2node, and linknode.			node, p1node, p2node, and linknode.
	"""			"""
	if revisions is None:			if revisions is None:
	revisions = [			revisions = [
	(			(
	b"filename",			b"filename",
	self.getFakeHash(),			self.getFakeHash(),
	nullid,			sha1nodeconstants.nullid,
	nullid,			sha1nodeconstants.nullid,
	self.getFakeHash(),			self.getFakeHash(),
	None,			None,
	)			)
	]			]

	packdir = pycompat.fsencode(self.makeTempDir())			packdir = pycompat.fsencode(self.makeTempDir())
	packer = historypack.mutablehistorypack(uimod.ui(), packdir, version=2)			packer = historypack.mutablehistorypack(uimod.ui(), packdir, version=2)

	self.assertEqual(copyfrom, actual[3])			self.assertEqual(copyfrom, actual[3])

	def testAddAncestorChain(self):			def testAddAncestorChain(self):
	"""Test putting multiple revisions in into a pack and read the ancestor			"""Test putting multiple revisions in into a pack and read the ancestor
	chain.			chain.
	"""			"""
	revisions = []			revisions = []
	filename = b"foo"			filename = b"foo"
	lastnode = nullid			lastnode = sha1nodeconstants.nullid
	for i in range(10):			for i in range(10):
	node = self.getFakeHash()			node = self.getFakeHash()
	revisions.append((filename, node, lastnode, nullid, nullid, None))			revisions.append(
				(
				filename,
				node,
				lastnode,
				sha1nodeconstants.nullid,
				sha1nodeconstants.nullid,
				None,
				)
				)
	lastnode = node			lastnode = node

	# revisions must be added in topological order, newest first			# revisions must be added in topological order, newest first
	revisions = list(reversed(revisions))			revisions = list(reversed(revisions))
	pack = self.createPack(revisions)			pack = self.createPack(revisions)

	# Test that the chain has all the entries			# Test that the chain has all the entries
	ancestors = pack.getancestors(revisions[0][0], revisions[0][1])			ancestors = pack.getancestors(revisions[0][0], revisions[0][1])
	# Build a random pack file			# Build a random pack file
	allentries = {}			allentries = {}
	ancestorcounts = {}			ancestorcounts = {}
	revisions = []			revisions = []
	random.seed(0)			random.seed(0)
	for i in range(100):			for i in range(100):
	filename = b"filename-%d" % i			filename = b"filename-%d" % i
	entries = []			entries = []
	p2 = nullid			p2 = sha1nodeconstants.nullid
	linknode = nullid			linknode = sha1nodeconstants.nullid
	for j in range(random.randint(1, 100)):			for j in range(random.randint(1, 100)):
	node = self.getFakeHash()			node = self.getFakeHash()
	p1 = nullid			p1 = sha1nodeconstants.nullid
	if len(entries) > 0:			if len(entries) > 0:
	p1 = entries[random.randint(0, len(entries) - 1)]			p1 = entries[random.randint(0, len(entries) - 1)]
	entries.append(node)			entries.append(node)
	revisions.append((filename, node, p1, p2, linknode, None))			revisions.append((filename, node, p1, p2, linknode, None))
	allentries[(filename, node)] = (p1, p2, linknode)			allentries[(filename, node)] = (p1, p2, linknode)
	if p1 == nullid:			if p1 == sha1nodeconstants.nullid:
	ancestorcounts[(filename, node)] = 1			ancestorcounts[(filename, node)] = 1
	else:			else:
	newcount = ancestorcounts[(filename, p1)] + 1			newcount = ancestorcounts[(filename, p1)] + 1
	ancestorcounts[(filename, node)] = newcount			ancestorcounts[(filename, node)] = newcount

	# Must add file entries in reverse topological order			# Must add file entries in reverse topological order
	revisions = list(reversed(revisions))			revisions = list(reversed(revisions))
	pack = self.createPack(revisions)			pack = self.createPack(revisions)

	# Verify the pack contents			# Verify the pack contents
	for (filename, node) in allentries:			for (filename, node) in allentries:
	ancestors = pack.getancestors(filename, node)			ancestors = pack.getancestors(filename, node)
	self.assertEqual(ancestorcounts[(filename, node)], len(ancestors))			self.assertEqual(ancestorcounts[(filename, node)], len(ancestors))
	for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items():			for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items():
	ep1, ep2, elinknode = allentries[(filename, anode)]			ep1, ep2, elinknode = allentries[(filename, anode)]
	self.assertEqual(ap1, ep1)			self.assertEqual(ap1, ep1)
	self.assertEqual(ap2, ep2)			self.assertEqual(ap2, ep2)
	self.assertEqual(alinknode, elinknode)			self.assertEqual(alinknode, elinknode)
	self.assertEqual(copyfrom, None)			self.assertEqual(copyfrom, None)

	def testGetNodeInfo(self):			def testGetNodeInfo(self):
	revisions = []			revisions = []
	filename = b"foo"			filename = b"foo"
	lastnode = nullid			lastnode = sha1nodeconstants.nullid
	for i in range(10):			for i in range(10):
	node = self.getFakeHash()			node = self.getFakeHash()
	revisions.append((filename, node, lastnode, nullid, nullid, None))			revisions.append(
				(
				filename,
				node,
				lastnode,
				sha1nodeconstants.nullid,
				sha1nodeconstants.nullid,
				None,
				)
				)
	lastnode = node			lastnode = node

	pack = self.createPack(revisions)			pack = self.createPack(revisions)

	# Test that getnodeinfo returns the expected results			# Test that getnodeinfo returns the expected results
	for filename, node, p1, p2, linknode, copyfrom in revisions:			for filename, node, p1, p2, linknode, copyfrom in revisions:
	ap1, ap2, alinknode, acopyfrom = pack.getnodeinfo(filename, node)			ap1, ap2, alinknode, acopyfrom = pack.getnodeinfo(filename, node)
	self.assertEqual(ap1, p1)			self.assertEqual(ap1, p1)
	# Test getmissing on a non-existant filename			# Test getmissing on a non-existant filename
	missing = pack.getmissing([(b"bar", fakenode)])			missing = pack.getmissing([(b"bar", fakenode)])
	self.assertEqual(missing, [(b"bar", fakenode)])			self.assertEqual(missing, [(b"bar", fakenode)])

	def testAddThrows(self):			def testAddThrows(self):
	pack = self.createPack()			pack = self.createPack()

	try:			try:
	pack.add(b'filename', nullid, nullid, nullid, nullid, None)			pack.add(
				b'filename',
				sha1nodeconstants.nullid,
				sha1nodeconstants.nullid,
				sha1nodeconstants.nullid,
				sha1nodeconstants.nullid,
				None,
				)
	self.assertTrue(False, "historypack.add should throw")			self.assertTrue(False, "historypack.add should throw")
	except RuntimeError:			except RuntimeError:
	pass			pass

	def testBadVersionThrows(self):			def testBadVersionThrows(self):
	pack = self.createPack()			pack = self.createPack()
	path = pack.path + b'.histpack'			path = pack.path + b'.histpack'
	with open(path, 'rb') as f:			with open(path, 'rb') as f:

tests/test-revlog-raw.py

	# test revlog interaction about raw data (flagprocessor)			# test revlog interaction about raw data (flagprocessor)

	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	import collections			import collections
	import hashlib			import hashlib
	import sys			import sys

	from mercurial.node import nullid
	from mercurial import (			from mercurial import (
	encoding,			encoding,
	revlog,			revlog,
	transaction,			transaction,
	vfs,			vfs,
	)			)

	from mercurial.revlogutils import (			from mercurial.revlogutils import (

	def appendrev(rlog, text, tr, isext=False, isdelta=True):			def appendrev(rlog, text, tr, isext=False, isdelta=True):
	"""Append a revision. If isext is True, set the EXTSTORED flag so flag			"""Append a revision. If isext is True, set the EXTSTORED flag so flag
	processor will be used (and rawtext is different from text). If isdelta is			processor will be used (and rawtext is different from text). If isdelta is
	True, force the revision to be a delta, otherwise it's full text.			True, force the revision to be a delta, otherwise it's full text.
	"""			"""
	nextrev = len(rlog)			nextrev = len(rlog)
	p1 = rlog.node(nextrev - 1)			p1 = rlog.node(nextrev - 1)
	p2 = nullid			p2 = rlog.nullid
	if isext:			if isext:
	flags = revlog.REVIDX_EXTSTORED			flags = revlog.REVIDX_EXTSTORED
	else:			else:
	flags = revlog.REVIDX_DEFAULT_FLAGS			flags = revlog.REVIDX_DEFAULT_FLAGS
	# Change storedeltachains temporarily, to override revlog's delta decision			# Change storedeltachains temporarily, to override revlog's delta decision
	rlog._storedeltachains = isdelta			rlog._storedeltachains = isdelta
	try:			try:
	rlog.addrevision(text, tr, nextrev, p1, p2, flags=flags)			rlog.addrevision(text, tr, nextrev, p1, p2, flags=flags)

	This exercises some revlog.addgroup (and revlog._addrevision(text=None))			This exercises some revlog.addgroup (and revlog._addrevision(text=None))
	code path, which is not covered by "appendrev" alone.			code path, which is not covered by "appendrev" alone.
	"""			"""

	class dummychangegroup(object):			class dummychangegroup(object):
	@staticmethod			@staticmethod
	def deltachunk(pnode):			def deltachunk(pnode):
	pnode = pnode or nullid			pnode = pnode or rlog.nullid
	parentrev = rlog.rev(pnode)			parentrev = rlog.rev(pnode)
	r = parentrev + 1			r = parentrev + 1
	if r >= len(rlog):			if r >= len(rlog):
	return {}			return {}
	if optimaldelta:			if optimaldelta:
	deltaparent = parentrev			deltaparent = parentrev
	else:			else:
	# suboptimal deltaparent			# suboptimal deltaparent
	deltaparent = min(0, parentrev)			deltaparent = min(0, parentrev)
	if not rlog.candelta(deltaparent, r):			if not rlog.candelta(deltaparent, r):
	deltaparent = -1			deltaparent = -1
	return {			return {
	b'node': rlog.node(r),			b'node': rlog.node(r),
	b'p1': pnode,			b'p1': pnode,
	b'p2': nullid,			b'p2': rlog.nullid,
	b'cs': rlog.node(rlog.linkrev(r)),			b'cs': rlog.node(rlog.linkrev(r)),
	b'flags': rlog.flags(r),			b'flags': rlog.flags(r),
	b'deltabase': rlog.node(deltaparent),			b'deltabase': rlog.node(deltaparent),
	b'delta': rlog.revdiff(deltaparent, r),			b'delta': rlog.revdiff(deltaparent, r),
	b'sidedata': rlog.sidedata(r),			b'sidedata': rlog.sidedata(r),
	}			}

	def deltaiter(self):			def deltaiter(self):
	def lowlevelcopy(rlog, tr, destname=b'_destrevlog.i'):			def lowlevelcopy(rlog, tr, destname=b'_destrevlog.i'):
	"""Like addgroupcopy, but use the low level revlog._addrevision directly.			"""Like addgroupcopy, but use the low level revlog._addrevision directly.

	It exercises some code paths that are hard to reach easily otherwise.			It exercises some code paths that are hard to reach easily otherwise.
	"""			"""
	dlog = newrevlog(destname, recreate=True)			dlog = newrevlog(destname, recreate=True)
	for r in rlog:			for r in rlog:
	p1 = rlog.node(r - 1)			p1 = rlog.node(r - 1)
	p2 = nullid			p2 = rlog.nullid
	if r == 0 or (rlog.flags(r) & revlog.REVIDX_EXTSTORED):			if r == 0 or (rlog.flags(r) & revlog.REVIDX_EXTSTORED):
	text = rlog.rawdata(r)			text = rlog.rawdata(r)
	cachedelta = None			cachedelta = None
	else:			else:
	# deltaparent cannot have EXTSTORED flag.			# deltaparent cannot have EXTSTORED flag.
	deltaparent = max(			deltaparent = max(
	[-1]			[-1]
	+ [			+ [

tests/testlib/ext-sidedata.py

	# ext-sidedata.py - small extension to test the sidedata logic			# ext-sidedata.py - small extension to test the sidedata logic
	#			#
	# Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net>			# Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	import hashlib			import hashlib
	import struct			import struct

	from mercurial.node import (			from mercurial.node import nullrev
	nullid,
	nullrev,
	)
	from mercurial import (			from mercurial import (
	extensions,			extensions,
	requirements,			requirements,
	revlog,			revlog,
	)			)

	from mercurial.upgrade_utils import engine as upgrade_engine			from mercurial.upgrade_utils import engine as upgrade_engine



	def wrap_revisiondata(orig, self, nodeorrev, args, *kwargs):			def wrap_revisiondata(orig, self, nodeorrev, args, *kwargs):
	text, sd = orig(self, nodeorrev, args, *kwargs)			text, sd = orig(self, nodeorrev, args, *kwargs)
	if getattr(self, 'sidedatanocheck', False):			if getattr(self, 'sidedatanocheck', False):
	return text, sd			return text, sd
	if self.version & 0xFFFF != 2:			if self.version & 0xFFFF != 2:
	return text, sd			return text, sd
	if nodeorrev != nullrev and nodeorrev != nullid:			if nodeorrev != nullrev and nodeorrev != self.nullid:
	cat1 = sd.get(sidedata.SD_TEST1)			cat1 = sd.get(sidedata.SD_TEST1)
	if cat1 is not None and len(text) != struct.unpack('>I', cat1)[0]:			if cat1 is not None and len(text) != struct.unpack('>I', cat1)[0]:
	raise RuntimeError('text size mismatch')			raise RuntimeError('text size mismatch')
	expected = sd.get(sidedata.SD_TEST2)			expected = sd.get(sidedata.SD_TEST2)
	got = hashlib.sha256(text).digest()			got = hashlib.sha256(text).digest()
	if expected is not None and got != expected:			if expected is not None and got != expected:
	raise RuntimeError('sha256 mismatch')			raise RuntimeError('sha256 mismatch')
	return text, sd			return text, sd

			Path	Packages
M			hgext/absorb.py (5 lines)
M			hgext/convert/git.py (14 lines)
M			hgext/convert/hg.py (15 lines)
M			hgext/git/dirstate.py (14 lines)
M			hgext/git/gitlog.py (36 lines)
M			hgext/git/gitutil.py (4 lines)
M			hgext/git/index.py (11 lines)
M			hgext/gpg.py (5 lines)
M			hgext/hgk.py (7 lines)
M			hgext/journal.py (7 lines)
M			hgext/largefiles/basestore.py (5 lines)
M			hgext/largefiles/lfcommands.py (7 lines)
M			hgext/largefiles/lfutil.py (7 lines)
M			hgext/lfs/wrapper.py (4 lines)
M			hgext/mq.py (9 lines)
M			hgext/narrow/narrowbundle2.py (5 lines)
M			hgext/narrow/narrowcommands.py (7 lines)
M			hgext/phabricator.py (6 lines)
M			hgext/remotefilelog/contentstore.py (35 lines)
M			hgext/remotefilelog/datapack.py (7 lines)
M			hgext/remotefilelog/debugcommands.py (16 lines)
M			hgext/remotefilelog/fileserverclient.py (10 lines)
M			hgext/remotefilelog/historypack.py (13 lines)
M			hgext/remotefilelog/metadatastore.py (9 lines)
M			hgext/remotefilelog/remotefilectx.py (22 lines)
M			hgext/remotefilelog/remotefilelog.py (48 lines)
M			hgext/remotefilelog/remotefilelogserver.py (14 lines)
M			hgext/remotefilelog/repack.py (27 lines)
M			hgext/remotefilelog/shallowbundle.py (10 lines)
M			hgext/remotefilelog/shallowrepo.py (6 lines)
M			hgext/sqlitestore.py (49 lines)
M			hgext/transplant.py (10 lines)
M			hgext/uncommit.py (3 lines)
M			mercurial/bookmarks.py (5 lines)
M			mercurial/branchmap.py (10 lines)
M			mercurial/bundle2.py (3 lines)
M			mercurial/bundlerepo.py (5 lines)
M			mercurial/changegroup.py (3 lines)
M			mercurial/changelog.py (3 lines)
M			mercurial/cmdutil.py (13 lines)
M			mercurial/commands.py (26 lines)
M			mercurial/commit.py (42 lines)
M			mercurial/context.py (58 lines)
M			mercurial/copies.py (7 lines)
M			mercurial/debugcommands.py (13 lines)
M			mercurial/dirstate.py (31 lines)
M			mercurial/discovery.py (7 lines)
M			mercurial/exchange.py (9 lines)
M			mercurial/exchangev2.py (15 lines)
M			mercurial/filelog.py (7 lines)
M			mercurial/filemerge.py (3 lines)
M			mercurial/hg.py (15 lines)
M			mercurial/hgweb/webutil.py (12 lines)
M			mercurial/interfaces/dirstate.py (4 lines)
M			mercurial/localrepo.py (25 lines)
M			mercurial/logcmdutil.py (17 lines)
M			mercurial/manifest.py (11 lines)
M			mercurial/merge.py (21 lines)
M			mercurial/mergestate.py (12 lines)
M			mercurial/metadata.py (7 lines)
M			mercurial/obsolete.py (13 lines)
M			mercurial/patch.py (6 lines)
M			mercurial/phases.py (7 lines)
M			mercurial/pure/parsers.py (11 lines)
M			mercurial/revlog.py (59 lines)
M			mercurial/scmutil.py (8 lines)
M			mercurial/setdiscovery.py (19 lines)
M			mercurial/shelve.py (7 lines)
M			mercurial/sparse.py (9 lines)
M			mercurial/strip.py (5 lines)
M			mercurial/subrepo.py (3 lines)
M			mercurial/tagmerge.py (7 lines)
M			mercurial/tags.py (25 lines)
M			mercurial/templatefuncs.py (7 lines)
M			mercurial/templatekw.py (9 lines)
M			mercurial/testing/storage.py (259 lines)
M			mercurial/treediscovery.py (19 lines)
M			mercurial/util.py (1 line)
M			mercurial/utils/storageutil.py (8 lines)
M			mercurial/verify.py (17 lines)
M			mercurial/wireprotov1server.py (7 lines)
M			mercurial/wireprotov2server.py (7 lines)
M			tests/drawdag.py (5 lines)
M			tests/simplestorerepo.py (29 lines)
M			tests/test-annotate.t (8 lines)
M			tests/test-commit.t (12 lines)
M			tests/test-fastannotate-hg.t (8 lines)
M			tests/test-filelog.py (9 lines)
M			tests/test-parseindex2.py (8 lines)
M			tests/test-remotefilelog-datapack.py (40 lines)
M			tests/test-remotefilelog-histpack.py (49 lines)
M			tests/test-revlog-raw.py (9 lines)
M			tests/testlib/ext-sidedata.py (7 lines)

This is an archive of the discontinued Mercurial Phabricator instance.

node: replace nullid and friends with nodeconstants classClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 27171

hgext/absorb.py

hgext/convert/git.py

hgext/convert/hg.py

hgext/git/dirstate.py

hgext/git/gitlog.py

hgext/git/gitutil.py

hgext/git/index.py

hgext/gpg.py

hgext/hgk.py

hgext/journal.py

hgext/largefiles/basestore.py

hgext/largefiles/lfcommands.py

hgext/largefiles/lfutil.py

hgext/lfs/wrapper.py

hgext/mq.py

hgext/narrow/narrowbundle2.py

hgext/narrow/narrowcommands.py

hgext/phabricator.py

hgext/remotefilelog/contentstore.py

hgext/remotefilelog/datapack.py

hgext/remotefilelog/debugcommands.py

hgext/remotefilelog/fileserverclient.py

hgext/remotefilelog/historypack.py

hgext/remotefilelog/metadatastore.py

hgext/remotefilelog/remotefilectx.py

hgext/remotefilelog/remotefilelog.py

hgext/remotefilelog/remotefilelogserver.py

hgext/remotefilelog/repack.py

hgext/remotefilelog/shallowbundle.py

hgext/remotefilelog/shallowrepo.py

hgext/sqlitestore.py

hgext/transplant.py

hgext/uncommit.py

mercurial/bookmarks.py

mercurial/branchmap.py

mercurial/bundle2.py

mercurial/bundlerepo.py

mercurial/changegroup.py

mercurial/changelog.py

mercurial/cmdutil.py

mercurial/commands.py

mercurial/commit.py

mercurial/context.py

mercurial/copies.py

mercurial/debugcommands.py

mercurial/dirstate.py

mercurial/discovery.py

mercurial/exchange.py

mercurial/exchangev2.py

mercurial/filelog.py

mercurial/filemerge.py

mercurial/hg.py

mercurial/hgweb/webutil.py

mercurial/interfaces/dirstate.py

mercurial/localrepo.py

mercurial/logcmdutil.py

mercurial/manifest.py

mercurial/merge.py

mercurial/mergestate.py

mercurial/metadata.py

mercurial/obsolete.py

mercurial/patch.py

mercurial/phases.py

mercurial/pure/parsers.py

mercurial/revlog.py

mercurial/scmutil.py

mercurial/setdiscovery.py

mercurial/shelve.py

mercurial/sparse.py

mercurial/strip.py

mercurial/subrepo.py

mercurial/tagmerge.py

mercurial/tags.py

node: replace nullid and friends with nodeconstants class
ClosedPublic

Revision Contents
Changeset List