X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;ds=sidebyside;f=git-debrebase;h=c32f257a5f0543d1d73c5c477aedb4ddd01aecf9;hb=9f3a065563b0277ee1ffffc747829884aa986e95;hp=2b6584630516bb3208c0874413c1bbe791168f94;hpb=0b6c2ca9024f4060476084b128a1a0e6fe395d68;p=dgit.git

diff --git a/git-debrebase b/git-debrebase
index 2b658463..c32f257a 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -29,8 +29,8 @@
 #    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>]
@@ -330,10 +330,12 @@ sub any_fproblems () {
 #     has additional entry in classification result
 #       OrigParents = [ subset of Parents ]
 #
-#   BreakwaterUpstreamMerge
+#   Anchor
 #     has additional entry in classification result
 #       OrigParents = [ subset of Parents ]  # singleton list
 #
+#   BreakwaterStart
+#
 #   Unknown
 #     has additional entry in classification result
 #       Why => "prose"
@@ -400,13 +402,36 @@ sub classify ($) {
 	return $r;
     };
 
-    my $claims_to_be_breakwater =
-	$r->{Msg} =~ m{^\[git-debrebase breakwater.*\]$}m;
+    my @identical = grep { !$_->{Differs} } @p;
+    my ($stype, $series) = git_cat_file "$t:debian/patches/series";
+    my $haspatches = $stype ne 'missing' && $series =~ m/^\s*[^#\n\t ]/m;
+
+    if ($r->{Msg} =~ m{^\[git-debrebase anchor.*\]$}m) {
+	# multi-orig upstreams are represented with an anchor merge
+	# from a single upstream commit which combines the orig tarballs
+
+	my $badanchor = sub { $unknown->("git-debrebase \`anchor' but @_"); };
+	@p == 2 or return $badanchor->("has other than two parents");
+	$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
+	# already an easy rune to look for debian/ history anyway (git log
+	# debian/) so debian breakwater branch should be 1st parent; that
+	# way also there's also an easy rune to look for the upstream
+	# patches (--topo-order).
+
+	$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");
+
+	return $classify->(qw(Anchor),
+			   OrigParents => [ $p[1] ]);
+    }
 
     if (@p == 1) {
-	if ($claims_to_be_breakwater) {
-	    return $unknown->("single-parent git-debrebase breakwater \`merge'");
-	}
 	my $d = $r->{Parents}[0]{Differs};
 	if ($d == D_PAT_ADD) {
 	    return $classify->(qw(AddPatches));
@@ -439,11 +464,7 @@ sub classify ($) {
 	return $unknown->("origin commit");
     }
 
-    my @identical = grep { !$_->{Differs} } @p;
-    if (@p == 2 && @identical == 1 && !$claims_to_be_breakwater
-	# breakwater merges can look like pseudomerges, if they are
-	# "declare" commits (ie, there are no upstream changes)
-       ) {
+    if (@p == 2 && @identical == 1) {
 	my @overwritten = grep { $_->{Differs} } @p;
 	confess "internal error $objid ?" unless @overwritten==1;
 	return $classify->(qw(Pseudomerge),
@@ -485,38 +506,6 @@ sub classify ($) {
 			   OrigParents => \@orig_ps);
     }
 
-    my ($stype, $series) = git_cat_file "$t:debian/patches/series";
-    my $haspatches = $stype ne 'missing' && $series =~ m/^\s*[^#\n\t ]/m;
-
-    # How to decide about l/r ordering of breakwater merges ?  git
-    # --topo-order prefers to expand 2nd parent first.  There's
-    # already an easy rune to look for debian/ history anyway (git log
-    # debian/) so debian breakwater branch should be 1st parent; that
-    # 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 breakwater merges generated manually,
-    # which might be the other way around.  In principle, in some odd
-    # situations, a breakwater 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.
-
-    foreach my $prevbrw (qw(0 1)) {
-	if (@p == 2 &&
-	    !$haspatches &&
-	    !$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(BreakwaterUpstreamMerge),
-			       OrigParents => [ $p[!$prevbrw] ]);
-	}
-    }
-
-    # multi-orig upstreams are represented with a breakwater merge
-    # from a single upstream commit which combines the orig tarballs
-
     return $unknown->("complex merge");
 }
 
@@ -533,7 +522,7 @@ sub breakwater_of ($) {
 	if ($ty eq 'Packaging' or
 	    $ty eq 'Changelog') {
 	    $breakwater //= $head;
-	} elsif ($ty eq 'BreakwaterUpstreamMerge' or
+	} elsif ($ty eq 'Anchor' or
 		 $ty eq 'BreakwaterStart') {
 	    $breakwater //= $head;
 	    last;
@@ -560,7 +549,7 @@ sub walk ($;$$);
 sub walk ($;$$) {
     my ($input,
 	$nogenerate,$report) = @_;
-    # => ($tip, $breakwater_tip, $last_upstream_merge_in_breakwater)
+    # => ($tip, $breakwater_tip, $last_anchor)
     # (or nothing, if $nogenerate)
 
     printdebug "*** WALK $input ".($nogenerate//0)." ".($report//'-')."\n";
@@ -622,7 +611,7 @@ sub walk ($;$$) {
 	no warnings qw(exiting); last;
     };
 
-    my $last_upstream_update;
+    my $last_anchor;
 
     for (;;) {
 	$cl = classify $cur;
@@ -641,7 +630,7 @@ sub walk ($;$$) {
 	    $cur = $p0;
 	    next;
 	} elsif ($ty eq 'BreakwaterStart') {
-            $last_upstream_update = $cur;
+            $last_anchor = $cur;
 	    $build_start->('FirstPackaging', $cur);
 	} elsif ($ty eq 'Upstream') {
 	    push @upp_cl, $cl;
@@ -665,9 +654,9 @@ sub walk ($;$$) {
 	    $rewrite_from_here->();
 	    $cur = $contrib;
 	    next;
-	} elsif ($ty eq 'BreakwaterUpstreamMerge') {
-            $last_upstream_update = $cur;
-	    $build_start->("PreviousBreakwater", $cur);
+	} elsif ($ty eq 'Anchor') {
+            $last_anchor = $cur;
+	    $build_start->("Anchor", $cur);
 	} elsif ($ty eq 'DgitImportUnpatched') {
 	    my $pm = $pseudomerges[-1];
 	    if (defined $pm) {
@@ -708,7 +697,7 @@ sub walk ($;$$) {
 		    %$cl,
 		    SpecialMethod => 'DgitImportUpstreamUpdate',
                     $xmsg->("convert dgit import: upstream update",
-			    " breakwater")
+			    " anchor")
 		};
 		$prline->(" Import");
 		$rewrite_from_here->();
@@ -829,7 +818,7 @@ sub walk ($;$$) {
 	    confess "$ch ?" unless $rewriting or $newcommit eq $cl->{CommitId};
 	    $build = $newcommit;
             if (grep { $method eq $_ } qw(DgitImportUpstreamUpdate)) {
-                $last_upstream_update = $cur;
+                $last_anchor = $cur;
             }
 	}
     };
@@ -838,7 +827,7 @@ sub walk ($;$$) {
     die sprintf "internal error %#x %s %s", $final_check, $build, $input
 	if $final_check & ~D_PAT_ADD;
 
-    my @r = ($build, $breakwater, $last_upstream_update);
+    my @r = ($build, $breakwater, $last_anchor);
     printdebug "*** WALK RETURN @r\n";
     return @r
 }
@@ -868,14 +857,14 @@ 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_upstream_merge) = walk $old;
+    my ($tip,$breakwater,$last_anchor) = walk $old;
     update_head_postlaunder $old, $tip, 'launder';
     printf "# breakwater tip\n%s\n", $breakwater;
     printf "# working tip\n%s\n", $tip;
-    printf "# last upstream merge\n%s\n", $last_upstream_merge;
+    printf "# last anchor\n%s\n", $last_anchor;
 }
 
 sub defaultcmd_rebase () {
@@ -1128,14 +1117,14 @@ sub cmd_new_upstream_v0 () {
 
 	# $new_upstream is either the single upstream commit, or the
 	# combined commit we just made.  Either way it will be the
-	# "upstream" parent of the breakwater special merge.
+	# "upstream" parent of the anchor merge.
 
 	read_tree_subdir 'debian', "$old_bw:debian";
 
-	# index now contains the breakwater merge contents
+	# index now contains the anchor merge contents
         $new_bw = make_commit [ $old_bw, $new_upstream ],
             [ "Update to upstream $new_upstream_version",
- "[git-debrebase breakwater: new upstream $new_upstream_version, merge]",
+ "[git-debrebase anchor: new upstream $new_upstream_version, merge]",
             ];
 
 	# Now we have to add a changelog stanza so the Debian version
@@ -1280,12 +1269,12 @@ sub cmd_convert_from_gbp () {
  'Delete debian/patches, as part of converting to git-debrebase format.',
  '[git-debrebase convert-from-gbp: drop patches from tree]'
 			      ];
-	# make the breakwater pseudomerge
+	# make the anchor merge
 	# the tree is already exactly right
 	$work = make_commit [$work, $upstream], [
  'git-debrebase import: declare upstream',
  'First breakwater merge.',
- '[git-debrebase breakwater: declare upstream]'
+ '[git-debrebase anchor: declare upstream]'
 			      ];
 
 	# rebase the patch queue onto the new breakwater