From aac68c70ee77a30d53db1ed588eeca4b01d8d572 Mon Sep 17 00:00:00 2001 From: Ian Jackson Date: Fri, 3 Feb 2017 16:36:27 +0000 Subject: [PATCH] WIP --- git-debrebase | 149 ++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 126 insertions(+), 23 deletions(-) diff --git a/git-debrebase b/git-debrebase index 310e1ad4..b44a0fb7 100755 --- a/git-debrebase +++ b/git-debrebase @@ -23,7 +23,7 @@ use strict; use Memoize; use Data::Dumper; -use Debian::Dgit; +use Debian::Dgit qw(:DEFAULT $wa); sub cfg ($) { my ($k) = @_; @@ -53,11 +53,22 @@ sub D_UPS () { return 0x2; } sub D_PAT_ADD () { return 0x4; } sub D_PAT_OTH () { return 0x8; } +our $rd = ".git/git-debrebase"; +our $ud = "$rd/work"; + sub commit_pr_info ($) { my ($r) = @_; return Data::Dumper->dump([$r], [qw(commit)]); } +sub calculate_committer_authline () { + my $c = cmdoutput @git, qw(commit-tree --no-gpg-sign -m), + 'XXX DUMMY COMMIT (git-debrebase)', "$basis:"; + my ($h,$m) = get_commit $c; + $h =~ m/^committer .*$/m or confess "($h) ?"; + return $&; +} + sub classify ($) { my ($objid) = @_; @@ -138,25 +149,27 @@ sub classify ($) { 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 .*\]$/m; - $p->{IsDgitImportOrig} = $p_m =~ m/^\[dgit import orig .*\]$/m; + ($p->{IsDgitImport},) = $p_m =~ m/^\[dgit import ([0-9a-z]+) .*\]$/m; } + my @orig_ps = grep { ($_->{IsDgitImport}//'X') eq 'orig' }; my $m2 = $m; - if (!grep { !($_->{IsOrigin} && $_->{isDgitImport}) } @p and + if (!(grep { !$_->{IsOrigin} } @p) and + (@origs >= @p - 1) and $m2 =~ s{^\[(dgit import unpatched .*)\]$}{[was: $1]}m) { - - xxx check exactly one IsDgitImport that is tarball $r->{NewMsg} = $m2; - return $classify->(qw(DgitImportUnpatched)); + return $classify->(qw(DgitImportUnpatched), + OrigParents => \@orig_ps); } my ($stype, $series) = git_cat_file "$t:debian/patches/series"; my $haspatches = $stype ne 'missing' && $series =~ m/^\s*[^#\n\t ]/m; - # how to decide about l/r ordering of breakwater merges - # git --topo-order prefers to expand 2nd parent first - # easy rune to look for debian/ history so that should - # be 1st parent. + # How to decide about l/r ordering of breakwater merges ? git + # --topo-order prefers to expand 2nd parent first. There's + # already an easy rune to look for debian/ history anyway (git log + # 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 @@ -169,15 +182,25 @@ sub classify ($) { return $unknown->("complex merge"); } -sub launder ($) { - my ($cur) = @_; +sub launder ($;$) { + my ($cur, $wantdebonly) = @_; # go through commits backwards # we generate two lists of commits to apply - my (@phases, @deb_cl, @ups_cl); + my (@deb_cl, @ups_cl); my %found; my @psuedomerges; + + my $cl; + my $xmsg = sub { + my ($appendinfo) = @_; + my $ms = $cl->{Msg}; + chomp $ms; + $ms .= "\n\n[git-debrebase $appendinfo]\n"; + return (Msg => $ms); + }; + for (;;) { - my $cl = classify $cur; + $cl = classify $cur; my $ty = $cl->{Type}; my $st = $cl->{SubType}; $found{$ty. ( defined($st) ? "-$st" : '' )}++; @@ -186,20 +209,17 @@ sub launder ($) { $cur = $p0; next; } elsif ($ty eq 'Packaging') { - push @deb_cl, $cur; + push @deb_cl, $cl; $cur = $p0; next; } elsif ($ty eq 'Upstream') { - push @ups_cl, $cur; + push @ups_cl, $cl; $cur = $p0; next; } elsif ($ty eq 'Mixed') { my $queue = sub { my ($q, $wh) = @_; - my $ms = $cl->{Msg}; - chomp $ms; - $ms .= "\n[git-debrebase split mixed commit: $wh part]\n"; - my $cls = { $cl, Msg => $ms }; + my $cls = { $cl, $xmsg->("split mixed commit: $wh part") }; push @$q, $cls; }; $queue->(\@deb_cl, "debian"); @@ -209,6 +229,9 @@ sub launder ($) { push @pseudomerges, $cl; $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 @@ -221,9 +244,85 @@ sub launder ($) { # 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. - my $previous_breakwater = launder $pseudomerges[0]{Overwritten}; - my $differs = get_differs $previous_breakwater, $cl->{Tree}; if ($differs & D_UPS) { + push @deb_cl, { + %r, + SpecialMethod => 'DgitImportUpstreamUpdate', + $xmsg->("convert dgit import: debian changes") + }; + } + 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}, 1; + last; + } else { + die "Reached difficult commit $cur: ".Dumper($cl); + } + } + # Now we build it back up again + + workarea_fresh(); + in_workarea sub { xxx attributes xxx }; + + my $build = $basis; + + 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"; + }; + my $read_tree_upstream = sub { + my ($treeish) = @_; + runcmd @git, qw(read-tree), $treeish; + $read_tree_debian->($build); + }; + + my $committer_authline = calculate_committer_authline(); + + in_workarea sub { + my $current_method; + foreach my $cl (qw(Debian), @deb_cl, qw(Upstream), @ups_cl) { + if (!ref $cl) { + $current_method = $cl; + next; + } + $method = $cl->{SpecialMethod} // $current_method; + my @parents = ($build); + my $cltree = $cl->{CommitId} + if ($method eq 'Debian') { + $read_tree_debian->($cltree); + } elsif ($method eq 'Upstream') { + $read_tree_upstream->($cltree); + } elsif ($method eq 'DgitImportDebianUpdate') { + $read_tree_debian->($cltree); + $rm_tree_cached(qw(debian/patches)); + } elsif ($method eq 'DgitImportUpstreamUpdate') { + $read_tree_upstream->($cltree); + push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} }; + } else { + confess "$method ?"; + } + my $newtree = cmdoutput @git, qw(write-tree); + my $ch = $cl->{Msg}; + $ch =~ s{^tree .*}{tree $newtree}m or confess "$ch ?"; + $ch =~ s{^committer .*$}{$committer_authline}m or confess "$ch ?"; + my $newcommit = cmdoutput @git, qw(hash-object -t commit), + $ch."\n".$cl->{Msg}; + + + #my $cdata = <{FixupUpstreamMerge} = $ push @deb_cl, { @@ -237,6 +336,10 @@ sub launder ($) { if (@pseudomerges != 1) { } + +chdir $GIT_DIR + + if ($ARGV[0] eq 'launder') { launder(); } -- 2.30.2