| hg-reviewers |
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.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/revlog.py (24 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| Gregory Szorc | Sep 18 2018, 7:28 PM |
| # 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) | ||||