X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=ddb7840cf997236d4d604c6468f84923209a2e53;hp=c180a2946c28c50c10f806c54b7e7d922b99449f;hb=238568870c670cd067578807c0a4f369f9af1c8a;hpb=39e84f67e266f87368e4bce44d4b4b469ef7165a

diff --git a/git-debrebase b/git-debrebase
index c180a294..ddb7840c 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -19,6 +19,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 END { $? = $Debian::Dgit::ExitStatus::desired // -1; };
+use Debian::Dgit::GDR;
 use Debian::Dgit::ExitStatus;
 
 use strict;
@@ -33,6 +34,7 @@ use Data::Dumper;
 use Getopt::Long qw(:config posix_default gnu_compat bundling);
 use Dpkg::Version;
 use File::FnMatch qw(:fnmatch);
+use File::Copy;
 
 our ($opt_force, $opt_noop_ok, @opt_anchors);
 our ($opt_defaultcmd_interactive);
@@ -116,7 +118,7 @@ sub run_deferred_updates ($) {
 
     confess 'dangerous internal error' unless all_snags_summarised();
 
-    my @upd_cmd = (@git, qw(update-ref --stdin -m), "debrebase: $mrest");
+    my @upd_cmd = (git_update_ref_cmd "debrebase: $mrest", qw(--stdin));
     debugcmd '>|', @upd_cmd;
     open U, "|-", @upd_cmd or die $!;
     foreach (@deferred_updates) {
@@ -268,7 +270,7 @@ sub snags_maybe_bail () {
 		$us, $snags_tripped;
 	} else {
 	    fail sprintf
-  "%s: snags: %d blockers (you could -f<tag>, or --force)",
+  "%s: snags: %d blocker(s) (you could -f<tag>, or --force)",
 		$us, $snags_tripped;
 	}
     }
@@ -566,11 +568,12 @@ sub keycommits ($;$$$$) {
     my $cl;
     $fatal //= sub { fail $_[2]; };
     my $x = sub {
-	my ($cb, $tagsfx, $why) = @_;
+	my ($cb, $tagsfx, $mainwhy, $xwhy) = @_;
+	my $why = $mainwhy.$xwhy;
 	my $m = "branch needs laundering (run git-debrebase): $why";
 	fail $m unless defined $cb;
 	return unless $cb;
-	$cb->("unclean-$tagsfx", $why, $cl);
+	$cb->("unclean-$tagsfx", $why, $cl, $mainwhy);
     };
     for (;;) {
 	$cl = classify $head;
@@ -591,27 +594,27 @@ sub keycommits ($;$$$$) {
 	    last;
 	} elsif ($ty eq 'Upstream') {
 	    $x->($unclean, 'ordering',
- "packaging change ($breakwater) follows upstream change (eg $head)")
+ "packaging change ($breakwater) follows upstream change"," (eg $head)")
 		if defined $breakwater;
 	    $clogonly = undef;
 	    $breakwater = undef;
 	} elsif ($ty eq 'Mixed') {
 	    $x->($unclean, 'mixed',
-		 "found mixed upstream/packaging commit ($head)");
+		 "found mixed upstream/packaging commit"," ($head)");
 	    $clogonly = undef;
 	    $breakwater = undef;
 	} elsif ($ty eq 'Pseudomerge' or
 		 $ty eq 'AddPatches') {
 	    $x->($furniture, (lc $ty),
-		 "found interchange bureaucracy commit ($ty, $head)");
+		 "found interchange bureaucracy commit ($ty)"," ($head)");
 	} elsif ($ty eq 'DgitImportUnpatched') {
 	    $x->($trouble, 'dgitimport',
 		 "found dgit dsc import ($head)");
 	    return (undef,undef);
 	} else {
 	    $x->($fatal, 'unprocessable',
-		 "found unprocessable commit, cannot cope: $head; $cl->{Why}"
-		);
+		 "found unprocessable commit, cannot cope: $cl->{Why}",
+		 " ($head)");
 	    return (undef,undef);
 	}
 	$head = $cl->{Parents}[0]{CommitId};
@@ -973,19 +976,8 @@ sub cmd_analyse () {
 }
 
 sub ffq_prev_branchinfo () {
-    # => ('status', "message", [$current, $ffq_prev, $gdrlast])
-    # 'status' may be
-    #    branch         message is undef
-    #    weird-symref   } no $current,
-    #    notbranch      }  no $ffq_prev
     my $current = git_get_symref();
-    return ('detached', 'detached HEAD') unless defined $current;
-    return ('weird-symref', 'HEAD symref is not to refs/')
-	unless $current =~ m{^refs/};
-    my $ffq_prev = "refs/$ffq_refprefix/$'";
-    my $gdrlast = "refs/$gdrlast_refprefix/$'";
-    printdebug "ffq_prev_branchinfo branch current $current\n";
-    return ('branch', undef, $current, $ffq_prev, $gdrlast);
+    return gdr_ffq_prev_branchinfo($current);
 }
 
 sub record_ffq_prev_deferred () {
@@ -1000,12 +992,12 @@ sub record_ffq_prev_deferred () {
     # if "deferred", will have added something about that to
     #   @deferred_update_messages, and also maybe printed (already)
     #   some messages about ff checks
+    my $currentval = get_head();
+
     my ($status, $message, $current, $ffq_prev, $gdrlast)
 	= ffq_prev_branchinfo();
     return ($status, $message) unless $status eq 'branch';
 
-    my $currentval = get_head();
-
     my $exists = git_get_ref $ffq_prev;
     return ('exists',"$ffq_prev already exists") if $exists;
 
@@ -1029,7 +1021,7 @@ sub record_ffq_prev_deferred () {
 	}
 	return if $invert;
 	my $lrval = git_get_ref $lrref;
-	return unless defined $lrval;
+	return unless length $lrval;
 
 	if (is_fast_fwd $lrval, $currentval) {
 	    print "OK, you are ahead of $lrref\n" or die $!;
@@ -1139,7 +1131,7 @@ sub do_stitch ($;$) {
     stitch($dangling_head, $ffq_prev, $gdrlast, $ffq_prev_commitish, $prose);
 }
 
-sub cmd_new_upstream_v0 () {
+sub cmd_new_upstream () {
     # automatically and unconditionally launders before rebasing
     # if rebase --abort is used, laundering has still been done
 
@@ -1148,10 +1140,30 @@ sub cmd_new_upstream_v0 () {
     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 $spec_version = shift @ARGV;
+    my $new_version = (new Dpkg::Version $spec_version, check => 1);
+    if ($new_version->is_native()) {
+	$new_version = (new Dpkg::Version "$spec_version-1", check => 1);
+    }
     my $new_upstream_version = $new_version->version();
 
-    my $new_upstream = git_rev_parse (shift @ARGV // 'upstream');
+    my $new_upstream = shift @ARGV;
+    if (!defined $new_upstream) {
+	my @tried;
+	# todo: at some point maybe use git-deborig to do this
+	foreach my $tagpfx ('', 'v', 'upstream/') {
+	    my $tag = $tagpfx.(dep14_version_mangle $new_upstream_version);
+	    $new_upstream = git_get_ref "refs/tags/$tag";
+	    last if length $new_upstream;
+	    push @tried, $tag;
+	}
+	if (!length $new_upstream) {
+	    fail "Could not determine appropriate upstream commitish.\n".
+		" (Tried these tags: @tried)\n".
+		" Check version, and specify upstream commitish explicitly.";
+	}
+    }
+    $new_upstream = git_rev_parse $new_upstream;
 
     record_ffq_auto();
 
@@ -1210,11 +1222,13 @@ sub cmd_new_upstream_v0 () {
 	   ) {
 	    my @oldpieces = (split / /, $1);
 	    my $old_n_parents = scalar @{ $old_upstream->{Parents} };
-	    if (@oldpieces != $old_n_parents) {
+	    if ($old_n_parents != @oldpieces &&
+		$old_n_parents != @oldpieces + 1) {
 		snag 'upstream-confusing', sprintf
 		    "previous upstream combine %s".
-		    " mentions %d pieces (each implying one orig commit)".
-		    " but has %d parents",
+		    " mentions %d pieces (each implying one parent)".
+		    " but has %d parents".
+		    " (one per piece plus maybe a previous combine)",
 		    $old_upstream->{CommitId},
 		    (scalar @oldpieces),
 		    $old_n_parents;
@@ -1227,7 +1241,8 @@ sub cmd_new_upstream_v0 () {
 		$oldpieces[0] = '';
 		foreach my $i (0..$#oldpieces) {
 		    my $n = $oldpieces[$i];
-		    $piece->($n, Old => $old_upstream->{CommitId}.'^'.($i+1));
+		    my $hat = 1 + $i + ($old_n_parents - @oldpieces);
+		    $piece->($n, Old => $old_upstream->{CommitId}.'^'.$hat);
 		}
 	    }
 	} else {
@@ -1341,6 +1356,8 @@ END
         'launder for new upstream';
 
     my @cmd = (@git, qw(rebase --onto), $new_bw, $old_bw, @ARGV);
+    local $ENV{GIT_REFLOG_ACTION} = git_reflog_action_msg
+	"debrebase new-upstream $new_version: rebase";
     runcmd @cmd;
     # now it's for the user to sort out
 }
@@ -1369,6 +1386,92 @@ sub cmd_breakwater () {
     print "$bw\n" or die $!;
 }
 
+sub cmd_status () {
+    badusage "no arguments allowed" if @ARGV;
+
+    # todo: gdr status should print divergence info
+    # todo: gdr status should print upstream component(s) info
+    # todo: gdr should leave/maintain some refs with this kind of info ?
+
+    my $oldest = { Badness => 0 };
+    my $newest;
+    my $note = sub {
+	my ($badness, $ourmsg, $snagname, $dummy, $cl, $kcmsg) = @_;
+	if ($oldest->{Badness} < $badness) {
+	    $oldest = $newest = undef;
+	}
+	$oldest = {
+		   Badness => $badness,
+		   CommitId => $cl->{CommitId},
+		   OurMsg => $ourmsg,
+		   KcMsg => $kcmsg,
+		  };
+	$newest //= $oldest;
+    };
+    my ($anchor, $bw) = keycommits +(git_rev_parse 'HEAD'),
+	sub { $note->(1, 'branch contains furniture (not laundered)', @_); },
+	sub { $note->(2, 'branch is unlaundered', @_); },
+	sub { $note->(3, 'branch needs laundering', @_); },
+	sub { $note->(4, 'branch not in git-debrebase form', @_); };
+
+    my $prcommitinfo = sub {
+	my ($cid) = @_;
+	flush STDOUT or die $!;
+	runcmd @git, qw(--no-pager log -n1),
+	    '--pretty=format:    %h %s%n',
+	    $cid;
+    };
+
+    print "current branch contents, in git-debrebase terms:\n";
+    if (!$oldest->{Badness}) {
+	print "  branch is laundered\n";
+    } else {
+	print "  $oldest->{OurMsg}\n";
+	my $printed = '';
+	foreach my $info ($oldest, $newest) {
+	    my $cid = $info->{CommitId};
+	    next if $cid eq $printed;
+	    $printed = $cid;
+	    print "  $info->{KcMsg}\n";
+	    $prcommitinfo->($cid);
+	}
+    }
+
+    my $prab = sub {
+	my ($cid, $what) = @_;
+	if (!defined $cid) {
+	    print "  $what is not well-defined\n";
+	} else {
+	    print "  $what\n";
+	    $prcommitinfo->($cid);
+	}
+    };
+    print "key git-debrebase commits:\n";
+    $prab->($anchor, 'anchor');
+    $prab->($bw, 'breakwater');
+
+    my ($ffqstatus, $ffq_msg, $current, $ffq_prev, $gdrlast) =
+	ffq_prev_branchinfo();
+
+    print "branch and ref status, in git-debrebase terms:\n";
+    if ($ffq_msg) {
+	print "  $ffq_msg\n";
+    } else {
+	$ffq_prev = git_get_ref $ffq_prev;
+	$gdrlast = git_get_ref $gdrlast;
+	if ($ffq_prev) {
+	    print "  unstitched; previous tip was:\n";
+	    $prcommitinfo->($ffq_prev);
+	} elsif (!$gdrlast) {
+	    print "  stitched? (no record of git-debrebase work)\n";
+	} elsif (is_fast_fwd $gdrlast, 'HEAD') {
+	    print "  stitched\n";
+	} else {
+	    print "  not git-debrebase (diverged since last stitch)\n"
+	}
+    }
+}
+
 sub cmd_stitch () {
     my $prose = 'stitch';
     GetOptions('prose=s', \$prose) or die badusage("bad options to stitch");
@@ -1405,8 +1508,13 @@ sub make_patches_staged ($) {
     in_workarea sub {
 	runcmd @git, qw(checkout -q -b bw), $secret_bw;
 	runcmd @git, qw(checkout -q -b patch-queue/bw), $secret_head;
-	runcmd qw(gbp pq export);
-	runcmd @git, qw(add debian/patches);
+	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);
     };
 }
 
@@ -1424,28 +1532,31 @@ sub make_patches ($) {
             '[git-debrebase: export and commit patches]',
         ];
     };
-    my $d = get_differs $head, $out;
-    if ($d == 0) {
-	return undef; # nothing to do
-    } elsif ($d == D_PAT_ADD) {
-	return $out; # OK
-    } else {
-	fail "Patch export produced patch amendments".
-	    " (abandoned output commit $out).".
-	    "  Try laundering first.";
-    }
+    return $out;
 }
 
 sub cmd_make_patches () {
+    my $opt_quiet_would_amend;
+    GetOptions('quiet-would-amend!', \$opt_quiet_would_amend)
+	or die badusage("bad options to make-patches");
     badusage "no arguments allowed" if @ARGV;
     my $old_head = get_head();
     my $new = make_patches $old_head;
-    snags_maybe_bail();
-    if (!$new) {
+    my $d = get_differs $old_head, $new;
+    if ($d == 0) {
 	fail "No (more) patches to export." unless $opt_noop_ok;
 	return;
+    } elsif ($d == D_PAT_ADD) {
+	snags_maybe_bail();
+	update_head_checkout $old_head, $new, 'make-patches';
+    } else {
+	print STDERR failmsg
+	    "Patch export produced patch amendments".
+	    " (abandoned output commit $new).".
+	    "  Try laundering first."
+	    unless $opt_quiet_would_amend;
+	finish 7;
     }
-    update_head_checkout $old_head, $new, 'make-patches';
 }
 
 sub cmd_convert_from_gbp () {