git-debrebase: wip, redoing origin handling

diff --git a/git-debrebase b/git-debrebase
index 3048793a8d6b6b254d292dba277cec576fe13788..cbf7e91ea12ec5ab5ec6aad1881fcb8bf3c1fc0b 100755 (executable)
--- 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->();
        }