# HG changeset patch # User Pierre-Yves David # Date 1504976570 -19800 # Node ID 5b514ab2ab4e74f5b36d0ec1ed7ce7d0afcd40d6 # Parent 0437158e0ed6ce5a827895f79c091ac8e1b7f8a7 stack: properly order stack when gaps existing inside it We transitively search for the next "stack" ancestors, of changeset in the stack not based on other revision of the stack. This should help having a consistent display when topic are interleaved. diff -r 0437158e0ed6 -r 5b514ab2ab4e hgext3rd/topic/stack.py --- a/hgext3rd/topic/stack.py Thu Sep 07 19:43:07 2017 +0200 +++ b/hgext3rd/topic/stack.py Sat Sep 09 22:32:50 2017 +0530 @@ -8,9 +8,10 @@ context, error, node, + phases, util, ) -from .evolvebits import builddependencies, _orderrevs, _singlesuccessor +from .evolvebits import builddependencies, _singlesuccessor short = node.short @@ -50,11 +51,84 @@ @util.propertycache def _dependencies(self): - return builddependencies(self._repo, self.revs[1:]) + deps, rdeps = builddependencies(self._repo, self._revs) + + repo = self._repo + srcpfunc = repo.changelog.parentrevs + + ### post process to skip over possible gaps in the stack + # + # For example in the following situation, we need to detect that "t3" + # indirectly depends on t2. + # + # o t3 + # | + # o other + # | + # o t2 + # | + # o t1 + + pmap = {} + + def pfuncrev(repo, rev): + """a special "parent func" that also consider successors""" + parents = pmap.get(rev) + if parents is None: + parents = [repo[_singlesuccessor(repo, repo[p])].rev() + for p in srcpfunc(rev) if 0 <= p] + pmap[rev] = parents + return parents + + revs = self._revs + stackrevs = set(self._revs) + for root in [r for r in revs if not deps[r]]: + seen = set() + stack = [root] + while stack: + current = stack.pop() + for p in pfuncrev(repo, current): + if p in seen: + continue + seen.add(p) + if p in stackrevs: + rdeps[p].add(root) + deps[root].add(p) + elif phases.public < repo[p].phase(): + # traverse only if we did not found a proper candidate + stack.append(p) + + return deps, rdeps @util.propertycache def revs(self): - revs = _orderrevs(self._repo, self._revs) + # some duplication/change from _orderrevs because we use a post + # processed dependency graph. + + # Step 1: compute relation of revision with each other + dependencies, rdependencies = self._dependencies + dependencies = dependencies.copy() + rdependencies = rdependencies.copy() + # Step 2: Build the ordering + # Remove the revisions with no dependency(A) and add them to the ordering. + # Removing these revisions leads to new revisions with no dependency (the + # one depending on A) that we can remove from the dependency graph and add + # to the ordering. We progress in a similar fashion until the ordering is + # built + solvablerevs = [r for r in sorted(dependencies.keys()) + if not dependencies[r]] + revs = [] + while solvablerevs: + rev = solvablerevs.pop() + for dependent in rdependencies[rev]: + dependencies[dependent].remove(rev) + if not dependencies[dependent]: + solvablerevs.append(dependent) + del dependencies[rev] + revs.append(rev) + + revs.extend(sorted(dependencies)) + # step 3: add t0 if revs: pt1 = self._repo[revs[0]].p1() if pt1.obsolete(): diff -r 0437158e0ed6 -r 5b514ab2ab4e tests/test-topic-stack.t --- a/tests/test-topic-stack.t Thu Sep 07 19:43:07 2017 +0200 +++ b/tests/test-topic-stack.t Sat Sep 09 22:32:50 2017 +0530 @@ -532,24 +532,26 @@ o 0 default {} public c_a XXX: The following should show single heads +XXX: The behind count is weird, because the topic are interleaved. + $ hg stack - ### topic: foobar (2 heads) + ### topic: foobar ### branch: default, 3 behind - t2: c_D - ^ c_c - t1@ c_e (current) - t0^ c_h (base) + t2@ c_e (current) + ^ c_h + t1: c_D + t0^ c_c (base) $ hg stack foo - ### topic: foo (3 heads) + ### topic: foo ### branch: default, ambigious rebase destination - t4: c_c - ^ c_b + t4: c_f + ^ c_e t3: c_h t2: c_g ^ c_D - t1: c_f - t0^ c_e (base) + t1: c_c + t0^ c_b (base) case involving a merge ---------------------- @@ -618,27 +620,26 @@ $ hg stack red - ### topic: red (3 heads) + ### topic: red ### branch: default, 6 behind - t5: c_C - t2^ c_B (base) - t4: c_F - t3: c_E - t2: c_B - ^ c_A - t1: c_H + t5: c_H ^ c_G ^ c_D - t0^ c_D (base) + t4: c_C + t1^ c_B (base) + t3: c_F + t2: c_E + t1: c_B + t0^ c_A (base) $ hg stack blue - ### topic: blue (3 heads) + ### topic: blue ### branch: default, ambigious rebase destination - t3: c_D + t3@ c_I (current) + ^ c_H + t2: c_D ^ c_C - t2: c_G - ^ c_F - t1@ c_I (current) - t0^ c_H (base) + t1: c_G + t0^ c_F (base) Even with some obsolete and orphan changesets @@ -684,7 +685,7 @@ $ hg stack red - ### topic: red (3 heads) + ### topic: red ### branch: default, ambigious rebase destination t5$ c_H (unstable) ^ c_G @@ -696,12 +697,12 @@ t1: c_B t0^ c_A (base) $ hg stack blue - ### topic: blue (3 heads) + ### topic: blue ### branch: default, ambigious rebase destination - t3$ c_G (unstable) + t3$ c_I (unstable) + ^ c_H + t2$ c_G (unstable) ^ c_F - t2$ c_I (unstable) - ^ c_H t1$ c_D (current unstable) t0^ c_C (base) @@ -758,7 +759,7 @@ $ hg stack red - ### topic: red (3 heads) + ### topic: red ### branch: default, ambigious rebase destination t5$ c_H (unstable) ^ c_G @@ -770,7 +771,7 @@ t1: c_B t0^ c_A (base) $ hg stack blue - ### topic: blue (3 heads) + ### topic: blue ### branch: default, ambigious rebase destination t3$ c_I (unstable) ^ c_H