This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6796

flagutil: introduce a flagprocessorsmixin class
ClosedPublic

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

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
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 added a comment.Sep 7 2019, 12:52 PM

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

PathPackages
Mmercurial/revlog.py (65 lines)
Mmercurial/revlogutils/flagutil.py (71 lines)

Diff 16434

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