This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6800

flagprocessors: introduce specialized functions
ClosedPublic

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

Details

Reviewers
yuja
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHG87a934684c3b: flagprocessors: introduce specialized functions
Summary

This make the call site clearer and the open the way to more diverse return
types.

For now, the same old code is still in use under the hood.

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:27 AM
indygreg accepted this revision.Sep 7 2019, 1:00 PM
indygreg added a subscriber: indygreg.
indygreg added inline comments.
mercurial/revlogutils/flagutil.py
98

Please follow up to make this more strongly typed by checking operation == 'write'.

This revision is now accepted and ready to land.Sep 7 2019, 1:00 PM
marmoute added a commit: rHG87a934684c3b: flagprocessors: introduce specialized functions.Sep 7 2019, 1:03 PM
Closed by commit rHG87a934684c3b: flagprocessors: introduce specialized functions (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.
indygreg added inline comments.Sep 7 2019, 1:05 PM
mercurial/revlogutils/flagutil.py
151

Please follow-up with a fix for the docstring to reflect that this does not return a 2-tuple.

Revision Contents
Changeset List

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

Diff 16438

mercurial/revlogutils/flagutil.py

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 _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 """deprecated entry point to access flag processors"""
registered flag processors. if raw:
return text, self._processflagsraw(text, flags)
elif operation == 'read':
return self._processflagsread(text, flags)
else: # write operation
indygregUnsubmitted
Not Done

Please follow up to make this more strongly typed by checking operation == 'write'.

indygreg: Please follow up to make this more strongly typed by checking `operation == 'write'`.
return self._processflagswrite(text, flags)
def _processflagsread(self, text, flags):
"""Inspect revision data flags and applies read transformations defined
by 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)
``raw`` - an optional argument describing if the raw transform should be ``raw`` - an optional argument describing if the raw transform should be
applied. applied.
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, 'read')
def _processflagswrite(self, text, flags):
"""Inspect revision data flags and applies write transformations defined
by registered flag processors.
``text`` - the revision data to process
``flags`` - the revision flags
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.
"""
return self._processflagsfunc(text, flags, 'write')
def _processflagsraw(self, text, flags):
"""Inspect revision data flags to check is the content hash should be
validated.
``text`` - the revision data to process
``flags`` - the revision flags
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.
Note: If the ``raw`` argument is set, it has precedence over the Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
indygregUnsubmitted
Not Done

Please follow-up with a fix for the docstring to reflect that this does not return a 2-tuple.

indygreg: Please follow-up with a fix for the docstring to reflect that this does not return a 2-tuple.
operation and will only update the value of ``validatehash``. processed text and ``validatehash`` is a bool indicating whether the
returned text should be checked for hash integrity.
""" """
return self._processflagsfunc(text, flags, 'read', raw=True)[1]
def _processflagsfunc(self, text, flags, operation, raw=False):
# 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: