X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=e3835e3d0d796442dc1bb9ba849e0d8b66fb80a2;hp=2a3804f39c2706f7d1f27a0633a75661185325f5;hb=842f62c97bc4d78cfda3ed76d3335bafd20e9fd0;hpb=2edca8d928612e96bb1935ff8b7a5d4ba92f2dfc diff --git a/git-debrebase b/git-debrebase index 2a3804f3..e3835e3d 100755 --- a/git-debrebase +++ b/git-debrebase @@ -63,7 +63,7 @@ # - no fast forward checks # for now only explicit with commitids - # implicitly uses `upstream' +# implicitly uses `upstream' # # (or multiple other branches) # git-debrebase new-upstream \ # [/]= @@ -87,14 +87,35 @@ # 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 Memoize; +use Carp; +use POSIX; use Data::Dumper; use Debian::Dgit qw(:DEFAULT $wa); +sub badusage ($) { + my ($m) = @_; + die "bad usage: $m\n"; +} + sub cfg ($) { my ($k) = @_; $/ = "\0"; @@ -122,6 +143,7 @@ sub D_PAT_OTH () { return 0x8; } # debian/patches other changes our $rd = ".git/git-debrebase"; our $ud = "$rd/work"; +our @git = qw(git); sub commit_pr_info ($) { my ($r) = @_; @@ -130,7 +152,7 @@ sub commit_pr_info ($) { sub calculate_committer_authline () { my $c = cmdoutput @git, qw(commit-tree --no-gpg-sign -m), - 'DUMMY COMMIT (git-debrebase)', "$basis:"; + 'DUMMY COMMIT (git-debrebase)', "HEAD:"; my ($h,$m) = get_commit $c; $h =~ m/^committer .*$/m or confess "($h) ?"; return $&; @@ -177,13 +199,13 @@ sub classify ($) { my ($h,$m) = get_commit $objid; - my ($t) = $h =~ m/^tree (\w+)$/m or die $cur; + my ($t) = $h =~ m/^tree (\w+)$/m or die $objid; my (@ph) = $h =~ m/^parent (\w+)$/m; my @p; my $r = { CommitId => $objid, - Hdr => $hdr, + Hdr => $h, Msg => $m, Tree => $t, Parents => \@p, @@ -199,26 +221,33 @@ sub classify ($) { my $classify = sub { my ($type, @rest) = @_; - $r = { %r, Type => $type, @rest }; + $r = { %$r, Type => $type, @rest }; return $r; }; my $unknown = sub { my ($why) = @_; - $r = { %r, Type => Unknown }; + $r = { %$r, Type => qw(Unknown) }; 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)); + my ($ty,$dummy) = git_cat_file "$ph[0]:debian"; + if ($ty eq 'tree') { + 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 == (D_DEB|D_UPS)) { return $classify->(qw(Mixed)); } elsif ($d == 0) { return $unknown->("no changes"); @@ -248,16 +277,16 @@ sub classify ($) { SubType => qw(Ambiguous), Overwritten => $bytime[0], Contributor => $bytime[1]); - }! + } foreach my $p (@p) { my ($p_h, $p_m) = get_commit $p; $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 @orig_ps = grep { ($_->{IsDgitImport}//'X') eq 'orig' } @p; my $m2 = $m; 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), @@ -286,23 +315,21 @@ sub classify ($) { return $unknown->("complex merge"); } -sub launder ($$$;$$$) { - my ($input, $pseudos_must_overwrite_this, $wantdebonly, - $report, $depth, $report_anomaly, $nogenerate) = @_; - # go through commits backwards - # we generate two lists of commits to apply +sub walk ($;$$); +sub walk ($;$$) { + my ($input, + $nogenerate,$report) = @_; # => ($tip, $breakwater_tip) - my (@deb_cl, @ups_cl, @processed); + # (or nothing, if $nogenerate) + + # go through commits backwards + # 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; - $report //= sub { }; - $report_anomaly //= sub { - my ($cl, $msg) = @_; - die "commit $cl: $msg\n"; - }; - $depth //= 0; - my $cl; my $xmsg = sub { my ($appendinfo) = @_; @@ -312,30 +339,60 @@ sub launder ($$$;$$$) { 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 = ""; + 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"; + }; + + my $build; + my $breakwater; + + my $build_start = sub { + my ($msg, $parent) = @_; + $prline->(" $msg"); + $build = $parent; + no warnings qw(exiting); last; + }; + for (;;) { $cl = classify $cur; my $ty = $cl->{Type}; my $st = $cl->{SubType}; - $report->($cl); + $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; - push @processed, $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 @processed, $cl; + push @upp_cl, $cl; $cur = $p0; next; } elsif ($ty eq 'Mixed') { @@ -344,70 +401,96 @@ sub launder ($$$;$$$) { 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 && - !grep { - is_fast_fwd $pseudos_must_overwrite_this, $_->{CommitId} - }, - @{ $cl->{Overwritten} }) { - $report_anomaly->($cl, - "Pseudomerge should overwrite". - " $pseudos_must_overwrite_this". - " but does not do so"); - } + print $report " Contributor=$ty->{Contributor}" if $report; push @pseudomerges, $cl; $rewrite_from_here->(); $cur = $ty->{Contributor}; 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', + $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 + $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, - $report, $depth+1, $nogenerate; - $rewrite_from_here->(); - last; - } else { - $report_anomaly->($cl, "Cannot cope with this commit"); + die "$ty ?"; + } else { + return $bomb->(); } } - # Now we build it back up again + $prprdelim->(); + return if $nogenerate; - + # Now we build it back up again workarea_fresh(); - my $rewriting = 1; - - my $build = $basis; + my $rewriting = 0; my $rm_tree_cached = sub { my ($subdir) = @_; @@ -429,16 +512,16 @@ sub launder ($$$;$$$) { 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; } - $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') { @@ -447,12 +530,11 @@ sub launder ($$$;$$$) { $rewriting = 1; next; } elsif ($method eq 'RecordBreakwaterTip') { - last if $wantdebonly; $breakwater = $build; 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} }; @@ -464,52 +546,63 @@ sub launder ($$$;$$$) { 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" : $_ }, - $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; } -sub cmd_analyse () { - sub cmd_launder () { + badusage "no arguments to launder allowed"; my $old = get_head(); - my ($tip,$breakwater) = launder $old, 0, undef, 0; + my ($tip,$breakwater) = walk $old; update_head $old, $tip, 'launder'; # no tree changes except debian/patches runcmd @git, qw(rm --quiet -rf debian/patches); - printf "# breakwater tip:\n%s\n", $breakwater; + printf "# breakwater tip\n%s\n", $breakwater; +} + +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; + print "$breakwater BREAKWATER\n"; + 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;