From 684e1dfb2e9cc5816a8488b6ad3d08796ed5f390 Mon Sep 17 00:00:00 2001 From: Ian Jackson Date: Sun, 29 Jan 2017 21:59:35 +0000 Subject: [PATCH] git-debrebase: WIP Signed-off-by: Ian Jackson --- git-debrebase | 246 ++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 217 insertions(+), 29 deletions(-) diff --git a/git-debrebase b/git-debrebase index bb2d91a2..0fb7c3c7 100755 --- a/git-debrebase +++ b/git-debrebase @@ -19,9 +19,11 @@ # along with this program. If not, see . use strict; + use Memoize; +use Data::Dumper; -use Debian::Dgit; +use Debian::Dgit qw(:DEFAULT $wa); sub cfg ($) { my ($k) = @_; @@ -51,6 +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) = @_; @@ -64,6 +82,7 @@ sub classify ($) { CommitId => $objid, Hdr => $hdr, Msg => $m, + Tree => $t, Parents => \@p, }; @@ -75,6 +94,17 @@ sub classify ($) { }; } + my $classify = sub { + my ($type, @rest) = @_; + $r = { %r, Type => $type, @rest }; + return $r; + }; + my $unknown = sub { + my ($why) = @_; + $r = { %r, Type => Unknown }; + return $r; + } + if (@p == 1) { my $d = $r->{Parents}[0]{Differs}; if ($d == D_DPAT_ADD) { @@ -112,26 +142,34 @@ sub classify ($) { $1; } @p; return $classify->(qw(Pseudomerge), - Xtype => qw(Ambiguous), + SubType => qw(Ambiguous), Overwritten => $bytime[0], - Contributyor => $bytime[1]); - } + Contributor => $bytime[1]); + }! foreach my $p (@p) { - my ($type) = git_cat_file "$p^1"; - $p->{IsOrigin} = $type eq 'missing'; + 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; } - if (!grep { !$_->{IsOrigin} } @p - && $m =~ m{^\[dgit import unpatched .*\]$}m) { - return $classify->(qw(DgitImport)); + my @orig_ps = grep { ($_->{IsDgitImport}//'X') eq 'orig' }; + my $m2 = $m; + if (!(grep { !$_->{IsOrigin} } @p) and + (@origs >= @p - 1) and + $m2 =~ s{^\[(dgit import unpatched .*)\]$}{[was: $1]}m) { + $r->{NewMsg} = $m2; + 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 @@ -144,6 +182,172 @@ sub classify ($) { return $unknown->("complex merge"); } +sub launder ($;$) { + my ($cur, $wantdebonly) = @_; + # go through commits backwards + # we generate two lists of commits to apply + my (@deb_cl, @ups_cl); + my %found; + my @pseudomerges; + + my $cl; + my $xmsg = sub { + my ($appendinfo) = @_; + my $ms = $cl->{Msg}; + chomp $ms; + $ms .= "\n\n[git-debrebase $appendinfo]\n"; + return (Msg => $ms); + }; + + for (;;) { + $cl = classify $cur; + my $ty = $cl->{Type}; + my $st = $cl->{SubType}; + $found{$ty. ( defined($st) ? "-$st" : '' )}++; + my $p0 = $cl->{Parents}[0]{CommitId}; + if ($ty eq 'AddPatches') { + $cur = $p0; + next; + } elsif ($ty eq 'Packaging') { + push @deb_cl, $cl; + $cur = $p0; + next; + } elsif ($ty eq 'Upstream') { + push @ups_cl, $cl; + $cur = $p0; + next; + } elsif ($ty eq 'Mixed') { + my $queue = sub { + my ($q, $wh) = @_; + my $cls = { $cl, $xmsg->("split mixed commit: $wh part") }; + push @$q, $cls; + }; + $queue->(\@deb_cl, "debian"); + $queue->(\@ups_cl, "upstream"); + next; + } elsif ($ty eq 'Pseudomerge') { + 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 + # 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', + $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, { + $cl, + Type => NonGitNewUpstreamDgitImport, + PreviousBreakwaterMerge => + + + push @phases, [ @deb_cl, @ups_cl ]; + + if (@pseudomerges != 1) { +} + + +chdir $GIT_DIR + + +if ($ARGV[0] eq 'launder') { + launder(); +} + +use Data::Dumper; +print Dumper(cfg('wombat.foo.bar')); + + ((git_cat_file "$t:debian/patches/series" @@ -167,22 +371,6 @@ sub classify ($) { -sub launder () { - # go through commits backwards - # we generate two lists of commits to apply - my (@deb_cl, @ups_cl); - my $cur = git_rev_parse('HEAD'); - for (;;) { -} - -if ($ARGV[0] eq 'launder') { - launder(); -} - -use Data::Dumper; -print Dumper(cfg('wombat.foo.bar')); - - -- 2.30.2