X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=dc55df8c821e93a37961d859b64ac68ba7881a7c;hp=40bf5d464a0f9b1aa589d476ff837b89906b6cc0;hb=8d534ac9006cef95a5b2e9e882039bcabb945543;hpb=cc83099c8a469266014d330ff7556013fbf7def8 diff --git a/git-debrebase b/git-debrebase index 40bf5d46..dc55df8c 100755 --- a/git-debrebase +++ b/git-debrebase @@ -116,6 +116,7 @@ use Carp; use POSIX; use Data::Dumper; use Getopt::Long qw(:config posix_default gnu_compat bundling); +use Dpkg::Version; our ($opt_force); @@ -262,7 +263,7 @@ sub rm_subdir_cached ($) { sub read_tree_subdir ($$) { my ($subdir, $new_tree_object) = @_; rm_subdir_cached $subdir; - runcmd @git, qw(read-tree), "--prefix=$subdir/"; + runcmd @git, qw(read-tree), "--prefix=$subdir/", $new_tree_object; } # classify returns an info hash like this @@ -342,7 +343,7 @@ sub classify ($) { 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", @@ -373,7 +374,7 @@ sub classify ($) { } 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)); @@ -472,7 +473,7 @@ sub walk ($;$$); sub walk ($;$$) { my ($input, $nogenerate,$report) = @_; - # => ($tip, $breakwater_tip) + # => ($tip, $breakwater_tip, $last_upstream_merge_in_breakwater) # (or nothing, if $nogenerate) # go through commits backwards @@ -528,6 +529,8 @@ sub walk ($;$$) { no warnings qw(exiting); last; }; + my $last_upstream_update; + for (;;) { $cl = classify $cur; my $ty = $cl->{Type}; @@ -545,6 +548,7 @@ sub walk ($;$$) { $cur = $p0; next; } elsif ($ty eq 'BreakwaterStart') { + $last_upstream_update = $cur; $build_start->('FirstPackaging', $cur); } elsif ($ty eq 'Upstream') { push @upp_cl, $cl; @@ -569,6 +573,7 @@ sub walk ($;$$) { $cur = $contrib; next; } elsif ($ty eq 'BreakwaterUpstreamMerge') { + $last_upstream_update = $cur; $build_start->("PreviousBreakwater", $cur); } elsif ($ty eq 'DgitImportUnpatched') { my $pm = $pseudomerges[-1]; @@ -622,6 +627,7 @@ sub walk ($;$$) { $prline->(" Import"); $rewrite_from_here->(); $upp_limit //= $#upp_cl; # further, deeper, patches discarded + die 'BUG $upp_limit is not used anywhere?'; $cur = $ovwr; next; } else { @@ -651,6 +657,7 @@ sub walk ($;$$) { my $read_tree_debian = sub { my ($treeish) = @_; read_tree_subdir 'debian', "$treeish:debian"; + rm_subdir_cached 'debian/patches'; }; my $read_tree_upstream = sub { my ($treeish) = @_; @@ -727,6 +734,9 @@ sub walk ($;$$) { my $newcommit = cmdoutput @cmd; confess "$ch ?" unless $rewriting or $newcommit eq $cl->{CommitId}; $build = $newcommit; + if (grep { $method eq $_ } qw(DgitImportUpstreamUpdate)) { + $last_upstream_update = $cur; + } } }; @@ -734,7 +744,7 @@ sub walk ($;$$) { die sprintf "internal error %#x %s %s", $final_check, $build, $input if $final_check & ~D_PAT_ADD; - return ($build, $breakwater); + return ($build, $breakwater, $last_upstream_update); } sub get_head () { return git_rev_parse qw(HEAD); } @@ -776,119 +786,201 @@ sub cmd_analyse () { } 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 $breakwater_cl = classify $breakwater; - my $old_orig_pi = $breakwater_cl->{OrigParents}[0]; + my $old_head = get_head(); + my ($old_laundered_tip,$old_bw,$old_upstream_update) = walk $old_head; + + my $old_bw_cl = classify $old_bw; + my $old_upstream_update_cl = classify $old_upstream_update; + confess unless $old_upstream_update_cl->{OrigParents}; + my $old_upstream = parsecommit + $old_upstream_update_cl->{OrigParents}[0]{CommitId}; + + my $problems = 0; + my $problem = sub { + my ($msg) = @_; + $problems++; + print STDERR "preflight check failed: $msg\n"; + }; - fresh_workarea(); - in_workarea sub { - my $ff_still_ok = 1; + $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"); + } + } - my $ffnot = sub { - my ($msg) = @_; - $ff_still_ok = 0; - print STDERR "upstream not fast forward: $msg\n"; - }; + 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}"); + } + } - 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)); + 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; } + } - my @upstream_merge_parents; + my $new_bw; - 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)"); + fresh_workarea(); + in_workarea sub { + my @upstream_merge_parents; - push @upstream_merge_parents, $newpc; + if (!$problems) { + push @upstream_merge_parents, $old_upstream->{CommitId}; + } - my @cmd = @git, qw(read-tree); - if (defined $pcname) { - push @cmd, "-prefix=$pcname/"; - runcmd @git, qw(rm --cached -f --ignore-unmatch), $pcname; + 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 <