comparison hgext/evolve.py @ 1361:043e5ca9322f

evolve: extract the code computing dependencies in a separate function

The code to compute dependencies between unstable changeset can be reused to
compute the next reveset. This patch extracts it in its own function to make
it reusable.

1360:5c13945b32fc

        newer = obsolete.successorssets(repo, obs.node())
    if len(newer) > 1:
        raise util.Abort(_("conflict rewriting. can't choose destination\n"))
    return repo[newer[0][0]].rev()

def orderrevs(repo, revs):
    """ Compute an ordering to solve instability for the given revs

    - Takes revs a list of instable revisions

    - Returns the same revisions ordered to solve their instability from the
    bottom to the top of the stack that the stabilization process will produce
    eventually.

    This ensure the minimal number of stabilization as we can stabilize each
    revision on its final, stabilized, destination.
    """

    # Step 1: Build the dependency graph
    # For each troubled revision we keep track of what instability if any should
    # be resolved in order to resolve it. Example:
    # dependencies = {3: [6], 6:[]}
    # Means that: 6 has no dependency, 3 depends on 6 to be solved
    dependencies = {}

        for p in repo[r].parents():
            succ = _singlesuccessor(repo, p)
            if succ in revs:
                dependencies[r].add(succ)
                rdependencies[succ].add(r)

    # 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

1361:043e5ca9322f

        newer = obsolete.successorssets(repo, obs.node())
    if len(newer) > 1:
        raise util.Abort(_("conflict rewriting. can't choose destination\n"))
    return repo[newer[0][0]].rev()

def builddependencies(repo, revs):
    """ returns dependency graphs giving an order to solve instability of revs
    (see orderrevs for more information on usage) """

    # For each troubled revision we keep track of what instability if any should
    # be resolved in order to resolve it. Example:
    # dependencies = {3: [6], 6:[]}
    # Means that: 6 has no dependency, 3 depends on 6 to be solved
    dependencies = {}

        for p in repo[r].parents():
            succ = _singlesuccessor(repo, p)
            if succ in revs:
                dependencies[r].add(succ)
                rdependencies[succ].add(r)
    return dependencies, rdependencies

def orderrevs(repo, revs):
    """ Compute an ordering to solve instability for the given revs

    - Takes revs a list of instable revisions

    - Returns the same revisions ordered to solve their instability from the
    bottom to the top of the stack that the stabilization process will produce
    eventually.

    This ensure the minimal number of stabilization as we can stabilize each
    revision on its final, stabilized, destination.
    """
    # Step 1: Build the dependency graph
    dependencies, rdependencies = builddependencies(repo, revs)
    # 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