diff mercurial/changegroup.py @ 38891:205c98e2f1ba

changegroup: rename "revlog" variables

"revlog" shadows the module import. But more importantly, changegroup
generation should be storage agnostic and not assume the existence
of revlogs. Let's rename the thing providing revision storage to
"store" to reflect this ideal property.

Differential Revision: https://phab.mercurial-scm.org/D4073

--- a/mercurial/changegroup.py	Thu Aug 02 14:15:10 2018 -0700
+++ b/mercurial/changegroup.py	Thu Aug 02 17:05:11 2018 -0700
@@ -557,7 +557,7 @@
         return chunkheader(len(fname)) + fname
 
     # Extracted both for clarity and for overriding in extensions.
-    def _sortgroup(self, revlog, nodelist, lookup):
+    def _sortgroup(self, store, nodelist, lookup):
         """Sort nodes for change group and turn them into revnums."""
         # Ellipses serving mode.
         #
@@ -577,17 +577,17 @@
         # by the order in which they are used by the changelog.
         if util.safehasattr(self, 'full_nodes') and self.clnode_to_rev:
             key = lambda n: self.clnode_to_rev[lookup(n)]
-            return [revlog.rev(n) for n in sorted(nodelist, key=key)]
+            return [store.rev(n) for n in sorted(nodelist, key=key)]
 
         # for generaldelta revlogs, we linearize the revs; this will both be
         # much quicker and generate a much smaller bundle
-        if (revlog._generaldelta and self._reorder is None) or self._reorder:
-            dag = dagutil.revlogdag(revlog)
-            return dag.linearize(set(revlog.rev(n) for n in nodelist))
+        if (store._generaldelta and self._reorder is None) or self._reorder:
+            dag = dagutil.revlogdag(store)
+            return dag.linearize(set(store.rev(n) for n in nodelist))
         else:
-            return sorted([revlog.rev(n) for n in nodelist])
+            return sorted([store.rev(n) for n in nodelist])
 
-    def group(self, nodelist, revlog, lookup, units=None):
+    def group(self, nodelist, store, lookup, units=None):
         """Calculate a delta group, yielding a sequence of changegroup chunks
         (strings).
 
@@ -606,10 +606,10 @@
             yield self.close()
             return
 
-        revs = self._sortgroup(revlog, nodelist, lookup)
+        revs = self._sortgroup(store, nodelist, lookup)
 
         # add the parent of the first rev
-        p = revlog.parentrevs(revs[0])[0]
+        p = store.parentrevs(revs[0])[0]
         revs.insert(0, p)
 
         # build deltas
@@ -621,8 +621,8 @@
             if progress:
                 progress.update(r + 1)
             prev, curr = revs[r], revs[r + 1]
-            linknode = lookup(revlog.node(curr))
-            for c in self.revchunk(revlog, curr, prev, linknode):
+            linknode = lookup(store.node(curr))
+            for c in self.revchunk(store, curr, prev, linknode):
                 yield c
 
         if progress:
@@ -630,13 +630,13 @@
         yield self.close()
 
     # filter any nodes that claim to be part of the known set
-    def prune(self, revlog, missing, commonrevs):
+    def prune(self, store, missing, commonrevs):
         # TODO this violates storage abstraction for manifests.
-        if isinstance(revlog, manifest.manifestrevlog):
-            if not self._filematcher.visitdir(revlog._dir[:-1] or '.'):
+        if isinstance(store, manifest.manifestrevlog):
+            if not self._filematcher.visitdir(store._dir[:-1] or '.'):
                 return []
 
-        rr, rl = revlog.rev, revlog.linkrev
+        rr, rl = store.rev, store.linkrev
         return [n for n in missing if rl(rr(n)) not in commonrevs]
 
     def _packmanifests(self, dir, mfnodes, lookuplinknode):
@@ -906,43 +906,43 @@
                 self._verbosenote(_('%8.i  %s\n') % (size, fname))
         progress.complete()
 
-    def deltaparent(self, revlog, rev, p1, p2, prev):
-        if not revlog.candelta(prev, rev):
+    def deltaparent(self, store, rev, p1, p2, prev):
+        if not store.candelta(prev, rev):
             raise error.ProgrammingError('cg1 should not be used in this case')
         return prev
 
-    def revchunk(self, revlog, rev, prev, linknode):
+    def revchunk(self, store, rev, prev, linknode):
         if util.safehasattr(self, 'full_nodes'):
             fn = self._revchunknarrow
         else:
             fn = self._revchunknormal
 
-        return fn(revlog, rev, prev, linknode)
+        return fn(store, rev, prev, linknode)
 
-    def _revchunknormal(self, revlog, rev, prev, linknode):
-        node = revlog.node(rev)
-        p1, p2 = revlog.parentrevs(rev)
-        base = self.deltaparent(revlog, rev, p1, p2, prev)
+    def _revchunknormal(self, store, rev, prev, linknode):
+        node = store.node(rev)
+        p1, p2 = store.parentrevs(rev)
+        base = self.deltaparent(store, rev, p1, p2, prev)
 
         prefix = ''
-        if revlog.iscensored(base) or revlog.iscensored(rev):
+        if store.iscensored(base) or store.iscensored(rev):
             try:
-                delta = revlog.revision(node, raw=True)
+                delta = store.revision(node, raw=True)
             except error.CensoredNodeError as e:
                 delta = e.tombstone
             if base == nullrev:
                 prefix = mdiff.trivialdiffheader(len(delta))
             else:
-                baselen = revlog.rawsize(base)
+                baselen = store.rawsize(base)
                 prefix = mdiff.replacediffheader(baselen, len(delta))
         elif base == nullrev:
-            delta = revlog.revision(node, raw=True)
+            delta = store.revision(node, raw=True)
             prefix = mdiff.trivialdiffheader(len(delta))
         else:
-            delta = revlog.revdiff(base, rev)
-        p1n, p2n = revlog.parents(node)
-        basenode = revlog.node(base)
-        flags = revlog.flags(rev)
+            delta = store.revdiff(base, rev)
+        p1n, p2n = store.parents(node)
+        basenode = store.node(base)
+        flags = store.flags(rev)
         meta = self.builddeltaheader(node, p1n, p2n, basenode, linknode, flags)
         meta += prefix
         l = len(meta) + len(delta)
@@ -950,7 +950,7 @@
         yield meta
         yield delta
 
-    def _revchunknarrow(self, revlog, rev, prev, linknode):
+    def _revchunknarrow(self, store, rev, prev, linknode):
         # build up some mapping information that's useful later. See
         # the local() nested function below.
         if not self.changelog_done:
@@ -964,7 +964,7 @@
         # This is a node to send in full, because the changeset it
         # corresponds to was a full changeset.
         if linknode in self.full_nodes:
-            for x in self._revchunknormal(revlog, rev, prev, linknode):
+            for x in self._revchunknormal(store, rev, prev, linknode):
                 yield x
             return
 
@@ -994,7 +994,7 @@
                 # our contained ellipsis nodes will be able to resolve
                 # their parents.
                 if clrev not in self.clrev_to_localrev:
-                    clnode = revlog.node(clrev)
+                    clnode = store.node(clrev)
                     self.clnode_to_rev[clnode] = clrev
                 return clrev
 
@@ -1034,28 +1034,28 @@
                     # where this breaks down a bit. That said, I don't
                     # know if it would hurt anything.
                     for i in pycompat.xrange(rev, 0, -1):
-                        if revlog.linkrev(i) == clrev:
+                        if store.linkrev(i) == clrev:
                             return i
                     # We failed to resolve a parent for this node, so
                     # we crash the changegroup construction.
                     raise error.Abort(
                         'unable to resolve parent while packing %r %r'
-                        ' for changeset %r' % (revlog.indexfile, rev, clrev))
+                        ' for changeset %r' % (store.indexfile, rev, clrev))
 
             return nullrev
 
         if not linkparents or (
-            revlog.parentrevs(rev) == (nullrev, nullrev)):
+            store.parentrevs(rev) == (nullrev, nullrev)):
             p1, p2 = nullrev, nullrev
         elif len(linkparents) == 1:
             p1, = sorted(local(p) for p in linkparents)
             p2 = nullrev
         else:
             p1, p2 = sorted(local(p) for p in linkparents)
-        n = revlog.node(rev)
+        n = store.node(rev)
 
         yield ellipsisdata(
-            self, rev, revlog, p1, p2, revlog.revision(n), linknode)
+            self, rev, store, p1, p2, store.revision(n), linknode)
 
     def builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
         # do nothing with basenode, it is implicitly the previous one in HG10
@@ -1076,7 +1076,7 @@
             # bundle.reorder=auto just like bundle.reorder=False).
             self._reorder = False
 
-    def deltaparent(self, revlog, rev, p1, p2, prev):
+    def deltaparent(self, store, rev, p1, p2, prev):
         # Narrow ellipses mode.
         if util.safehasattr(self, 'full_nodes'):
             # TODO: send better deltas when in narrow mode.
@@ -1092,8 +1092,8 @@
             # all revlogs, and we don't have the linkrev/linknode here.
             return p1
 
-        dp = revlog.deltaparent(rev)
-        if dp == nullrev and revlog.storedeltachains:
+        dp = store.deltaparent(rev)
+        if dp == nullrev and store.storedeltachains:
             # Avoid sending full revisions when delta parent is null. Pick prev
             # in that case. It's tempting to pick p1 in this case, as p1 will
             # be smaller in the common case. However, computing a delta against
@@ -1111,7 +1111,7 @@
             return prev
         else:
             base = dp
-        if base != nullrev and not revlog.candelta(base, rev):
+        if base != nullrev and not store.candelta(base, rev):
             base = nullrev
         return base