mercurial: comparison hgext/git/gitlog.py

equal deleted inserted replaced

-:d6afa9c149c3
+:59fa3890d40a
 from __future__ import absolute_import
 from mercurial.i18n import _
+from mercurial.node import (
+bin,
+hex,
+nullhex,
+nullid,
+nullrev,
+wdirhex,
+)
 from mercurial import (
 ancestor,
 changelog as hgchangelog,
 dagop,
 encoding,
 error,
 manifest,
-node as nodemod,
 pycompat,
 )
 from mercurial.interfaces import (
 repository,
 util as interfaceutil,
 return int(
 self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0]
 )
 def rev(self, n):
-if n == nodemod.nullid:
+if n == nullid:
 return -1
 t = self._db.execute(
 'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),)
 ).fetchone()
 if t is None:
 raise error.LookupError(n, b'00changelog.i', _(b'no node %d'))
 return t[0]
 def node(self, r):
-if r == nodemod.nullrev:
+if r == nullrev:
-return nodemod.nullid
+return nullid
 t = self._db.execute(
 'SELECT node FROM changelog WHERE rev = ?', (r,)
 ).fetchone()
 if t is None:
 raise error.LookupError(r, b'00changelog.i', _(b'no node'))
-return nodemod.bin(t[0])
+return bin(t[0])
 def hasnode(self, n):
 t = self._db.execute(
 'SELECT node FROM changelog WHERE node = ?', (n,)
 ).fetchone()
 return baselogindex(self)
 @property
 def nodemap(self):
 r = {
-nodemod.bin(v[0]): v[1]
+bin(v[0]): v[1]
 for v in self._db.execute('SELECT node, rev FROM changelog')
 }
-r[nodemod.nullid] = nodemod.nullrev
+r[nullid] = nullrev
 return r
 def tip(self):
 t = self._db.execute(
 'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1'
 ).fetchone()
 if t:
-return nodemod.bin(t[0])
+return bin(t[0])
-return nodemod.nullid
+return nullid
 def revs(self, start=0, stop=None):
 if stop is None:
 stop = self.tip()
 t = self._db.execute(
 'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1'
 )
 return next(t)
 def _partialmatch(self, id):
-if nodemod.wdirhex.startswith(id):
+if wdirhex.startswith(id):
 raise error.WdirUnsupported
 candidates = [
-nodemod.bin(x[0])
+bin(x[0])
 for x in self._db.execute(
 'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',)
 )
 ]
-if nodemod.nullhex.startswith(id):
+if nullhex.startswith(id):
-candidates.append(nodemod.nullid)
+candidates.append(nullid)
 if len(candidates) > 1:
 raise error.AmbiguousPrefixLookupError(
 id, b'00changelog.i', _(b'ambiguous identifier')
 )
 if candidates:
 def flags(self, rev):
 return 0
 def shortest(self, node, minlength=1):
-nodehex = nodemod.hex(node)
+nodehex = hex(node)
 for attempt in pycompat.xrange(minlength, len(nodehex) + 1):
 candidate = nodehex[:attempt]
 matches = int(
 self._db.execute(
 'SELECT COUNT(*) FROM changelog WHERE node LIKE ?',
 if isinstance(nodeorrev, int):
 n = self.node(nodeorrev)
 else:
 n = nodeorrev
 # handle looking up nullid
-if n == nodemod.nullid:
+if n == nullid:
 return hgchangelog._changelogrevision(extra={})
 hn = gitutil.togitnode(n)
 # We've got a real commit!
 files = [
 r[0]
 filesremoved = [
 r[0]
 for r in self._db.execute(
 'SELECT filename FROM changedfiles '
 'WHERE node = ? and filenode = ?',
-(hn, nodemod.nullhex),
+(hn, nullhex),
 )
 ]
 c = self.gitrepo[hn]
 return hgchangelog._changelogrevision(
 manifest=n,  # pretend manifest the same as the commit node
 'common' is a list of revision numbers. If common is not supplied, uses
 nullrev.
 """
 if common is None:
-common = [nodemod.nullrev]
+common = [nullrev]
 return ancestor.incrementalmissingancestors(self.parentrevs, common)
 def findmissing(self, common=None, heads=None):
 """Return the ancestors of heads that are not ancestors of common.
 '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 = [nodemod.nullid]
+common = [nullid]
 if heads is None:
 heads = self.heads()
 common = [self.rev(n) for n in common]
 heads = [self.rev(n) for n in heads]
 def children(self, node):
 """find the children of a given node"""
 c = []
 p = self.rev(node)
 for r in self.revs(start=p + 1):
-prevs = [pr for pr in self.parentrevs(r) if pr != nodemod.nullrev]
+prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
 if prevs:
 for pr in prevs:
 if pr == p:
 c.append(self.node(r))
-elif p == nodemod.nullrev:
+elif p == nullrev:
 c.append(self.node(r))
 return c
 def reachableroots(self, minroot, heads, roots, includepath=False):
 return dagop._reachablerootspure(
 a, b = self.rev(a), self.rev(b)
 return self.isancestorrev(a, b)
 # Cleanup opportunity: this is *identical* to the revlog.py version
 def isancestorrev(self, a, b):
-if a == nodemod.nullrev:
+if a == nullrev:
 return True
 elif a == b:
 return True
 elif a > b:
 return False
 n = self.node(rev)
 hn = gitutil.togitnode(n)
 if hn != gitutil.nullgit:
 c = self.gitrepo[hn]
 else:
-return nodemod.nullrev, nodemod.nullrev
+return nullrev, nullrev
-p1 = p2 = nodemod.nullrev
+p1 = p2 = nullrev
 if c.parents:
 p1 = self.rev(c.parents[0].id.raw)
 if len(c.parents) > 2:
 raise error.Abort(b'TODO octopus merge handling')
 if len(c.parents) == 2:
 filesadded=None,
 filesremoved=None,
 ):
 parents = []
 hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2)
-if p1 != nodemod.nullid:
+if p1 != nullid:
 parents.append(hp1)
-if p2 and p2 != nodemod.nullid:
+if p2 and p2 != nullid:
 parents.append(hp2)
 assert date is not None
 timestamp, tz = date
 sig = pygit2.Signature(
 encoding.unifromlocal(stringutil.person(user)),
 class manifestlog(baselog):
 def __getitem__(self, node):
 return self.get(b'', node)
 def get(self, relpath, node):
-if node == nodemod.nullid:
+if node == nullid:
 # TODO: this should almost certainly be a memgittreemanifestctx
 return manifest.memtreemanifestctx(self, relpath)
 commit = self.gitrepo[gitutil.togitnode(node)]
 t = commit.tree
 if relpath:
 super(filelog, self).__init__(gr, db)
 assert isinstance(path, bytes)
 self.path = path
 def read(self, node):
-if node == nodemod.nullid:
+if node == nullid:
 return b''
 return self.gitrepo[gitutil.togitnode(node)].data
 def lookup(self, node):
 if len(node) not in (20, 40):
 node = int(node)
 if isinstance(node, int):
 assert False, b'todo revnums for nodes'
 if len(node) == 40:
-node = nodemod.bin(node)
+node = bin(node)
 hnode = gitutil.togitnode(node)
 if hnode in self.gitrepo:
 return node
 raise error.LookupError(self.path, node, _(b'no match found'))
 ''',
 (rev, pycompat.fsdecode(self.path)),
 ).fetchone()
 if maybe is None:
 raise IndexError('gitlog %r out of range %d' % (self.path, rev))
-return nodemod.bin(maybe[0])
+return bin(maybe[0])
 def parents(self, node):
 gn = gitutil.togitnode(node)
 gp = pycompat.fsdecode(self.path)
 ps = []
 if pycompat.ispy3:
 commit = commit.decode('ascii')
 index.fill_in_filelog(self.gitrepo, self._db, commit, gp, gn)
 return self.parents(node)
 else:
-ps.append(nodemod.bin(p))
+ps.append(bin(p))
 return ps
 def renamed(self, node):
 # TODO: renames/copies
 return False

changeset 46113	59fa3890d40a
parent 45939	66f6ca2b7aee
child 46780	6266d19556ad