( )⚙ D10511 revlog: code for `revlogv0` in its own module

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10511

revlog: code for `revlogv0` in its own module
ClosedPublic

Authored by marmoute on Apr 23 2021, 10:30 AM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHG724db234b790: revlog: code for `revlogv0` in its own module
rHG5807cc9a8104: revlog: code for `revlogv0` in its own module
Summary

This code is mostly unused compatiblity code. Yet it take a prohiminent place in the revlog.py module. That module is already quite big, so we move all that code in a dedicated module.

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.Apr 23 2021, 10:30 AM
Alphare accepted this revision.Apr 29 2021, 10:43 AM
This revision is now accepted and ready to land.Apr 29 2021, 10:43 AM
marmoute added a commit: rHG5807cc9a8104: revlog: code for `revlogv0` in its own module.May 2 2021, 6:33 PM
Closed by commit rHG5807cc9a8104: revlog: code for `revlogv0` in its own module (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revlog.py (116 lines)
AMmercurial/revlogutils/revlogv0.py (144 lines)

Diff 27277

mercurial/revlog.py

short, short,
wdirrev, wdirrev,
) )
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .revlogutils.constants import ( from .revlogutils.constants import (
FLAG_GENERALDELTA, FLAG_GENERALDELTA,
FLAG_INLINE_DATA, FLAG_INLINE_DATA,
INDEX_ENTRY_V0,
INDEX_HEADER, INDEX_HEADER,
REVLOGV0, REVLOGV0,
REVLOGV1, REVLOGV1,
REVLOGV1_FLAGS, REVLOGV1_FLAGS,
REVLOGV2, REVLOGV2,
REVLOGV2_FLAGS, REVLOGV2_FLAGS,
REVLOG_DEFAULT_FLAGS, REVLOG_DEFAULT_FLAGS,
REVLOG_DEFAULT_FORMAT, REVLOG_DEFAULT_FORMAT,
from .interfaces import ( from .interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from .revlogutils import ( from .revlogutils import (
deltas as deltautil, deltas as deltautil,
flagutil, flagutil,
nodemap as nodemaputil, nodemap as nodemaputil,
revlogv0,
sidedata as sidedatautil, sidedata as sidedatautil,
) )
from .utils import ( from .utils import (
storageutil, storageutil,
stringutil, stringutil,
) )
# blanked usage of all the name to prevent pyflakes constraints # blanked usage of all the name to prevent pyflakes constraints
ellipsisprocessor = ( ellipsisprocessor = (
ellipsisreadprocessor, ellipsisreadprocessor,
ellipsiswriteprocessor, ellipsiswriteprocessor,
ellipsisrawprocessor, ellipsisrawprocessor,
) )
def getoffset(q):
return int(q >> 16)
def gettype(q):
return int(q & 0xFFFF)
def offset_type(offset, type): def offset_type(offset, type):
if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0: if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
raise ValueError(b'unknown revlog index flags') raise ValueError(b'unknown revlog index flags')
return int(int(offset) << 16 | type) return int(int(offset) << 16 | type)
def _verify_revision(rl, skipflags, state, node): def _verify_revision(rl, skipflags, state, node):
"""Verify the integrity of the given revlog ``node`` while providing a hook """Verify the integrity of the given revlog ``node`` while providing a hook
@interfaceutil.implementer(repository.iverifyproblem) @interfaceutil.implementer(repository.iverifyproblem)
@attr.s(frozen=True) @attr.s(frozen=True)
class revlogproblem(object): class revlogproblem(object):
warning = attr.ib(default=None) warning = attr.ib(default=None)
error = attr.ib(default=None) error = attr.ib(default=None)
node = attr.ib(default=None) node = attr.ib(default=None)
class revlogoldindex(list):
entry_size = INDEX_ENTRY_V0.size
@property
def nodemap(self):
msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"
util.nouideprecwarn(msg, b'5.3', stacklevel=2)
return self._nodemap
@util.propertycache
def _nodemap(self):
nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
for r in range(0, len(self)):
n = self[r][7]
nodemap[n] = r
return nodemap
def has_node(self, node):
"""return True if the node exist in the index"""
return node in self._nodemap
def rev(self, node):
"""return a revision for a node
If the node is unknown, raise a RevlogError"""
return self._nodemap[node]
def get_rev(self, node):
"""return a revision for a node
If the node is unknown, return None"""
return self._nodemap.get(node)
def append(self, tup):
self._nodemap[tup[7]] = len(self)
super(revlogoldindex, self).append(tup)
def __delitem__(self, i):
if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
raise ValueError(b"deleting slices only supports a:-1 with step 1")
for r in pycompat.xrange(i.start, len(self)):
del self._nodemap[self[r][7]]
super(revlogoldindex, self).__delitem__(i)
def clearcaches(self):
self.__dict__.pop('_nodemap', None)
def __getitem__(self, i):
if i == -1:
return (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid)
return list.__getitem__(self, i)
def entry_binary(self, rev):
"""return the raw binary string representing a revision"""
entry = self[rev]
if gettype(entry[0]):
raise error.RevlogError(
_(b'index entry flags need revlog version 1')
)
e2 = (
getoffset(entry[0]),
entry[1],
entry[3],
entry[4],
self[entry[5]][7],
self[entry[6]][7],
entry[7],
)
return INDEX_ENTRY_V0.pack(*e2)
def pack_header(self, header):
"""Pack header information in binary"""
return b''
def parse_index_v0(data, inline):
s = INDEX_ENTRY_V0.size
index = []
nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
n = off = 0
l = len(data)
while off + s <= l:
cur = data[off : off + s]
off += s
e = INDEX_ENTRY_V0.unpack(cur)
# transform to revlogv1 format
e2 = (
offset_type(e[0], 0),
e[1],
-1,
e[2],
e[3],
nodemap.get(e[4], nullrev),
nodemap.get(e[5], nullrev),
e[6],
)
index.append(e2)
nodemap[e[6]] = n
n += 1
index = revlogoldindex(index)
return index, None
def parse_index_v1(data, inline): def parse_index_v1(data, inline):
# call the C implementation to parse the index data # call the C implementation to parse the index data
index, cache = parsers.parse_index2(data, inline) index, cache = parsers.parse_index2(data, inline)
return index, cache return index, cache
def parse_index_v2(data, inline): def parse_index_v2(data, inline):
# call the C implementation to parse the index data # call the C implementation to parse the index data
if rustrevlog is not None: if rustrevlog is not None:
if self.nodemap_file is not None: if self.nodemap_file is not None:
use_rust_index = True use_rust_index = True
else: else:
use_rust_index = self.opener.options.get(b'rust.index') use_rust_index = self.opener.options.get(b'rust.index')
self._parse_index = parse_index_v1 self._parse_index = parse_index_v1
if self.version == REVLOGV0: if self.version == REVLOGV0:
self._parse_index = parse_index_v0 self._parse_index = revlogv0.parse_index_v0
elif fmt == REVLOGV2: elif fmt == REVLOGV2:
self._parse_index = parse_index_v2 self._parse_index = parse_index_v2
elif devel_nodemap: elif devel_nodemap:
self._parse_index = parse_index_v1_nodemap self._parse_index = parse_index_v1_nodemap
elif use_rust_index: elif use_rust_index:
self._parse_index = parse_index_v1_mixed self._parse_index = parse_index_v1_mixed
try: try:
d = self._parse_index(indexdata, self._inline) d = self._parse_index(indexdata, self._inline)

mercurial/revlogutils/revlogv0.py

  • This file was added.
# revlogv0 - code related to revlog format "V0"
#
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
from ..node import sha1nodeconstants
from .constants import (
INDEX_ENTRY_V0,
)
from ..i18n import _
from .. import (
error,
node,
pycompat,
util,
)
from . import (
flagutil,
nodemap as nodemaputil,
)
def getoffset(q):
return int(q >> 16)
def gettype(q):
return int(q & 0xFFFF)
def offset_type(offset, type):
if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
raise ValueError(b'unknown revlog index flags')
return int(int(offset) << 16 | type)
class revlogoldindex(list):
entry_size = INDEX_ENTRY_V0.size
@property
def nodemap(self):
msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"
util.nouideprecwarn(msg, b'5.3', stacklevel=2)
return self._nodemap
@util.propertycache
def _nodemap(self):
nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: node.nullrev})
for r in range(0, len(self)):
n = self[r][7]
nodemap[n] = r
return nodemap
def has_node(self, node):
"""return True if the node exist in the index"""
return node in self._nodemap
def rev(self, node):
"""return a revision for a node
If the node is unknown, raise a RevlogError"""
return self._nodemap[node]
def get_rev(self, node):
"""return a revision for a node
If the node is unknown, return None"""
return self._nodemap.get(node)
def append(self, tup):
self._nodemap[tup[7]] = len(self)
super(revlogoldindex, self).append(tup)
def __delitem__(self, i):
if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
raise ValueError(b"deleting slices only supports a:-1 with step 1")
for r in pycompat.xrange(i.start, len(self)):
del self._nodemap[self[r][7]]
super(revlogoldindex, self).__delitem__(i)
def clearcaches(self):
self.__dict__.pop('_nodemap', None)
def __getitem__(self, i):
if i == -1:
return (0, 0, 0, -1, -1, -1, -1, node.nullid)
return list.__getitem__(self, i)
def pack_header(self, header):
"""pack header information in binary"""
return b''
def entry_binary(self, rev):
"""return the raw binary string representing a revision"""
entry = self[rev]
if gettype(entry[0]):
raise error.RevlogError(
_(b'index entry flags need revlog version 1')
)
e2 = (
getoffset(entry[0]),
entry[1],
entry[3],
entry[4],
self[entry[5]][7],
self[entry[6]][7],
entry[7],
)
return INDEX_ENTRY_V0.pack(*e2)
def parse_index_v0(data, inline):
s = INDEX_ENTRY_V0.size
index = []
nodemap = nodemaputil.NodeMap({node.nullid: node.nullrev})
n = off = 0
l = len(data)
while off + s <= l:
cur = data[off : off + s]
off += s
e = INDEX_ENTRY_V0.unpack(cur)
# transform to revlogv1 format
e2 = (
offset_type(e[0], 0),
e[1],
-1,
e[2],
e[3],
nodemap.get(e[4], node.nullrev),
nodemap.get(e[5], node.nullrev),
e[6],
)
index.append(e2)
nodemap[e[6]] = n
n += 1
index = revlogoldindex(index)
return index, None