Hi Phillip & Buga,
On Tue, 6 Mar 2018, Phillip Wood wrote:
> On 02/03/18 23:33, Igor Djordjevic wrote:
> > [...]
> > Otherwise, I would be interested to learn how context/semantics
> > guessing could provide a better default action (without introducing
> > more complexity for might not be much benefit, if any).
> I don't think its possible to guess the semantics of the original merge
> as users can use custom merge strategies and amend the result. It would
> be possible to detect and unamended '-s ours' merge but special casing
> that may end up causing users more confusion rather than helping them.
FWIW I agree.
My original plan was to always merge recursively and suggest to use `exec`
commands if anything else is needed.
But now with that excellent new idea to perform successive three-way
merges of the original merge commit with the new tips, using the old tips
as merge base, I am considering to change that.
There is a big problem here, though: consistency. See below for more
musings about that.
> > And I guess being consistent is pretty important, too - if you add new
> > content during merge rebase, it should always show up in the merge,
> > period.
> Yes, that should make it easy for the user to know what to expect from
Indeed. We have seen time and time again that consistent behavior is the
only thing that lets us adhere to the Law of Least Surprise.
And here lies the rub: do we really want to let `merge -C <commit>` behave
completely differently than `merge`? Granted, in one case we provide a
template merge commit, in the other case, we do not. And the idea is
already to behave differently, although that difference only extends to
the commit message so far.
But given the benefit (i.e. that the strategy to transform the original
merge commit into the new merge commit), I am willing to run that risk,
especially since I foresee only few users wanting to create new merge
commits from scratch using the `merge` todo command.
Of course, even then we need to be careful: the user might have
*changed* or *moved* the original `merge` command. For example, if the
merge command read:
merge -C deadbee cafecafe bedbedbed
and the user switched the order of the merged branches into
merge -C deadbee bedbedbed cafecafe
we would have to detect the changed order of the arguments so that we
could still find the original branch tips.
But the user might also have changed the branch(es) to merge completely,
in which case we might not even be able to find original branch tips.
My preferred solution would be to let the `merge` command figure out
whether the passed arguments correspond to the rewritten versions of the
original merge parents. And only in that case would we use the fancy
strategy, in all other cases we would fall back to performing a regular
recursive (or octopus) merge.
How does that sound?
It will be slightly inconsistent. But in a defendable way, I think.