X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=8c77dbccdcc1bc9c713983a30d33ba5cb2b730f4;hp=f740ed0520917193c80bdbec9320db8df640f754;hb=ece8834f77855aab622f427ffc858e05917ca77d;hpb=f3bb0b33b8b467dd0a03549fdb32d0e3ce7d8e6a diff --git a/git-debrebase b/git-debrebase index f740ed05..8c77dbcc 100755 --- a/git-debrebase +++ b/git-debrebase @@ -18,14 +18,20 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . +# git-debrebase new-upstreams-v0 \ +# NEW-VERSION ORIG-COMMITISH +# [EXTRA-ORIG-NAME EXTRA-ORIG-COMMITISH ...] + # usages: -# git-debrebase launder # prints breakwater tip -# git-debrebase analyse -# git-debrebase start # like ffrebase start + debrebase launder -# git-debrebase create-new-upstream [-f] -# git-debrebase new-upstream [-f] +# git-debrebase status +# git-debrebase start # like ffqrebase start + debrebase launder +# git-debrebase new-upstream [stuff] # see below # git-debrebase # does debrebase start if necessary # +# git-debrebase analyse +# git-debrebase launder # prints breakwater tip +# git-debrebase create-new-upstream-breakwater [-f] ... +# # is # [,][:][+][,...] # @@ -34,9 +40,37 @@ # xxx want auto branch names # xxx too complicated # how about for now -# [+] [ [+]...] +# [+] [ [+]...] # ? plus options # --new-upstream-different-subtrees +# +# automatic case +# git-debrebase new-upstream +# - previous breakwater merge must be gdr-generated +# - orig set is the same as before +# - implicitly uses upstream branches according to orig set +# - not all upstream branches need be updated +# - insists on fast-forward of each branch, unless +# --force (or --force=[/]) +# branch set adjustments +# git-debrebase new-upstream --add / +# git-debrebase new-upstream --rm / +# git-debrebase new-upstream / [/ ...] +# - orig set is adjusted +# - otherwise like auto (--add is not checked for ffness, obv) +# - multiple --add and --rm may be specified +# - --add makes new upstream the last contributor +# explicit +# git-debrebase / [] [/ [] ...] +# - orig set is precisely as specified now +# - previous breakwater merge is irrelevant +# - no fast forward checks +# for now only explicit with commitids + +# implicitly uses `upstream' +# # (or multiple other branches) +# git-debrebase new-upstream \ +# [/]= # UPSTREAM[,[[SUBDIR:]SUBUPSTREAM] # default for SUBDIR: is from previous upstream merge[xxx terminology] @@ -46,23 +80,50 @@ # when starting must record original start (for ff) # and new rebase basis # -# git-ffrebase start [BASE] # records previous HEAD so it can be overwritten -# # records base for future git-ffrebase -# git-ffrebase set-base BASE -# git-ffrebase -# git-ffrebase finish -# git-ffrebase status [BRANCH] +# git-ffqrebase start [BASE] +# # records previous HEAD so it can be overwritten +# # records base for future git-ffqrebase +# git-ffqrebase set-base BASE +# git-ffqrebase +# git-ffqrebase finish +# git-ffqrebase status [BRANCH] # -# refs/ffrebase-prev/BRANCH BRANCH may be refs/...; if not it means -# refs/ffrebase-base/BRANCH refs/heads/BRANCH +# refs/ffqrebase-prev/BRANCH BRANCH may be refs/...; if not it means +# refs/ffqrebase-base/BRANCH refs/heads/BRANCH # zero, one, or both of these may exist +# +# git-debrebase without start, if already started, is willing +# to strip pseudomerges provided that they overwrite exactly +# the previous HEAD +# xxxx is this right ? what matters is have we pushed +# I think in fact the right answer is: +# git-debrebase always strips out pseudomerges from its branch +# a pseudomerge is put in at the time we want to push +# at that time, we make a pseudomerge of the remote tracking +# branch (if raw git) or the dgit view (if dgit) +# for raw git git-ffqrebase, do want preciseley to record +# value of remote tracking branch or our branch, on start, so we +# overwrite only things we intend to +# the previous pseudomerge check for tags and remote branches ? use strict; +use Debian::Dgit qw(:DEFAULT :playground); +setup_sigwarn(); + use Memoize; +use Carp; +use POSIX; use Data::Dumper; +use Getopt::Long qw(:config posix_default gnu_compat bundling); +use Dpkg::Version; + +our ($opt_force); -use Debian::Dgit qw(:DEFAULT $wa); +sub badusage ($) { + my ($m) = @_; + die "bad usage: $m\n"; +} sub cfg ($) { my ($k) = @_; @@ -78,19 +139,108 @@ memoize('cfg'); sub get_commit ($) { my ($objid) = @_; - my ($type,$data) = git_cat_file $objid; - die unless $type eq 'commit'; - $data =~ m/(?<=\n)\n/; + my $data = git_cat_file $objid, 'commit'; + $data =~ m/(?<=\n)\n/ or die "$objid ($data) ?"; return ($`,$'); } -sub D_DEB () { return 0x1; } -sub D_UPS () { return 0x2; } -sub D_PAT_ADD () { return 0x4; } -sub D_PAT_OTH () { return 0x8; } +sub D_UPS () { 0x02; } # upstream files +sub D_PAT_ADD () { 0x04; } # debian/patches/ extra patches at end +sub D_PAT_OTH () { 0x08; } # debian/patches other changes +sub D_DEB_CLOG () { 0x10; } # debian/ (not patches/ or changelog) +sub D_DEB_OTH () { 0x20; } # debian/changelog +sub DS_DEB () { D_DEB_CLOG | D_DEB_OTH; } # debian/ (not patches/) + +our $playprefix = 'debrebase'; +our $rd; +our $workarea; + +our @git = qw(git); + +sub in_workarea ($) { + my ($sub) = @_; + changedir $workarea; + my $r = eval { $sub->(); }; + { local $@; changedir $maindir; } + die $@ if $@; +} + +sub fresh_workarea () { + $workarea = fresh_playground "$playprefix/work"; + in_workarea sub { playtree_setup }; +} + +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. + # Conversely we need to distinguish different kinds of changes to + # debian/ and debian/patches/. + + my $differs = 0; + + my $rundiff = sub { + my ($opts, $limits, $fn) = @_; + my @cmd = (@git, qw(diff-tree -z --no-renames)); + push @cmd, @$opts; + push @cmd, "$_:" foreach $x, $y; + push @cmd, @$limits; + my $diffs = cmdoutput @cmd; + foreach (split /\0/, $diffs) { $fn->(); } + }; -our $rd = ".git/git-debrebase"; -our $ud = "$rd/work"; + $rundiff->([qw(--name-only)], [], sub { + $differs |= $_ eq 'debian' ? DS_DEB : D_UPS; + }); + + if ($differs & DS_DEB) { + $differs &= ~DS_DEB; + $rundiff->([qw(--name-only -r)], [qw(debian)], sub { + $differs |= + m{^debian/patches/} ? D_PAT_OTH : + $_ eq 'debian/changelog' ? D_DEB_CLOG : + D_DEB_OTH; + }); + die "mysterious debian changes $x..$y" + unless $differs & (D_PAT_OTH|DS_DEB); + } + + if ($differs & D_PAT_OTH) { + my $mode; + $differs &= ~D_PAT_OTH; + my $pat_oth = sub { + $differs |= D_PAT_OTH; + no warnings qw(exiting); last; + }; + $rundiff->([qw(--name-status -r)], [qw(debian/patches/)], sub { + no warnings qw(exiting); + if (!defined $mode) { + $mode = $_; next; + } + die unless s{^debian/patches/}{}; + my $ok; + if ($mode eq 'A' && !m/\.series$/s) { + $ok = 1; + } elsif ($mode eq 'M' && $_ eq 'series') { + my $x_s = git_cat_file "$x:debian/patches/series", 'blob'; + my $y_s = git_cat_file "$y:debian/patches/series", 'blob'; + chomp $x_s; $x_s .= "\n"; + $ok = $x_s eq substr($y_s, 0, length $x_s); + } else { + # nope + } + $mode = undef; + $differs |= $ok ? D_PAT_ADD : D_PAT_OTH; + }); + die "mysterious debian/patches changes $x..$y" + unless $differs & (D_PAT_ADD|D_PAT_OTH); + } + + printdebug sprintf "get_differs %s, %s = %#x\n", $x, $y, $differs; + + return $differs; +} sub commit_pr_info ($) { my ($r) = @_; @@ -99,59 +249,146 @@ sub commit_pr_info ($) { sub calculate_committer_authline () { my $c = cmdoutput @git, qw(commit-tree --no-gpg-sign -m), - 'XXX DUMMY COMMIT (git-debrebase)', "$basis:"; + 'DUMMY COMMIT (git-debrebase)', "HEAD:"; my ($h,$m) = get_commit $c; $h =~ m/^committer .*$/m or confess "($h) ?"; return $&; } -sub classify ($) { - my ($objid) = @_; +sub rm_subdir_cached ($) { + my ($subdir) = @_; + runcmd @git, qw(rm --quiet -rf --cached --ignore-unmatch), $subdir; +} + +sub read_tree_subdir ($$) { + my ($subdir, $new_tree_object) = @_; + rm_subdir_cached $subdir; + runcmd @git, qw(read-tree), "--prefix=$subdir/", $new_tree_object; +} + +# classify returns an info hash like this +# CommitId => $objid +# Hdr => # commit headers, including 1 final newline +# Msg => # commit message (so one newline is dropped) +# Tree => $treeobjid +# Type => (see below) +# Parents = [ { +# Ix => $index # ie 0, 1, 2, ... +# CommitId +# Differs => return value from get_differs +# IsOrigin +# IsDggitImport => 'orig' 'tarball' 'unpatched' 'package' (as from dgit) +# } ...] +# NewMsg => # commit message, but with any [dgit import ...] edited +# # to say "[was: ...]" +# +# Types: +# Packaging +# Changelog +# Upstream +# AddPatches +# Mixed +# Unknown +# +# Pseudomerge +# has additional entres in classification result +# Overwritten = [ subset of Parents ] +# Contributor = $the_remaining_Parent +# +# DgitImportUnpatched +# has additional entry in classification result +# OrigParents = [ subset of Parents ] +# +# BreakwaterUpstreamMerge +# has additional entry in classification result +# OrigParents = [ subset of Parents ] # singleton list + +sub parsecommit ($;$) { + my ($objid, $p_ref) = @_; + # => hash with CommitId Hdr Msg Tree Parents + # Parents entries have only Ix CommitId + # $p_ref, if provided, must be [] and is used as a base for Parents + + $p_ref //= []; + die if @$p_ref; my ($h,$m) = get_commit $objid; - my ($t) = $h =~ m/^tree (\w+)$/m or die $cur; - my (@ph) = $h =~ m/^parent (\w+)$/m; - my @p; + my ($t) = $h =~ m/^tree (\w+)$/m or die $objid; + my (@ph) = $h =~ m/^parent (\w+)$/mg; my $r = { CommitId => $objid, - Hdr => $hdr, + Hdr => $h, Msg => $m, Tree => $t, - Parents => \@p, + Parents => $p_ref, }; foreach my $ph (@ph) { - push @p, { - Ix => $#p, + push @$p_ref, { + Ix => $#$p_ref, CommitId => $ph, - Differs => (get_differs $t, $ph), }; } + return $r; +} + +sub classify ($) { + my ($objid) = @_; + + my @p; + my $r = parsecommit($objid, \@p); + my $t = $r->{Tree}; + + foreach my $p (@p) { + $p->{Differs} = (get_differs $p->{CommitId}, $t), + } + + printdebug "classify $objid \$t=$t \@p", + (map { sprintf " %s/%#x", $_->{CommitId}, $_->{Differs} } @p), + "\n"; + my $classify = sub { my ($type, @rest) = @_; - $r = { %r, Type => $type, @rest }; + $r = { %$r, Type => $type, @rest }; + if ($debuglevel) { + my $dd = new Data::Dumper [ $r ]; + Terse $dd 1; Indent $dd 0; Useqq $dd 1; + printdebug " = $type ".(Dump $dd)."\n"; + } return $r; }; my $unknown = sub { my ($why) = @_; - $r = { %r, Type => Unknown }; + $r = { %$r, Type => qw(Unknown) }; + printdebug " ** Unknown\n"; return $r; - } + }; if (@p == 1) { my $d = $r->{Parents}[0]{Differs}; - if ($d == D_DPAT_ADD) { + if ($d == D_PAT_ADD) { return $classify->(qw(AddPatches)); - } elsif ($d & (D_DPAT_ADD|D_DPAT_OTH)) { + } elsif ($d & (D_PAT_ADD|D_PAT_OTH)) { return $unknown->("edits debian/patches"); - } elsif ($d == D_DEB) { - return $classify->(qw(Packaging)); + } elsif ($d & DS_DEB and !($d & ~DS_DEB)) { + my ($ty,$dummy) = git_cat_file "$p[0]{CommitId}:debian"; + if ($ty eq 'tree') { + if ($d == D_DEB_CLOG) { + return $classify->(qw(Changelog)); + } else { + return $classify->(qw(Packaging)); + } + } elsif ($ty eq 'missing') { + return $classify->(qw(BreakwaterStart)); + } else { + return $unknown->("parent's debian is not a directory"); + } } elsif ($d == D_UPS) { return $classify->(qw(Upstream)); - } elsif ($d == D_DEB|D_UPS) { + } elsif ($d & DS_DEB and $d & D_UPS and !($d & ~(DS_DEB|D_UPS))) { return $classify->(qw(Mixed)); } elsif ($d == 0) { return $unknown->("no changes"); @@ -181,16 +418,16 @@ sub classify ($) { SubType => qw(Ambiguous), Overwritten => $bytime[0], Contributor => $bytime[1]); - }! + } foreach my $p (@p) { - my ($p_h, $p_m) = get_commit $p; + my ($p_h, $p_m) = get_commit $p->{CommitId}; $p->{IsOrigin} = $p_h !~ m/^parent \w+$/m; ($p->{IsDgitImport},) = $p_m =~ m/^\[dgit import ([0-9a-z]+) .*\]$/m; } - my @orig_ps = grep { ($_->{IsDgitImport}//'X') eq 'orig' }; - my $m2 = $m; + my @orig_ps = grep { ($_->{IsDgitImport}//'X') eq 'orig' } @p; + my $m2 = $r->{Msg}; if (!(grep { !$_->{IsOrigin} } @p) and - (@origs >= @p - 1) and + (@orig_ps >= @p - 1) and $m2 =~ s{^\[(dgit import unpatched .*)\]$}{[was: $1]}m) { $r->{NewMsg} = $m2; return $classify->(qw(DgitImportUnpatched), @@ -206,24 +443,45 @@ sub classify ($) { # debian/) so debian breakwater branch should be 1st parent; that # way also there's also an easy rune to look for the upstream # patches (--topo-order). - if (@p == 2 && - !$haspatches && - !$p[0]{IsOrigin} && # breakwater merge never starts with an origin - !($p[0]{Differs} & ~D_DEB) && - !($p[1]{Differs} & ~D_UPS)) { - return $classify->(qw(BreakwaterUpstreamMerge), - Upstream => $p[1]); + + # The above tells us which way *we* will generate them. But we + # might encounter ad-hoc breakwater merges generated manually, + # which might be the other way around. In principle, in some odd + # situations, a breakwater merge might have two identical parents. + # In that case we guess which way round it is (ie, which parent + # has the upstream history). The order of the 2-iteration loop + # controls which guess we make. + + foreach my $prevbrw (qw(0 1)) { + if (@p == 2 && + !$haspatches && + !$p[$prevbrw]{IsOrigin} && # breakwater never starts with an origin + !($p[$prevbrw]{Differs} & ~DS_DEB) && + !($p[!$prevbrw]{Differs} & ~D_UPS)) { + return $classify->(qw(BreakwaterUpstreamMerge), + OrigParents => [ $p[!$prevbrw] ]); + } } + # multi-orig upstreams are represented with a breakwater merge + # from a single upstream commit which combines the orig tarballs + return $unknown->("complex merge"); } -sub launder ($$$) { - my ($input, $pseudos_must_overwrite_this, $wantdebonly) = @_; +sub walk ($;$$); +sub walk ($;$$) { + my ($input, + $nogenerate,$report) = @_; + # => ($tip, $breakwater_tip, $last_upstream_merge_in_breakwater) + # (or nothing, if $nogenerate) + # go through commits backwards - # we generate two lists of commits to apply - my (@deb_cl, @ups_cl); + # 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; my $cl; @@ -234,91 +492,171 @@ sub launder ($$$) { $ms .= "\n\n[git-debrebase $appendinfo]\n"; return (Msg => $ms); }; - + my $rewrite_from_here = sub { + my $sp_cl = { SpecialMethod => 'StartRewrite' }; + push @brw_cl, $sp_cl; + push @processed, $sp_cl; + }; my $cur = $input; + my $prdelim = ""; + my $prprdelim = sub { print $report $prdelim if $report; $prdelim=""; }; + + my $prline = sub { + return unless $report; + print $report $prdelim, @_; + $prdelim = "\n"; + }; + + 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 (d.". + (join ' ', map { sprintf "%#x", $_->{Differs} } + @{ $cl->{Parents} }). ")"; + }; + + my $build; + my $breakwater; + + my $build_start = sub { + my ($msg, $parent) = @_; + $prline->(" $msg"); + $build = $parent; + no warnings qw(exiting); last; + }; + + my $last_upstream_update; + for (;;) { $cl = classify $cur; my $ty = $cl->{Type}; my $st = $cl->{SubType}; + $prline->("$cl->{CommitId} $cl->{Type}"); $found{$ty. ( defined($st) ? "-$st" : '' )}++; - my $p0 = $cl->{Parents}[0]{CommitId}; + push @processed, $cl; + 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; + } elsif ($ty eq 'Packaging' or $ty eq 'Changelog') { + push @brw_cl, $cl; $cur = $p0; next; + } elsif ($ty eq 'BreakwaterStart') { + $last_upstream_update = $cur; + $build_start->('FirstPackaging', $cur); } elsif ($ty eq 'Upstream') { - push @ups_cl, $cl; + push @upp_cl, $cl; $cur = $p0; next; } elsif ($ty eq 'Mixed') { my $queue = sub { my ($q, $wh) = @_; - my $cls = { $cl, $xmsg->("split mixed commit: $wh part") }; + 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') { - if (defined $pseudos_must_overwrite_this) { - confess 'xxx actually check this'; - } + my $contrib = $cl->{Contributor}{CommitId}; + print $report " Contributor=$contrib" if $report; push @pseudomerges, $cl; - $cur = $ty->{Contributor}; + $rewrite_from_here->(); + $cur = $contrib; next; } elsif ($ty eq 'BreakwaterUpstreamMerge') { - $basis = $cur; - 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. - if ($differs & D_UPS) { - push @deb_cl, { - %r, - SpecialMethod => 'DgitImportUpstreamUpdate', + $last_upstream_update = $cur; + $build_start->("PreviousBreakwater", $cur); + } elsif ($ty eq 'DgitImportUnpatched') { + my $pm = $pseudomerges[-1]; + if (defined $pm) { + # 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 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. + my $ovwrs = $pm->{Overwritten}; + printf $report " PM=%s \@Overwr:%d", $pm, (scalar @$ovwrs) + if $report; + if (@$ovwrs != 1) { + return $bomb->(); + } + 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 + # 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 @brw_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 @brw_cl, { + %$cl, + SpecialMethod => 'DgitImportUpstreamUpdate', + $xmsg->("convert dgit import: upstream changes") + }; + } + $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 { + # 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; + # 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 + $build_start->("ImportOrigin", $cur); } - push @deb_cl, { - %r, - SpecialMethod => 'DgitImportDebianUpdate', - $xmsg->("convert dgit import: upstream changes") - }; - my $differs = get_differs $previous_breakwater, $cl->{Tree}; - $basis = launder $pseudomerges[0]{Overwritten}, undef, 1; - last; - } else { - die "Reached difficult commit $cur: ".Dumper($cl); + die "$ty ?"; + } else { + return $bomb->(); } } + $prprdelim->(); + return if $nogenerate; + # Now we build it back up again - workarea_fresh(); - in_workarea sub { xxx attributes xxx }; + fresh_workarea(); - my $build = $basis; + my $rewriting = 0; - my $rm_tree_cached = sub { - my ($subdir) = @_; - runcmd @git, qw(rm --quiet -rf --cached), $subdir; - }; my $read_tree_debian = sub { my ($treeish) = @_; - $rm_tree_cached->(qw(debian)); - runcmd @git, qw(read-tree --prefix=debian/), "$treeish:debian"; + read_tree_subdir 'debian', "$treeish:debian"; }; my $read_tree_upstream = sub { my ($treeish) = @_; @@ -328,66 +666,380 @@ sub launder ($$$) { my $committer_authline = calculate_committer_authline(); + printdebug "WALK REBUILD $build ".(scalar @processed)."\n"; + + confess "internal error" unless $build eq (pop @processed)->{CommitId}; + in_workarea sub { mkdir $rd or $!==EEXIST or die $!; - my $current_method; - foreach my $cl (qw(Debian), @deb_cl, qw(Upstream), @ups_cl) { + runcmd @git, qw(read-tree), $build; + foreach my $cl (qw(Debian), (reverse @brw_cl), + { SpecialMethod => 'RecordBreakwaterTip' }, + qw(Upstream), (reverse @upp_cl)) { if (!ref $cl) { $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}; + printdebug "WALK BUILD ".($cltree//'undef'). + " $method (rewriting=$rewriting)\n"; if ($method eq 'Debian') { $read_tree_debian->($cltree); } elsif ($method eq 'Upstream') { $read_tree_upstream->($cltree); + } elsif ($method eq 'StartRewrite') { + $rewriting = 1; + next; + } elsif ($method eq 'RecordBreakwaterTip') { + $breakwater = $build; + next; } elsif ($method eq 'DgitImportDebianUpdate') { $read_tree_debian->($cltree); - $rm_tree_cached(qw(debian/patches)); + rm_subdir_cached qw(debian/patches); } elsif ($method eq 'DgitImportUpstreamUpdate') { $read_tree_upstream->($cltree); push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} }; } else { confess "$method ?"; } + if (!$rewriting) { + my $procd = (pop @processed) // 'UNDEF'; + if ($cl ne $procd) { + $rewriting = 1; + printdebug "WALK REWRITING NOW cl=$cl procd=$procd\n"; + } + } my $newtree = cmdoutput @git, qw(write-tree); - my $ch = $cl->{Msg}; + my $ch = $cl->{Hdr}; $ch =~ s{^tree .*}{tree $newtree}m or confess "$ch ?"; - $ch =~ s{^committer .*$}{$committer_authline}m or confess "$ch ?"; - open CD, ">", "$rd/m" or die $!; - print CD $ch, "\n", $cl->{Msg}; or die $!; + $ch =~ s{^parent .*\n}{}m; + $ch =~ s{(?=^author)}{ + join '', map { "parent $_\n" } @parents + }me or confess "$ch ?"; + if ($rewriting) { + $ch =~ s{^committer .*$}{$committer_authline}m + or confess "$ch ?"; + } + my $cf = "$rd/m$rewriting"; + open CD, ">", $cf or die $!; + print CD $ch, "\n", $cl->{Msg} or die $!; close CD or die $!; - my $newcommit = cmdoutput @git, qw(hash-object -t commit), "$rd/m"; + my @cmd = (@git, qw(hash-object)); + push @cmd, qw(-w) if $rewriting; + push @cmd, qw(-t commit), $cf; + 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; + } } }; - runcmd @git, qw(diff-tree --quiet), - map { $wantdebonly ? "$_:debian" : $_ }, - $input, $build; + my $final_check = get_differs $build, $input; + die sprintf "internal error %#x %s %s", $final_check, $build, $input + if $final_check & ~D_PAT_ADD; - return $build; + return ($build, $breakwater, $last_upstream_update); } 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), "debrebase: $mrest", 'HEAD', $new, $old; +} + +sub update_head_checkout ($$$) { my ($old, $new, $mrest) = @_; - runcmd @git, qw(update-ref -m), "git-debrebase $mrest", $new, $old; + my $symref = git_get_symref(); + runcmd @git, qw(checkout), $new, qw(.); + update_head $old, $new, $mrest; } sub cmd_launder () { + badusage "no arguments to launder allowed" if @ARGV; my $old = get_head(); - my $got = launder $old, 0, undef, 0; - update_head $old, $new, 'launder'; # no tree changes! + my ($tip,$breakwater) = walk $old; + update_head $old, $tip, 'launder'; + # no tree changes except debian/patches + runcmd @git, qw(rm --quiet --ignore-unmatch -rf debian/patches); + printf "# breakwater tip\n%s\n", $breakwater; + printf "# working tip\n%s\n", $tip; +} + +sub cmd_analyse () { + die if ($ARGV[0]//'') =~ m/^-/; + badusage "too many arguments to analyse" if @ARGV>1; + my ($old) = @ARGV; + if (defined $old) { + $old = git_rev_parse $old; + } else { + $old = get_head(); + } + my ($dummy,$breakwater) = walk $old, 1,*STDOUT; + STDOUT->error and die $!; } -my $toplevel = runcmd @git, qw(rev-parse --show-toplevel); +sub cmd_new_upstream_v0 () { + # xxx would like to support more git-rebase options + badusage + "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), check => 1); + my $new_upstream_version = $new_version->version(); + + 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 $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_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"; + }; + + $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"); + } + } + + 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 ($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 $new_bw; + + fresh_workarea(); + in_workarea sub { + my @upstream_merge_parents; + + 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 @upstream_merge_parents, $pc->{New}; + } + + # index now contains the new upstream + + 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); + push @cmd, qw(-p), $_ foreach @upstream_merge_parents; + push @cmd, qw(-m), "Combine upstreams for $new_upstream_version"; + push @cmd, qw(-m), + "[git-debrebase new-upstream combine . ". + (join " ", map { $_->{Name} } @newpieces[1..$#newpieces]). + "]"; + $new_upstream = cmdoutput @cmd; + } + + # $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 <{Type}"; + my $keep = 0; + my $p0 = $cl->{Parents}[0]{CommitId}; + my $next; + if ($cl->{Type} eq 'Pseudomerge') { + print " ^".($cl->{Contributor}{Ix}+1); + $next = $cl->{Contributor}{CommitId}; + } elsif ($cl->{Type} eq 'AddPatches' or + $cl->{Type} eq 'Changelog') { + print " strip"; + $next = $p0; + } else { + print " keep"; + $next = $p0; + $keep = 1; + } + print "\n"; + if ($keep) { + $topmost_keep //= $current; + } else { + die "to-be stripped changes not on top of the branch\n" + if $topmost_keep; + } + $current = $next; + } + if ($topmost_keep eq $old_head) { + print "unchanged\n"; + } else { + print "updating to $topmost_keep\n"; + update_head_checkout + $old_head, $topmost_keep, + 'downstream-rebase-launder-v0'; + } +} + +GetOptions("D+" => \$debuglevel, + 'force!') or die badusage "bad options\n"; +initdebug('git-debrebase '); +enabledebug if $debuglevel; + +my $toplevel = cmdoutput @git, qw(rev-parse --show-toplevel); chdir $toplevel or die "chdir $toplevel: $!"; +$rd = fresh_playground "$playprefix/misc"; + my $cmd = shift @ARGV; my $cmdfn = $cmd; $cmdfn =~ y/-/_/;