use Debian::Dgit qw(:DEFAULT $wa);
+sub badusage ($) {
+ my ($m) = @_;
+ die "bad usage: $m\n";
+}
+
sub cfg ($) {
my ($k) = @_;
$/ = "\0";
} elsif ($d & (D_PAT_ADD|D_PAT_OTH)) {
return $unknown->("edits debian/patches");
} elsif ($d == D_DEB) {
+ check if there were any deb before, if not this is
+ a packaging introduction (ie breakwater root)
return $classify->(qw(Packaging));
} elsif ($d == D_UPS) {
return $classify->(qw(Upstream));
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;
my $rewrite_from_here = sub {
push @processed, { SpecialMethod => 'StartRewrite' };
};
+ my $bomb = sub { # usage: return $bomb->();
+ print $report " Unprocessable" if $report;
+ $prprdelim->();
+ if ($nogenerate) {
+ return (undef,undef);
+ }
+ die "commit $cur: Cannot cope with this commit";
+ };
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) {
+ 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}[0]{CommitId};
+ my $p0 = @[ $cl->{Parents} }==1 ? $cl->{Parents}[0]{CommitId} : undef;
if ($ty eq 'AddPatches') {
$cur = $p0;
$rewrite_from_here->();
$cur = $ty->{Contributor};
next;
} elsif ($ty eq 'BreakwaterUpstreamMerge') {
- $basis = $cur;
+ push @deb_cl, { ExactlyParents -> [$cur] };
+ $prline->("PreviousBreakwater");
last;
- } elsif ($ty eq 'DgitImportUnpatched' &&
- @pseudomerges == 1) {
- # 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;
+ } elsif ($ty eq 'DgitImportUnpatched') {
+ my $pm = $pseudomerges[-1];
+ if (defined $pm) {
+ # To an extent, this is heurstic. Imports don't have
+ # a useful history of the debian/ branch. We assume
+ # that the first pseudomerge after an import has a
+ # useful history or debian/, and ignore the histories
+ # from later pseudomerge. Often the first pseudomerge
+ # 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 $ovwrs = $pm->{Overwritten};
+ printf $report " PM=%s \@Overwr:%d", $pm, (scalar @$ovwrs)
+ if $report;
+ if (@$ovwrs != 1) {
+ return $bomb->();
+ }
+ 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, {
- %r,
- SpecialMethod => 'DgitImportUpstreamUpdate',
+ %$cl,
+ SpecialMethod => 'DgitImportDebianUpdate',
$xmsg->("convert dgit import: debian changes")
- };
- }
- push @deb_cl, {
- %r,
- SpecialMethod => 'DgitImportDebianUpdate',
- $xmsg->("convert dgit import: upstream changes")
- };
- $prprdelim->();
- $basis = walk
- $pseudomerges[0]{Overwritten},
- $nogenerate, $report,
- 1, $depth+1;
- $rewrite_from_here->();
- last;
- } else {
- print $report " Unprocessable" if $report;
- $prprdelim->();
- if ($nogenerate) {
- return (undef,undef);
+ };
+ 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. This kind of import
+ # is already in valid breakwater format, with the
+ # patches as commits.
+ printf $report " NoPM" if $report;
+ 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;
}
- die "commit $cur: Cannot cope with this commit";
+ die "$ty ?";
+ } else {
+ return $bomb->();
}
}
$prprdelim->();
$current_method = $cl;
next;
}
- $method = $cl->{SpecialMethod} // $current_method;
+ my $method = $cl->{SpecialMethod} // $current_method;
my @parents = ($build);
- my $cltree = $cl->{CommitId}
+ my $cltree = $cl->{CommitId};
if ($method eq 'Debian') {
$read_tree_debian->($cltree);
} elsif ($method eq 'Upstream') {
next;
} elsif ($method eq 'DgitImportDebianUpdate') {
$read_tree_debian->($cltree);
- $rm_tree_cached(qw(debian/patches));
+ $rm_tree_cached->(qw(debian/patches));
} elsif ($method eq 'DgitImportUpstreamUpdate') {
$read_tree_upstream->($cltree);
push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} };
my $ch = $cl->{Hdr};
$ch =~ s{^tree .*}{tree $newtree}m or confess "$ch ?";
$ch =~ s{^parent .*\n}{}m;
- $ch =~ s{(?=^author}{
+ $ch =~ s{(?=^author)}{
map { "parent $_\n" } @parents
}me or confess "$ch ?";
- if ($rewrite) {
+ if ($rewriting) {
$ch =~ s{^committer .*$}{$committer_authline}m
or confess "$ch ?";
}
- my $cf = "$rd/m$rewrite"
- open CD, ">", $cf or die $!;
- print CD $ch, "\n", $cl->{Msg}; or die $!;
+ my $cf = "$rd/m$rewriting";
+ open CD, ">", $cf or die $!;
+ print CD $ch, "\n", $cl->{Msg} or die $!;
close CD or die $!;
my @cmd = (@git, qw(hash-object));
- push @cmd, qw(-w) if $rewrite;
+ push @cmd, qw(-w) if $rewriting;
push @cmd, qw(-t commit), $cf;
my $newcommit = cmdoutput @cmd;
- confess "$ch ?" unless $rewrite or $newcommit eq $cl->{CommitId};
+ confess "$ch ?" unless $rewriting or $newcommit eq $cl->{CommitId};
$build = $newcommit;
}
};
runcmd @git, qw(diff-tree --quiet),
- map { $wantdebonly ? "$_:debian" : $_ },
+ map { $wantdebonly ? "$_:debian" : $_ }
$input, $build;
return ($build, $breakwater);