use POSIX;
use Data::Dumper;
use Getopt::Long qw(:config posix_default gnu_compat bundling);
+use Dpkg::Version;
our ($opt_force);
my $t = $r->{Tree};
foreach my $p (@p) {
- $p->{Differs} => (get_differs $p->{CommitId}, $t),
+ $p->{Differs} = (get_differs $p->{CommitId}, $t),
}
printdebug "classify $objid \$t=$t \@p",
} elsif ($d & (D_PAT_ADD|D_PAT_OTH)) {
return $unknown->("edits debian/patches");
} elsif ($d & DS_DEB and !($d & ~DS_DEB)) {
- my ($ty,$dummy) = git_cat_file "$ph[0]:debian";
+ my ($ty,$dummy) = git_cat_file "$p[0]{CommitId}:debian";
if ($ty eq 'tree') {
if ($d == D_DEB_CLOG) {
return $classify->(qw(Changelog));
}
sub cmd_new_upstream_v0 () {
+ # xxx would like to support more git-rebase options
badusage
- "need NEW-VERSION ORIG-COMMITISH [EXTRA-ORIG-NAME EXTRA-ORIG-COMMITISH...]"
+ "need NEW-VERSION UPS-COMMITISH [EXTRA-UPS-NAME EXTRA-UPS-COMMITISH...]"
unless @ARGV % 2 == 0 and @ARGV >= 2;
# tree should be clean and this is not checked
# automatically and unconditionally launders before rebasing
# if rebase --abort is used, laundering has still been done
+ my %pieces;
+
# parse args - low commitment
- my $new_version = new Dpkg::Version scalar(shift @ARGV), 1;
+ my $new_version = (new Dpkg::Version scalar(shift @ARGV), check => 1);
my $new_upstream_version = $new_version->version();
- my $new_orig_commitish = git_rev_parse shift @ARGV;
- my @extra_origs;
+
+ my $new_upstream = git_rev_parse shift @ARGV;
+
+ my $piece = sub {
+ my ($n, @x) = @_; # may be ''
+ my $pc = $pieces{$n} //= {
+ Name => $n,
+ Desc => ($n ? "upstream piece $n" : "upstream (main piece"),
+ };
+ while (my $k = shift @x) { $pc->{$k} = shift @x; }
+ };
+
+ my @newpieces;
+ my $newpiece = sub {
+ my ($n, @x) = @_; # may be ''
+ my $pc = $piece->($n, @x, NewIx => (scalar @newpieces));
+ push @newpieces, $pc;
+ };
+
+ $newpiece->('',
+ OldIx => 0,
+ New => $new_upstream,
+ );
while (@ARGV) {
- my $xo = {
- Name => shift @ARGV,
- New => git_rev_parse shift @ARGV,
- };
- die unless $xo->{Name} =~ m/^$extra_orig_namepart_re$/;
- push @extra_origs, $xo;
+ my $n = shift @ARGV;
+ my $c = git_rev_parse shift @ARGV;
+ die unless $n =~ m/^$extra_orig_namepart_re$/;
+ $newpiece->($n, New => $c);
}
# now we need to investigate the branch this generates the
# laundered version but we don't switch to it yet
- my $old = get_head();
- my ($laundered_tip,$breakwater) = walk $old;
+ my $old_head = get_head();
+ my ($old_laundered_tip,$old_bw) = walk $old_head;
- my $breakwater_cl = classify $breakwater;
- my $old_orig_pi = $breakwater_cl->{OrigParents}[0];
+ my $old_bw_cl = classify $old_bw;
+ my $old_upstream = parsecommit $old_bw_cl->{OrigParents}[0]{CommitId};
- fresh_workarea();
- in_workarea sub {
- my $ff_still_ok = 1;
+ my $problems = 0;
+ my $problem = sub {
+ my ($msg) = @_;
+ $problems++;
+ print STDERR "preflight check failed: $msg\n";
+ };
- my $ffnot = sub {
- my ($msg) = @_;
- $ff_still_ok = 0;
- print STDERR "upstream not fast forward: $msg\n";
- };
+ $piece->('', Old => $old_upstream);
+
+ if ($old_upstream->{Msg} =~ m{^\[git-debrebase }m) {
+ if ($old_upstream->{Msg} =~
+ m{^\[git-debrebase new-upstream combine \.((?: $extra_orig_namepart_re)+)\]}
+ ) {
+ my @oldpieces = ('', split / /, $1);
+ my $parentix = -1 + scalar @{ $old_upstream->{Parents} };
+ foreach my $i (0..$#oldpieces) {
+ my $n = $oldpieces[$i];
+ $piece->($n, Old => $old_upstream->{CommitId}.'^'.$parentix);
+ }
+ } else {
+ $problem->("previous upstream $old_upstream->{CommitId} is from".
+ " git-debrebase but not a \`new-upstream combine' commit");
+ }
+ }
- if (@extra_origs) {
- # check fast forward, and make new combined-orig commit
- my $old_orig_ci = parsecommit $old_orig_pi->{CommitId};
- my $n_old_origs = scalar @{ $old_orig_cp->{Parents} };
- @{ $n_old_origs } == @extra_origs+1 or
- $ffnot->(sprintf
- "previous breakwater upstream has %d parents".
- " but new upstream has %d pieces, cannot check ff",
- $n_old_origs,
- (1 + scalar @extra_origs));
+ foreach my $pc (values %pieces) {
+ if (!$pc->{Old}) {
+ $problem->("introducing upstream piece $pc->{Name}");
+ } elsif (!$pc->{New}) {
+ $problem->("dropping upstream piece $pc->{Name}");
+ } elsif (!is_fast_fwd $pc->{Old}, $pc->{New}) {
+ $problem->("not fast forward: $pc->{Name} $pc->{Old}..$pc->{New}");
}
+ }
- my @upstream_merge_parents;
+ if ($problems) {
+ if ($opt_force) {
+ printf STDERR
+ "preflight check failures (%d) overriden by --force\n",
+ $problems;
+ } else {
+ fail sprintf
+ "preflight check failures (%d) (you could --force)",
+ $problems;
+ }
+ }
- foreach my $piece_ix (0..$n_old_origs-1) {
- my $prevpc = $breakwater.'^'.($old_orig_pi->{Ix} + 1);
- if (@extra_origs) {
- $prevpc .= '^'.($piece_ix + 1);
- }
- die unless $ git_rev_parse $prevpc;
- my ($newpc,$newdesc,$pcname);
- if (!$piece_ix) {
- $newpc = $new_orig_commitish;
- $newdesc = 'new main upstream piece';
- } else {
- $newpc = $extra_origs[$piece_ix+1]{New};
- $pcname = $extra_origs[$piece_ix-1]{Name}
- $newdesc = "new upstream extra piece \`$pcname";
- }
- $ffwant->($prevpc, "previous upstream piece ($prevpc)",
- $newpc, "newdesc ($newpc)");
+ my $new_bw;
- push @upstream_merge_parents, $newpc;
+ fresh_workarea();
+ in_workarea sub {
+ my @upstream_merge_parents;
- my @cmd = @git, qw(read-tree);
- if (defined $pcname) {
- push @cmd, "-prefix=$pcname/";
- runcmd @git, qw(rm --cached -f --ignore-unmatch), $pcname;
+ if (!$problems) {
+ push @upstream_merge_parents, $old_upstream->{CommitId};
+ }
+
+ foreach my $pc (@newpieces) { # always has '' first
+ if ($pc->{Name}) {
+ read_tree_subdir $pc->{Name}, $pc->{New};
+ } else {
+ runcmd @git, qw(read-tree), $pc->{New};
}
- push @cmd, $newpc;
- runcmd @cmd;
+ push @upstream_merge_parents, $pc->{New};
}
# index now contains the new upstream
- if (!$ff_still_ok) {
- die "upstreams not fast forward, stopping".
- " (xxx should be an override option)";
- }
- if (@extra_origs) {
+ if (@newpieces > 1) {
# need to make the upstream subtree merge commit
my $us_tree = cmdoutput @git, qw(write-tree);
- my @cmd = @git, qw(commit-tree), $us_tree;
- if ($ff_still_ok) {
- push @cmd, qw(-p),
- } else {
- die 'do we want to make ff from previous upstream comb?"';
- }
+ my @cmd = (@git, qw(commit-tree), $us_tree);
push @cmd, qw(-p), $_ foreach @upstream_merge_parents;
push @cmd, qw(-m), "Combine upstreams for $new_upstream_version";
push @cmd, qw(-m),
- "[git-debrebase combine-upstreams . ".
- (join " ", map { $_->{Name} } @extra_upstreams)."]";
- my $combined = cmdoutput @cmd;
+ "[git-debrebase new-upstream combine . ".
+ (join " ", map { $_->{Name} } @newpieces[1..$#newpieces]).
+ "]";
+ $new_upstream = cmdoutput @cmd;
}
-
- my $us_txt = "
- make_commit_te
+ # $new_upstream is either the single upstream commit, or the
+ # combined commit we just made. Either way it will be the
+ # "upstream" parent of the breakwater special merge.
+
+ read_tree_subdir 'debian', "$old_bw:debian";
+
+ # index now contains the breakwater merge contents
+
+ my $bw_tree = cmdoutput @git, qw(write_tree);
+ my @cmd = (@git, qw(commit-tree), $bw_tree);
+ push @cmd, qw(-p), $old_bw, qw(-p), $new_upstream;
+ push @cmd, qw(-m), "Update to upstream $new_upstream_version";
+ push @cmd, qw(-m),
+ "[git-debrebase new-upstream breakwater $new_upstream_version]";
+ $new_bw = cmdoutput @git;
+
+ # Now we have to add a changelog stanza so the Debian version
+ # is right.
+
+ die if unlink "debian";
+ die unless $!==ENOTEMPTY;
+ unlink "debian/changelog" or die $!;
+ open CN, ">", "debian/changelog" or die $!;
+ my $oldclog = git_cat_file ":debian/changelog";
+ $oldclog =~ m/^($package_re) \(\S+\) / or
+ fail "cannot parse old changelog to get package name";
+ my $p = $1;
+ print CN <<END, $oldclog or die $!;
+$p ($new_version) UNRELEASED; urgency=medium
+
+ * Update to new upstream version $new_upstream_version.
+
+ --
+
+END
+ close CN or die $!;
+ runcmd @git, qw(update-index --add --replace), 'debian/changelog';
+
+ # Now we have the final new breakwater branch in the index
+
+ $bw_tree = cmdoutput @git, qw(write_tree);
+ @cmd = (@git, qw(commit-tree), $bw_tree);
+ push @cmd, qw(-p), $new_bw;
+ push @cmd, qw(-m),
+ "Update changelog for new upstream $new_upstream_version";
+ push @cmd, qw(-m),
+ "[git-debrebase new-upstream changelog $new_upstream_version]";
+ $new_bw = cmdoutput @git;
+ };
+
+ # we have constructed the new breakwater. we now need to commit to
+ # the laundering output, because git-rebase can't easily be made
+ # to make a replay list which is based on some other branch
- update_head
- xxx check new orig version is reasonable;
- xxx decorate new orig version to get new debian version;
-
+ update_head $old_head, $old_laundered_tip, 'launder for new upstream';
+
+ my @cmd = (@git, qw(rebase --onto), $new_bw, $old_bw);
+ runcmd @cmd;
+ # now it's for the user to sort out
+}
sub cmd_downstream_rebase_launder_v0 () {
badusage "needs 1 argument, the baseline" unless @ARGV==1;
~ianmdlvl / dgit.git / blobdiff