This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6812

flagprocessors: return flagdata in the main processing function
ClosedPublic

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

Details

Reviewers
yuja
durin42
Group Reviewers
hg-reviewers
Commits
rHG66dc5a522f37: flagprocessors: return flagdata in the main processing function
Summary

This function input and return are becoming stranger and stranger bnut I don't
have a good plan to make is saner without problematic code duplication, so it
will be this way to now.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/revlogutils/flagutil.py (10 lines)

Diff 16478

mercurial/revlogutils/flagutil.py

``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
flag processors registered for present flags. The order of flags defined flag processors registered for present flags. The order of flags defined
in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity. in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
processed text and ``validatehash`` is a bool indicating whether the processed text and ``validatehash`` is a bool indicating whether the
returned text should be checked for hash integrity. returned text should be checked for hash integrity.
""" """
text, vhash = self._processflagsfunc(text, flags, 'read') return self._processflagsfunc(text, flags, 'read')
return text, vhash, {}
def _processflagswrite(self, text, flags): def _processflagswrite(self, text, flags):
"""Inspect revision data flags and applies write transformations defined """Inspect revision data flags and applies write transformations defined
by registered flag processors. by registered flag processors.
``text`` - the revision data to process ``text`` - the revision data to process
``flags`` - the revision flags ``flags`` - the revision flags
This method processes the flags in the order (or reverse order if This method processes the flags in the order (or reverse order if
``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
flag processors registered for present flags. The order of flags defined flag processors registered for present flags. The order of flags defined
in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity. in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
processed text and ``validatehash`` is a bool indicating whether the processed text and ``validatehash`` is a bool indicating whether the
returned text should be checked for hash integrity. returned text should be checked for hash integrity.
""" """
return self._processflagsfunc(text, flags, 'write') return self._processflagsfunc(text, flags, 'write')[:2]
def _processflagsraw(self, text, flags): def _processflagsraw(self, text, flags):
"""Inspect revision data flags to check is the content hash should be """Inspect revision data flags to check is the content hash should be
validated. validated.
``text`` - the revision data to process ``text`` - the revision data to process
``flags`` - the revision flags ``flags`` - the revision flags
This method processes the flags in the order (or reverse order if This method processes the flags in the order (or reverse order if
``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
flag processors registered for present flags. The order of flags defined flag processors registered for present flags. The order of flags defined
in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity. in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
processed text and ``validatehash`` is a bool indicating whether the processed text and ``validatehash`` is a bool indicating whether the
returned text should be checked for hash integrity. returned text should be checked for hash integrity.
""" """
return self._processflagsfunc(text, flags, 'raw')[1] return self._processflagsfunc(text, flags, 'raw')[1]
def _processflagsfunc(self, text, flags, operation): def _processflagsfunc(self, text, flags, operation):
# fast path: no flag processors will run # fast path: no flag processors will run
if flags == 0: if flags == 0:
return text, True return text, True, {}
if operation not in ('read', 'write', 'raw'): if operation not in ('read', 'write', 'raw'):
raise error.ProgrammingError(_("invalid '%s' operation") % raise error.ProgrammingError(_("invalid '%s' operation") %
operation) operation)
# Check all flags are known. # Check all flags are known.
if flags & ~REVIDX_KNOWN_FLAGS: if flags & ~REVIDX_KNOWN_FLAGS:
raise self._flagserrorclass(_("incompatible revision flag '%#x'") % raise self._flagserrorclass(_("incompatible revision flag '%#x'") %
(flags & ~REVIDX_KNOWN_FLAGS)) (flags & ~REVIDX_KNOWN_FLAGS))
validatehash = True validatehash = True
# Depending on the operation (read or write), the order might be # Depending on the operation (read or write), the order might be
# reversed due to non-commutative transforms. # reversed due to non-commutative transforms.
orderedflags = REVIDX_FLAGS_ORDER orderedflags = REVIDX_FLAGS_ORDER
if operation == 'write': if operation == 'write':
orderedflags = reversed(orderedflags) orderedflags = reversed(orderedflags)
outsidedata = {}
for flag in orderedflags: for flag in orderedflags:
# If a flagprocessor has been registered for a known flag, apply the # If a flagprocessor has been registered for a known flag, apply the
# related operation transform and update result tuple. # related operation transform and update result tuple.
if flag & flags: if flag & flags:
vhash = True vhash = True
if flag not in self._flagprocessors: if flag not in self._flagprocessors:
message = _("missing processor for flag '%#x'") % (flag) message = _("missing processor for flag '%#x'") % (flag)
raise self._flagserrorclass(message) raise self._flagserrorclass(message)
processor = self._flagprocessors[flag] processor = self._flagprocessors[flag]
if processor is not None: if processor is not None:
readtransform, writetransform, rawtransform = processor readtransform, writetransform, rawtransform = processor
if operation == 'raw': if operation == 'raw':
vhash = rawtransform(self, text) vhash = rawtransform(self, text)
elif operation == 'read': elif operation == 'read':
text, vhash = readtransform(self, text) text, vhash = readtransform(self, text)
else: # write operation else: # write operation
text, vhash = writetransform(self, text) text, vhash = writetransform(self, text)
validatehash = validatehash and vhash validatehash = validatehash and vhash
return text, validatehash return text, validatehash, outsidedata