use Memoize;
use Carp;
+use POSIX;
use Data::Dumper;
use Debian::Dgit qw(:DEFAULT $wa);
our $ud = "$rd/work";
our @git = qw(git);
+sub get_differs ($$) {
+ my ($x,$y) = @_;
+ # This resembles quiltify_trees_differ, in dgit, a bit. But: we
+ # don't care about modes, or dpkg-source-unrepresentable changes,
+ # and we don't need the plethora of different modes.
+
+ my $differs = 0;
+
+ my $f;
+ my $rundiff = sub {
+ my ($sfx, $fn) = @_;
+ my @cmd = (@git, qw(diff-tree -z --name-only));
+ push @cmd "$_:$sfx" foreach $x, $y;
+ my $diffs = cmdoutput @bcmd, $x, $y;
+ foreach $f (split /\0/, $diffs) { $fn->(); }
+ };
+
+ $rundiff('', sub {
+ $differs |= $f eq 'debian' ? D_DEB : D_UPS;
+ });
+
+ if ($differs & D_DEB) {
+ $differs &= ~D_DEB;
+ $rundiff(':debian', sub {
+ $differs |= $f eq 'patches' ? D_PAT_OTH : D_DEB;
+ });
+ }
+
+ if ($differs & D_PAT_OTH) {
+ $rundiff(':debian/patches', sub {
+
+ });
+
+
+
+ }
+ $f eq '
+
sub commit_pr_info ($) {
my ($r) = @_;
return Data::Dumper->dump([$r], [qw(commit)]);
return $unknown->("complex merge");
}
-sub walk ($;$$$$);
-sub walk {
+sub walk ($;$$);
+sub walk ($;$$) {
my ($input,
- $nogenerate,$report,
- $wantdebonly,$depth) = @_;
+ $nogenerate,$report) = @_;
# => ($tip, $breakwater_tip)
+ # (or nothing, if $nogenerate)
# go through commits backwards
- # we generate two lists of commits to apply
- my (@deb_cl, @ups_cl, @processed);
+ # we generate two lists of commits to apply:
+ # breakwater branch and upstream patches
+ my (@brw_cl, @upp_cl, @processed);
my %found;
+ my $upp_limit;
my @pseudomerges;
- $depth //= 0;
-
my $cl;
my $xmsg = sub {
my ($appendinfo) = @_;
return (Msg => $ms);
};
my $rewrite_from_here = sub {
- push @processed, { SpecialMethod => 'StartRewrite' };
+ my $sp_cl = { SpecialMethod => 'StartRewrite' };
+ push @brw_cl, $sp_cl;
+ push @processed, $sp_cl;
};
-
my $cur = $input;
my $prdelim = "";
die "commit $cur: Cannot cope with this commit";
};
+ my $build;
+ my $breakwater;
+
+ my $build_start = sub {
+ my ($msg, $parent) = @_;
+ $prline->(" $msg");
+ $build = $parent;
+ no warnings qw(exiting); last;
+ };
+
for (;;) {
- if (!defined $cur) {
- push @deb_cl, { ExactlyParents => [] };
- $prline->("Origin");
- last;
- }
$cl = classify $cur;
my $ty = $cl->{Type};
my $st = $cl->{SubType};
$prline->("$cl->{CommitId} $cl->{Type}");
$found{$ty. ( defined($st) ? "-$st" : '' )}++;
push @processed, $cl;
- my $p0 = @[ $cl->{Parents} }==1 ? $cl->{Parents}[0]{CommitId} : undef;
+ my $p0 = @{ $cl->{Parents} }==1 ? $cl->{Parents}[0]{CommitId} : undef;
if ($ty eq 'AddPatches') {
$cur = $p0;
$rewrite_from_here->();
next;
} elsif ($ty eq 'Packaging') {
- push @deb_cl, $cl;
- $cur = $p0;
- next;
- } elsif ($ty eq 'Packaging') {
- push @deb_cl, $cl;
+ push @brw_cl, $cl;
$cur = $p0;
next;
+ } elsif ($ty eq 'BreakwaterStart') {
+ $build_start->('FirstPackaging', $cur);
} elsif ($ty eq 'Upstream') {
- push @ups_cl, $cl;
+ push @upp_cl, $cl;
$cur = $p0;
next;
} elsif ($ty eq 'Mixed') {
my $cls = { $cl, $xmsg->("split mixed commit: $wh part") };
push @$q, $cls;
};
- $queue->(\@deb_cl, "debian");
- $queue->(\@ups_cl, "upstream");
+ $queue->(\@brw_cl, "debian");
+ $queue->(\@upp_cl, "upstream");
$rewrite_from_here->();
+ $cur = $p0;
next;
} elsif ($ty eq 'Pseudomerge') {
print $report " Contributor=$ty->{Contributor}" if $report;
$cur = $ty->{Contributor};
next;
} elsif ($ty eq 'BreakwaterUpstreamMerge') {
- push @deb_cl, { ExactlyParents -> [$cur] };
- $prline->("PreviousBreakwater");
- last;
+ $build_start->("PreviousBreakwater", $cur);
} elsif ($ty eq 'DgitImportUnpatched') {
my $pm = $pseudomerges[-1];
if (defined $pm) {
- # To an extent, this is heurstic. Imports don't have
+ # To an extent, this is heuristic. 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
+ # useful history of debian/, and ignore the histories
+ # from later pseudomerges. 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.
if (@$ovwrs != 1) {
return $bomb->();
}
- my $ovwr = $ovwr->[0]{CommitId};
+ my $ovwr = $ovwrs->[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
# 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, {
+ push @brw_cl, {
%$cl,
SpecialMethod => 'DgitImportDebianUpdate',
$xmsg->("convert dgit import: debian changes")
};
- my $differs = get_differs $ovwr, $cl->{Tree};
+ my $differs = (get_differs $ovwr, $cl->{Tree});
printf $report " Differs=%#x", $differs if $report;
if ($differs & D_UPS) {
printf $report " D_UPS" if $report;
# 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, {
+ push @brw_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] };
+ $prline->(" Import");
$rewrite_from_here->();
- last
+ $upp_limit //= $#upp_cl; # further, deeper, patches discarded
+ $cur = $ovwr;
+ next;
} 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;
+ $build_start->("ImportOrigin", $cur);
}
die "$ty ?";
} else {
}
}
$prprdelim->();
- if ($nogenerate) {
- return (undef, $basis);
- }
+ return if $nogenerate;
# Now we build it back up again
my $rewriting = 0;
- my $build = $basis;
-
my $rm_tree_cached = sub {
my ($subdir) = @_;
runcmd @git, qw(rm --quiet -rf --cached), $subdir;
in_workarea sub {
mkdir $rd or $!==EEXIST or die $!;
my $current_method;
- foreach my $cl (qw(Debian), (reverse @deb_cl),
+ foreach my $cl (qw(Debian), (reverse @brw_cl),
{ SpecialMethod => 'RecordBreakwaterTip' },
- qw(Upstream), (reverse @ups_cl)) {
+ qw(Upstream), (reverse @upp_cl)) {
if (!ref $cl) {
$current_method = $cl;
next;
$rewriting = 1;
next;
} elsif ($method eq 'RecordBreakwaterTip') {
- last if $wantdebonly;
$breakwater = $build;
next;
} elsif ($method eq 'DgitImportDebianUpdate') {
}
};
- runcmd @git, qw(diff-tree --quiet),
- map { $wantdebonly ? "$_:debian" : $_ }
- $input, $build;
+ runcmd @git, qw(diff-tree --quiet), $input, $build;
return ($build, $breakwater);
}
sub get_head () { return git_rev_parse qw(HEAD); }
-sub update_head ($$) {
+sub update_head ($$$) {
my ($old, $new, $mrest) = @_;
runcmd @git, qw(update-ref -m), "git-debrebase $mrest", $new, $old;
}
STDOUT->error and die $!;
}
-my $toplevel = runcmd @git, qw(rev-parse --show-toplevel);
+my $toplevel = cmdoutput @git, qw(rev-parse --show-toplevel);
chdir $toplevel or die "chdir $toplevel: $!";
my $cmd = shift @ARGV;