( )⚙ D4142 changegroup: extract _revisiondeltanormal() to standalone function

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4142

changegroup: extract _revisiondeltanormal() to standalone function
ClosedPublic

Authored by indygreg on Aug 6 2018, 3:51 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd85b0d81112b: changegroup: extract _revisiondeltanormal() to standalone function
Summary

It wasn't accessing anything important on the cgpacker that warranted
it being a method instead of a function.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (75 lines)

Diff 10149

mercurial/changegroup.py

# The one invariant we *know* holds is that the new (potentially # The one invariant we *know* holds is that the new (potentially
# bogus) DAG shape will be valid if we order the nodes in the # bogus) DAG shape will be valid if we order the nodes in the
# order that they're introduced in dramatis personae by the # order that they're introduced in dramatis personae by the
# changelog, so what we do is we sort the non-changelog histories # changelog, so what we do is we sort the non-changelog histories
# by the order in which they are used by the changelog. # by the order in which they are used by the changelog.
key = lambda n: clnodetorev[lookup(n)] key = lambda n: clnodetorev[lookup(n)]
return [store.rev(n) for n in sorted(nodes, key=key)] return [store.rev(n) for n in sorted(nodes, key=key)]
def _revisiondeltanormal(store, rev, prev, linknode, deltaparentfn):
"""Construct a revision delta for non-ellipses changegroup generation."""
node = store.node(rev)
p1, p2 = store.parentrevs(rev)
base = deltaparentfn(store, rev, p1, p2, prev)
prefix = ''
if store.iscensored(base) or store.iscensored(rev):
try:
delta = store.revision(node, raw=True)
except error.CensoredNodeError as e:
delta = e.tombstone
if base == nullrev:
prefix = mdiff.trivialdiffheader(len(delta))
else:
baselen = store.rawsize(base)
prefix = mdiff.replacediffheader(baselen, len(delta))
elif base == nullrev:
delta = store.revision(node, raw=True)
prefix = mdiff.trivialdiffheader(len(delta))
else:
delta = store.revdiff(base, rev)
p1n, p2n = store.parents(node)
return revisiondelta(
node=node,
p1node=p1n,
p2node=p2n,
basenode=store.node(base),
linknode=linknode,
flags=store.flags(rev),
deltachunks=(prefix, delta),
)
class cgpacker(object): class cgpacker(object):
def __init__(self, repo, filematcher, version, allowreorder, def __init__(self, repo, filematcher, version, allowreorder,
deltaparentfn, builddeltaheader, manifestsend, deltaparentfn, builddeltaheader, manifestsend,
bundlecaps=None, ellipses=False, bundlecaps=None, ellipses=False,
shallow=False, ellipsisroots=None, fullnodes=None): shallow=False, ellipsisroots=None, fullnodes=None):
"""Given a source repo, construct a bundler. """Given a source repo, construct a bundler.
filematcher is a matcher that matches on files to include in the filematcher is a matcher that matches on files to include in the
progress.update(r + 1) progress.update(r + 1)
prev, curr = revs[r], revs[r + 1] prev, curr = revs[r], revs[r + 1]
linknode = lookup(store.node(curr)) linknode = lookup(store.node(curr))
if self._ellipses: if self._ellipses:
delta = self._revisiondeltanarrow(store, ischangelog, delta = self._revisiondeltanarrow(store, ischangelog,
curr, prev, linknode) curr, prev, linknode)
else: else:
delta = self._revisiondeltanormal(store, ischangelog, delta = _revisiondeltanormal(store, curr, prev, linknode,
curr, prev, linknode) self._deltaparentfn)
if not delta: if not delta:
continue continue
meta = self._builddeltaheader(delta) meta = self._builddeltaheader(delta)
l = len(meta) + sum(len(x) for x in delta.deltachunks) l = len(meta) + sum(len(x) for x in delta.deltachunks)
yield chunkheader(l) yield chunkheader(l)
yield meta yield meta
size = len(h) size = len(h)
yield h yield h
for chunk in self.group(revs, filerevlog, False, lookupfilelog): for chunk in self.group(revs, filerevlog, False, lookupfilelog):
size += len(chunk) size += len(chunk)
yield chunk yield chunk
self._verbosenote(_('%8.i %s\n') % (size, fname)) self._verbosenote(_('%8.i %s\n') % (size, fname))
progress.complete() progress.complete()
def _revisiondeltanormal(self, store, ischangelog, rev, prev, linknode):
node = store.node(rev)
p1, p2 = store.parentrevs(rev)
base = self._deltaparentfn(store, rev, p1, p2, prev)
prefix = ''
if store.iscensored(base) or store.iscensored(rev):
try:
delta = store.revision(node, raw=True)
except error.CensoredNodeError as e:
delta = e.tombstone
if base == nullrev:
prefix = mdiff.trivialdiffheader(len(delta))
else:
baselen = store.rawsize(base)
prefix = mdiff.replacediffheader(baselen, len(delta))
elif base == nullrev:
delta = store.revision(node, raw=True)
prefix = mdiff.trivialdiffheader(len(delta))
else:
delta = store.revdiff(base, rev)
p1n, p2n = store.parents(node)
return revisiondelta(
node=node,
p1node=p1n,
p2node=p2n,
basenode=store.node(base),
linknode=linknode,
flags=store.flags(rev),
deltachunks=(prefix, delta),
)
def _revisiondeltanarrow(self, store, ischangelog, rev, prev, linknode): def _revisiondeltanarrow(self, store, ischangelog, rev, prev, linknode):
# build up some mapping information that's useful later. See # build up some mapping information that's useful later. See
# the local() nested function below. # the local() nested function below.
if ischangelog: if ischangelog:
self._clnodetorev[linknode] = rev self._clnodetorev[linknode] = rev
linkrev = rev linkrev = rev
self._clrevtolocalrev[linkrev] = rev self._clrevtolocalrev[linkrev] = rev
else: else:
linkrev = self._clnodetorev[linknode] linkrev = self._clnodetorev[linknode]
self._clrevtolocalrev[linkrev] = rev self._clrevtolocalrev[linkrev] = rev
# This is a node to send in full, because the changeset it # This is a node to send in full, because the changeset it
# corresponds to was a full changeset. # corresponds to was a full changeset.
if linknode in self._fullnodes: if linknode in self._fullnodes:
return self._revisiondeltanormal(store, ischangelog, rev, prev, return _revisiondeltanormal(store, rev, prev, linknode,
linknode) self._deltaparentfn)
# At this point, a node can either be one we should skip or an # At this point, a node can either be one we should skip or an
# ellipsis. If it's not an ellipsis, bail immediately. # ellipsis. If it's not an ellipsis, bail immediately.
if linkrev not in self._precomputedellipsis: if linkrev not in self._precomputedellipsis:
return return
linkparents = self._precomputedellipsis[linkrev] linkparents = self._precomputedellipsis[linkrev]
def local(clrev): def local(clrev):