How to specify this revset?

[sullyj3]

Suppose I have something like this:

a -> b -> c -> d
     \
      e -> f

A revset operation I often want to perform is: "given a set of commits, get me everything from their least common ancestor to them" (generally to pass to jj log).

For example, if we're interested in the two commits f and d, the least common ancestor is b, so the revset I want would be b::(d | f) (let's suppose we don't want any hypothetical descendants of d or f). We can see that easily here, because we can see the whole history and it's small and simple.

But how do I perform this operation more generally? Ie in cases where the common ancestor is obscured by (elided revisions), or I just don't want to have to find it visually in a messy commit graph.

If I had a least common ancestor function, say, lca(), I could write lca(d | f)::(d | f). Or, preferably there would just be a function that takes a revset r to lca(r)::r. I don't know what a good name for this operation is though. Some sort of closure?
Is there an existing way or does this need to be added?

[sullyj3]

Here's a monstrosity I came up with for the 2 case:

   {e, f}                                              {b, c, e}          
      │                                                   │               
┌─────┴────────┐                      ┌───────────────────┴──────────────┐
│              │                      │                                  │
(((::f) ~ (::d)) | ((::d) ~ (::f))) | (((::f) ~ (::d)) | ((::d) ~ (::f)))-
                   │              │                                       
                   └─────┬────────┘                                       
                         │                                                
                      {c, d}                                              
                                                                                 

[arxanas]

I think you can write heads(::lhs, ::rhs) for least-common ancestor (and add your own alias), but it probably deserves its own function.

[sullyj3]

Ah, nice, thanks (it seems like you mean heads(::lhs & ::rhs))

[martinvonz]

I'm not sure exactly what you're looking for. Let's say you have this history:

E
| D
|/
C
| B
|/
A

If you now have E|D|B in your input set, then maybe you want both C and A in the output. That seems useful but we don't have that function yet.

You might have instead only wanted A in the output set. I can't think of calculating that for a given set using the existing functions (::x means "ancestors of any commit in x"; we don't have an operator or function for "ancestors of all commits in x").

The same thing was asked on Discord a while ago (here). I looped you in there but I'm not sure you're on Discord these days, and it's useful to have an answer here anyway.

For the 2-argument case, see @arxanas reply (it was that reply that prompted me to finish this draft I had since yesterday).

[sullyj3]

Yes. Why not?

[martinvonz]

Because C might be a thousand commits (though it doesn't look like it in the graph above)

[sullyj3]

Ahh gotcha. Yeah, the motivation for this question was getting a jj log overview of the divergence of branches in a personal project, where "C" is small. I think even in collaborative contexts this would be a common case.

Are you saying there's a principled rule that gets you E|B -> A|B|E? I'm not really following what it is.

[martinvonz]

I don't think there's a way of expressing that with the functions we have today, but maybe a principled rule is: "a commit that is the greatest common ancestor between any two commits in the input set"?

[arxanas]

It might be more general to implement map with a callback function, and a function which yields pairs (or combinations) of commits in a revset, or alternatively, universal/existential qualification (with a Datalog-like interface?).

[sullyj3]

For posterity we now have fork_point(), so for a set s we can do fork_point(s)::s, which is a big improvement.