This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4663

filelog: stop proxying headrevs() (API)
ClosedPublic

Authored by indygreg on Sep 18 2018, 10:34 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG979e9f124caa: filelog: stop proxying headrevs() (API)
Summary

The previous commit removed the last user of this method. It is
redundant with heads() and adds little to no value other than
convenience. Let's nuke 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 18 2018, 10:34 PM
Closed by commit rHG979e9f124caa: filelog: stop proxying headrevs() (API) (authored by indygreg). · Explain WhySep 23 2018, 6:26 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11289

mercurial/filelog.py

def commonancestorsheads(self, node1, node2): def commonancestorsheads(self, node1, node2):
return self._revlog.commonancestorsheads(node1, node2) return self._revlog.commonancestorsheads(node1, node2)
# Used by dagop.blockdescendants(). # Used by dagop.blockdescendants().
def descendants(self, revs): def descendants(self, revs):
return self._revlog.descendants(revs) return self._revlog.descendants(revs)
# Used by hgweb.
def headrevs(self):
return self._revlog.headrevs()
def heads(self, start=None, stop=None): def heads(self, start=None, stop=None):
return self._revlog.heads(start, stop) return self._revlog.heads(start, stop)
# Used by hgweb, children extension. # Used by hgweb, children extension.
def children(self, node): def children(self, node):
return self._revlog.children(node) return self._revlog.children(node)
def deltaparent(self, rev): def deltaparent(self, rev):

mercurial/repository.py

""" """
def descendants(revs): def descendants(revs):
"""Obtain descendant revision numbers for a set of revision numbers. """Obtain descendant revision numbers for a set of revision numbers.
If ``nullrev`` is in the set, this is equivalent to ``revs()``. If ``nullrev`` is in the set, this is equivalent to ``revs()``.
""" """
def headrevs():
"""Obtain a list of revision numbers that are DAG heads.
The list is sorted oldest to newest.
TODO determine if sorting is required.
"""
def heads(start=None, stop=None): def heads(start=None, stop=None):
"""Obtain a list of nodes that are DAG heads, with control. """Obtain a list of nodes that are DAG heads, with control.
The set of revisions examined can be limited by specifying The set of revisions examined can be limited by specifying
``start`` and ``stop``. ``start`` is a node. ``stop`` is an ``start`` and ``stop``. ``start`` is a node. ``stop`` is an
iterable of nodes. DAG traversal starts at earlier revision iterable of nodes. DAG traversal starts at earlier revision
``start`` and iterates forward until any node in ``stop`` is ``start`` and iterates forward until any node in ``stop`` is
encountered. encountered.

mercurial/testing/storage.py

self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), []) self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), [])
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
self.assertEqual(list(f.descendants([])), []) self.assertEqual(list(f.descendants([])), [])
self.assertEqual(list(f.descendants([nullrev])), []) self.assertEqual(list(f.descendants([nullrev])), [])
self.assertEqual(f.headrevs(), [nullrev])
self.assertEqual(f.heads(), [nullid]) self.assertEqual(f.heads(), [nullid])
self.assertEqual(f.heads(nullid), [nullid]) self.assertEqual(f.heads(nullid), [nullid])
self.assertEqual(f.heads(None, [nullid]), [nullid]) self.assertEqual(f.heads(None, [nullid]), [nullid])
self.assertEqual(f.heads(nullid, [nullid]), [nullid]) self.assertEqual(f.heads(nullid, [nullid]), [nullid])
self.assertEqual(f.children(nullid), []) self.assertEqual(f.children(nullid), [])
with self.assertRaises(error.LookupError): with self.assertRaises(error.LookupError):
self.assertFalse(f.iscensored(0)) self.assertFalse(f.iscensored(0))
with self.assertRaises(IndexError): with self.assertRaises(IndexError):
f.iscensored(1) f.iscensored(1)
self.assertEqual(list(f.descendants([0])), []) self.assertEqual(list(f.descendants([0])), [])
self.assertEqual(f.headrevs(), [0])
self.assertEqual(f.heads(), [node]) self.assertEqual(f.heads(), [node])
self.assertEqual(f.heads(node), [node]) self.assertEqual(f.heads(node), [node])
self.assertEqual(f.heads(stop=[node]), [node]) self.assertEqual(f.heads(stop=[node]), [node])
with self.assertRaises(error.LookupError): with self.assertRaises(error.LookupError):
f.heads(stop=[b'\x01' * 20]) f.heads(stop=[b'\x01' * 20])
self.assertEqual(f.children(node), []) self.assertEqual(f.children(node), [])
self.assertEqual(f.commonancestorsheads(node0, node1), [node0]) self.assertEqual(f.commonancestorsheads(node0, node1), [node0])
self.assertEqual(f.commonancestorsheads(node1, node2), [node1]) self.assertEqual(f.commonancestorsheads(node1, node2), [node1])
self.assertEqual(f.commonancestorsheads(node2, node1), [node1]) self.assertEqual(f.commonancestorsheads(node2, node1), [node1])
self.assertEqual(list(f.descendants([0])), [1, 2]) self.assertEqual(list(f.descendants([0])), [1, 2])
self.assertEqual(list(f.descendants([1])), [2]) self.assertEqual(list(f.descendants([1])), [2])
self.assertEqual(list(f.descendants([0, 1])), [1, 2]) self.assertEqual(list(f.descendants([0, 1])), [1, 2])
self.assertEqual(f.headrevs(), [2])
self.assertEqual(f.heads(), [node2]) self.assertEqual(f.heads(), [node2])
self.assertEqual(f.heads(node0), [node2]) self.assertEqual(f.heads(node0), [node2])
self.assertEqual(f.heads(node1), [node2]) self.assertEqual(f.heads(node1), [node2])
self.assertEqual(f.heads(node2), [node2]) self.assertEqual(f.heads(node2), [node2])
# TODO this behavior seems wonky. Is it correct? If so, the # TODO this behavior seems wonky. Is it correct? If so, the
# docstring for heads() should be updated to reflect desired # docstring for heads() should be updated to reflect desired
# behavior. # behavior.
self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5]) self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5])
self.assertEqual(list(f.descendants([1])), [2]) self.assertEqual(list(f.descendants([1])), [2])
self.assertEqual(list(f.descendants([2])), []) self.assertEqual(list(f.descendants([2])), [])
self.assertEqual(list(f.descendants([3])), [4]) self.assertEqual(list(f.descendants([3])), [4])
self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5]) self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5])
self.assertEqual(list(f.descendants([1, 3])), [2, 4]) self.assertEqual(list(f.descendants([1, 3])), [2, 4])
self.assertEqual(f.headrevs(), [2, 4, 5])
self.assertEqual(f.heads(), [node2, node4, node5]) self.assertEqual(f.heads(), [node2, node4, node5])
self.assertEqual(f.heads(node0), [node2, node4, node5]) self.assertEqual(f.heads(node0), [node2, node4, node5])
self.assertEqual(f.heads(node1), [node2]) self.assertEqual(f.heads(node1), [node2])
self.assertEqual(f.heads(node2), [node2]) self.assertEqual(f.heads(node2), [node2])
self.assertEqual(f.heads(node3), [node4]) self.assertEqual(f.heads(node3), [node4])
self.assertEqual(f.heads(node4), [node4]) self.assertEqual(f.heads(node4), [node4])
self.assertEqual(f.heads(node5), [node5]) self.assertEqual(f.heads(node5), [node5])

tests/simplestorerepo.py

p2node=request.p2node, p2node=request.p2node,
linknode=request.linknode, linknode=request.linknode,
basenode=self.node(baserev), basenode=self.node(baserev),
flags=self.flags(rev) | extraflags, flags=self.flags(rev) | extraflags,
baserevisionsize=baserevisionsize, baserevisionsize=baserevisionsize,
revision=revision, revision=revision,
delta=delta) delta=delta)
def headrevs(self):
# Assume all revisions are heads by default.
revishead = {rev: True for rev in self._indexbyrev}
for rev, entry in self._indexbyrev.items():
# Unset head flag for all seen parents.
revishead[self.rev(entry[b'p1'])] = False
revishead[self.rev(entry[b'p2'])] = False
return [rev for rev, ishead in sorted(revishead.items())
if ishead]
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:
def getstrippoint(self, minlink): def getstrippoint(self, minlink):
# This is largely a copy of revlog.getstrippoint(). # This is largely a copy of revlog.getstrippoint().
brokenrevs = set() brokenrevs = set()
strippoint = len(self) strippoint = len(self)
heads = {} heads = {}
futurelargelinkrevs = set() futurelargelinkrevs = set()
for head in self.headrevs(): for head in self.heads():
headlinkrev = self.linkrev(head) headlinkrev = self.linkrev(self.rev(head))
heads[head] = headlinkrev heads[head] = headlinkrev
if headlinkrev >= minlink: if headlinkrev >= minlink:
futurelargelinkrevs.add(headlinkrev) futurelargelinkrevs.add(headlinkrev)
# This algorithm involves walking down the rev graph, starting at the # This algorithm involves walking down the rev graph, starting at the
# heads. Since the revs are topologically sorted according to linkrev, # heads. Since the revs are topologically sorted according to linkrev,
# once all head linkrevs are below the minlink, we know there are # once all head linkrevs are below the minlink, we know there are
# no more revs that could have a linkrev greater than minlink. # no more revs that could have a linkrev greater than minlink.