X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=2b257dd6bfea76d923a1e3da918f10c4d911ac1d;hp=0d3162fd9a50d9c7a00969bf91997d017b2f8970;hb=e8ab02477159b5bd91a3566dc28367ed4a910b3a;hpb=1d40cf793435df8be77fd789ada3faa18c480f8e

diff --git a/git-debrebase b/git-debrebase
index 0d3162fd..2b257dd6 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -36,6 +36,8 @@ use Dpkg::Version;
 use File::FnMatch qw(:fnmatch);
 use File::Copy;
 
+$debugcmd_when_debuglevel = 2;
+
 our ($usage_message) = <<'END';
 usages:
   git-debrebase [<options>] [--|-i <git rebase options...>]
@@ -226,7 +228,7 @@ sub get_differs ($$) {
 	    unless $differs & (D_PAT_ADD|D_PAT_OTH);
     }
 
-    printdebug sprintf "get_differs %s, %s = %#x\n", $x, $y, $differs;
+    printdebug sprintf "get_differs %s %s = %#x\n", $x, $y, $differs;
 
     return $differs;
 }
@@ -255,6 +257,20 @@ sub read_tree_subdir ($$) {
     runcmd @git, qw(read-tree), "--prefix=$subdir/", $new_tree_object;
 }
 
+sub read_tree_debian ($) {
+    my ($treeish) = @_;
+    read_tree_subdir 'debian', "$treeish:debian";
+    rm_subdir_cached 'debian/patches';
+}
+
+sub read_tree_upstream ($;$) {
+    my ($treeish, $keep_patches) = @_;
+    my $save = cmdoutput @git, qw(write-tree --prefix=debian/);
+    runcmd @git, qw(read-tree), $treeish;
+    read_tree_subdir 'debian', $save;
+    rm_subdir_cached 'debian/patches' unless $keep_patches;
+};
+
 sub make_commit ($$) {
     my ($parents, $message_paras) = @_;
     my $tree = cmdoutput @git, qw(write-tree);
@@ -310,6 +326,214 @@ sub any_snags () {
     return $snags_forced || $snags_tripped;
 }
 
+sub gbp_pq_export ($$$) {
+    my ($bname, $base, $tip) = @_;
+    # must be run in a workarea.  $bname and patch-queue/$bname
+    # ought not to exist.  Leaves you on patch-queue/$bname with
+    # the patches staged but not committed.
+    printdebug "gbp_pq_export $bname $base $tip\n";
+    runcmd @git, qw(checkout -q -b), $bname, $base;
+    runcmd @git, qw(checkout -q -b), "patch-queue/$bname", $tip;
+    my @gbp_cmd = (qw(gbp pq export));
+    my $r = system shell_cmd 'exec >../gbp-pq-err 2>&1', @gbp_cmd;
+    if ($r) {
+	{ local ($!,$?); copy('../gbp-pq-err', \*STDERR); }
+	failedcmd @gbp_cmd;
+    }
+    runcmd @git, qw(add -f debian/patches);
+}
+
+
+# xxx allow merge resolution separately from laundering, before git merge
+#
+# xxx general gdr docs highlight forbidden things
+# xxx general gdr docs list allowable things ?
+# xxx general gdr docs explicitly forbid some rebase
+#
+# xxx provide a way for the user to help
+# xxx (eg, provide wreckage provide way to continue)
+
+# later/rework?
+#  use git-format-patch?
+#  our own patch identification algorithm?
+#  this is an alternative strategy
+
+sub merge_series ($$;@) {
+    my ($newbase, $base_q, @input_qs) = @_;
+    # $base_q{SeriesBase}  $input_qs[]{SeriesBase}
+    # $base_q{SeriesTip}   $input_qs[]{SeriesTip}
+    # ^ specifies several patch series (currently we only support exactly 2)
+    # return value is a commit which is the result of
+    # merging the two versions of the same topic branch
+    #   $input_q[0] and $input_q[1]
+    # with respect to the old version
+    #   $base_q
+    # all onto $newbase.
+
+    # Creates, in *_q, a key MR for its private use
+
+    printdebug "merge_series newbase=$newbase\n";
+
+    $input_qs[$_]{MR}{S} = $_ foreach (0..$#input_qs);
+    $base_q->{MR}{S} = 'base';
+
+    my %prereq;
+    # $prereq{<patch filename>}{<possible prereq}{<S>} = 1 or absent
+    # $prereq{<patch filename>}{<possible prereq}  exists or not (later)
+    # $prereq{<patch filename>}               exists or not (even later)
+
+    my $result;
+
+    local $workarea = fresh_playground "$playprefix/merge";
+    my $seriesfile = "debian/patches/series";
+    in_workarea sub {
+	playtree_setup();
+	foreach my $q ($base_q, reverse @input_qs) {
+	    my $s = $q->{MR}{S};
+	    gbp_pq_export "p-$s", $q->{SeriesBase}, $q->{SeriesTip};
+	    if (open S, $seriesfile) {
+		my @earlier;
+		while (my $patch = <S>) {
+		    chomp $patch or die $!;
+		    $prereq{$patch} //= {};
+		    foreach my $earlier (@earlier) {
+			$prereq{$patch}{$earlier}{$s}++ and die;
+		    }
+		    push @earlier, $patch;
+		    stat "debian/patches/$patch" or die "$patch ?";
+		}
+		S->error and die "$seriesfile $!";
+		close S;
+	    } else {
+		die "$seriesfile $!" unless $!==ENOENT;
+	    }
+	    read_tree_upstream $newbase, 1;
+	    my $pec = make_commit [ grep { defined } $base_q->{MR}{PEC} ], [
+                "Convert $s to patch queue for merging",
+                "[git-debrebase merge-innards patch-queue import:".
+                " $q->{SeriesTip}]"
+            ];
+	    printdebug "merge_series  pec $pec ";
+	    runcmd @git, qw(rm -q --cached), $seriesfile;
+	    $pec = make_commit [ $pec ], [
+                "Drop series file from $s to avoid merge trouble",
+                "[git-debrebase merge-innards patch-queue prep:".
+                " $q->{SeriesTip}]"
+            ];
+	    printdebug "pec' $pec\n";
+            runcmd @git, qw(reset -q --hard), $pec;
+	    $q->{MR}{PEC} = $pec;
+	}
+	# now, because of reverse, we are on $input_q->{MR}{OQC}
+	runcmd @git, qw(checkout -q -b merge);
+	printdebug "merge_series merging...\n";
+	my @mergecmd = (@git, qw(merge --quiet --no-edit), "p-1");
+	debugcmd '+', @mergecmd;
+	$!=0; $?=-1;
+	if (system @mergecmd) {
+	    failedcmd @mergecmd;
+	}
+
+	printdebug "merge_series merge ok, series...\n";
+	# We need to construct a new series file
+	# Firstly, resolve prereq
+	foreach my $f (sort keys %prereq) {
+	    printdebug "merge_series  patch\t$f\t";
+	    if (!stat_exists "debian/patches/$f") {
+		print DEBUG " drop\n" if $debuglevel;
+		# git merge deleted it; that's how we tell it's not wanted
+		delete $prereq{$f};
+		next;
+	    }
+	    print DEBUG " keep\n" if $debuglevel;
+	    foreach my $g (sort keys %{ $prereq{$f} }) {
+		my $gfp = $prereq{$f}{$g};
+		printdebug "merge_series  prereq\t$f\t-> $g\t";
+		if (!!$gfp->{0} == !!$gfp->{1}
+		    ? $gfp->{0}
+		    : !$gfp->{base}) {
+		    print DEBUG "\tkeep\n" if $debuglevel;
+		} else {
+		    print DEBUG "\tdrop\n" if $debuglevel;
+		    delete $prereq{$f}{$g};
+		}
+	    }
+	}
+
+	my $unsat = sub {
+	    my ($f) = @_;
+	    return scalar keys %{ $prereq{$f} };
+	};
+
+	my $nodate = time + 1;
+	my %authordate;
+	# $authordate{<patch filename>};
+	my $authordate = sub {
+	    my ($f) = @_;
+	    $authordate{$f} //= do {
+		open PF, "<", "debian/patches/$f" or die "$f $!";
+		while (<PF>) {
+		    return $nodate if m/^$/;
+		    last if s{^Date: }{};
+		}
+		chomp;
+		return cmdoutput qw(date +%s -d), $_;
+	    };
+	};
+
+	open NS, '>', $seriesfile or die $!;
+
+	while (keys %prereq) {
+	    my $best;
+	    foreach my $try (sort keys %prereq) {
+		if ($best) {
+		    next if (
+			     $unsat->($try) <=> $unsat->($best) or
+			     $authordate->($try) <=> $authordate->($best) or
+			     $try cmp $best
+			    ) >= 0;
+		}
+		$best = $try;
+	    }
+	    printdebug "merge_series series next $best\n";
+	    print NS "$best\n" or die $!;
+	    delete $prereq{$best};
+	    foreach my $gp (values %prereq) {
+		delete $gp->{$best};
+	    }
+	}
+
+	runcmd @git, qw(add), $seriesfile;
+	runcmd @git, qw(commit --quiet -m), 'Merged series';
+
+	printdebug "merge_series series gbp pq import\n";
+	runcmd qw(gbp pq import);
+
+	# OK now we are on patch-queue/merge, and we need to rebase
+	# onto the intended parent and drop the patches from each one
+
+	printdebug "merge_series series ok, building...\n";
+	my $build = $newbase;
+	my @lcmd = (@git, qw(rev-list --reverse merge..patch-queue/merge));
+	foreach my $c (grep /./, split /\n/, cmdoutput @lcmd) {
+	    my $commit = git_cat_file $c, 'commit';
+	    printdebug "merge_series series ok, building $c\n";
+	    read_tree_upstream $c;
+	    my $tree = cmdoutput @git, qw(write-tree);
+	    $commit =~ s{^parent (\S+)$}{parent $build}m or confess;
+	    $commit =~ s{^tree (\S+)$}{tree $tree}m      or confess;
+	    open C, ">", "../mcommit" or die $!;
+	    print C $commit or die $!;
+	    close C or die $!;
+	    $build = cmdoutput @git, qw(hash-object -w -t commit ../mcommit);
+	}
+	$result = $build;
+	runcmd @git, qw(update-ref refs/heads/result), $result;
+    };
+    printdebug "merge_series returns $result\n";
+    return $result;
+}
+
 # classify returns an info hash like this
 #   CommitId => $objid
 #   Hdr => # commit headers, including 1 final newline
@@ -567,7 +791,23 @@ sub classify ($) {
 			   OrigParents => \@orig_ps);
     }
 
-    return $unknown->("complex merge");
+    if (@p == 2 and
+	$r->{Msg} =~ m{^\[git-debrebase merged-breakwater.*\]$}m) {
+	# xxx ^ metadata tag needs adding to (5)
+	return $classify->("MergedBreakwaters");
+    }
+    if ($r->{Msg} =~ m{^\[(git-debrebase|dgit)[: ].*\]$}m) {
+	return $unknown->("unknown kind of merge from $1");
+    }
+    if (@p > 2) {
+	return $unknown->("octopus merge");
+    }
+
+    if (!$ENV{GIT_DEBREBASE_EXPERIMENTAL_MERGE}) {
+	return $unknown->("general two-parent merge");
+    }
+
+    return $classify->("VanillaMerge");
 }
 
 sub keycommits ($;$$$$) {
@@ -650,6 +890,10 @@ sub keycommits ($;$$$$) {
 		     " ($head)");
 		return (undef,undef);
 	    }
+	} elsif ($ty eq 'VanillaMerge') {
+	    $x->($trouble, 'vanillamerge',
+		 "found vanilla merge"," ($head)");
+	    return (undef,undef);
 	} else {
 	    $x->($fatal, 'unprocessable',
 		 "found unprocessable commit, cannot cope: $cl->{Why}",
@@ -730,6 +974,10 @@ sub walk ($;$$$) {
 	no warnings qw(exiting); last;
     };
 
+    my $nomerge = sub {
+	fail "something useful about failed merge attempt @_ xxx".Dumper($cl);
+    };
+
     my $last_anchor;
 
     for (;;) {
@@ -833,6 +1081,147 @@ sub walk ($;$$$) {
 		return $bomb->();
 	    }
 	    die "$ty ?";
+	} elsif ($ty eq 'VanillaMerge' or $ty eq 'MergedBreakwaters') {
+	    # User may have merged unstitched branch(es).  We will
+	    # have now lost what ffq-prev was then (since the later
+	    # pseudomerge may introduce further changes).  The effect
+	    # of resolving such a merge is that we may have to go back
+	    # further in history to find a merge base, since the one
+	    # which was reachable via ffq-prev is no longer findable.
+	    # This is suboptimal, but if it all works we'll have done
+	    # the right thing.
+	    # xxx we should warn the user in the docs about this
+
+	    my $ok=1;
+	    my $best_anchor;
+	    # We expect to find a dominating anchor amongst the
+	    # inputs' anchors.  That will be the new anchor.
+	    #
+	    # More complicated is finding a merge base for the
+	    # breakwaters.  We need a merge base that is a breakwater
+	    # commit.  The ancestors of breakwater commits are more
+	    # breakwater commits and possibly upstream commits and the
+	    # ancestors of those upstream.  Upstreams might have
+	    # arbitrary ancestors.  But any upstream commit U is
+	    # either included in both anchors, in which case the
+	    # earlier anchor is a better merge base than any of U's
+	    # ancestors; or U is not included in the older anchor, in
+	    # which case U is not an ancestor of the vanilla merge at
+	    # all.  So no upstream commit, nor any ancestor thereof,
+	    # is a best merge base.  As for non-breakwater Debian
+	    # commits: these are never ancestors of any breakwater.
+	    #
+	    # So any best merge base as found by git-merge-base
+	    # is a suitable breakwater anchor.  Usually there will
+	    # be only one.
+
+	    printdebug "*** MERGE\n";
+
+	    # xxx avoid calling walk without nogenerate when
+	    # we have a MergedBreakwater; instead call keycommits ?
+
+	    my @bwbcmd = (@git, qw(merge-base));
+	    my @ibcmd = (@git, qw(merge-base --all));
+	    my $might_be_in_bw = 1;
+
+	    my $ps = $cl->{Parents};
+
+	    foreach my $p (@$ps) {
+		$prline->(" VanillaMerge ".$p->{Ix});
+		$prprdelim->();
+		my ($ptip, $pbw, $panchor) =
+		    walk $p->{CommitId}, 0, $report,
+		         $report_lprefix.'  ';
+		$p->{Laundered} = $p->{SeriesTip} = $ptip;
+		$p->{Breakwater} = $p->{SeriesBase} = $pbw;
+		$p->{Anchor} = $panchor;
+
+		$best_anchor = $panchor if
+		    !defined $best_anchor or
+		    is_fast_fwd $best_anchor, $panchor;
+
+		printdebug " MERGE BA best=".($best_anchor//'-').
+		    " p=$panchor\n";
+	    }
+
+	    foreach my $p (@$ps) {
+		$prline->(" VanillaMerge ".$p->{Ix});
+		if (!is_fast_fwd $p->{Anchor}, $best_anchor) {
+		    $nomerge->('DivergentAnchor');
+		} elsif ($p->{Anchor} eq $best_anchor) {
+		    print $report " SameAnchor" if $report;
+		} else {
+		    print $report " SupersededAnchor" if $report;
+		}
+		if ($p->{Breakwater} eq $p->{CommitId}) {
+		    # this parent commit was its own breakwater,
+		    # ie it is part of the breakwater
+		    print $report " Breakwater" if $report;
+		} else {
+		    $might_be_in_bw = 0;
+		}
+		push @bwbcmd, $p->{Breakwater};
+		push @ibcmd, $p->{CommitId};
+	    }
+
+	    if ($ok && $might_be_in_bw) {
+		$prline->(" VanillaMerge MergedBreakwaters");
+		$last_anchor = $best_anchor;
+		$build_start->('MergedBreakwaters', $cur);
+	    }
+
+	    $nomerge->("alleged merged-breakwater is not a breakwater")
+		unless $ty eq 'VanillaMerge';
+
+	    my $bwb = cmdoutput @bwbcmd;
+
+	    # OK, now we have a breakwater base, but we need the merge
+	    # base for the interchange branch because we need the delta
+	    # queue.
+	    #
+	    # This a the best merge base of our inputs which has the
+	    # breakwater merge base as an ancestor.
+
+	    my @ibs =
+		grep { is_fast_fwd $bwb, $_ }
+		grep /./,
+		split /\n/,
+		cmdoutput @ibcmd;
+	    my ($ib) = @ibs
+		or $nomerge->("no suitable interchange merge base");
+
+	    $prline->("  VanillaMerge Base");
+	    $prprdelim->();
+	    my ($btip, $bbw, $banchor) =
+		walk $ib, 0, $report, $report_lprefix.'  ';
+
+	    my $ibinfo = { SeriesTip => $btip,
+			   SeriesBase => $bbw,
+			   Anchor => $banchor };
+	    $bbw eq $bwb
+		or $nomerge->("interchange merge-base ($ib)'s".
+			      " breakwater ($bbw)".
+			      " != breakwaters' merge-base ($bwb)");
+	    grep { $_->{Anchor} eq $ibinfo->{Anchor} } @$ps
+		 or $nomerge->("interchange merge-base ($ib)'s".
+			       " anchor ($ibinfo->{SeriesBase})".
+			       " != any merge input's anchor (".
+			       (join ' ', map { $_->{Anchor} } @$ps).
+			       ")");
+
+
+	    $cl->{MergeInterchangeBaseInfo} = $ibinfo;
+	    $cl->{MergeBestAnchor} = $best_anchor;
+	    push @brw_cl, {
+                %$cl,
+                SpecialMethod => 'MergeCreateMergedBreakwaters',
+                $xmsg->('construct merged breakwater from vanilla merge'),
+            };
+	    push @upp_cl, {
+                %$cl,
+                SpecialMethod => 'MergeMergeSeries',
+            };
+	    $build_start->('MergeBreakwaters', $cur);
         } else {
             printdebug "*** WALK BOMB unrecognised\n";
 	    return $bomb->();
@@ -851,17 +1240,6 @@ sub walk ($;$$$) {
 
     my $rewriting = 0;
 
-    my $read_tree_debian = sub {
-	my ($treeish) = @_;
-	read_tree_subdir 'debian', "$treeish:debian";
-        rm_subdir_cached 'debian/patches';
-    };
-    my $read_tree_upstream = sub {
-	my ($treeish) = @_;
-	runcmd @git, qw(read-tree), $treeish;
-	$read_tree_debian->($build);
-    };
-
     $#upp_cl = $upp_limit if defined $upp_limit;
  
     my $committer_authline = calculate_committer_authline();
@@ -887,9 +1265,9 @@ sub walk ($;$$$) {
 	    printdebug "WALK BUILD ".($cltree//'undef').
 		" $method (rewriting=$rewriting)\n";
 	    if ($method eq 'Debian') {
-		$read_tree_debian->($cltree);
+		read_tree_debian($cltree);
 	    } elsif ($method eq 'Upstream') {
-		$read_tree_upstream->($cltree);
+		read_tree_upstream($cltree);
 	    } elsif ($method eq 'StartRewrite') {
 		$rewriting = 1;
 		next;
@@ -897,13 +1275,30 @@ sub walk ($;$$$) {
 		$breakwater = $build;
 		next;
 	    } elsif ($method eq 'DgitImportDebianUpdate') {
-		$read_tree_debian->($cltree);
+		read_tree_debian($cltree);
 	    } elsif ($method eq 'DgitImportUpstreamUpdate') {
  		confess unless $rewriting;
 		my $differs = (get_differs $build, $cltree);
 		next unless $differs & D_UPS;
-		$read_tree_upstream->($cltree);
+		read_tree_upstream($cltree);
 		push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} };
+	    } elsif ($method eq 'MergeCreateMergedBreakwaters') {
+		print "Found a general merge, will try to tidy it up.\n";
+		$rewriting = 1;
+		read_tree_upstream($cl->{MergeBestAnchor});
+		read_tree_upstream($cl->{MergeBestAnchor});
+		read_tree_debian($cltree);
+		@parents = map { $_->{Breakwater} } @{ $cl->{Parents} };
+	    } elsif ($method eq 'MergeMergeSeries') {
+		print "Running merge resolution for $cl->{CommitId}...\n";
+		$build = merge_series
+		    $build,
+		    $cl->{MergeInterchangeBaseInfo},
+		    @{ $cl->{Parents} };
+		$last_anchor = $cl->{MergeBestAnchor};
+		# xxx need to check the tree somehow
+		print "Merge resolution successful.\n";
+		next;
 	    } else {
 		confess "$method ?";
 	    }
@@ -942,7 +1337,7 @@ sub walk ($;$$$) {
     };
 
     my $final_check = get_differs $build, $input;
-    die sprintf "internal error %#x %s %s", $final_check, $build, $input
+    die sprintf "internal error %#x %s %s", $final_check, $input, $build
 	if $final_check & ~D_PAT_ADD;
 
     my @r = ($build, $breakwater, $last_anchor);
@@ -1137,7 +1532,7 @@ sub record_ffq_prev_deferred () {
 
     push @deferred_updates, "update $ffq_prev $currentval $git_null_obj";
     push @deferred_updates, "delete $gdrlast";
-    push @deferred_update_messages, "Recorded current head for preservation";
+    push @deferred_update_messages, "Recorded previous head for preservation";
     return ('deferred', undef);
 }
 
@@ -1618,15 +2013,7 @@ sub make_patches_staged ($) {
     my ($secret_head, $secret_bw, $last_anchor) = walk $head;
     fresh_workarea();
     in_workarea sub {
-	runcmd @git, qw(checkout -q -b bw), $secret_bw;
-	runcmd @git, qw(checkout -q -b patch-queue/bw), $secret_head;
-	my @gbp_cmd = (qw(gbp pq export));
-	my $r = system shell_cmd 'exec >../gbp-pq-err 2>&1', @gbp_cmd;
-	if ($r) {
-	    { local ($!,$?); copy('../gbp-pq-err', \*STDERR); }
-	    failedcmd @gbp_cmd;
-	}
-	runcmd @git, qw(add -f debian/patches);
+	gbp_pq_export 'bw', $secret_bw, $secret_head;
     };
 }