comparison mercurial/hbisect.py @ 15146:b39d85be78a8

hbisect.get: use simpler code with repo.set(), fix 'pruned' set

Use repo.set() wherever possible, instead of locally trying to
reproduce complex graph computations.

'pruned' now means 'all csets that will no longer be visited by the
bisection'. The change is done is this very patch instead of its own
dedicated one becasue the code changes all over the place, and the
previous 'pruned' code was totally rewritten by the cleanup, so it
was easier to just change the behavior at the same time.

The previous series went in too fast for this cleanup pass to be
included, so here it is. ;-)

Signed-off-by: "Yann E. MORIN" <[e-mail]>

15145:ff26712a0c50

    """
    Return a list of revision(s) that match the given status:

    - ``good``, ``bad``, ``skip``: as the names imply
    - ``range``              : all csets taking part in the bisection
    - ``pruned``             : good|bad|skip, excluding out-of-range csets
    - ``untested``           : csets whose fate is yet unknown
    """
    state = load_state(repo)
    if status in ('good', 'bad', 'skip'):
        return [repo.changelog.rev(n) for n in state[status]]
    else:
        # Build sets of good, bad, and skipped csets
        goods = set(repo.changelog.rev(n) for n in state['good'])
        bads  = set(repo.changelog.rev(n) for n in state['bad'])
        skips = set(repo.changelog.rev(n) for n in state['skip'])

        # Build kinship of good csets
        ga = goods.copy()   # Goods' Ancestors
        gd = goods.copy()   # Goods' Descendants
        for g in goods:
            ga |= set(repo.changelog.ancestors(g))
            gd |= set(repo.changelog.descendants(g))

        # Build kinship of bad csets
        ba = bads.copy()    # Bads' Ancestors
        bd = bads.copy()    # Bads' Descendants
        for b in bads:
            ba |= set(repo.changelog.ancestors(b))
            bd |= set(repo.changelog.descendants(b))

        # Build the range of the bisection
        range  = set(c for c in ba if c in gd)
        range |= set(c for c in ga if c in bd)

        if status == 'range':
            return [c for c in range]
        elif status == 'pruned':
            # We do not want skipped csets that are out-of-range
            return [c for c in range if c in (goods | bads | skips)]
        elif status == 'untested':
            # Return the csets in range that are not pruned
            return [c for c in range if not c in (goods | bads | skips)]

        else:
            raise error.ParseError(_('invalid bisect state'))

15146:b39d85be78a8

    """
    Return a list of revision(s) that match the given status:

    - ``good``, ``bad``, ``skip``: as the names imply
    - ``range``              : all csets taking part in the bisection
    - ``pruned``             : csets that are good, bad or skipped
    - ``untested``           : csets whose fate is yet unknown
    """
    state = load_state(repo)
    if status in ('good', 'bad', 'skip'):
        return [repo.changelog.rev(n) for n in state[status]]
    else:
        # In the floowing sets, we do *not* call 'bisect()' with more
        # than one level of recusrsion, because that can be very, very
        # time consuming. Instead, we always develop the expression as
        # much as possible.

        # 'range' is all csets that make the bisection:
        #   - have a good ancestor and a bad descendant, or conversely
        # that's because the bisection can go either way
        range = '( bisect(bad)::bisect(good) | bisect(good)::bisect(bad) )'

        # 'pruned' is all csets whose fate is already known:
        #   - a good ancestor and a good ascendant, or
        #   - a bad ancestor and a bad descendant, or
        #   - skipped
        # But in case of irrelevant goods/bads, we also need to
        # include them.
        pg = 'bisect(good)::bisect(good)'   # Pruned goods
        pb = 'bisect(bad)::bisect(bad)'     # Pruned bads
        ps = 'bisect(skip)'                 # Pruned skipped
        pruned = '( (%s) | (%s) | (%s) )' % (pg, pb, ps)

        # 'untested' is all cset that are- in 'range', but not in 'pruned'
        untested = '( (%s) - (%s) )' % (range, pruned)

        if status == 'range':
            return [c.rev() for c in repo.set(range)]
        elif status == 'pruned':
            return [c.rev() for c in repo.set(pruned)]
        elif status == 'untested':
            return [c.rev() for c in repo.set(untested)]

        else:
            raise error.ParseError(_('invalid bisect state'))