mercurial: comparison mercurial/revlog.py

equal deleted inserted replaced

-:5fa019ceb499
+:d55b71393907
 # import stuff from node for others to import from revlog
 from .node import (
 bin,
 hex,
-nullhex,
-nullid,
 nullrev,
 sha1nodeconstants,
 short,
-wdirfilenodeids,
-wdirhex,
-wdirid,
 wdirrev,
 )
 from .i18n import _
 from .pycompat import getattr
 from .revlogutils.constants import (
 util.nouideprecwarn(msg, b'5.3', stacklevel=2)
 return self._nodemap
 @util.propertycache
 def _nodemap(self):
-nodemap = nodemaputil.NodeMap({nullid: nullrev})
+nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
 for r in range(0, len(self)):
 n = self[r][7]
 nodemap[n] = r
 return nodemap
 def clearcaches(self):
 self.__dict__.pop('_nodemap', None)
 def __getitem__(self, i):
 if i == -1:
-return (0, 0, 0, -1, -1, -1, -1, nullid)
+return (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid)
 return list.__getitem__(self, i)
 class revlogoldio(object):
 def parseindex(self, data, inline):
 s = INDEX_ENTRY_V0.size
 index = []
-nodemap = nodemaputil.NodeMap({nullid: nullrev})
+nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
 n = off = 0
 l = len(data)
 while off + s <= l:
 cur = data[off : off + s]
 off += s
 return self.index.rev(node)
 except TypeError:
 raise
 except error.RevlogError:
 # parsers.c radix tree lookup failed
-if node == wdirid or node in wdirfilenodeids:
+if (
+node == self.nodeconstants.wdirid
+or node in self.nodeconstants.wdirfilenodeids
+):
 raise error.WdirUnsupported
 raise error.LookupError(node, self.indexfile, _(b'no node'))
 # Accessors for index entries.
 def parents(self, node):
 i = self.index
 d = i[self.rev(node)]
 # inline node() to avoid function call overhead
-if d[5] == nullid:
+if d[5] == self.nullid:
 return i[d[6]][7], i[d[5]][7]
 else:
 return i[d[5]][7], i[d[6]][7]
 def chainlen(self, rev):
 'heads' and 'common' are both lists of node IDs.  If heads is
 not supplied, uses all of the revlog's heads.  If common is not
 supplied, uses nullid."""
 if common is None:
-common = [nullid]
+common = [self.nullid]
 if heads is None:
 heads = self.heads()
 common = [self.rev(n) for n in common]
 heads = [self.rev(n) for n in heads]
 'heads' and 'common' are both lists of node IDs.  If heads is
 not supplied, uses all of the revlog's heads.  If common is not
 supplied, uses nullid."""
 if common is None:
-common = [nullid]
+common = [self.nullid]
 if heads is None:
 heads = self.heads()
 common = [self.rev(n) for n in common]
 heads = [self.rev(n) for n in heads]
 roots = list(roots)
 if not roots:
 return nonodes
 lowestrev = min([self.rev(n) for n in roots])
 else:
-roots = [nullid]  # Everybody's a descendant of nullid
+roots = [self.nullid]  # Everybody's a descendant of nullid
 lowestrev = nullrev
 if (lowestrev == nullrev) and (heads is None):
 # We want _all_ the nodes!
-return ([self.node(r) for r in self], [nullid], list(self.heads()))
+return (
+[self.node(r) for r in self],
+[self.nullid],
+list(self.heads()),
+)
 if heads is None:
 # All nodes are ancestors, so the latest ancestor is the last
 # node.
 highestrev = len(self) - 1
 # Set ancestors to None to signal that every node is an ancestor.
 highestrev = max([self.rev(n) for n in nodestotag])
 while nodestotag:
 # grab a node to tag
 n = nodestotag.pop()
 # Never tag nullid
-if n == nullid:
+if n == self.nullid:
 continue
 # A node's revision number represents its place in a
 # topologically sorted list of nodes.
 r = self.rev(n)
 if r >= lowestrev:
 # If we are possibly a descendant of one of the roots
 # and we haven't already been marked as an ancestor
 ancestors.add(n)  # Mark as ancestor
 # Add non-nullid parents to list of nodes to tag.
 nodestotag.update(
-[p for p in self.parents(n) if p != nullid]
+[p for p in self.parents(n) if p != self.nullid]
 )
 elif n in heads:  # We've seen it before, is it a fake head?
 # So it is, real heads should not be the ancestors of
 # any other heads.
 heads.pop(n)
 return nonodes
 else:
 # We are descending from nullid, and don't need to care about
 # any other roots.
 lowestrev = nullrev
-roots = [nullid]
+roots = [self.nullid]
 # Transform our roots list into a set.
 descendants = set(roots)
 # Also, keep the original roots so we can filter out roots that aren't
 # 'real' roots (i.e. are descended from other roots).
 roots = descendants.copy()
 if stop is specified, it will consider all the revs from stop
 as if they had no children
 """
 if start is None and stop is None:
 if not len(self):
-return [nullid]
+return [self.nullid]
 return [self.node(r) for r in self.headrevs()]
 if start is None:
 start = nullrev
 else:
 except (AttributeError, OverflowError):
 ancs = ancestor.ancestors(self.parentrevs, a, b)
 if ancs:
 # choose a consistent winner when there's a tie
 return min(map(self.node, ancs))
-return nullid
+return self.nullid
 def _match(self, id):
 if isinstance(id, int):
 # rev
 return self.node(id)
 except (TypeError, error.LookupError):
 pass
 def _partialmatch(self, id):
 # we don't care wdirfilenodeids as they should be always full hash
-maybewdir = wdirhex.startswith(id)
+maybewdir = self.nodeconstants.wdirhex.startswith(id)
 try:
 partial = self.index.partialmatch(id)
 if partial and self.hasnode(partial):
 if maybewdir:
 # single 'ff...' match in radix tree, ambiguous with wdir
 prefix = bin(id[: l * 2])
 nl = [e[7] for e in self.index if e[7].startswith(prefix)]
 nl = [
 n for n in nl if hex(n).startswith(id) and self.hasnode(n)
 ]
-if nullhex.startswith(id):
+if self.nodeconstants.nullhex.startswith(id):
-nl.append(nullid)
+nl.append(self.nullid)
 if len(nl) > 0:
 if len(nl) == 1 and not maybewdir:
 self._pcache[id] = nl[0]
 return nl[0]
 raise error.AmbiguousPrefixLookupError(
 if not getattr(self, 'filteredrevs', None):
 try:
 length = max(self.index.shortest(node), minlength)
 return disambiguate(hexnode, length)
 except error.RevlogError:
-if node != wdirid:
+if node != self.nodeconstants.wdirid:
 raise error.LookupError(node, self.indexfile, _(b'no node'))
 except AttributeError:
 # Fall through to pure code
 pass
-if node == wdirid:
+if node == self.nodeconstants.wdirid:
 for length in range(minlength, len(hexnode) + 1):
 prefix = hexnode[:length]
 if isvalid(prefix):
 return prefix
 else:
 node = nodeorrev
 rev = None
 # fast path the special `nullid` rev
-if node == nullid:
+if node == self.nullid:
 return b"", {}
 # ``rawtext`` is the text as stored inside the revlog. Might be the
 # revision or might need to be processed to retrieve the revision.
 rev, rawtext, validated = self._rawtext(node, rev, _df=_df)
 invariants:
 - rawtext is optional (can be None); if not set, cachedelta must be set.
 if both are set, they must correspond to each other.
 """
-if node == nullid:
+if node == self.nullid:
 raise error.RevlogError(
 _(b"%s: attempt to add null revision") % self.indexfile
 )
-if node == wdirid or node in wdirfilenodeids:
+if (
+node == self.nodeconstants.wdirid
+or node in self.nodeconstants.wdirfilenodeids
+):
 raise error.RevlogError(
 _(b"%s: attempt to add wdir revision") % self.indexfile
 )
 if self._inline:

changeset 47012	d55b71393907
parent 46974	3c9208702db3
child 47034	0d8ff1f4ab0c