This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6818

flagprocessors: make `processflagswrite` 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
rHGa04b2c010d03: flagprocessors: make `processflagswrite` a module level function
Summary

One more step towards 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 16637

hgext/remotefilelog/remotefilelog.py

sidedata=None): sidedata=None):
# text passed to "addrevision" includes hg filelog metadata header # text passed to "addrevision" includes hg filelog metadata header
if node is None: if node is None:
node = storageutil.hashrevisionsha1(text, p1, p2) node = storageutil.hashrevisionsha1(text, p1, p2)
if sidedata is None: if sidedata is None:
sidedata = {} sidedata = {}
meta, metaoffset = storageutil.parsemeta(text) meta, metaoffset = storageutil.parsemeta(text)
rawtext, validatehash = self._processflagswrite(text, flags, rawtext, validatehash = flagutil.processflagswrite(self, text, flags,
sidedata=sidedata) sidedata=sidedata)
return self.addrawrevision(rawtext, transaction, linknode, p1, p2, return self.addrawrevision(rawtext, transaction, linknode, p1, p2,
node, flags, cachedelta, node, flags, cachedelta,
_metatuple=(meta, metaoffset)) _metatuple=(meta, metaoffset))
def addrawrevision(self, rawtext, transaction, linknode, p1, p2, node, def addrawrevision(self, rawtext, transaction, linknode, p1, p2, node,
flags, cachedelta=None, _metatuple=None): flags, cachedelta=None, _metatuple=None):
if _metatuple: if _metatuple:
# _metatuple: used by "addrevision" internally by remotefilelog # _metatuple: used by "addrevision" internally by remotefilelog

mercurial/revlog.py

% self.indexfile) % self.indexfile)
if sidedata is None: if sidedata is None:
sidedata = {} sidedata = {}
if flags: if flags:
node = node or self.hash(text, p1, p2) node = node or self.hash(text, p1, p2)
rawtext, validatehash = self._processflagswrite(text, flags, rawtext, validatehash = flagutil.processflagswrite(self, text, flags,
sidedata=sidedata) sidedata=sidedata)
# If the flag processor modifies the revision data, ignore any provided # If the flag processor modifies the revision data, ignore any provided
# cachedelta. # cachedelta.
if rawtext != text: if rawtext != text:
cachedelta = None cachedelta = None
if len(rawtext) > _maxentrysize: if len(rawtext) > _maxentrysize:
raise error.RevlogError( raise error.RevlogError(

mercurial/revlogutils/flagutil.py

"""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, self._processflagsraw(text, flags)
elif operation == 'read': elif operation == 'read':
return self._processflagsread(text, flags) return self._processflagsread(text, flags)
else: # write operation else: # write operation
return self._processflagswrite(text, flags) return processflagswrite(self, text, flags)
def _processflagsread(self, text, flags): def _processflagsread(self, text, flags):
"""Inspect revision data flags and applies read 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 ``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 _processflagsfunc(self, text, flags, 'read') return _processflagsfunc(self, text, flags, 'read')
def _processflagswrite(self, text, flags, sidedata): def _processflagsraw(self, text, flags):
"""Inspect revision data flags and applies write 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
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, 'write', return _processflagsfunc(self, text, flags, 'raw')[1]
sidedata=sidedata)[:2]
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 _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

def addrevision(self, text, transaction, linkrev, p1, p2, node=None, def addrevision(self, text, transaction, linkrev, p1, p2, node=None,
flags=revlog.REVIDX_DEFAULT_FLAGS, cachedelta=None): flags=revlog.REVIDX_DEFAULT_FLAGS, cachedelta=None):
validatenode(p1) validatenode(p1)
validatenode(p2) validatenode(p2)
if flags: if flags:
node = node or storageutil.hashrevisionsha1(text, p1, p2) node = node or storageutil.hashrevisionsha1(text, p1, p2)
rawtext, validatehash = self._processflagswrite(text, flags) rawtext, validatehash = flagutil.processflagswrite(self, text, flags)
node = node or storageutil.hashrevisionsha1(text, p1, p2) node = node or storageutil.hashrevisionsha1(text, p1, p2)
if node in self._indexbynode: if node in self._indexbynode:
return node return node
if validatehash: if validatehash:
self.checkhash(rawtext, node, p1=p1, p2=p2) self.checkhash(rawtext, node, p1=p1, p2=p2)