X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=dgit;h=2c72213a56bd04ace2af90aaa6514ee164de5a9e;hb=e17b7eb17ed4aa309c1a1b3757db1e0fc123df68;hp=ae75cb9be9a127cc6b2438b544ba4164fcd683f4;hpb=79194f4a7a74b1d6fce6812e379315e0b0984833;p=dgit.git

diff --git a/dgit b/dgit
index ae75cb9b..2c72213a 100755
--- a/dgit
+++ b/dgit
@@ -1209,10 +1209,12 @@ our ($dsc_hash,$lastpush_hash);
 
 our $ud = '.git/dgit/unpack';
 
-sub prep_ud () {
-    rmtree($ud);
+sub prep_ud (;$) {
+    my ($d) = @_;
+    $d //= $ud;
+    rmtree($d);
     mkpath '.git/dgit';
-    mkdir $ud or die $!;
+    mkdir $d or die $!;
 }
 
 sub mktree_in_ud_here () {
@@ -1977,6 +1979,7 @@ END
     my $format = getfield $dsc, 'Format';
     printdebug "format $format\n";
     if (madformat($format)) {
+	# user might have not used dgit build, so maybe do this now:
 	commit_quilty_patch();
     }
     check_not_dirty();
@@ -2507,14 +2510,15 @@ END
     }
 }
 
-sub quiltify_trees_differ ($$) {
-    my ($x,$y) = @_;
+sub quiltify_trees_differ ($$;$) {
+    my ($x,$y,$ignoregitignore) = @_;
     # returns 1 iff the two tree objects differ other than in debian/
     local $/=undef;
     my @cmd = (@git, qw(diff-tree --name-only -z), $x, $y);
     my $diffs= cmdoutput @cmd;
     foreach my $f (split /\0/, $diffs) {
 	next if $f eq 'debian';
+	next if $f eq '.gitignore' && $ignoregitignore;
 	return 1;
     }
     return 0;
@@ -2529,8 +2533,15 @@ sub quiltify_tree_sentinelfiles ($) {
     return $r;
 }
 
-sub quiltify ($$) {
-    my ($clogp,$target) = @_;
+sub quilt_could_gbp ($$$) {
+    my ($userhead,$unapplied,$applied) = @_;
+    return
+	!quiltify_trees_differ($userhead,$unapplied,1) &&
+	quiltify_trees_differ($userhead,$applied,1);
+}
+
+sub quiltify ($$$$) {
+    my ($clogp,$target,$unapplied,$oldtiptree) = @_;
 
     # Quilt patchification algorithm
     #
@@ -2556,14 +2567,6 @@ sub quiltify ($$) {
     # After traversing PT, we git commit the changes which
     # should be contained within debian/patches.
 
-    changedir '../fake';
-    remove_stray_gits();
-    mktree_in_ud_here();
-    rmtree '.pc';
-    runcmd @git, qw(add -Af .);
-    my $oldtiptree=git_write_tree();
-    changedir '../work';
-
     # The search for the path S..T is breadth-first.  We maintain a
     # todo list containing search nodes.  A search node identifies a
     # commit, and looks something like this:
@@ -2676,6 +2679,12 @@ sub quiltify ($$) {
 	    foreach my $notp (@nots) {
 		print STDERR "$us:  ", $reportnot->($notp), "\n";
 	    }
+	    if (quilt_could_gbp($target,$unapplied,$oldtiptree)) {
+		print STDERR <<END;
+$us: Tree looks like a patches-unapplied git branch.
+$us: Maybe you forgot --quilt=gbp (aka --quilt=apply) ?
+END
+	    }
 	    fail "quilt fixup naive history linearisation failed.\n".
  "Use dpkg-source --commit by hand; or, --quilt=smash for one ugly patch";
 	} elsif ($quilt_mode eq 'smash') {
@@ -2881,6 +2890,31 @@ sub quilt_fixup_multipatch ($$$) {
     #     5. If we had a .pc in-tree, delete it, and git-commit
     #     6. Back in the main tree, fast forward to the new HEAD
 
+    # Another situation we may have to cope with is gbp-style
+    # patches-unapplied trees.
+    #
+    # We would want to detect these, so we know to escape into
+    # quilt_fixup_gbp.  However, this is in general not possible.
+    # Consider a package with a one patch which the dgit user reverts
+    # (with git-revert or the moral equivalent).
+    #
+    # That is indistinguishable in contents from a patches-unapplied
+    # tree.  And looking at the history to distinguish them is not
+    # useful because the user might have made a confusing-looking git
+    # history structure (which ought to produce an error if dgit can't
+    # cope, not a silent reintroduction of an unwanted patch).
+    #
+    # So gbp users will have to pass an option.  But we can usually
+    # detect their failure to do so: if the tree is not a clean
+    # patches-applied tree, quilt linearisation fails, but the tree
+    # _is_ a clean patches-unapplied tree, we can suggest that maybe
+    # they want --quilt=unapplied.
+    #
+    # To help detect this, when we are extracting the fake dsc, we
+    # first extract it with --skip-patches, and then apply the patches
+    # afterwards with dpkg-source --before-build.  That lets us save a
+    # tree object corresponding to .origs.
+
     my $fakeversion="$upstreamversion-~~DGITFAKE";
 
     my $fakedsc=new IO::File 'fake.dsc', '>' or die $!;
@@ -2906,7 +2940,8 @@ END
 
     quilt_fixup_linkorigs($upstreamversion, $dscaddfile);
 
-    my @files=qw(debian/source/format debian/rules);
+    my @files=qw(debian/source/format debian/rules
+                 debian/control debian/changelog);
     foreach my $maybe (qw(debian/patches debian/source/options)) {
         next unless stat_exists "../../../$maybe";
         push @files, $maybe;
@@ -2918,11 +2953,30 @@ END
     $dscaddfile->($debtar);
     close $fakedsc or die $!;
 
-    runcmd qw(sh -ec), 'exec dpkg-source --no-check -x fake.dsc >/dev/null';
+    runcmd qw(sh -ec),
+        'exec dpkg-source --no-check --skip-patches -x fake.dsc >/dev/null';
 
     my $fakexdir= $package.'-'.(stripepoch $upstreamversion);
     rename $fakexdir, "fake" or die "$fakexdir $!";
 
+    changedir 'fake';
+
+    remove_stray_gits();
+    mktree_in_ud_here();
+
+    rmtree '.pc';
+
+    runcmd @git, qw(add -Af .);
+    my $unapplied=git_write_tree();
+    printdebug "fake orig tree object $unapplied\n";
+
+    ensuredir '.pc';
+
+    runcmd qw(sh -ec),
+        'exec dpkg-source --before-build . >/dev/null';
+
+    changedir '..';
+
     quilt_fixup_mkwork($headref);
 
     my $mustdeletepc=0;
@@ -2934,7 +2988,13 @@ END
         rename '../fake/.pc','.pc' or die $!;
     }
 
-    quiltify($clogp,$headref);
+    changedir '../fake';
+    rmtree '.pc';
+    runcmd @git, qw(add -Af .);
+    my $oldtiptree=git_write_tree();
+    changedir '../work';
+
+    quiltify($clogp,$headref,$unapplied,$oldtiptree);
 
     if (!open P, '>>', ".pc/applied-patches") {
 	$!==&ENOENT or die $!;