This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6820

flagprocessors: make `processflagsraw` a module level function
ClosedPublic

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

Details

Reviewers
yuja
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHGdff95420480f: flagprocessors: make `processflagsraw` a module level function
Summary

One more steps toward removing the mixin.

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.

Revision Contents
Changeset List

Diff 16640

mercurial/revlog.py

flags = self.flags(rev) flags = self.flags(rev)
if validated and flags == REVIDX_DEFAULT_FLAGS: if validated and flags == REVIDX_DEFAULT_FLAGS:
# no extra flags set, no flag processor runs, text = rawtext # no extra flags set, no flag processor runs, text = rawtext
return rawtext, {} return rawtext, {}
sidedata = {} sidedata = {}
if raw: if raw:
validatehash = self._processflagsraw(rawtext, flags) validatehash = flagutil.processflagsraw(self, rawtext, flags)
text = rawtext text = rawtext
else: else:
r = flagutil.processflagsread(self, rawtext, flags) r = flagutil.processflagsread(self, rawtext, flags)
text, validatehash, sidedata = r text, validatehash, sidedata = r
if validatehash: if validatehash:
self.checkhash(text, node, rev=rev) self.checkhash(text, node, rev=rev)
if not validated: if not validated:
self._revisioncache = (node, rev, rawtext) self._revisioncache = (node, rev, rawtext)

mercurial/revlogutils/deltas.py

) )
from .. import ( from .. import (
error, error,
mdiff, mdiff,
util, util,
) )
from . import (
flagutil,
)
# maximum <delta-chain-data>/<revision-text-length> ratio # maximum <delta-chain-data>/<revision-text-length> ratio
LIMIT_DELTA2TEXT = 2 LIMIT_DELTA2TEXT = 2
class _testrevlog(object): class _testrevlog(object):
"""minimalist fake revlog to use in doctests""" """minimalist fake revlog to use in doctests"""
def __init__(self, data, density=0.5, mingap=0, snapshot=()): def __init__(self, data, density=0.5, mingap=0, snapshot=()):
"""data is an list of revision payload boundaries""" """data is an list of revision payload boundaries"""
fulltext = delta[hlen:] fulltext = delta[hlen:]
else: else:
# deltabase is rawtext before changed by flag processors, which is # deltabase is rawtext before changed by flag processors, which is
# equivalent to non-raw text # equivalent to non-raw text
basetext = revlog.revision(baserev, _df=fh, raw=False) basetext = revlog.revision(baserev, _df=fh, raw=False)
fulltext = mdiff.patch(basetext, delta) fulltext = mdiff.patch(basetext, delta)
try: try:
validatehash = revlog._processflagsraw(fulltext, flags) validatehash = flagutil.processflagsraw(revlog, fulltext, flags)
if validatehash: if validatehash:
revlog.checkhash(fulltext, expectednode, p1=p1, p2=p2) revlog.checkhash(fulltext, expectednode, p1=p1, p2=p2)
if flags & REVIDX_ISCENSORED: if flags & REVIDX_ISCENSORED:
raise error.StorageError(_('node %s is not censored') % raise error.StorageError(_('node %s is not censored') %
expectednode) expectednode)
except error.CensoredNodeError: except error.CensoredNodeError:
# must pass the censored index flag to add censored revisions # must pass the censored index flag to add censored revisions
if not flags & REVIDX_ISCENSORED: if not flags & REVIDX_ISCENSORED:

mercurial/revlogutils/flagutil.py

_flagserrorclass = error.RevlogError _flagserrorclass = error.RevlogError
def _processflags(self, text, flags, operation, raw=False): def _processflags(self, text, flags, operation, raw=False):
"""deprecated entry point to access flag processors""" """deprecated entry point to access flag processors"""
msg = ('_processflag(...) use the specialized variant') msg = ('_processflag(...) use the specialized variant')
util.nouideprecwarn(msg, '5.2', stacklevel=2) util.nouideprecwarn(msg, '5.2', stacklevel=2)
if raw: if raw:
return text, self._processflagsraw(text, flags) return text, processflagsraw(self, text, flags)
elif operation == 'read': elif operation == 'read':
return processflagsread(self, text, flags) return processflagsread(self, text, flags)
else: # write operation else: # write operation
return processflagswrite(self, text, flags) return processflagswrite(self, text, flags)
def _processflagsraw(self, text, flags): def processflagswrite(revlog, text, flags, sidedata):
"""Inspect revision data flags to check is the content hash should be """Inspect revision data flags and applies write transformations defined
validated. 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 _processflagsfunc(self, text, flags, 'raw')[1] return _processflagsfunc(revlog, text, flags, 'write',
sidedata=sidedata)[:2]
def processflagswrite(revlog, text, flags, sidedata): def processflagsread(revlog, text, flags):
"""Inspect revision data flags and applies write transformations defined """Inspect revision data flags and applies read 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
``raw`` - an optional argument describing if the raw transform should be
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 _processflagsfunc(revlog, text, flags, 'write', return _processflagsfunc(revlog, text, flags, 'read')
sidedata=sidedata)[:2]
def processflagsread(revlog, text, flags): def processflagsraw(revlog, text, flags):
"""Inspect revision data flags and applies read transformations defined """Inspect revision data flags to check is the content hash should be
by registered flag processors. validated.
``text`` - the revision data to process ``text`` - the revision data to process
``flags`` - the revision flags ``flags`` - the revision flags
``raw`` - an optional argument describing if the raw transform should be
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 _processflagsfunc(revlog, text, flags, 'read') return _processflagsfunc(revlog, text, flags, 'raw')[1]
def _processflagsfunc(revlog, text, flags, operation, sidedata=None): def _processflagsfunc(revlog, text, flags, operation, sidedata=None):
"""internal function to process flag on a revlog """internal function to process flag on a revlog
This function is private to this module, code should never needs to call it This function is private to this module, code should never needs to call it
directly.""" directly."""
# fast path: no flag processors will run # fast path: no flag processors will run
if flags == 0: if flags == 0:

tests/simplestorerepo.py

rev = self.rev(node) rev = self.rev(node)
flags = self._flags(rev) flags = self._flags(rev)
path = b'/'.join([self._storepath, hex(node)]) path = b'/'.join([self._storepath, hex(node)])
rawtext = self._svfs.read(path) rawtext = self._svfs.read(path)
if raw: if raw:
validatehash = self._processflagsraw(rawtext, flags) validatehash = flagutil.processflagsraw(self, rawtext, flags)
text = rawtext text = rawtext
else: else:
r = flagutil.processflagsread(self, rawtext, flags) r = flagutil.processflagsread(self, rawtext, flags)
text, validatehash, sidedata = r text, validatehash, sidedata = r
if validatehash: if validatehash:
self.checkhash(text, node, rev=rev) self.checkhash(text, node, rev=rev)
return text return text