This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6815

flagprocessors: add a `sidedata` parameters to _processflagswrite
ClosedPublic

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

Details

Reviewers
yuja
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHG36a0a1951d64: flagprocessors: add a `sidedata` parameters to _processflagswrite
Summary

To read sidedata using flagprocessors, we need flag processors to store them. So
we pass this information to the flag processing layer.

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 16635

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 = self._processflagswrite(text, flags,
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 = self._processflagswrite(text, flags,
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

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') return self._processflagsfunc(text, flags, 'read')
def _processflagswrite(self, text, flags): def _processflagswrite(self, text, flags, sidedata):
"""Inspect revision data flags and applies write transformations defined """Inspect revision data flags and applies write 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
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.
""" """
assert not sidedata # XXX until it is actually processed
return self._processflagsfunc(text, flags, 'write')[:2] return self._processflagsfunc(text, flags, 'write')[:2]
def _processflagsraw(self, text, flags): def _processflagsraw(self, text, flags):
"""Inspect revision data flags to check is the content hash should be """Inspect revision data flags to check is the content hash should be
validated. validated.
``text`` - the revision data to process ``text`` - the revision data to process
``flags`` - the revision flags ``flags`` - the revision flags