X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=c273976cc3448885e834b2e9c269778114d6d7dd;hp=24aefbe574c4e53703c0dff6969e376c24d97984;hb=e66c2cf3f7182a3e6f52945636a807ed4a959d5b;hpb=abd3af0ed03160a5dc627baafe633f303e65fb4c

diff --git a/git-debrebase b/git-debrebase
index 24aefbe5..c273976c 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -50,9 +50,11 @@ usages:
 See git-debrebase(1), git-debrebase(5), dgit-maint-debrebase(7) (in dgit).
 END
 
-our ($opt_force, $opt_noop_ok, @opt_anchors);
+our ($opt_force, $opt_careful, $opt_noop_ok, @opt_anchors);
 our ($opt_defaultcmd_interactive);
 
+$opt_careful = 0;
+
 our $us = qw(git-debrebase);
 
 our $wrecknoteprefix = 'refs/debrebase/wreckage';
@@ -110,8 +112,8 @@ sub get_commit ($) {
 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 D_DEB_CLOG () { 0x10; } # debian/changelog
+sub D_DEB_OTH ()  { 0x20; } # debian/ (not patches/ or changelog)
 sub DS_DEB ()     { D_DEB_CLOG | D_DEB_OTH; } # debian/ (not patches/)
 
 our $playprefix = 'debrebase';
@@ -181,72 +183,141 @@ sub run_deferred_updates ($) {
     @deferred_update_messages = ();
 }
 
+sub get_tree ($) {
+    # tree object name => ([ $name, $info ], ...)
+    # where $name is the sort key, ie has / at end for subtrees
+    # $info is the LHS from git-ls-tree (<mode> <type> <hash>)
+    # will crash if $x does not exist, so don't do that;
+    # instead pass '' to get ().
+    my ($x) = @_;
+
+    return () if !length $x;
+
+    our (@get_tree_memo, %get_tree_memo);
+    my $memo = $get_tree_memo{$x};
+    return @$memo if $memo;
+
+    local $Debian::Dgit::debugcmd_when_debuglevel = 3;
+    my @l;
+    my @cmd = (qw(git ls-tree -z --full-tree --), $x);
+    my $o = cmdoutput @cmd;
+    $o =~ s/\0$//s;
+    my $last = '';
+    foreach my $l (split /\0/, $o) {
+	my ($i, $n) = split /\t/, $l, 2;
+	$n .= '/' if $i =~ m/^\d+ tree /;
+	push @l, [ $n, $i ];
+	confess "$x need $last < $n ?" unless $last lt $n;
+    }
+    $get_tree_memo{$x} = \@l;
+    push @get_tree_memo, $x;
+    if (@get_tree_memo > 10) {
+	delete $get_tree_memo{ shift @get_tree_memo };
+    }
+    return @l;
+}
+
+sub trees_diff_walk ($$$;$) {
+    # trees_diff_walk [$all,] $x, $y, sub {... }
+    # calls sub->($name, $ix, $iy) for each difference (with $all, each name)
+    # $x and $y are as for get_tree
+    # where $name, $ix, $iy are $name and $info from get_tree
+    my $all = shift @_ if @_>=4;
+    my ($x,$y,$call) = @_;
+    return if !$all and $x eq $y;
+    my @x = get_tree $x;
+    my @y = get_tree $y;
+    printdebug "trees_diff_walk(..$x,$y..) ".Dumper(\@x,\@y)
+	if $debuglevel >= 3;
+    while (@x || @y) {
+	my $cmp = !@x       <=> !@y          # eg @y empty? $cmp=-1, use x
+ 	     ||    $x[0][0] cmp  $y[0][0];   # eg, x lt y ? $cmp=-1, use x
+	my ($n, $ix, $iy);                   # all same? $cmp=0, use both
+	$ix=$iy='';
+	printdebug "trees_diff_walk $cmp : @{ $x[0]//[] } | @{ $y[0]//[] }\n"
+	    if $debuglevel >= 3;
+	($n, $ix) = @{ shift @x } if $cmp <= 0;
+	($n, $iy) = @{ shift @y } if $cmp >= 0;
+	next if !$all and $ix eq $iy;
+	printdebug sprintf
+	    "trees_diff_walk(%d,'%s','%s') call('%s','%s','%s')\n",
+	    !!$all,$x,$y, $n,$ix,$iy
+	    if $debuglevel >= 2;
+	$call->($n, $ix, $iy);
+    }
+}
+
 sub get_differs ($$) {
     my ($x,$y) = @_;
-    # This resembles quiltify_trees_differ, in dgit, a bit.
+    # This does a similar job to 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/.
+    # Also, here we have, and want to use, trees_diff_walk, because
+    # we may be calling this an awful lot and we want it to be fast.
 
     my $differs = 0;
+    my @debian_info;
 
-    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->(); }
-    };
+    no warnings qw(exiting);
 
-    $rundiff->([qw(--name-only)], [], sub {
-        $differs |= $_ eq 'debian' ? DS_DEB : D_UPS;
-    });
+    my $plain = sub { $_[0] =~ m{^(100|0*)644 blob }s; };
 
-    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;
+    trees_diff_walk "$x:", "$y:", sub {
+	my ($n,$ix,$iy) = @_;
+
+	# analyse difference at the toplevel
+
+	if ($n ne 'debian/') {
+	    $differs |= D_UPS;
+	    next;
+	}
+	if ($n eq 'debian') {
+	    # one side has a non-tree for ./debian !
+	    $differs |= D_DEB_OTH;
+	    next;
+	}
+
+	my $xd = $ix && "$x:debian";
+	my $yd = $iy && "$y:debian";
+	trees_diff_walk $xd, $yd, sub {
+	    my ($n,$ix,$iy) = @_;
+	    
+	    # analyse difference in debian/
+
+	    if ($n eq 'changelog' && (!$ix || $plain->($ix))
+                                  &&          $plain->($iy) ) {
+		$differs |= D_DEB_CLOG;
+		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
+	    if ($n ne 'patches/') {
+		$differs |= D_DEB_OTH;
+		next;
 	    }
-	    $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);
-    }
+
+	    my $xp = $ix && "$xd/patches";
+	    my $yp = $iy && "$yd/patches";
+	    trees_diff_walk $xp, $yp, sub {
+		my ($n,$ix,$iy) = @_;
+
+		# analyse difference in debian/patches
+
+		my $ok;
+		if ($n !~ m/\.series$/s && !$ix && $plain->($iy)) {
+		    $ok = 1;
+		} elsif ($n eq 'series' && $plain->($ix) && $plain->($iy)) {
+		    my $x_s = (git_cat_file "$xp/series", 'blob');
+		    my $y_s = (git_cat_file "$yp/series", 'blob');
+		    chomp $x_s;  $x_s .= "\n";
+		    $ok = $x_s eq substr($y_s, 0, length $x_s);
+		} else {
+		    # nope
+		}
+		$differs |= $ok ? D_PAT_ADD : D_PAT_OTH;
+	    };    
+	};
+    };
 
     printdebug sprintf "get_differs %s %s = %#x\n", $x, $y, $differs;
 
@@ -1434,12 +1505,11 @@ sub walk ($;$$$) {
     in_workarea sub {
 	mkdir $rd or $!==EEXIST or die $!;
 	my $current_method;
-	runcmd @git, qw(read-tree), $build;
+	my $want_debian = $build;
+	my $want_upstream = $build;
 
-	my $read_tree_upstream = sub {
-	    my ($treeish) = @_;
-	    read_tree_upstream $treeish, 0, $build;
-	};
+	my $read_tree_upstream = sub { ($want_upstream) = @_; };
+	my $read_tree_debian = sub { ($want_debian) = @_; };
 
 	foreach my $cl (qw(Debian), (reverse @brw_cl),
 			{ SpecialMethod => 'RecordBreakwaterTip' },
@@ -1454,7 +1524,7 @@ sub walk ($;$$$) {
 	    printdebug "WALK BUILD ".($cltree//'undef').
 		" $method (rewriting=$rewriting)\n";
 	    if ($method eq 'Debian') {
-		read_tree_debian($cltree);
+		$read_tree_debian->($cltree);
 	    } elsif ($method eq 'Upstream') {
 		$read_tree_upstream->($cltree);
 	    } elsif ($method eq 'StartRewrite') {
@@ -1464,7 +1534,7 @@ sub walk ($;$$$) {
 		$breakwater = $build;
 		next;
 	    } elsif ($method eq 'DgitImportDebianUpdate') {
-		read_tree_debian($cltree);
+		$read_tree_debian->($cltree);
 	    } elsif ($method eq 'DgitImportUpstreamUpdate') {
  		confess unless $rewriting;
 		my $differs = (get_differs $build, $cltree);
@@ -1475,7 +1545,7 @@ sub walk ($;$$$) {
 		print "Found a general merge, will try to tidy it up.\n";
 		$rewriting = 1;
 		$read_tree_upstream->($cl->{MergeBestAnchor});
-		read_tree_debian($cltree);
+		$read_tree_debian->($cltree);
 		@parents = map { $_->{Breakwater} } @{ $cl->{Parents} };
 	    } elsif ($method eq 'MergeMergeSeries') {
 		my $cachehit = reflog_cache_lookup
@@ -1528,27 +1598,46 @@ sub walk ($;$$$) {
 		    printdebug "WALK REWRITING NOW cl=$cl procd=$procd\n";
 		}
 	    }
-	    my $newtree = cmdoutput @git, qw(write-tree);
-	    my $ch = $cl->{Hdr};
-	    $ch =~ s{^tree .*}{tree $newtree}m or confess "$ch ?";
-	    $ch =~ s{^parent .*\n}{}mg;
-	    $ch =~ s{(?=^author)}{
-		join '', map { "parent $_\n" } @parents
-	    }me or confess "$ch ?";
-	    if ($rewriting) {
-		$ch =~ s{^committer .*$}{$committer_authline}m
-		    or confess "$ch ?";
+	    if ($rewriting || $opt_careful) {
+		read_tree_upstream $want_upstream, 0, $want_debian;
+
+		my $newtree = cmdoutput @git, qw(write-tree);
+		my $ch = $cl->{Hdr};
+		$ch =~ s{^tree .*}{tree $newtree}m or confess "$ch ?";
+		$ch =~ s{^parent .*\n}{}mg;
+		$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 @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;
+	    } else {
+		$build = $cl->{CommitId};
+		trees_diff_walk "$want_upstream:", "$build:", sub {
+		    my ($n) = @_;
+		    no warnings qw(exiting);
+		    next if $n eq 'debian/';
+		    confess "mismatch @_ ?";
+		};
+		trees_diff_walk "$want_debian:debian", "$build:debian", sub {
+		    confess "mismatch @_ ?";
+		};
+		my @old_parents = map { $_->{CommitId} } @{ $cl->{Parents} };
+		confess "mismatch @parents != @old_parents ?"
+		    unless "@parents" eq "@old_parents";
 	    }
-	    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 $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_anchor = $cur;
             }
@@ -2186,7 +2275,10 @@ sub cmd_stitch () {
     badusage "no arguments allowed" if @ARGV;
     do_stitch $prose, 0;
 }
-sub cmd_prepush () { cmd_stitch(); }
+sub cmd_prepush () {
+    $opt_noop_ok = 1;
+    cmd_stitch();
+}
 
 sub cmd_quick () {
     badusage "no arguments allowed" if @ARGV;