This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6819

flagprocessors: make `processflagsread` 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
rHGeb5048f8c533: flagprocessors: make `processflagsread` 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 16639

hgext/remotefilelog/remotefilelog.py

store = self.repo.contentstore store = self.repo.contentstore
rawtext = store.get(self.filename, node) rawtext = store.get(self.filename, node)
if raw: if raw:
return rawtext return rawtext
flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0) flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0)
if flags == 0: if flags == 0:
return rawtext return rawtext
text, verifyhash, sidedata = self._processflagsread(rawtext, flags) return flagutil.processflagsread(self, rawtext, flags)[0]
return text
def rawdata(self, node): def rawdata(self, node):
return self.revision(node, raw=False) return self.revision(node, raw=False)
def _read(self, id): def _read(self, id):
"""reads the raw file blob from disk, cache, or server""" """reads the raw file blob from disk, cache, or server"""
fileservice = self.repo.fileservice fileservice = self.repo.fileservice
localcache = fileservice.localcache localcache = fileservice.localcache

mercurial/revlog.py

# 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 = self._processflagsraw(rawtext, flags)
text = rawtext text = rawtext
else: else:
r = self._processflagsread(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)
return text, sidedata return text, sidedata

mercurial/revlogutils/flagutil.py

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, self._processflagsraw(text, flags)
elif operation == 'read': elif operation == 'read':
return self._processflagsread(text, flags) return processflagsread(self, text, flags)
else: # write operation else: # write operation
return processflagswrite(self, text, flags) return processflagswrite(self, text, flags)
def _processflagsread(self, text, flags): def _processflagsraw(self, 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(self, text, flags, 'read') return _processflagsfunc(self, text, flags, 'raw')[1]
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 _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

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 = self._processflagsraw(rawtext, flags)
text = rawtext text = rawtext
else: else:
r = self._processflagsread(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
def rawdata(self, nodeorrev): def rawdata(self, nodeorrev):
return self.revision(raw=True) return self.revision(raw=True)