( )⚙ D8540 git: implement some changelog methods

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8540

git: implement some changelog methods
ClosedPublic

Authored by rom1dep on May 17 2020, 1:41 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG3e09d22a0bf5: git: implement some changelog methods

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

rom1dep created this revision.May 17 2020, 1:41 PM
durin42 added a comment.May 17 2020, 9:25 PM

I assume this fixed ... something? Is there any test you could add to one of the test-git*.t tests that would demonstrate that?

rom1dep added a comment.May 18 2020, 2:46 AM

hi @durin42 , yes indeed, that fixes tortoisehg's loading of a hgit repo (now the DAG is fully visible, selection of commits work, I have other patches there too to work around things for status),
I didn't think much of these changes because the added methods are rip-offs of the ones in /mercurial/revlog.py,
maybe there is an abstraction which could be used there so not to duplicate this code/these tests?

rom1dep added a commit: rHG3e09d22a0bf5: git: implement some changelog methods.May 18 2020, 12:47 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG3e09d22a0bf5: git: implement some changelog methods (authored by rom1dep). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/git/gitlog.py (54 lines)

Diff 21404

hgext/git/gitlog.py

return ancestor.lazyancestors( return ancestor.lazyancestors(
self.parentrevs, revs, stoprev=stoprev, inclusive=inclusive self.parentrevs, revs, stoprev=stoprev, inclusive=inclusive
) )
# Cleanup opportunity: this is *identical* to the revlog.py version # Cleanup opportunity: this is *identical* to the revlog.py version
def descendants(self, revs): def descendants(self, revs):
return dagop.descendantrevs(revs, self.revs, self.parentrevs) return dagop.descendantrevs(revs, self.revs, self.parentrevs)
def incrementalmissingrevs(self, common=None):
"""Return an object that can be used to incrementally compute the
revision numbers of the ancestors of arbitrary sets that are not
ancestors of common. This is an ancestor.incrementalmissingancestors
object.
'common' is a list of revision numbers. If common is not supplied, uses
nullrev.
"""
if common is None:
common = [nodemod.nullrev]
return ancestor.incrementalmissingancestors(self.parentrevs, common)
def findmissing(self, common=None, heads=None):
"""Return the ancestors of heads that are not ancestors of common.
More specifically, return a list of nodes N such that every N
satisfies the following constraints:
1. N is an ancestor of some node in 'heads'
2. N is not an ancestor of any node in 'common'
The list is sorted by revision number, meaning it is
topologically sorted.
'heads' and 'common' are both lists of node IDs. If heads is
not supplied, uses all of the revlog's heads. If common is not
supplied, uses nullid."""
if common is None:
common = [nodemod.nullid]
if heads is None:
heads = self.heads()
common = [self.rev(n) for n in common]
heads = [self.rev(n) for n in heads]
inc = self.incrementalmissingrevs(common=common)
return [self.node(r) for r in inc.missingancestors(heads)]
def children(self, node):
"""find the children of a given node"""
c = []
p = self.rev(node)
for r in self.revs(start=p + 1):
prevs = [pr for pr in self.parentrevs(r) if pr != nodemod.nullrev]
if prevs:
for pr in prevs:
if pr == p:
c.append(self.node(r))
elif p == nodemod.nullrev:
c.append(self.node(r))
return c
def reachableroots(self, minroot, heads, roots, includepath=False): def reachableroots(self, minroot, heads, roots, includepath=False):
return dagop._reachablerootspure( return dagop._reachablerootspure(
self.parentrevs, minroot, roots, heads, includepath self.parentrevs, minroot, roots, heads, includepath
) )
# Cleanup opportunity: this is *identical* to the revlog.py version # Cleanup opportunity: this is *identical* to the revlog.py version
def isancestor(self, a, b): def isancestor(self, a, b):
a, b = self.rev(a), self.rev(b) a, b = self.rev(a), self.rev(b)