From: Ian Jackson Date: Sun, 14 May 2017 21:37:45 +0000 (+0100) Subject: git-debrebase: wip, redoing origin handling X-Git-Tag: archive/debian/5.0~353 X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=commitdiff_plain;h=9895af2b1bf07290614e4ee2d57fb84f44ed023a git-debrebase: wip, redoing origin handling --- diff --git a/git-debrebase b/git-debrebase index 3048793a..cbf7e91e 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->(); }