X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=dgit;h=41a7fe2f466c430cbbcb74b759aff74fa57f13c8;hp=e74445ba23ea07e545e8fc1336a443af698ddf69;hb=979ce26f5de342743c7b6fa207cd22c66f55af1d;hpb=fbb2767a1a26503fd930aed3240209dd0ea3a541

diff --git a/dgit b/dgit
index e74445ba..41a7fe2f 100755
--- a/dgit
+++ b/dgit
@@ -30,6 +30,7 @@ use Dpkg::Version;
 use POSIX;
 use IPC::Open2;
 use Digest::SHA;
+use Digest::MD5;
 use Config;
 
 our $our_version = 'UNRELEASED'; ###substituted###
@@ -119,9 +120,14 @@ sub stripepoch ($) {
     return $vsn;
 }
 
+sub srcfn ($$) {
+    my ($vsn,$sfx) = @_;
+    return "${package}_".(stripepoch $vsn).$sfx
+}
+
 sub dscfn ($) {
     my ($vsn) = @_;
-    return "${package}_".(stripepoch $vsn).".dsc";
+    return srcfn($vsn,".dsc");
 }
 
 our $us = 'dgit';
@@ -991,6 +997,10 @@ sub mktree_in_ud_from_only_subdir () {
     changedir $dir;
     fail "source package contains .git directory" if stat_exists '.git';
     mktree_in_ud_here();
+    my $format=get_source_format();
+    if (madformat($format)) {
+	rmtree '.pc';
+    }
     runcmd @git, qw(add -Af);
     my $tree = cmdoutput @git, qw(write-tree);
     $tree =~ m/^\w+$/ or die "$tree ?";
@@ -1366,6 +1376,12 @@ sub check_not_dirty () {
     }
 }
 
+sub commit_admin ($) {
+    my ($m) = @_;
+    progress "$m";
+    runcmd_ordryrun_local @git, qw(commit -m), $m;
+}
+
 sub commit_quilty_patch () {
     my $output = cmdoutput @git, qw(status --porcelain);
     my %adds;
@@ -1375,24 +1391,34 @@ sub commit_quilty_patch () {
 	    $adds{$1}++;
 	}
     }
+    delete $adds{'.pc'}; # if there wasn't one before, don't add it
     if (!%adds) {
 	progress "nothing quilty to commit, ok.";
 	return;
     }
     runcmd_ordryrun_local @git, qw(add), sort keys %adds;
-    my $m = "Commit Debian 3.0 (quilt) metadata";
-    progress "$m";
-    runcmd_ordryrun_local @git, qw(commit -m), $m;
+    commit_admin "Commit Debian 3.0 (quilt) metadata";
+}
+
+sub get_source_format () {
+    if (!open F, "debian/source/format") {
+	die $! unless $!==&ENOENT;
+	return '';
+    }
+    $_ = <F>;
+    F->error and die $!;
+    chomp;
+    return $_;
 }
 
 sub madformat ($) {
     my ($format) = @_;
     return 0 unless $format eq '3.0 (quilt)';
-    progress "Format \`$format', urgh";
     if ($noquilt) {
 	progress "Not doing any fixup of \`$format' due to --no-quilt-fixup";
 	return 0;
     }
+    progress "Format \`$format', checking/updating patch stack";
     return 1;
 }
 
@@ -1943,30 +1969,124 @@ our $dscfn;
 our $fakeeditorenv = 'DGIT_FAKE_EDITOR_QUILT';
 
 sub build_maybe_quilt_fixup () {
-    if (!open F, "debian/source/format") {
-	die $! unless $!==&ENOENT;
-	return;
-    }
-    $_ = <F>;
-    F->error and die $!;
-    chomp;
-    return unless madformat($_);
+    my $format=get_source_format;
+    return unless madformat $format;
     # sigh
-    
-    my @cmd = (@git, qw(ls-files --exclude-standard -iodm));
-    my $problems = cmdoutput @cmd;
-    if (length $problems) {
-	print STDERR "problematic files:\n";
-	print STDERR "  $_\n" foreach split /\n/, $problems;
-	fail "Cannot do quilt fixup in tree containing ignored files.  ".
-	    "Perhaps your package's clean target is broken, in which".
-	    " case -wg (which says to use git-clean -xdf) may help.";
-    }
+
+    # Our objective is:
+    #  - honour any existing .pc in case it has any strangeness
+    #  - determine the git commit corresponding to the tip of
+    #    the patch stack (if there is one)
+    #  - if there is such a git commit, convert each subsequent
+    #    git commit into a quilt patch with dpkg-source --commit
+    #  - otherwise convert all the differences in the tree into
+    #    a single git commit
+    #
+    # To do this we:
+
+    # Our git tree doesn't necessarily contain .pc.  (Some versions of
+    # dgit would include the .pc in the git tree.)  If there isn't
+    # one, we need to generate one by unpacking the patches that we
+    # have.
+    #
+    # We first look for a .pc in the git tree.  If there is one, we
+    # will use it.  (This is not the normal case.)
+    #
+    # Otherwise need to regenerate .pc so that dpkg-source --commit
+    # can work.  We do this as follows:
+    #     1. Collect all relevant .orig from parent directory
+    #     2. Generate a debian.tar.gz out of
+    #         debian/{patches,rules,source/format}
+    #     3. Generate a fake .dsc containing just these fields:
+    #          Format Source Version Files
+    #     4. Extract the fake .dsc
+    #        Now the fake .dsc has a .pc directory.
+    # (In fact we do this in every case, because in future we will
+    # want to search for a good base commit for generating patches.)
+    #
+    # Then we can actually do the dpkg-source --commit
+    #     1. Make a new working tree with the same object
+    #        store as our main tree and check out the main
+    #        tree's HEAD.
+    #     2. Copy .pc from the fake's extraction, if necessary
+    #     3. Run dpkg-source --commit
+    #     4. If the result has changes to debian/, then
+    #          - git-add them them
+    #          - git-add .pc if we had a .pc in-tree
+    #          - git-commit
+    #     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
 
     my $clogp = parsechangelog();
-    my $version = getfield $clogp, 'Version';
-    my $author = getfield $clogp, 'Maintainer';
     my $headref = rev_parse('HEAD');
+
+    prep_ud();
+    changedir $ud;
+
+    my $upstreamversion=$version;
+    $upstreamversion =~ s/-[^-]*$//;
+
+    my $fakeversion="$upstreamversion-~~DGITFAKE";
+
+    my $fakedsc=new IO::File 'fake.dsc', '>' or die $!;
+    print $fakedsc <<END or die $!;
+Format: 3.0 (quilt)
+Source: $package
+Version: $fakeversion
+Files:
+END
+
+    my $dscaddfile=sub {
+        my ($b) = @_;
+        
+	my $md = new Digest::MD5;
+
+	my $fh = new IO::File $b, '<' or die "$b $!";
+	stat $fh or die $!;
+	my $size = -s _;
+
+	$md->addfile($fh);
+	print $fakedsc " ".$md->hexdigest." $size $b\n" or die $!;
+    };
+
+    foreach my $f (<../../../../*>) { #/){
+	my $b=$f; $b =~ s{.*/}{};
+	next unless is_orig_file $b, srcfn $upstreamversion,'';
+	link $f, $b or die "$b $!";
+        $dscaddfile->($b);
+    }
+
+    my @files=qw(debian/source/format debian/rules);
+    if (stat_exists '../../../debian/patches') {
+        push @files, 'debian/patches';
+    }
+
+    my $debtar= srcfn $fakeversion,'.debian.tar.gz';
+    runcmd qw(env GZIP=-1 tar -zcf), "./$debtar", qw(-C ../../..), @files;
+
+    $dscaddfile->($debtar);
+    close $fakedsc or die $!;
+
+    runcmd qw(sh -ec), 'exec dpkg-source --no-check -x fake.dsc >/dev/null';
+
+    my $fakexdir= $package.'-'.(stripepoch $upstreamversion);
+    rename $fakexdir, "fake" or die "$fakexdir $!";
+
+    mkdir "work" or die $!;
+    changedir "work";
+    mktree_in_ud_here();
+    runcmd @git, qw(reset --hard), $headref;
+
+    my $mustdeletepc=0;
+    if (stat_exists ".pc") {
+        -d _ or die;
+	progress "Tree already contains .pc - will use it then delete it.";
+        $mustdeletepc=1;
+    } else {
+        rename '../fake/.pc','.pc' or die $!;
+    }
+
+    my $author = getfield $clogp, 'Maintainer';
     my $time = time;
     my $ncommits = 3;
     my $patchname = "auto-$version-$headref-$time";
@@ -2001,6 +2121,14 @@ END
     }
 
     commit_quilty_patch();
+
+    if ($mustdeletepc) {
+        runcmd @git, qw(rm -rq .pc);
+        commit_admin "Commit removal of .pc (quilt series tracking data)";
+    }
+
+    changedir '../../../..';
+    runcmd @git, qw(pull --ff-only -q .git/dgit/unpack/work master);
 }
 
 sub quilt_fixup_editor () {
@@ -2155,6 +2283,7 @@ sub cmd_quilt_fixup {
     badusage "incorrect arguments to dgit quilt-fixup" if @ARGV;
     my $clogp = parsechangelog();
     $version = getfield $clogp, 'Version';
+    $package = getfield $clogp, 'Source';
     build_maybe_quilt_fixup();
 }