This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4792

filelog: remove revdiff() (API)
ClosedPublic

Authored by indygreg on Sep 28 2018, 8:18 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG2f80eaf38ed4: filelog: remove revdiff() (API)
Summary

This proxy method is no longer used.

While it might be useful to query a storage backend for the delta
between any 2 revisions because the store could have a delta cached
and could compute it more efficiently than the caller calling
revision() twice in order to compute a delta, since nothing in core
is using this API now, I feel comfortable nuking it.

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.

Event Timeline

indygreg created this revision.Sep 28 2018, 8:18 PM
Closed by commit rHG2f80eaf38ed4: filelog: remove revdiff() (API) (authored by indygreg). · Explain WhyOct 3 2018, 11:04 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11606

mercurial/filelog.py

# Might be unused. # Might be unused.
def checkhash(self, text, node, p1=None, p2=None, rev=None): def checkhash(self, text, node, p1=None, p2=None, rev=None):
return self._revlog.checkhash(text, node, p1=p1, p2=p2, rev=rev) return self._revlog.checkhash(text, node, p1=p1, p2=p2, rev=rev)
def revision(self, node, _df=None, raw=False): def revision(self, node, _df=None, raw=False):
return self._revlog.revision(node, _df=_df, raw=raw) return self._revlog.revision(node, _df=_df, raw=raw)
def revdiff(self, rev1, rev2):
return self._revlog.revdiff(rev1, rev2)
def emitrevisions(self, nodes, nodesorder=None, def emitrevisions(self, nodes, nodesorder=None,
revisiondata=False, assumehaveparentrevisions=False, revisiondata=False, assumehaveparentrevisions=False,
deltaprevious=False): deltaprevious=False):
return self._revlog.emitrevisions( return self._revlog.emitrevisions(
nodes, nodesorder=nodesorder, revisiondata=revisiondata, nodes, nodesorder=nodesorder, revisiondata=revisiondata,
assumehaveparentrevisions=assumehaveparentrevisions, assumehaveparentrevisions=assumehaveparentrevisions,
deltaprevious=deltaprevious) deltaprevious=deltaprevious)

mercurial/repository.py

Returns True if the fulltext is different from what is stored. Returns True if the fulltext is different from what is stored.
This takes copy metadata into account. This takes copy metadata into account.
TODO better document the copy metadata and censoring logic. TODO better document the copy metadata and censoring logic.
""" """
def revdiff(rev1, rev2):
"""Obtain a delta between two revision numbers.
Operates on raw data in the store (``revision(node, raw=True)``).
The returned data is the result of ``bdiff.bdiff`` on the raw
revision data.
"""
def emitrevisions(nodes, def emitrevisions(nodes,
nodesorder=None, nodesorder=None,
revisiondata=False, revisiondata=False,
assumehaveparentrevisions=False, assumehaveparentrevisions=False,
deltaprevious=False): deltaprevious=False):
"""Produce ``irevisiondelta`` for revisions. """Produce ``irevisiondelta`` for revisions.
Given an iterable of nodes, emits objects conforming to the Given an iterable of nodes, emits objects conforming to the

mercurial/testing/storage.py

f.read(b'\x01' * 20) f.read(b'\x01' * 20)
self.assertTrue(f.cmp(nullid, b'')) self.assertTrue(f.cmp(nullid, b''))
self.assertTrue(f.cmp(nullid, b'foo')) self.assertTrue(f.cmp(nullid, b'foo'))
with self.assertRaises(error.LookupError): with self.assertRaises(error.LookupError):
f.cmp(b'\x01' * 20, b'irrelevant') f.cmp(b'\x01' * 20, b'irrelevant')
self.assertEqual(f.revdiff(nullrev, nullrev), b'')
with self.assertRaises(IndexError):
f.revdiff(0, nullrev)
with self.assertRaises(IndexError):
f.revdiff(nullrev, 0)
with self.assertRaises(IndexError):
f.revdiff(0, 0)
# Emitting empty list is an empty generator. # Emitting empty list is an empty generator.
gen = f.emitrevisions([]) gen = f.emitrevisions([])
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(gen) next(gen)
# Emitting null node yields nothing. # Emitting null node yields nothing.
gen = f.emitrevisions([nullid]) gen = f.emitrevisions([nullid])
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
self.assertEqual(f.read(node), fulltext) self.assertEqual(f.read(node), fulltext)
self.assertFalse(f.renamed(node)) self.assertFalse(f.renamed(node))
self.assertFalse(f.cmp(node, fulltext)) self.assertFalse(f.cmp(node, fulltext))
self.assertTrue(f.cmp(node, fulltext + b'extra')) self.assertTrue(f.cmp(node, fulltext + b'extra'))
self.assertEqual(f.revdiff(0, 0), b'')
self.assertEqual(f.revdiff(nullrev, 0),
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07%s' %
fulltext)
self.assertEqual(f.revdiff(0, nullrev),
b'\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00')
# Emitting a single revision works. # Emitting a single revision works.
gen = f.emitrevisions([node]) gen = f.emitrevisions([node])
rev = next(gen) rev = next(gen)
self.assertEqual(rev.node, node) self.assertEqual(rev.node, node)
self.assertEqual(rev.p1node, nullid) self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid) self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode) self.assertIsNone(rev.linknode)
self.assertFalse(f.cmp(node2, fulltext2)) self.assertFalse(f.cmp(node2, fulltext2))
self.assertTrue(f.cmp(node1, fulltext0)) self.assertTrue(f.cmp(node1, fulltext0))
self.assertTrue(f.cmp(node2, fulltext1)) self.assertTrue(f.cmp(node2, fulltext1))
with self.assertRaises(error.LookupError): with self.assertRaises(error.LookupError):
f.cmp(b'\x01' * 20, b'irrelevant') f.cmp(b'\x01' * 20, b'irrelevant')
self.assertEqual(f.revdiff(0, 1),
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
fulltext1)
self.assertEqual(f.revdiff(0, 2),
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x02' +
fulltext2)
# Nodes should be emitted in order. # Nodes should be emitted in order.
gen = f.emitrevisions([node0, node1, node2], revisiondata=True) gen = f.emitrevisions([node0, node1, node2], revisiondata=True)
rev = next(gen) rev = next(gen)
self.assertEqual(rev.node, node0) self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid) self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid) self.assertEqual(rev.p2node, nullid)

tests/simplestorerepo.py

self._addrawrevision(node, text, transaction, linkrev, p1, p2, self._addrawrevision(node, text, transaction, linkrev, p1, p2,
flags) flags)
if addrevisioncb: if addrevisioncb:
addrevisioncb(self, node) addrevisioncb(self, node)
return nodes return nodes
def revdiff(self, rev1, rev2):
validaterev(rev1)
validaterev(rev2)
node1 = self.node(rev1)
node2 = self.node(rev2)
return mdiff.textdiff(self.revision(node1, raw=True),
self.revision(node2, raw=True))
def heads(self, start=None, stop=None): def heads(self, start=None, stop=None):
# This is copied from revlog.py. # This is copied from revlog.py.
if start is None and stop is None: if start is None and stop is None:
if not len(self): if not len(self):
return [nullid] return [nullid]
return [self.node(r) for r in self.headrevs()] return [self.node(r) for r in self.headrevs()]
if start is None: if start is None: