This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4653

revlog: drop LookupError alias (API)
ClosedPublic

Authored by indygreg on Sep 18 2018, 8:06 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG974592474dee: revlog: drop LookupError alias (API)
Summary

This alias is especially bad because it shadows the built-in
LookupError type. This has caused me confusion in the past
when reading revlog code. Qualifying all uses with "error." will
make it obvious that we're using a Mercurial error type.

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

indygreg created this revision.Sep 18 2018, 8:06 PM
Closed by commit rHG974592474dee: revlog: drop LookupError alias (API) (authored by indygreg). · Explain WhySep 23 2018, 6:13 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revlog.py (24 lines)

Diff 11279

mercurial/revlog.py

# Aliased for performance. # Aliased for performance.
_zlibdecompress = zlib.decompress _zlibdecompress = zlib.decompress
# max size of revlog with inline data # max size of revlog with inline data
_maxinline = 131072 _maxinline = 131072
_chunksize = 1048576 _chunksize = 1048576
LookupError = error.LookupError
# Store flag processors (cf. 'addflagprocessor()' to register) # Store flag processors (cf. 'addflagprocessor()' to register)
_flagprocessors = { _flagprocessors = {
REVIDX_ISCENSORED: None, REVIDX_ISCENSORED: None,
} }
# Flag processors for REVIDX_ELLIPSIS. # Flag processors for REVIDX_ELLIPSIS.
def ellipsisreadprocessor(rl, text): def ellipsisreadprocessor(rl, text):
return text, False return text, False
try: try:
return self._nodecache[node] return self._nodecache[node]
except TypeError: except TypeError:
raise raise
except error.RevlogError: except error.RevlogError:
# parsers.c radix tree lookup failed # parsers.c radix tree lookup failed
if node == wdirid or node in wdirfilenodeids: if node == wdirid or node in wdirfilenodeids:
raise error.WdirUnsupported raise error.WdirUnsupported
raise LookupError(node, self.indexfile, _('no node')) raise error.LookupError(node, self.indexfile, _('no node'))
except KeyError: except KeyError:
# pure python cache lookup failed # pure python cache lookup failed
n = self._nodecache n = self._nodecache
i = self.index i = self.index
p = self._nodepos p = self._nodepos
if p is None: if p is None:
p = len(i) - 1 p = len(i) - 1
else: else:
assert p < len(i) assert p < len(i)
for r in pycompat.xrange(p, -1, -1): for r in pycompat.xrange(p, -1, -1):
v = i[r][7] v = i[r][7]
n[v] = r n[v] = r
if v == node: if v == node:
self._nodepos = r - 1 self._nodepos = r - 1
return r return r
if node == wdirid or node in wdirfilenodeids: if node == wdirid or node in wdirfilenodeids:
raise error.WdirUnsupported raise error.WdirUnsupported
raise LookupError(node, self.indexfile, _('no node')) raise error.LookupError(node, self.indexfile, _('no node'))
# Accessors for index entries. # Accessors for index entries.
# First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
# are flags. # are flags.
def start(self, rev): def start(self, rev):
return int(self.index[rev][0] >> 16) return int(self.index[rev][0] >> 16)
return self.node(id) return self.node(id)
if len(id) == 20: if len(id) == 20:
# possibly a binary node # possibly a binary node
# odds of a binary node being all hex in ASCII are 1 in 10**25 # odds of a binary node being all hex in ASCII are 1 in 10**25
try: try:
node = id node = id
self.rev(node) # quick search the index self.rev(node) # quick search the index
return node return node
except LookupError: except error.LookupError:
pass # may be partial hex id pass # may be partial hex id
try: try:
# str(rev) # str(rev)
rev = int(id) rev = int(id)
if "%d" % rev != id: if "%d" % rev != id:
raise ValueError raise ValueError
if rev < 0: if rev < 0:
rev = len(self) + rev rev = len(self) + rev
if rev < 0 or rev >= len(self): if rev < 0 or rev >= len(self):
raise ValueError raise ValueError
return self.node(rev) return self.node(rev)
except (ValueError, OverflowError): except (ValueError, OverflowError):
pass pass
if len(id) == 40: if len(id) == 40:
try: try:
# a full hex nodeid? # a full hex nodeid?
node = bin(id) node = bin(id)
self.rev(node) self.rev(node)
return node return node
except (TypeError, LookupError): except (TypeError, error.LookupError):
pass pass
def _partialmatch(self, id): def _partialmatch(self, id):
# we don't care wdirfilenodeids as they should be always full hash # we don't care wdirfilenodeids as they should be always full hash
maybewdir = wdirhex.startswith(id) maybewdir = wdirhex.startswith(id)
try: try:
partial = self.index.partialmatch(id) partial = self.index.partialmatch(id)
if partial and self.hasnode(partial): if partial and self.hasnode(partial):
""" """
n = self._match(id) n = self._match(id)
if n is not None: if n is not None:
return n return n
n = self._partialmatch(id) n = self._partialmatch(id)
if n: if n:
return n return n
raise LookupError(id, self.indexfile, _('no match found')) raise error.LookupError(id, self.indexfile, _('no match found'))
def shortest(self, node, minlength=1): def shortest(self, node, minlength=1):
"""Find the shortest unambiguous prefix that matches node.""" """Find the shortest unambiguous prefix that matches node."""
def isvalid(prefix): def isvalid(prefix):
try: try:
node = self._partialmatch(prefix) node = self._partialmatch(prefix)
except error.RevlogError: except error.RevlogError:
return False return False
except error.WdirUnsupported: except error.WdirUnsupported:
# single 'ff...' match # single 'ff...' match
return True return True
if node is None: if node is None:
raise LookupError(node, self.indexfile, _('no node')) raise error.LookupError(node, self.indexfile, _('no node'))
return True return True
def maybewdir(prefix): def maybewdir(prefix):
return all(c == 'f' for c in prefix) return all(c == 'f' for c in prefix)
hexnode = hex(node) hexnode = hex(node)
def disambiguate(hexnode, minlength): def disambiguate(hexnode, minlength):
"""Disambiguate against wdirid.""" """Disambiguate against wdirid."""
for length in range(minlength, 41): for length in range(minlength, 41):
prefix = hexnode[:length] prefix = hexnode[:length]
if not maybewdir(prefix): if not maybewdir(prefix):
return prefix return prefix
if not getattr(self, 'filteredrevs', None): if not getattr(self, 'filteredrevs', None):
try: try:
length = max(self.index.shortest(node), minlength) length = max(self.index.shortest(node), minlength)
return disambiguate(hexnode, length) return disambiguate(hexnode, length)
except error.RevlogError: except error.RevlogError:
if node != wdirid: if node != wdirid:
raise LookupError(node, self.indexfile, _('no node')) raise error.LookupError(node, self.indexfile, _('no node'))
except AttributeError: except AttributeError:
# Fall through to pure code # Fall through to pure code
pass pass
if node == wdirid: if node == wdirid:
for length in range(minlength, 41): for length in range(minlength, 41):
prefix = hexnode[:length] prefix = hexnode[:length]
if isvalid(prefix): if isvalid(prefix):
nodes.append(node) nodes.append(node)
if node in self.nodemap: if node in self.nodemap:
# this can happen if two branches make the same change # this can happen if two branches make the same change
continue continue
for p in (p1, p2): for p in (p1, p2):
if p not in self.nodemap: if p not in self.nodemap:
raise LookupError(p, self.indexfile, raise error.LookupError(p, self.indexfile,
_('unknown parent')) _('unknown parent'))
if deltabase not in self.nodemap: if deltabase not in self.nodemap:
raise LookupError(deltabase, self.indexfile, raise error.LookupError(deltabase, self.indexfile,
_('unknown delta base')) _('unknown delta base'))
baserev = self.rev(deltabase) baserev = self.rev(deltabase)
if baserev != nullrev and self.iscensored(baserev): if baserev != nullrev and self.iscensored(baserev):
# if base is censored, delta must be full replacement in a # if base is censored, delta must be full replacement in a
# single patch operation # single patch operation
hlen = struct.calcsize(">lll") hlen = struct.calcsize(">lll")
oldlen = self.rawsize(baserev) oldlen = self.rawsize(baserev)