This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6817

flagprocessors: make `_processflagsfunc` a module level function
ClosedPublic

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

Details

Reviewers
yuja
durin42
Group Reviewers
hg-reviewers
Commits
rHG50d9de61ce02: flagprocessors: make `_processflagsfunc` a module level function
Summary

This is the first step toward removing the flag processing mixin.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

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

Diff 16483

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.
""" """
return self._processflagsfunc(text, flags, 'read') return _processflagsfunc(self, text, flags, 'read')
def _processflagswrite(self, text, flags, sidedata): def _processflagswrite(self, text, flags, sidedata):
"""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 _processflagsfunc(self, text, flags, 'write',
sidedata=sidedata)[:2] sidedata=sidedata)[: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 _processflagsfunc(self, text, flags, 'raw')[1]
def _processflagsfunc(self, text, flags, operation, sidedata=None): def _processflagsfunc(revlog, text, flags, operation, sidedata=None):
"""internal function to process flag on a revlog
This function is private to this module, code should never needs to call it
directly."""
# 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 revlog._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 = {} 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 revlog._flagprocessors:
message = _("missing processor for flag '%#x'") % (flag) message = _("missing processor for flag '%#x'") % (flag)
raise self._flagserrorclass(message) raise revlog._flagserrorclass(message)
processor = self._flagprocessors[flag] processor = revlog._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(revlog, text)
elif operation == 'read': elif operation == 'read':
text, vhash, s = readtransform(self, text) text, vhash, s = readtransform(revlog, text)
outsidedata.update(s) outsidedata.update(s)
else: # write operation else: # write operation
text, vhash = writetransform(self, text, sidedata) text, vhash = writetransform(revlog, text, sidedata)
validatehash = validatehash and vhash validatehash = validatehash and vhash
return text, validatehash, outsidedata return text, validatehash, outsidedata