X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=2b38d4f85d2cdb89f95b3af03627d09b3516a5e8;hp=92fa86b7483ca92cea57de2bafb7835573068961;hb=a87e08ae2e6861e87a386dd5c621e3da9c5d41d1;hpb=5958f33adfaa49981accb3cd4036916ac8daf64e

diff --git a/git-debrebase b/git-debrebase
index 92fa86b7..2b38d4f8 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -22,15 +22,15 @@
 # usages:
 #
 #    git-debrebase [<options>] new-upstream-v0 \
-#             <new-version> <orig-commitish> \
+#             <new-version> [<orig-commitish> \
 #            [<extra-orig-name> <extra-orig-commitish> ...] \
-#            [<git-rebase options>...]
+#            [<git-rebase options>...]]
 #
 #    git-debrebase [<options> --] [<git-rebase options...>]
 #    git-debrebase [<options>] analyse
 #    git-debrebase [<options>] breakwater      # prints breakwater tip only
-#    git-debrebase [<options>] launder         # prints breakwater tip etc.
 #    git-debrebase [<options>] stitch [--prose=<for commit message>]
+#    git-debrebase [<options>] launder-v0      # prints breakwater tip etc.
 #    git-debrebase [<options>] downstream-rebase-launder-v0  # experimental
 #
 #    git-debrebase [<options>] convert-from-gbp [<upstream-git-rev>]
@@ -157,6 +157,28 @@ sub fresh_workarea () {
     in_workarea sub { playtree_setup };
 }
 
+our @deferred_updates;
+our @deferred_update_messages;
+
+sub run_deferred_updates ($) {
+    my ($mrest) = @_;
+
+    my @upd_cmd = (@git, qw(update-ref --stdin -m), "debrebase: $mrest");
+    debugcmd '>|', @upd_cmd;
+    open U, "|-", @upd_cmd or die $!;
+    foreach (@deferred_updates) {
+	printdebug ">= ", $_, "\n";
+	print U $_, "\n" or die $!;
+    }
+    printdebug ">\$\n";
+    close U or failedcmd @upd_cmd;
+
+    print $_, "\n" foreach @deferred_update_messages;
+
+    @deferred_updates = ();
+    @deferred_update_messages = ();
+}
+
 sub get_differs ($$) {
     my ($x,$y) = @_;
     # This resembles quiltify_trees_differ, in dgit, a bit.
@@ -412,7 +434,7 @@ sub classify ($) {
 
 	my $badanchor = sub { $unknown->("git-debrebase \`anchor' but @_"); };
 	@p == 2 or return $badanchor->("has other than two parents");
-	$haspatches and return $unknown->("contains debian/patches");
+	$haspatches and return $badanchor->("contains debian/patches");
 
 	# How to decide about l/r ordering of anchors ?  git
 	# --topo-order prefers to expand 2nd parent first.  There's
@@ -421,26 +443,14 @@ sub classify ($) {
 	# way also there's also an easy rune to look for the upstream
 	# patches (--topo-order).
 
-	# The above tells us which way *we* will generate them.  But we
-	# might encounter ad-hoc anchor merges generated manually,
-	# which might be the other way around.  In principle, in some odd
-	# situations, an anchor merge might have two identical parents.
-	# In that case we guess which way round it is (ie, which parent
-	# has the upstream history).  The order of the 2-iteration loop
-	# controls which guess we make.
-
-	# XXX we are going to desupport non-git-debrebase-generated anchors
-
-	foreach my $prevbrw (qw(0 1)) {
-	    if (!$p[$prevbrw]{IsOrigin} && # breakwater never starts with an origin
-		!($p[!$prevbrw]{Differs} & ~DS_DEB) && # no non-debian changess
-		!($p[$prevbrw]{Differs} & ~D_UPS)) { # no non-upstream changes
-		return $classify->(qw(Anchor),
-				   OrigParents => [ $p[!$prevbrw] ]);
-	    }
-	}
+	$p[0]{IsOrigin} and $badanchor->("is an origin commit");
+	$p[1]{Differs} & ~DS_DEB and
+	    $badanchor->("upstream files differ from left parent");
+	$p[0]{Differs} & ~D_UPS and
+	    $badanchor->("debian/ differs from right parent");
 
-	$badanchor->("violation");
+	return $classify->(qw(Anchor),
+			   OrigParents => [ $p[1] ]);
     }
 
     if (@p == 1) {
@@ -584,8 +594,9 @@ sub walk ($;$$) {
 	return (Msg => $ms);
     };
     my $rewrite_from_here = sub {
+	my ($cl) = @_;
 	my $sp_cl = { SpecialMethod => 'StartRewrite' };
-	push @brw_cl, $sp_cl;
+	push @$cl, $sp_cl;
 	push @processed, $sp_cl;
     };
     my $cur = $input;
@@ -635,7 +646,7 @@ sub walk ($;$$) {
 	my $p0 = @{ $cl->{Parents} }==1 ? $cl->{Parents}[0]{CommitId} : undef;
 	if ($ty eq 'AddPatches') {
 	    $cur = $p0;
-	    $rewrite_from_here->();
+	    $rewrite_from_here->(\@upp_cl);
 	    next;
 	} elsif ($ty eq 'Packaging' or $ty eq 'Changelog') {
 	    push @brw_cl, $cl;
@@ -656,14 +667,14 @@ sub walk ($;$$) {
 	    };
 	    $queue->(\@brw_cl, "debian");
 	    $queue->(\@upp_cl, "upstream");
-	    $rewrite_from_here->();
+	    $rewrite_from_here->(\@brw_cl);
 	    $cur = $p0;
 	    next;
 	} elsif ($ty eq 'Pseudomerge') {
 	    my $contrib = $cl->{Contributor}{CommitId};
 	    print $report " Contributor=$contrib" if $report;
 	    push @pseudomerges, $cl;
-	    $rewrite_from_here->();
+	    $rewrite_from_here->(\@upp_cl);
 	    $cur = $contrib;
 	    next;
 	} elsif ($ty eq 'Anchor') {
@@ -712,7 +723,7 @@ sub walk ($;$$) {
 			    " anchor")
 		};
 		$prline->(" Import");
-		$rewrite_from_here->();
+		$rewrite_from_here->(\@brw_cl);
 		$upp_limit //= $#upp_cl; # further, deeper, patches discarded
 		$cur = $ovwr;
 		next;
@@ -851,7 +862,8 @@ sub get_head () {
 
 sub update_head ($$$) {
     my ($old, $new, $mrest) = @_;
-    runcmd @git, qw(update-ref -m), "debrebase: $mrest", 'HEAD', $new, $old;
+    push @deferred_updates, "update HEAD $new $old";
+    run_deferred_updates $mrest;
 }
 
 sub update_head_checkout ($$$) {
@@ -869,8 +881,8 @@ sub update_head_postlaunder ($$$) {
     runcmd @git, qw(rm --quiet --ignore-unmatch -rf debian/patches);
 }
 
-sub cmd_launder () {
-    badusage "no arguments to launder allowed" if @ARGV;
+sub cmd_launder_v0 () {
+    badusage "no arguments to launder-v0 allowed" if @ARGV;
     my $old = get_head();
     my ($tip,$breakwater,$last_anchor) = walk $old;
     update_head_postlaunder $old, $tip, 'launder';
@@ -881,12 +893,7 @@ sub cmd_launder () {
 
 sub defaultcmd_rebase () {
     my $old = get_head();
-    my ($status, $message) = record_ffq_prev();
-    if ($status eq 'written' || $status eq 'exists') {
-    } else {
-	fproblem $status, "could not record ffq-prev: $message";
-	fproblems_maybe_bail();
-    }
+    record_ffq_auto();
     my ($tip,$breakwater) = walk $old;
     update_head_postlaunder $old, $tip, 'launder for rebase';
     runcmd @git, qw(rebase), @ARGV, $breakwater;
@@ -920,17 +927,18 @@ sub ffq_prev_branchinfo () {
     return ('branch', undef, $current, $ffq_prev);
 }
 
-sub record_ffq_prev () {
+sub record_ffq_prev_deferred () {
     # => ('status', "message")
     # 'status' may be
-    #    written          message is undef
+    #    deferred          message is undef
     #    exists
     #    detached
     #    weird-symref
     #    notbranch
     # if not ff from some branch we should be ff from, is an fproblem
-    # if "written", will have printed something about that to stdout,
-    #   and also some messages about ff checks
+    # if "deferred", will have added something about that to
+    #   @deferred_update_messages, and also maybe printed (already)
+    #   some messages about ff checks
     my ($status, $message, $current, $ffq_prev) = ffq_prev_branchinfo();
     return ($status, $message) unless $status eq 'branch';
 
@@ -996,10 +1004,19 @@ sub record_ffq_prev () {
     }
 
     fproblems_maybe_bail();
-    runcmd @git, qw(update-ref -m), "record current head for preservation",
-	$ffq_prev, $currentval, $git_null_obj;
-    print "Recorded current head for preservation\n" or die $!;
-    return ('written', undef);
+
+    push @deferred_updates, "update $ffq_prev $currentval $git_null_obj";
+    push @deferred_update_messages, "Recorded current head for preservation";
+    return ('deferred', undef);
+}
+
+sub record_ffq_auto () {
+    my ($status, $message) = record_ffq_prev_deferred();
+    if ($status eq 'deferred' || $status eq 'exists') {
+    } else {
+	fproblem $status, "could not record ffq-prev: $message";
+	fproblems_maybe_bail();
+    }
 }
 
 sub cmd_new_upstream_v0 () {
@@ -1008,13 +1025,15 @@ sub cmd_new_upstream_v0 () {
 
     my %pieces;
 
-    badusage "need NEW-VERSION UPS-COMMITTISH" unless @ARGV >= 2;
+    badusage "need NEW-VERSION [UPS-COMMITTISH]" unless @ARGV >= 1;
 
     # parse args - low commitment
     my $new_version = (new Dpkg::Version scalar(shift @ARGV), check => 1);
     my $new_upstream_version = $new_version->version();
 
-    my $new_upstream = git_rev_parse shift @ARGV;
+    my $new_upstream = git_rev_parse (shift @ARGV // 'upstream');
+
+    record_ffq_auto();
 
     my $piece = sub {
         my ($n, @x) = @_; # may be ''
@@ -1051,13 +1070,13 @@ sub cmd_new_upstream_v0 () {
     # now we need to investigate the branch this generates the
     # laundered version but we don't switch to it yet
     my $old_head = get_head();
-    my ($old_laundered_tip,$old_bw,$old_upstream_update) = walk $old_head;
+    my ($old_laundered_tip,$old_bw,$old_anchor) = walk $old_head;
 
     my $old_bw_cl = classify $old_bw;
-    my $old_upstream_update_cl = classify $old_upstream_update;
-    confess unless $old_upstream_update_cl->{OrigParents};
+    my $old_anchor_cl = classify $old_anchor;
+    confess unless $old_anchor_cl->{OrigParents};
     my $old_upstream = parsecommit
-        $old_upstream_update_cl->{OrigParents}[0]{CommitId};
+        $old_anchor_cl->{OrigParents}[0]{CommitId};
 
     $piece->('', Old => $old_upstream->{CommitId});
 
@@ -1182,10 +1201,11 @@ END
 
 sub cmd_record_ffq_prev () {
     badusage "no arguments allowed" if @ARGV;
-    my ($status, $msg) = record_ffq_prev();
+    my ($status, $msg) = record_ffq_prev_deferred();
     if ($status eq 'exists' && $opt_noop_ok) {
 	print "Previous head already recorded\n" or die $!;
-    } elsif ($status eq 'written') {
+    } elsif ($status eq 'deferred') {
+	run_deferred_updates 'record-ffq-prev';
     } else {
 	fail "Could not preserve: $msg";
     }
@@ -1210,23 +1230,25 @@ sub cmd_stitch () {
     if (!$prev) {
 	fail "No ffq-prev to stitch." unless $opt_noop_ok;
     }
-    fresh_workarea();
+    push @deferred_updates, "delete $ffq_prev $prev";
+
     my $old_head = get_head();
+    if (is_fast_fwd $old_head, $prev) {
+	my $differs = get_differs $old_head, $prev;
+	unless ($differs & ~D_PAT_ADD) {
+	    # ffq-prev is ahead of us, and the only tree changes it has
+	    # are possibly addition of things in debian/patches/.
+	    # Just wind forwards rather than making a pointless pseudomerge.
+	    update_head_checkout $old_head, $prev, "stitch (fast forward)";
+	    return;
+	}
+    }
+    fresh_workarea();
     my $new_head = make_commit [ $old_head, $ffq_prev ], [
 	'Declare fast forward / record previous work',
         "[git-debrebase pseudomerge: stitch$prose]",
     ];
-    my @upd_cmd = (@git, qw(update-ref --stdin));
-    debugcmd '>|', @upd_cmd;
-    open U, "|-", @upd_cmd or die $!;
-    my $u = <<END;
-update HEAD $new_head $old_head
-delete $ffq_prev $prev
-END
-    printdebug ">= ", $_, "\n" foreach split /\n/, $u;
-    print U $u;
-    printdebug ">\$\n";
-    close U or failedcmd @upd_cmd;
+    update_head $old_head, $new_head, "stitch";
 }
 
 sub cmd_convert_from_gbp () {
@@ -1316,9 +1338,7 @@ sub cmd_convert_to_gbp () {
         ];
     };
     if (defined $ffq) {
-	runcmd @git, qw(update-ref -m),
-	    "debrebase: converting corresponding main branch to gbp format",
-	    $ffq, $git_null_obj;
+	push @deferred_updates, "delete $ffq";
     }
     update_head_checkout $head, $out, "convert to gbp (v0)";
     print <<END or die $!;