git-debrebase: wip, redoing origin handling

1 files changed, 67 insertions, 51 deletions

diff --git a/git-debrebase b/git-debrebase
index 3048793..cbf7e91 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -236,6 +236,8 @@ sub classify ($) {
 	} elsif ($d & (D_PAT_ADD|D_PAT_OTH)) {
 	    return $unknown->("edits debian/patches");
 	} elsif ($d == D_DEB) {
+	    check if there were any deb before, is not this is
+		a packaging introduction (ie breakwater root)
 	    return $classify->(qw(Packaging));
 	} elsif ($d == D_UPS) {
 	    return $classify->(qw(Upstream));
@@ -312,9 +314,10 @@ sub walk {
     my ($input,
 	$nogenerate,$report,
 	$wantdebonly,$depth) = @_;
+    # => ($tip, $breakwater_tip)
+
     # go through commits backwards
     # we generate two lists of commits to apply
-    # => ($tip, $breakwater_tip)
     my (@deb_cl, @ups_cl, @processed);
     my %found;
     my @pseudomerges;
@@ -342,27 +345,26 @@ sub walk {
     };
 
     my $cur = $input;
-    my $basis;
 
     my $prdelim = "";
     my $prprdelim = sub { print $report $prdelim if $report; $prdelim=""; };
 
+    my $prline = sub {
+	return unless $report;
+	print $report $prdelim, @_;
+	$prdelim = "\n";
+    };
+
     for (;;) {
 	if (!defined $cur) {
-	    if ($report) {
-		print $report $predelim, "Origin";
-		$prdelim = "\n";
-	    }
-	    $basis = undef;
+	    push @deb_cl, { ExactlyParents => [] };
+	    $prline->("Origin");
 	    last;
 	}
 	$cl = classify $cur;
 	my $ty = $cl->{Type};
 	my $st = $cl->{SubType};
-	if ($report) {
-	    print $report $prdelim, "$cl->{CommitId} $cl->{Type}";
-	    $prdelim = "\n";
-	}
+	$prline->("$cl->{CommitId} $cl->{Type}");
 	$found{$ty. ( defined($st) ? "-$st" : '' )}++;
 	push @processed, $cl;
 	my $p0 = @[ $cl->{Parents} }==1 ? $cl->{Parents}[0]{CommitId} : undef;
@@ -395,38 +397,10 @@ sub walk {
 	    $cur = $ty->{Contributor};
 	    next;
 	} elsif ($ty eq 'BreakwaterUpstreamMerge') {
-	    $basis = $cur;
+	    push @deb_cl, { ExactlyParents -> [$cur] };
+	    $prline->("PreviousBreakwater");
 	    last;
 	} elsif ($ty eq 'DgitImportUnpatched') {
-	    # This import has a tree which is just like a breakwater
-	    # tree, but it has the wrong history.  Its ought to have
-	    # the previous breakwater (which dgit ought to have
-	    # generated a pseudomerge to overwrite) as an ancestor.
-	    # That will make the history of the debian/ files correct.
-	    # As for the upstream version: either it's the same upstream
-	    # as the previous breakwater, in which case that history is
-	    # precisely right.  Otherwise, it was a non-gitish upload
-	    # of a new upstream version.  We can tell these apart
-	    # by looking at the tree of the supposed upstream.
-	    my $differs = get_differs $previous_breakwater, $cl->{Tree};
-	    printf $report " Differs=%#x", $differs if $report;
-	    if ($differs & D_UPS) {
-		printf $report " D_UPS" if $report;
-		# This will also trigger if a non-dgit git-based NMU
-		# deleted .gitignore (which is a thing that some of
-		# the existing git tools do if the user doesn't
-		# somehow tell them not to).  Ah well.
-		push @deb_cl, {
-                    %$cl,
-                    SpecialMethod => 'DgitImportUpstreamUpdate',
-                    $xmsg->("convert dgit import: debian changes")
-                };
-	    }
-	    push @deb_cl, {
-		%$cl,
-		SpecialMethod => 'DgitImportDebianUpdate',
-                $xmsg->("convert dgit import: upstream changes")
-            };
 	    my $pm = $pseudomerges[-1];
 	    if (defined $pm) {
 		# To an extent, this is heurstic.  Imports don't have
@@ -437,24 +411,66 @@ sub walk {
 		# will be the dgit import of the upload to the actual
 		# suite intended by the non-dgit NMUer, and later
 		# pseudomerges may represent in-archive copies.
-		my $ovwr = $pm->{Overwritten};
-		printf $report " PM=%s \@Ovewritten:%d", $pm, (scalar @$ovwr)
+		my $ovwrs = $pm->{Overwritten};
+		printf $report " PM=%s \@Overwr:%d", $pm, (scalar @$ovwrs)
 		    if $report;
-		if (@$ovwr != 1) {
+		if (@$ovwrs != 1) {
 		    return $bomb->();
 		}
-		$basis = walk
-		    $ovwr->[0]{CommitId},
+		my $ovwr = $ovwr->[0]{CommitId};
+		printf $report " Overwr=%s", $ovwr if $report;
+		# This import has a tree which is just like a
+		# breakwater tree, but it has the wrong history.  It
+		# ought to have the previous breakwater (which the
+		# pseudomerge overwrote) as an ancestor.  That will
+		# make the history of the debian/ files correct.  As
+		# for the upstream version: either it's the same as
+		# was ovewritten (ie, same as the previous
+		# breakwater), in which case that history is precisely
+		# right; or, otherwise, it was a non-gitish upload of a
+		# new upstream version.  We can tell these apart by
+		# looking at the tree of the supposed upstream.
+		push @deb_cl, {
+		    %$cl,
+		    SpecialMethod => 'DgitImportDebianUpdate',
+                    $xmsg->("convert dgit import: debian changes")
+		};
+		my $differs = get_differs $ovwr, $cl->{Tree};
+		printf $report " Differs=%#x", $differs if $report;
+		if ($differs & D_UPS) {
+		    printf $report " D_UPS" if $report;
+		    # This will also trigger if a non-dgit git-based NMU
+		    # deleted .gitignore (which is a thing that some of
+		    # the existing git tools do if the user doesn't
+		    # somehow tell them not to).  Ah well.
+		    push @deb_cl, {
+			%$cl,
+			SpecialMethod => 'DgitImportUpstreamUpdate',
+		        $xmsg->("convert dgit import: upstream changes")
+		    };
+		}
+		$prline->("Import");
+		$prprdelim->();
+		my ($basis,$dummy) = walk
+		    $ovwr,
 		    $nogenerate, $report,
 		    1, $depth+1;
+		push @deb_cl, { ExactlyParents => [$basis] };
+		$rewrite_from_here->();
+		last
 	    } else {
-		# Everything is from this import.
+		# Everything is from this import.  This kind of import
+		# is already in valid breakwater format, with the
+		# patches as commits.
 		printf $report " NoPM" if $report;
-		
-		xxx set basis to undef or something to mean make origin
+		push @deb_cl, { ExactlyParents => [$cur] };
+		# last thing we processed will have been the first patch,
+		# if there is one; which is fine, so no need to rewrite
+		# on account of this import
+		$prline->("ImportOrigin");
+		last;
 	    }
-	    $rewrite_from_here->();
-	    last;
+	    die "$ty ?";
         } else {
 	    return $bomb->();
 	}