This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6798

flagutil: make the error class used by the mixin configurable
ClosedPublic

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

Details

Reviewers
yuja
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHG7907008a0bb5: flagutil: make the error class used by the mixin configurable
Summary

One of the code duplication use a different error class. So let's make it
possible to do so.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Sep 7 2019, 5:26 AM
indygreg accepted this revision.Sep 7 2019, 12:57 PM
This revision is now accepted and ready to land.Sep 7 2019, 12:57 PM

Revision Contents
Changeset List

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

Diff 16436

mercurial/revlogutils/flagutil.py

class flagprocessorsmixin(object): class flagprocessorsmixin(object):
"""basic mixin to support revlog flag processing """basic mixin to support revlog flag processing
Make sure the `_flagprocessors` attribute is set at ``__init__`` time. Make sure the `_flagprocessors` attribute is set at ``__init__`` time.
See the documentation of the ``_processflags`` method for details. See the documentation of the ``_processflags`` method for details.
""" """
_flagserrorclass = error.RevlogError
def _processflags(self, text, flags, operation, raw=False): def _processflags(self, text, flags, operation, raw=False):
"""Inspect revision data flags and applies transforms defined by """Inspect revision data flags and applies transforms defined by
registered flag processors. registered flag processors.
``text`` - the revision data to process ``text`` - the revision data to process
``flags`` - the revision flags ``flags`` - the revision flags
``operation`` - the operation being performed (read or write) ``operation`` - the operation being performed (read or write)
``raw`` - an optional argument describing if the raw transform should be ``raw`` - an optional argument describing if the raw transform should be
# 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 not operation in ('read', 'write'): if not operation in ('read', 'write'):
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 error.RevlogError(_("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)
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 error.RevlogError(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 raw: if 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