X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=dgit;h=29cf5076acd0942d746dda59249ef3c7469115c7;hp=ae75cb9be9a127cc6b2438b544ba4164fcd683f4;hb=74cca49dc0958db0556eabfbaf8bdc6d9d639701;hpb=79194f4a7a74b1d6fce6812e379315e0b0984833 diff --git a/dgit b/dgit index ae75cb9b..29cf5076 100755 --- a/dgit +++ b/dgit @@ -61,7 +61,7 @@ our $cleanmode; our $changes_since_version; our $rmchanges; our $quilt_mode; -our $quilt_modes_re = 'linear|smash|auto|nofix|nocheck'; +our $quilt_modes_re = 'linear|smash|auto|nofix|nocheck|gbp|unapplied'; our $we_are_responder; our $initiator_tempdir; @@ -70,6 +70,8 @@ our %format_ok = map { $_=>1 } ("1.0","3.0 (native)","3.0 (quilt)"); our $suite_re = '[-+.0-9a-z]+'; our $cleanmode_re = 'dpkg-source(?:-d)?|git|git-ff|check|none'; +our $git_authline_re = '^([^<>]+) \<(\S+)\> (\d+ [-+]\d+)$'; + our (@git) = qw(git); our (@dget) = qw(dget); our (@curl) = qw(curl -f); @@ -83,6 +85,7 @@ our (@dpkgbuildpackage) = qw(dpkg-buildpackage -i\.git/ -I.git); our (@dpkgsource) = qw(dpkg-source -i\.git/ -I.git); our (@dpkggenchanges) = qw(dpkg-genchanges); our (@mergechanges) = qw(mergechanges -f); +our (@gbppq) = qw(gbp-pq); our (@changesopts) = (''); our %opts_opt_map = ('dget' => \@dget, # accept for compatibility @@ -114,6 +117,7 @@ autoflush STDOUT 1; our $supplementary_message = ''; our $need_split_build_invocation = 0; +our $split_brain = 0; END { local ($@, $?); @@ -1209,10 +1213,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 () { @@ -1312,9 +1318,10 @@ sub clogp_authline ($) { $author =~ s#,.*##ms; my $date = cmdoutput qw(date), '+%s %z', qw(-d), getfield($clogp,'Date'); my $authline = "$author $date"; - $authline =~ m/^[^<>]+ \<\S+\> \d+ [-+]\d+$/ or + $authline =~ m/$git_authline_re/o or fail "unexpected commit author line format \`$authline'". " (was generated from changelog Maintainer field)"; + return ($1,$2,$3) if wantarray; return $authline; } @@ -1977,6 +1984,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,17 +2515,24 @@ END } } -sub quiltify_trees_differ ($$) { - my ($x,$y) = @_; - # returns 1 iff the two tree objects differ other than in debian/ +sub quiltify_trees_differ ($$;$) { + my ($x,$y,$finegrained) = @_; + # returns true iff the two tree objects differ other than in debian/ + # with $finegrained, + # returns bitmask 01 - differ in upstream files except .gitignore + # 02 - differ in .gitignore local $/=undef; - my @cmd = (@git, qw(diff-tree --name-only -z), $x, $y); + my @cmd = (@git, qw(diff-tree --name-only -z)); + push @cmd, qw(-r) if $finegrained; + push @cmd, $x, $y; my $diffs= cmdoutput @cmd; + my $r = 0; foreach my $f (split /\0/, $diffs) { - next if $f eq 'debian'; - return 1; + next if $f =~ m#^debian(?:/.*)?$#s; + $r |= ($f =~ m#^(?:.*/)?.gitignore$#s) ? 02 : 01; } - return 0; + printdebug "quiltify_trees_differ $x $y => $r\n"; + return $r; } sub quiltify_tree_sentinelfiles ($) { @@ -2527,10 +2542,37 @@ sub quiltify_tree_sentinelfiles ($) { qw(-- debian/rules debian/control); $r =~ s/\n/,/g; return $r; + } + +sub quiltify_splitbrain_needed () { + if (!$split_brain) { + progress "creating dgit view"; + runcmd @git, qw(checkout -q -b dgit-view); + $split_brain = 1; + } } -sub quiltify ($$) { - my ($clogp,$target) = @_; +sub quiltify_splitbrain ($$) { + my ($clogp, $diffbits) = @_; + if ($quilt_mode !~ m/gbp|dpm/) { + # treat .gitignore just like any other upstream file + $diffbits = { %$diffbits }; + $_ = !!$_ foreach values %$diffbits; + } + if ($quilt_mode =~ m/gbp|unapplied/ && + ($diffbits->{O2A} & 01) && # some patches + !($diffbits->{H2O} & 01)) { # but HEAD is like orig + quiltify_splitbrain_needed(); + runcmd @gbppq, qw(import); + die "SPLIT BRAIN"; + } + die 'xxx gitignore'; + die 'xxx memoisation via git-reflog'; + die 'xxx fast forward'; +} + +sub quiltify ($$$$) { + my ($clogp,$target,$oldtiptree,$failsuggestion) = @_; # Quilt patchification algorithm # @@ -2556,14 +2598,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 +2710,7 @@ sub quiltify ($$) { foreach my $notp (@nots) { print STDERR "$us: ", $reportnot->($notp), "\n"; } + print STDERR "$us: $_\n" foreach @$failsuggestion; 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 +2916,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,8 +2966,10 @@ END quilt_fixup_linkorigs($upstreamversion, $dscaddfile); - my @files=qw(debian/source/format debian/rules); - foreach my $maybe (qw(debian/patches debian/source/options)) { + my @files=qw(debian/source/format debian/rules + debian/control debian/changelog); + foreach my $maybe (qw(debian/patches debian/source/options + debian/tests/control)) { next unless stat_exists "../../../$maybe"; push @files, $maybe; } @@ -2918,11 +2980,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 +3015,54 @@ 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'; + + + # We calculate some guesswork now about what kind of tree this might + # be. This is mostly for error reporting. + + my $diffbits = { + # H = user's HEAD + # O = orig, without patches applied + # A = "applied", ie orig with H's debian/patches applied + H2O => quiltify_trees_differ($headref, $unapplied, 1), + H2A => quiltify_trees_differ($headref, $oldtiptree,1), + O2A => quiltify_trees_differ($unapplied,$oldtiptree,1), + }; + + my @dl; + foreach my $b (qw(01 02)) { + foreach my $v (qw(H2O O2A H2A)) { + push @dl, ($diffbits->{$v} & $b) ? '##' : '=='; + } + } + printdebug "differences \@dl @dl.\n"; + + progress sprintf +"$us: quilt differences: src: %s orig %s gitignores: %s orig %s\n". +"$us: quilt differences: HEAD %s o+d/p HEAD %s o+d/p", + $dl[0], $dl[1], $dl[3], $dl[4], + $dl[2], $dl[5]; + + my @failsuggestion; + if (!($diffbits->{H2O} & $diffbits->{O2A})) { + push @failsuggestion, "This might be a patches-unapplied branch."; + } elsif (!($diffbits->{H2A} & $diffbits->{O2A})) { + push @failsuggestion, "This might be a patches-applied branch."; + } + push @failsuggestion, "Maybe you need to specify one of". + " --quilt=gbp --quilt=dpm --quilt=unapplied ?"; + + if ($quilt_mode =~ m/gbp|dpm|unapplied/) { + quiltify_splitbrain($clogp, $diffbits); + return; + } + + quiltify($clogp,$headref,$oldtiptree,\@failsuggestion); if (!open P, '>>', ".pc/applied-patches") { $!==&ENOENT or die $!;