This is an archive of the discontinued Mercurial Phabricator instance.

In D7256#107172, @yuja wrote:

+ cl.class = type('filteredchangelog',
+ (filteredchangelogmixin, cl.class),
+ {})

Nit: maybe this can be just class filteredchangelog(...): pass since
we don't name the type dynamically.

Done in https://www.mercurial-scm.org/repo/hg/rev/85628a595c37.

And we might need a class cache like _filteredrepotypes to work around
leaks of dynamically-created types.

It seems like there's some caching in _clcache already. Maybe that's enough?

> And we might need a class cache like _filteredrepotypes to work around
> leaks of dynamically-created types.
It seems like there's some caching in `_clcache` already. Maybe that's enough?

Maybe not because clcache won't live longer than the repo instance, but
I have no idea if that actually impact the leak seen in hgweb.

Revision Contents
Changeset List

			Path	Packages
M			mercurial/repoview.py (173 lines)

Diff 17707

mercurial/repoview.py

	repo.filteredrevcache[filtername] = func(repo.unfiltered())			repo.filteredrevcache[filtername] = func(repo.unfiltered())
	return repo.filteredrevcache[filtername]			return repo.filteredrevcache[filtername]


	def wrapchangelog(unfichangelog, filteredrevs):			def wrapchangelog(unfichangelog, filteredrevs):
	cl = copy.copy(unfichangelog)			cl = copy.copy(unfichangelog)
	cl.filteredrevs = filteredrevs			cl.filteredrevs = filteredrevs

	class filteredchangelog(cl.__class__):			cl.__class__ = type('filteredchangelog',
				(filteredchangelogmixin, cl.__class__),
				{})

				return cl


				class filteredchangelogmixin(object):
	def tiprev(self):			def tiprev(self):
	"""filtered version of revlog.tiprev"""			"""filtered version of revlog.tiprev"""
	for i in pycompat.xrange(len(self) - 1, -2, -1):			for i in pycompat.xrange(len(self) - 1, -2, -1):
	if i not in self.filteredrevs:			if i not in self.filteredrevs:
	return i			return i

	def __contains__(self, rev):			def __contains__(self, rev):
	"""filtered version of revlog.__contains__"""			"""filtered version of revlog.__contains__"""
	return 0 <= rev < len(self) and rev not in self.filteredrevs			return 0 <= rev < len(self) and rev not in self.filteredrevs

	def __iter__(self):			def __iter__(self):
	"""filtered version of revlog.__iter__"""			"""filtered version of revlog.__iter__"""

	def filterediter():			def filterediter():
	for i in pycompat.xrange(len(self)):			for i in pycompat.xrange(len(self)):
	if i not in self.filteredrevs:			if i not in self.filteredrevs:
	yield i			yield i

	return filterediter()			return filterediter()

	def revs(self, start=0, stop=None):			def revs(self, start=0, stop=None):
	"""filtered version of revlog.revs"""			"""filtered version of revlog.revs"""
	for i in super(filteredchangelog, self).revs(start, stop):			for i in super(filteredchangelogmixin, self).revs(start, stop):
	if i not in self.filteredrevs:			if i not in self.filteredrevs:
	yield i			yield i

	def _checknofilteredinrevs(self, revs):			def _checknofilteredinrevs(self, revs):
	"""raise the appropriate error if 'revs' contains a filtered revision			"""raise the appropriate error if 'revs' contains a filtered revision

	This returns a version of 'revs' to be used thereafter by the caller.			This returns a version of 'revs' to be used thereafter by the caller.
	In particular, if revs is an iterator, it is converted into a set.			In particular, if revs is an iterator, it is converted into a set.
	"""			"""
	safehasattr = util.safehasattr			safehasattr = util.safehasattr
	if safehasattr(revs, '__next__'):			if safehasattr(revs, '__next__'):
	# Note that inspect.isgenerator() is not true for iterators,			# Note that inspect.isgenerator() is not true for iterators,
	revs = set(revs)			revs = set(revs)

	filteredrevs = self.filteredrevs			filteredrevs = self.filteredrevs
	if safehasattr(revs, 'first'): # smartset			if safehasattr(revs, 'first'): # smartset
	offenders = revs & filteredrevs			offenders = revs & filteredrevs
	else:			else:
	offenders = filteredrevs.intersection(revs)			offenders = filteredrevs.intersection(revs)

	for rev in offenders:			for rev in offenders:
	raise error.FilteredIndexError(rev)			raise error.FilteredIndexError(rev)
	return revs			return revs

	def headrevs(self, revs=None):			def headrevs(self, revs=None):
	if revs is None:			if revs is None:
	try:			try:
	return self.index.headrevsfiltered(self.filteredrevs)			return self.index.headrevsfiltered(self.filteredrevs)
	# AttributeError covers non-c-extension environments and			# AttributeError covers non-c-extension environments and
	# old c extensions without filter handling.			# old c extensions without filter handling.
	except AttributeError:			except AttributeError:
	return self._headrevs()			return self._headrevs()

	revs = self._checknofilteredinrevs(revs)			revs = self._checknofilteredinrevs(revs)
	return super(filteredchangelog, self).headrevs(revs)			return super(filteredchangelogmixin, self).headrevs(revs)

	def strip(self, args, *kwargs):			def strip(self, args, *kwargs):
	# XXX make something better than assert			# XXX make something better than assert
	# We can't expect proper strip behavior if we are filtered.			# We can't expect proper strip behavior if we are filtered.
	assert not self.filteredrevs			assert not self.filteredrevs
	super(filteredchangelog, self).strip(args, *kwargs)			super(filteredchangelogmixin, self).strip(args, *kwargs)

	def rev(self, node):			def rev(self, node):
	"""filtered version of revlog.rev"""			"""filtered version of revlog.rev"""
	r = super(filteredchangelog, self).rev(node)			r = super(filteredchangelogmixin, self).rev(node)
	if r in self.filteredrevs:			if r in self.filteredrevs:
	raise error.FilteredLookupError(			raise error.FilteredLookupError(
	hex(node), self.indexfile, _(b'filtered node')			hex(node), self.indexfile, _(b'filtered node')
	)			)
	return r			return r

	def node(self, rev):			def node(self, rev):
	"""filtered version of revlog.node"""			"""filtered version of revlog.node"""
	if rev in self.filteredrevs:			if rev in self.filteredrevs:
	raise error.FilteredIndexError(rev)			raise error.FilteredIndexError(rev)
	return super(filteredchangelog, self).node(rev)			return super(filteredchangelogmixin, self).node(rev)

	def linkrev(self, rev):			def linkrev(self, rev):
	"""filtered version of revlog.linkrev"""			"""filtered version of revlog.linkrev"""
	if rev in self.filteredrevs:			if rev in self.filteredrevs:
	raise error.FilteredIndexError(rev)			raise error.FilteredIndexError(rev)
	return super(filteredchangelog, self).linkrev(rev)			return super(filteredchangelogmixin, self).linkrev(rev)

	def parentrevs(self, rev):			def parentrevs(self, rev):
	"""filtered version of revlog.parentrevs"""			"""filtered version of revlog.parentrevs"""
	if rev in self.filteredrevs:			if rev in self.filteredrevs:
	raise error.FilteredIndexError(rev)			raise error.FilteredIndexError(rev)
	return super(filteredchangelog, self).parentrevs(rev)			return super(filteredchangelogmixin, self).parentrevs(rev)

	def flags(self, rev):			def flags(self, rev):
	"""filtered version of revlog.flags"""			"""filtered version of revlog.flags"""
	if rev in self.filteredrevs:			if rev in self.filteredrevs:
	raise error.FilteredIndexError(rev)			raise error.FilteredIndexError(rev)
	return super(filteredchangelog, self).flags(rev)			return super(filteredchangelogmixin, self).flags(rev)

	cl.__class__ = filteredchangelog

	return cl


	class repoview(object):			class repoview(object):
	"""Provide a read/write view of a repo through a filtered changelog			"""Provide a read/write view of a repo through a filtered changelog

	This object is used to access a filtered version of a repository without			This object is used to access a filtered version of a repository without
	altering the original repository object itself. We can not alter the			altering the original repository object itself. We can not alter the
	original object for two main reasons:			original object for two main reasons:

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	17624		Nov 6 2019, 11:27 AM	★	★
Diff 2	17707	rHGf0662e7c935a7cfb0254536d225bc2527a9b82e9	Nov 6 2019, 3:35 AM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

repoview: define filteredchangelog as a top-level (non-local) classClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 17707

mercurial/repoview.py

repoview: define filteredchangelog as a top-level (non-local) class
ClosedPublic

Revision Contents
Changeset List