This is an archive of the discontinued Mercurial Phabricator instance.

flagutil: introduce a flagprocessorsmixin class
ClosedPublic

Authored by marmoute on Sep 7 2019, 5:26 AM.

Download Raw Diff

Details

Reviewers

yuja
durin42
indygreg

Group Reviewers

hg-reviewers

Commits

rHG5bb68fb72df2: flagutil: introduce a flagprocessorsmixin class

Summary

To avoid code duplication, we will provide a simple "ready to use" mixin that
carry the appropriate logic. First we use it in standard revlog, we'll remove
code duplication in later changesets.

Diff Detail

Repository

rHG Mercurial

Lint

Lint Skipped

Unit

Unit Tests Skipped

Event Timeline

marmoute created this revision.Sep 7 2019, 5:26 AM

Herald added a reviewer: indygreg. · View Herald TranscriptSep 7 2019, 5:26 AM

Herald added a reviewer: hg-reviewers. · View Herald Transcript

Herald added a subscriber: mercurial-devel. · View Herald Transcript

marmoute added a child revision: D6797: flagutil: use the new mixin use in remotefilelog.Sep 7 2019, 5:26 AM

I'm going to attempt to look at this series...

indygreg accepted this revision.Sep 7 2019, 12:55 PM

This revision is now accepted and ready to land.Sep 7 2019, 12:55 PM

marmoute added a commit: rHG5bb68fb72df2: flagutil: introduce a flagprocessorsmixin class.Sep 7 2019, 12:59 PM

Closed by commit rHG5bb68fb72df2: flagutil: introduce a flagprocessorsmixin class (authored by marmoute). · Explain Why

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

			Path	Packages
M			mercurial/revlog.py (65 lines)
M			mercurial/revlogutils/flagutil.py (71 lines)

Commit	Parents	Author	Summary	Date
df7967f1b6a5	c085cb134b9e	Pierre-Yves David		Aug 7 2019, 7:12 PM

Status	Author	Revision
Closed	marmoute	D6823 flagprocessors: remove flagprocessorsmixin
Closed	marmoute	D6822 flagprocessors: move _flagserrorclass attribute on revlog & co
Closed	marmoute	D6821 flagprocessors: directly duplicate the deprecated layer back into revlog
Closed	marmoute	D6820 flagprocessors: make `processflagsraw` a module level function
Closed	marmoute	D6819 flagprocessors: make `processflagsread` a module level function
Closed	marmoute	D6818 flagprocessors: make `processflagswrite` a module level function
Closed	marmoute	D6817 flagprocessors: make `_processflagsfunc` a module level function
Closed	marmoute	D6816 flagprocessors: writetransform function take side data as parameter (API)
Closed	marmoute	D6815 flagprocessors: add a `sidedata` parameters to _processflagswrite
Closed	marmoute	D6814 revlog: add a `sidedata` parameters to addrevision
Closed	marmoute	D6813 flagprocessors: have the read transform function return side data (API)
Closed	marmoute	D6812 flagprocessors: return flagdata in the main processing function
Closed	marmoute	D6811 flagprocessors: return sidedata map in `_processflagsread`
Closed	marmoute	D6810 revlog: use the new sidedata map return in the sidedata method
Closed	marmoute	D6809 revlog: return sidedata map from `_revisiondata`
Closed	marmoute	D6808 revlog: introduce a `sidedata` method
Closed	marmoute	D6807 flagprocessors: small code update to clarify parameters
Closed	marmoute	D6806 flagprocessors: _processflags
Closed	marmoute	D6805 simplestorerepo: stop using `_processflags` directly
Closed	marmoute	D6804 revlog: stop using `_processflags` directly
Closed	marmoute	D6803 flagprocessors: use _processflagsraw in easy cases
Closed	marmoute	D6802 flagprocessors: use _processflagsread in simple cases
Closed	marmoute	D6801 flagprocessors: use _processflagswrite for write operation
Closed	marmoute	D6800 flagprocessors: introduce specialized functions
Closed	marmoute	D6799 flagutil: use it in simplestorerepo
Closed	marmoute	D6798 flagutil: make the error class used by the mixin configurable
Closed	marmoute	D6797 flagutil: use the new mixin use in remotefilelog
Closed	marmoute	D6796 flagutil: introduce a flagprocessorsmixin class

Diff 16401

mercurial/revlog.py

	return index, getattr(index, 'nodemap', None), cache			return index, getattr(index, 'nodemap', None), cache

	def packentry(self, entry, node, version, rev):			def packentry(self, entry, node, version, rev):
	p = indexformatng_pack(*entry)			p = indexformatng_pack(*entry)
	if rev == 0:			if rev == 0:
	p = versionformat_pack(version) + p[4:]			p = versionformat_pack(version) + p[4:]
	return p			return p

	class revlog(object):			class revlog(flagutil.flagprocessorsmixin):
	"""			"""
	the underlying revision storage object			the underlying revision storage object

	A revlog consists of two parts, an index and the revision data.			A revlog consists of two parts, an index and the revision data.

	The index is a file with a fixed record size containing			The index is a file with a fixed record size containing
	information on each revision, including its nodeid (hash), the			information on each revision, including its nodeid (hash), the
	nodeids of its parents, the position and offset of its data within			nodeids of its parents, the position and offset of its data within
	def hash(self, text, p1, p2):			def hash(self, text, p1, p2):
	"""Compute a node hash.			"""Compute a node hash.

	Available as a function so that subclasses can replace the hash			Available as a function so that subclasses can replace the hash
	as needed.			as needed.
	"""			"""
	return storageutil.hashrevisionsha1(text, p1, p2)			return storageutil.hashrevisionsha1(text, p1, p2)

	def _processflags(self, text, flags, operation, raw=False):
	"""Inspect revision data flags and applies transforms defined by
	registered flag processors.

	``text`` - the revision data to process
	``flags`` - the revision flags
	``operation`` - the operation being performed (read or write)
	``raw`` - an optional argument describing if the raw transform should be
	applied.

	This method processes the flags in the order (or reverse order if
	``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
	flag processors registered for present flags. The order of flags defined
	in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.

	Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
	processed text and ``validatehash`` is a bool indicating whether the
	returned text should be checked for hash integrity.

	Note: If the ``raw`` argument is set, it has precedence over the
	operation and will only update the value of ``validatehash``.
	"""
	# fast path: no flag processors will run
	if flags == 0:
	return text, True
	if not operation in ('read', 'write'):
	raise error.ProgrammingError(_("invalid '%s' operation") %
	operation)
	# Check all flags are known.
	if flags & ~flagutil.REVIDX_KNOWN_FLAGS:
	raise error.RevlogError(_("incompatible revision flag '%#x'") %
	(flags & ~flagutil.REVIDX_KNOWN_FLAGS))
	validatehash = True
	# Depending on the operation (read or write), the order might be
	# reversed due to non-commutative transforms.
	orderedflags = REVIDX_FLAGS_ORDER
	if operation == 'write':
	orderedflags = reversed(orderedflags)

	for flag in orderedflags:
	# If a flagprocessor has been registered for a known flag, apply the
	# related operation transform and update result tuple.
	if flag & flags:
	vhash = True

	if flag not in self._flagprocessors:
	message = _("missing processor for flag '%#x'") % (flag)
	raise error.RevlogError(message)

	processor = self._flagprocessors[flag]
	if processor is not None:
	readtransform, writetransform, rawtransform = processor

	if raw:
	vhash = rawtransform(self, text)
	elif operation == 'read':
	text, vhash = readtransform(self, text)
	else: # write operation
	text, vhash = writetransform(self, text)
	validatehash = validatehash and vhash

	return text, validatehash

	def checkhash(self, text, node, p1=None, p2=None, rev=None):			def checkhash(self, text, node, p1=None, p2=None, rev=None):
	"""Check node hash integrity.			"""Check node hash integrity.

	Available as a function so that subclasses can extend hash mismatch			Available as a function so that subclasses can extend hash mismatch
	behaviors as needed.			behaviors as needed.
	"""			"""
	try:			try:
	if p1 is None and p2 is None:			if p1 is None and p2 is None:

mercurial/revlogutils/flagutil.py

	raise error.ProgrammingError(msg)			raise error.ProgrammingError(msg)
	if flag not in REVIDX_FLAGS_ORDER:			if flag not in REVIDX_FLAGS_ORDER:
	msg = _("flag '%#x' undefined in REVIDX_FLAGS_ORDER.") % (flag)			msg = _("flag '%#x' undefined in REVIDX_FLAGS_ORDER.") % (flag)
	raise error.ProgrammingError(msg)			raise error.ProgrammingError(msg)
	if flag in flagprocessors:			if flag in flagprocessors:
	msg = _("cannot register multiple processors on flag '%#x'.") % (flag)			msg = _("cannot register multiple processors on flag '%#x'.") % (flag)
	raise error.Abort(msg)			raise error.Abort(msg)
	flagprocessors[flag] = processor			flagprocessors[flag] = processor

				class flagprocessorsmixin(object):
				"""basic mixin to support revlog flag processing

				Make sure the `_flagprocessors` attribute is set at ``__init__`` time.

				See the documentation of the ``_processflags`` method for details.
				"""

				def _processflags(self, text, flags, operation, raw=False):
				"""Inspect revision data flags and applies transforms defined by
				registered flag processors.

				``text`` - the revision data to process
				``flags`` - the revision flags
				``operation`` - the operation being performed (read or write)
				``raw`` - an optional argument describing if the raw transform should be
				applied.

				This method processes the flags in the order (or reverse order if
				``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
				flag processors registered for present flags. The order of flags defined
				in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.

				Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
				processed text and ``validatehash`` is a bool indicating whether the
				returned text should be checked for hash integrity.

				Note: If the ``raw`` argument is set, it has precedence over the
				operation and will only update the value of ``validatehash``.
				"""
				# fast path: no flag processors will run
				if flags == 0:
				return text, True
				if not operation in ('read', 'write'):
				raise error.ProgrammingError(_("invalid '%s' operation") %
				operation)
				# Check all flags are known.
				if flags & ~REVIDX_KNOWN_FLAGS:
				raise error.RevlogError(_("incompatible revision flag '%#x'") %
				(flags & ~REVIDX_KNOWN_FLAGS))
				validatehash = True
				# Depending on the operation (read or write), the order might be
				# reversed due to non-commutative transforms.
				orderedflags = REVIDX_FLAGS_ORDER
				if operation == 'write':
				orderedflags = reversed(orderedflags)

				for flag in orderedflags:
				# If a flagprocessor has been registered for a known flag, apply the
				# related operation transform and update result tuple.
				if flag & flags:
				vhash = True

				if flag not in self._flagprocessors:
				message = _("missing processor for flag '%#x'") % (flag)
				raise error.RevlogError(message)

				processor = self._flagprocessors[flag]
				if processor is not None:
				readtransform, writetransform, rawtransform = processor

				if raw:
				vhash = rawtransform(self, text)
				elif operation == 'read':
				text, vhash = readtransform(self, text)
				else: # write operation
				text, vhash = writetransform(self, text)
				validatehash = validatehash and vhash

				return text, validatehash

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	16401		Sep 7 2019, 5:26 AM	★	★
Diff 2	16434	rHG5bb68fb72df26c01ce94eab5b110651bebd47a70	Aug 7 2019, 7:12 PM	★	★