branchmap: make update a method

mercurial/branchmap.py

@@ -42,10 +42,59 b' def read(repo):'
         partial = branchcache()
     return partial
 
-def update(repo, partial, ctxgen):
-    """Given a branchhead cache, partial, that may have extra nodes or be
+
+
+def updatecache(repo):
+    repo = repo.unfiltered()  # Until we get a smarter cache management
+    cl = repo.changelog
+    tip = cl.tip()
+    partial = repo._branchcache
+    if partial is not None and partial.tipnode == tip:
+        return
+
+    if partial is None or partial.tipnode not in cl.nodemap:
+        partial = read(repo)
+
+    catip = repo._cacheabletip()
+    # if partial.tiprev == catip: cache is already up to date
+    # if partial.tiprev >  catip: we have uncachable element in `partial` can't
+    #                             write on disk
+    if partial.tiprev < catip:
+        ctxgen = (repo[r] for r in cl.revs(partial.tiprev + 1, catip))
+        partial.update(repo, ctxgen)
+        partial.write(repo)
+    # If cacheable tip were lower than actual tip, we need to update the
+    # cache up to tip. This update (from cacheable to actual tip) is not
+    # written to disk since it's not cacheable.
+    tiprev = len(repo) - 1
+    if partial.tiprev < tiprev:
+        ctxgen = (repo[r] for r in cl.revs(partial.tiprev + 1, tiprev))
+        partial.update(repo, ctxgen)
+    repo._branchcache = partial
+
+class branchcache(dict):
+    """A dict like object that hold branches heads cache"""
+
+    def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev):
+        super(branchcache, self).__init__(entries)
+        self.tipnode = tipnode
+        self.tiprev = tiprev
+
+    def write(self, repo):
+        try:
+            f = repo.opener("cache/branchheads", "w", atomictemp=True)
+            f.write("%s %s\n" % (hex(self.tipnode), self.tiprev))
+            for label, nodes in self.iteritems():
+                for node in nodes:
+                    f.write("%s %s\n" % (hex(node), encoding.fromlocal(label)))
+            f.close()
+        except (IOError, OSError):
+            pass
+
+    def update(self, repo, ctxgen):
+        """Given a branchhead cache, self, that may have extra nodes or be
     missing heads, and a generator of nodes that are at least a superset of
-    heads missing, this function updates partial to be correct.
+        heads missing, this function updates self to be correct.
     """
     cl = repo.changelog
     # collect new branch entries
@@ -56,7 +105,7 b' def update(repo, partial, ctxgen):'
     # really branchheads. Note checking parents is insufficient:
     # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
     for branch, newnodes in newbranches.iteritems():
-        bheads = partial.setdefault(branch, [])
+            bheads = self.setdefault(branch, [])
         # Remove candidate heads that no longer are in the repo (e.g., as
         # the result of a strip that just happened).  Avoid using 'node in
         # self' here because that dives down into branchcache code somewhat
@@ -90,12 +139,11 b' def update(repo, partial, ctxgen):'
                                                      bheadrevs[0]))
             if ancestors:
                 bheadrevs = [b for b in bheadrevs if b not in ancestors]
-        partial[branch] = [cl.node(rev) for rev in bheadrevs]
+            self[branch] = [cl.node(rev) for rev in bheadrevs]
         tiprev = max(bheadrevs)
-        if tiprev > partial.tiprev:
-            partial.tipnode = cl.node(tiprev)
-            partial.tiprev = tiprev
-
+            if tiprev > self.tiprev:
+                self.tipnode = cl.node(tiprev)
+                self.tiprev = tiprev
 
     # There may be branches that cease to exist when the last commit in the
     # branch was stripped.  This code filters them out.  Note that the
@@ -103,71 +151,23 b' def update(repo, partial, ctxgen):'
     # newbranches is the set of candidate heads, which when you strip the
     # last commit in a branch will be the parent branch.
     droppednodes = []
-    for branch in partial.keys():
-        nodes = [head for head in partial[branch]
+        for branch in self.keys():
+            nodes = [head for head in self[branch]
                  if cl.hasnode(head)]
         if not nodes:
             droppednodes.extend(nodes)
-            del partial[branch]
+                del self[branch]
     try:
-        node = cl.node(partial.tiprev)
+            node = cl.node(self.tiprev)
     except IndexError:
         node = None
-    if ((partial.tipnode != node)
-        or (partial.tipnode in droppednodes)):
+        if ((self.tipnode != node)
+            or (self.tipnode in droppednodes)):
         # cache key are not valid anymore
-        partial.tipnode = nullid
-        partial.tiprev = nullrev
-        for heads in partial.values():
+            self.tipnode = nullid
+            self.tiprev = nullrev
+            for heads in self.values():
             tiprev = max(cl.rev(node) for node in heads)
-            if tiprev > partial.tiprev:
-                partial.tipnode = cl.node(tiprev)
-                partial.tiprev = tiprev
-
-
-def updatecache(repo):
-    repo = repo.unfiltered()  # Until we get a smarter cache management
-    cl = repo.changelog
-    tip = cl.tip()
-    partial = repo._branchcache
-    if partial is not None and partial.tipnode == tip:
-        return
-
-    if partial is None or partial.tipnode not in cl.nodemap:
-        partial = read(repo)
-
-    catip = repo._cacheabletip()
-    # if partial.tiprev == catip: cache is already up to date
-    # if partial.tiprev >  catip: we have uncachable element in `partial` can't
-    #                             write on disk
-    if partial.tiprev < catip:
-        ctxgen = (repo[r] for r in cl.revs(partial.tiprev + 1, catip))
-        update(repo, partial, ctxgen)
-        partial.write(repo)
-    # If cacheable tip were lower than actual tip, we need to update the
-    # cache up to tip. This update (from cacheable to actual tip) is not
-    # written to disk since it's not cacheable.
-    tiprev = len(repo) - 1
-    if partial.tiprev < tiprev:
-        ctxgen = (repo[r] for r in cl.revs(partial.tiprev + 1, tiprev))
-        update(repo, partial, ctxgen)
-    repo._branchcache = partial
-
-class branchcache(dict):
-    """A dict like object that hold branches heads cache"""
-
-    def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev):
-        super(branchcache, self).__init__(entries)
-        self.tipnode = tipnode
+                if tiprev > self.tiprev:
+                    self.tipnode = cl.node(tiprev)
         self.tiprev = tiprev
-
-    def write(self, repo):
-        try:
-            f = repo.opener("cache/branchheads", "w", atomictemp=True)
-            f.write("%s %s\n" % (hex(self.tipnode), self.tiprev))
-            for label, nodes in self.iteritems():
-                for node in nodes:
-                    f.write("%s %s\n" % (hex(node), encoding.fromlocal(label)))
-            f.close()
-        except (IOError, OSError):
-            pass

mercurial/discovery.py

@@ -196,7 +196,7 b' def _headssummary(repo, remote, outgoing'
     newmap = branchmap.branchcache((branch, heads[1])
                                  for branch, heads in headssum.iteritems()
                                  if heads[0] is not None)
-    branchmap.update(repo, newmap, missingctx)
+    newmap.update(repo, missingctx)
     for branch, newheads in newmap.iteritems():
         headssum[branch][1][:] = newheads
     return headssum

mercurial/localrepo.py

@@ -666,7 +666,7 b' class localrepository(object):'
         if self.changelog.filteredrevs:
             # some changeset are excluded we can't use the cache
             bmap = branchmap.branchcache()
-            branchmap.update(self, bmap, (self[r] for r in self))
+            bmap.update(self, (self[r] for r in self))
             return bmap
         else:
             branchmap.updatecache(self)
@@ -1437,7 +1437,7 b' class localrepository(object):'
             ctxgen = (self[node] for node in newheadnodes
                       if self.changelog.hasnode(node))
             cache = self._branchcache
-            branchmap.update(self, cache, ctxgen)
+            cache.update(self, ctxgen)
             cache.write(self)
 
         # Ensure the persistent tag cache is updated.  Doing it now