X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=98e645a43a9255b81a7821a671b406239c922f90;hp=216d7dfa150e9018a488839d07a9c60341d7313b;hb=485a61ef66da7ad675e0495355b1f9f1df952bf5;hpb=93c90551df21fc7df60ade835e29bdbe91f65744 diff --git a/git-debrebase b/git-debrebase index 216d7dfa..98e645a4 100755 --- a/git-debrebase +++ b/git-debrebase @@ -34,18 +34,43 @@ use Data::Dumper; use Getopt::Long qw(:config posix_default gnu_compat bundling); use Dpkg::Version; use File::FnMatch qw(:fnmatch); +use File::Copy; + +our ($usage_message) = <<'END'; +usages: + git-debrebase [] [--|-i ] + git-debrebase [] status + git-debrebase [] prepush [--prose=...] + git-debrebase [] quick|conclude + git-debrebase [] new-upstream [
] + git-debrebase [] convert-from-gbp [] + ... +See git-debrebase(1), git-debrebase(5), dgit-maint-debrebase(7) (in dgit). +END our ($opt_force, $opt_noop_ok, @opt_anchors); our ($opt_defaultcmd_interactive); our $us = qw(git-debrebase); +$|=1; + sub badusage ($) { my ($m) = @_; - print STDERR "bad usage: $m\n"; + print STDERR "$us: bad usage: $m\n"; finish 8; } +sub getoptions_main { + my $m = shift; + local $SIG{__WARN__}; # GetOptions calls `warn' to print messages + GetOptions @_ or badusage $m; +} +sub getoptions { + my $sc = shift; + getoptions_main "bad options follow \`git-debrebase $sc'", @_; +} + sub cfg ($;$) { my ($k, $optional) = @_; local $/ = "\0"; @@ -89,6 +114,7 @@ our $rd; our $workarea; our @git = qw(git); +our @dgit = qw(dgit); sub in_workarea ($) { my ($sub) = @_; @@ -117,7 +143,7 @@ sub run_deferred_updates ($) { confess 'dangerous internal error' unless all_snags_summarised(); - my @upd_cmd = (@git, qw(update-ref --stdin -m), "debrebase: $mrest"); + my @upd_cmd = (git_update_ref_cmd "debrebase: $mrest", qw(--stdin)); debugcmd '>|', @upd_cmd; open U, "|-", @upd_cmd or die $!; foreach (@deferred_updates) { @@ -269,12 +295,17 @@ sub snags_maybe_bail () { $us, $snags_tripped; } else { fail sprintf - "%s: snags: %d blockers (you could -f, or --force)", + "%s: snags: %d blocker(s) (you could -f, or --force)", $us, $snags_tripped; } } $snags_summarised = $snags_forced + $snags_tripped; } +sub snags_maybe_bail_early () { + # useful to bail out early without doing a lot of work; + # not a substitute for snags_maybe_bail. + snags_maybe_bail() if $snags_tripped && !$opt_force; +} sub any_snags () { return $snags_forced || $snags_tripped; } @@ -565,13 +596,15 @@ sub keycommits ($;$$$$) { my ($anchor, $breakwater); my $clogonly; my $cl; - $fatal //= sub { fail $_[2]; }; + my $found_pm; + $fatal //= sub { fail $_[1]; }; my $x = sub { - my ($cb, $tagsfx, $why) = @_; + my ($cb, $tagsfx, $mainwhy, $xwhy) = @_; + my $why = $mainwhy.$xwhy; my $m = "branch needs laundering (run git-debrebase): $why"; fail $m unless defined $cb; return unless $cb; - $cb->("unclean-$tagsfx", $why, $cl); + $cb->("unclean-$tagsfx", $why, $cl, $mainwhy); }; for (;;) { $cl = classify $head; @@ -592,27 +625,35 @@ sub keycommits ($;$$$$) { last; } elsif ($ty eq 'Upstream') { $x->($unclean, 'ordering', - "packaging change ($breakwater) follows upstream change (eg $head)") + "packaging change ($breakwater) follows upstream change"," (eg $head)") if defined $breakwater; $clogonly = undef; $breakwater = undef; } elsif ($ty eq 'Mixed') { $x->($unclean, 'mixed', - "found mixed upstream/packaging commit ($head)"); + "found mixed upstream/packaging commit"," ($head)"); $clogonly = undef; $breakwater = undef; } elsif ($ty eq 'Pseudomerge' or $ty eq 'AddPatches') { + my $found_pm = 1; $x->($furniture, (lc $ty), - "found interchange bureaucracy commit ($ty, $head)"); + "found interchange bureaucracy commit ($ty)"," ($head)"); } elsif ($ty eq 'DgitImportUnpatched') { - $x->($trouble, 'dgitimport', - "found dgit dsc import ($head)"); - return (undef,undef); + if ($found_pm) { + $x->($trouble, 'dgitimport', + "found dgit dsc import"," ($head)"); + return (undef,undef); + } else { + $x->($fatal, 'unprocessable', + "found bare dgit dsc import with no prior history", + " ($head)"); + return (undef,undef); + } } else { $x->($fatal, 'unprocessable', - "found unprocessable commit, cannot cope: $head; $cl->{Why}" - ); + "found unprocessable commit, cannot cope: $cl->{Why}", + " ($head)"); return (undef,undef); } $head = $cl->{Parents}[0]{CommitId}; @@ -670,10 +711,11 @@ sub walk ($;$$) { if ($nogenerate) { return (undef,undef); } - die "commit $cur: Cannot cope with this commit (d.". + fail "found unprocessable commit, cannot cope". + (defined $cl->{Why} ? "; $cl->{Why}:": ':'). + " (commit $cur) (d.". (join ' ', map { sprintf "%#x", $_->{Differs} } @{ $cl->{Parents} }). - (defined $cl->{Why} ? "; $cl->{Why}": ''). ")"; }; @@ -782,13 +824,12 @@ sub walk ($;$$) { next; } else { # Everything is from this import. This kind of import - # is already in valid breakwater format, with the - # patches as commits. - printf $report " NoPM" if $report; - # last thing we processed will have been the first patch, - # if there is one; which is fine, so no need to rewrite - # on account of this import - $build_start->("ImportOrigin", $cur); + # is already nearly in valid breakwater format, with the + # patches as commits. Unfortunately it contains + # debian/patches/. + printdebug "*** WALK BOMB bare dgit import\n"; + $cl->{Why} = "bare dgit dsc import"; + return $bomb->(); } die "$ty ?"; } else { @@ -961,7 +1002,8 @@ sub defaultcmd_rebase () { } sub cmd_analyse () { - die if ($ARGV[0]//'') =~ m/^-/; + badusage "analyse does not support any options" + if @ARGV and $ARGV[0] =~ m/^-/; badusage "too many arguments to analyse" if @ARGV>1; my ($old) = @ARGV; if (defined $old) { @@ -978,24 +1020,27 @@ sub ffq_prev_branchinfo () { return gdr_ffq_prev_branchinfo($current); } -sub record_ffq_prev_deferred () { - # => ('status', "message") - # 'status' may be - # deferred message is undef +sub ffq_check ($;$$) { + # calls $ff and/or $notff zero or more times + # then returns either (status,message) where status is # exists # detached # weird-symref # notbranch - # if not ff from some branch we should be ff from, is an snag - # if "deferred", will have added something about that to - # @deferred_update_messages, and also maybe printed (already) - # some messages about ff checks + # or (undef,undef, $ffq_prev,$gdrlast) + # $ff and $notff are called like this: + # $ff->("message for stdout\n"); + # $notff->('snag-name', $message); + # normally $currentval should be HEAD + my ($currentval, $ff, $notff) =@_; + + $ff //= sub { print $_[0] or die $!; }; + $notff //= \&snag; + my ($status, $message, $current, $ffq_prev, $gdrlast) = ffq_prev_branchinfo(); return ($status, $message) unless $status eq 'branch'; - my $currentval = get_head(); - my $exists = git_get_ref $ffq_prev; return ('exists',"$ffq_prev already exists") if $exists; @@ -1022,14 +1067,14 @@ sub record_ffq_prev_deferred () { return unless length $lrval; if (is_fast_fwd $lrval, $currentval) { - print "OK, you are ahead of $lrref\n" or die $!; + $ff->("OK, you are ahead of $lrref\n"); $checked{$lrref} = 1; } elsif (is_fast_fwd $currentval, $lrval) { $checked{$lrref} = -1; - snag 'behind', "you are behind $lrref, divergence risk"; + $notff->('behind', "you are behind $lrref, divergence risk"); } else { $checked{$lrref} = -1; - snag 'diverged', "you have diverged from $lrref"; + $notff->('diverged', "you have diverged from $lrref"); } }; @@ -1054,6 +1099,25 @@ sub record_ffq_prev_deferred () { } elsif ($branch =~ m{^master$}) { $check->("refs/remotes/dgit/dgit/sid", 'remote dgit branch for sid'); } + return (undef, undef, $ffq_prev, $gdrlast); +} + +sub record_ffq_prev_deferred () { + # => ('status', "message") + # 'status' may be + # deferred message is undef + # exists + # detached + # weird-symref + # notbranch + # if not ff from some branch we should be ff from, is an snag + # if "deferred", will have added something about that to + # @deferred_update_messages, and also maybe printed (already) + # some messages about ff checks + my $currentval = get_head(); + + my ($status,$message, $ffq_prev,$gdrlast) = ffq_check $currentval; + return ($status,$message) if defined $status; snags_maybe_bail(); @@ -1129,28 +1193,23 @@ sub do_stitch ($;$) { stitch($dangling_head, $ffq_prev, $gdrlast, $ffq_prev_commitish, $prose); } -sub cmd_new_upstream_v0 () { - # automatically and unconditionally launders before rebasing - # if rebase --abort is used, laundering has still been done - - my %pieces; - - badusage "need NEW-VERSION [UPS-COMMITTISH]" unless @ARGV >= 1; +sub upstream_commitish_search ($$) { + my ($upstream_version, $tried) = @_; + # todo: at some point maybe use git-deborig to do this + foreach my $tagpfx ('', 'v', 'upstream/') { + my $tag = $tagpfx.(dep14_version_mangle $upstream_version); + my $new_upstream = git_get_ref "refs/tags/$tag"; + push @$tried, $tag; + return $new_upstream if length $new_upstream; + } +} - # parse args - low commitment - my $new_version = (new Dpkg::Version scalar(shift @ARGV), check => 1); - my $new_upstream_version = $new_version->version(); +sub resolve_upstream_version ($$) { + my ($new_upstream, $upstream_version) = @_; - my $new_upstream = shift @ARGV; if (!defined $new_upstream) { my @tried; - # todo: at some point maybe use git-deborig to do this - foreach my $tagpfx ('', 'v', 'upstream/') { - my $tag = $tagpfx.(dep14_version_mangle $new_upstream_version); - $new_upstream = git_get_ref "refs/tags/$tag"; - last if length $new_upstream; - push @tried, $tag; - } + $new_upstream = upstream_commitish_search $upstream_version, \@tried; if (!length $new_upstream) { fail "Could not determine appropriate upstream commitish.\n". " (Tried these tags: @tried)\n". @@ -1159,6 +1218,30 @@ sub cmd_new_upstream_v0 () { } $new_upstream = git_rev_parse $new_upstream; + return $new_upstream; +} + +sub cmd_new_upstream () { + # automatically and unconditionally launders before rebasing + # if rebase --abort is used, laundering has still been done + + my %pieces; + + badusage "need NEW-VERSION [UPS-COMMITTISH]" unless @ARGV >= 1; + + # parse args - low commitment + my $spec_version = shift @ARGV; + my $new_version = (new Dpkg::Version $spec_version, check => 1); + fail "bad version number \`$spec_version'" unless defined $new_version; + if ($new_version->is_native()) { + $new_version = (new Dpkg::Version "$spec_version-1", check => 1); + } + + my $new_upstream = shift @ARGV; + my $new_upstream_version = upstreamversion $new_version; + $new_upstream = + resolve_upstream_version $new_upstream, $new_upstream_version; + record_ffq_auto(); my $piece = sub { @@ -1216,11 +1299,13 @@ sub cmd_new_upstream_v0 () { ) { my @oldpieces = (split / /, $1); my $old_n_parents = scalar @{ $old_upstream->{Parents} }; - if (@oldpieces != $old_n_parents) { + if ($old_n_parents != @oldpieces && + $old_n_parents != @oldpieces + 1) { snag 'upstream-confusing', sprintf "previous upstream combine %s". - " mentions %d pieces (each implying one orig commit)". - " but has %d parents", + " mentions %d pieces (each implying one parent)". + " but has %d parents". + " (one per piece plus maybe a previous combine)", $old_upstream->{CommitId}, (scalar @oldpieces), $old_n_parents; @@ -1233,7 +1318,8 @@ sub cmd_new_upstream_v0 () { $oldpieces[0] = ''; foreach my $i (0..$#oldpieces) { my $n = $oldpieces[$i]; - $piece->($n, Old => $old_upstream->{CommitId}.'^'.($i+1)); + my $hat = 1 + $i + ($old_n_parents - @oldpieces); + $piece->($n, Old => $old_upstream->{CommitId}.'^'.$hat); } } } else { @@ -1347,6 +1433,8 @@ END 'launder for new upstream'; my @cmd = (@git, qw(rebase --onto), $new_bw, $old_bw, @ARGV); + local $ENV{GIT_REFLOG_ACTION} = git_reflog_action_msg + "debrebase new-upstream $new_version: rebase"; runcmd @cmd; # now it's for the user to sort out } @@ -1382,15 +1470,20 @@ sub cmd_status () { # todo: gdr status should print upstream component(s) info # todo: gdr should leave/maintain some refs with this kind of info ? - my $oldest = [ 0 ]; + my $oldest = { Badness => 0 }; my $newest; my $note = sub { - my ($badness, $ourmsg, $snagname, $kcmsg, $cl) = @_; - if ($oldest->[0] < $badness) { + my ($badness, $ourmsg, $snagname, $dummy, $cl, $kcmsg) = @_; + if ($oldest->{Badness} < $badness) { $oldest = $newest = undef; } - $oldest = \@_; # we're walking backwards - $newest //= \@_; + $oldest = { + Badness => $badness, + CommitId => $cl->{CommitId}, + OurMsg => $ourmsg, + KcMsg => $kcmsg, + }; + $newest //= $oldest; }; my ($anchor, $bw) = keycommits +(git_rev_parse 'HEAD'), sub { $note->(1, 'branch contains furniture (not laundered)', @_); }, @@ -1407,16 +1500,16 @@ sub cmd_status () { }; print "current branch contents, in git-debrebase terms:\n"; - if (!$oldest->[0]) { + if (!$oldest->{Badness}) { print " branch is laundered\n"; } else { - print " $oldest->[1]\n"; + print " $oldest->{OurMsg}\n"; my $printed = ''; foreach my $info ($oldest, $newest) { - my $cid = $info->[4]{CommitId}; + my $cid = $info->{CommitId}; next if $cid eq $printed; $printed = $cid; - print " $info->[3]\n"; + print " $info->{KcMsg}\n"; $prcommitinfo->($cid); } } @@ -1458,7 +1551,8 @@ sub cmd_status () { sub cmd_stitch () { my $prose = 'stitch'; - GetOptions('prose=s', \$prose) or die badusage("bad options to stitch"); + getoptions("stitch", + 'prose=s', \$prose); badusage "no arguments allowed" if @ARGV; do_stitch $prose, 0; } @@ -1492,8 +1586,13 @@ sub make_patches_staged ($) { in_workarea sub { runcmd @git, qw(checkout -q -b bw), $secret_bw; runcmd @git, qw(checkout -q -b patch-queue/bw), $secret_head; - runcmd qw(gbp pq export); - runcmd @git, qw(add debian/patches); + my @gbp_cmd = (qw(gbp pq export)); + my $r = system shell_cmd 'exec >../gbp-pq-err 2>&1', @gbp_cmd; + if ($r) { + { local ($!,$?); copy('../gbp-pq-err', \*STDERR); } + failedcmd @gbp_cmd; + } + runcmd @git, qw(add -f debian/patches); }; } @@ -1516,8 +1615,8 @@ sub make_patches ($) { sub cmd_make_patches () { my $opt_quiet_would_amend; - GetOptions('quiet-would-amend!', \$opt_quiet_would_amend) - or die badusage("bad options to make-patches"); + getoptions("make-patches", + 'quiet-would-amend!', \$opt_quiet_would_amend); badusage "no arguments allowed" if @ARGV; my $old_head = get_head(); my $new = make_patches $old_head; @@ -1539,19 +1638,31 @@ sub cmd_make_patches () { } sub cmd_convert_from_gbp () { - badusage "needs 1 optional argument, the upstream git rev" + badusage "want only 1 optional argument, the upstream git commitish" unless @ARGV<=1; + + my $clogp = parsechangelog(); + my $version = $clogp->{'Version'} + // die "missing Version from changelog"; + my ($upstream_spec) = @ARGV; - $upstream_spec //= 'refs/heads/upstream'; - my $upstream = git_rev_parse $upstream_spec; + + my $upstream_version = upstreamversion $version; + my $upstream = + resolve_upstream_version($upstream_spec, $upstream_version); + my $old_head = get_head(); my $upsdiff = get_differs $upstream, $old_head; if ($upsdiff & D_UPS) { - runcmd @git, qw(--no-pager diff), + runcmd @git, qw(--no-pager diff --stat), $upstream, $old_head, qw( -- :!/debian :/); - fail "upstream ($upstream_spec) and HEAD are not identical in upstream files"; + fail <{Date}; + next unless $stz->{Distribution} ne 'UNRELEASED'; + $lvsn = $stz->{Version}; + $suite = $stz->{Distribution}; + last; + }; + die "neither of the first two changelog entries are released\n" + unless defined $lvsn; + print "last finished-looking changelog entry: ($lvsn) $suite\n"; + my $mtag_pat = debiantag_maintview $lvsn, '*'; + my $mtag = cmdoutput @git, qw(describe --always --abbrev=0 --match), + $mtag_pat; + die "could not find suitable maintainer view tag $mtag_pat\n" + unless $mtag_pat =~ m{/}; + is_fast_fwd $mtag, 'HEAD' or + die "HEAD is not FF from maintainer tag $mtag!"; + my $dtag = "archive/$mtag"; + is_fast_fwd $mtag, $dtag or + die "dgit view tag $dtag is not FF from maintainer tag $mtag"; + print "will stitch in dgit view, $dtag\n"; + git_rev_parse $dtag; + }; + if (!$previous_dgit_view) { + $@ =~ s/^\n+//; + chomp $@; + print STDERR "cannot stitch in dgit view: $@\n"; + } + + snags_maybe_bail_early(); my $work; @@ -1602,8 +1748,17 @@ sub cmd_convert_from_gbp () { runcmd @git, qw(reset --quiet --hard patch-queue/gdr-internal); runcmd @git, qw(rebase --quiet --onto), $work, qw(gdr-internal); $work = git_rev_parse 'HEAD'; + + if ($previous_dgit_view) { + $work = make_commit [$work, $previous_dgit_view], [ + 'git-debrebase import: declare ff from dgit archive view', + '[git-debrebase pseudomerge: import-from-gbp]', + ]; + } }; + ffq_check $work; + snags_maybe_bail(); update_head_checkout $old_head, $work, 'convert-from-gbp'; } @@ -1633,6 +1788,194 @@ git-debrebase: WARNING: doing so would drop all upstream patches! END } +sub cmd_convert_from_dgit_view () { + my $clogp = parsechangelog(); + + my $bpd = (cfg 'dgit.default.build-products-dir',1) // '..'; + my $do_origs = 1; + my $do_tags = 1; + my $always = 0; + my $diagnose = 0; + + getoptions("convert-from-dgit-view", + 'diagnose!', \$diagnose, + 'build-products-dir:s', \$bpd, + 'origs!', \$do_origs, + 'tags!', \$do_tags, + 'always-convert-anyway!', \$always); + fail "takes 1 optional argument, the upstream commitish" if @ARGV>1; + + my @upstreams; + + if (@ARGV) { + my $spec = shift @ARGV; + my $commit = git_rev_parse "$spec^{commit}"; + push @upstreams, { Commit => $commit, + Source => "$ARGV[0], from command line", + Only => 1, + }; + } + + my $head = get_head(); + + if (!$always) { + my $troubles = 0; + my $trouble = sub { $troubles++; }; + keycommits $head, sub{}, sub{}, $trouble, $trouble; + printdebug "troubles=$troubles\n"; + if (!$troubles) { + print STDERR <{Version}; + print STDERR "Considering possible commits corresponding to upstream:\n"; + + if (!@upstreams) { + if ($do_tags) { + my @tried; + my $ups_tag = upstream_commitish_search $version, \@tried; + if ($ups_tag) { + my $this = "git tag $tried[-1]"; + push @upstreams, { Commit => $ups_tag, + Source => $this, + }; + } else { + printf STDERR + " git tag: no suitable tag found (tried %s)\n", + "@tried"; + } + } + if ($do_origs) { + my $p = $clogp->{'Source'}; + # we do a quick check to see if there are plausible origs + my $something=0; + if (!opendir BPD, $bpd) { + die "$bpd: opendir: $!" unless $!==ENOENT; + } else { + while ($!=0, my $f = readdir BPD) { + next unless is_orig_file_of_p_v $f, $p, $version; + printf STDERR + " orig: found what looks like a .orig, %s\n", + "$bpd/$f"; + $something=1; + last; + } + die "read $bpd: $!" if $!; + closedir BPD; + } + if ($something) { + my $tree = cmdoutput + @dgit, qw(--build-products-dir), $bpd, + qw(print-unapplied-treeish); + fresh_workarea(); + in_workarea sub { + runcmd @git, qw(reset --quiet), $tree, qw(-- .); + rm_subdir_cached 'debian'; + $tree = cmdoutput @git, qw(write-tree); + my $ups_synth = make_commit [], [ < $ups_synth, + Source => "orig(s) imported via dgit", + }; + } + } else { + printf STDERR + " orig: no suitable origs found (looked for %s in %s)\n", + "${p}_".(stripeoch $version)."...", $bpd; + } + } + } + + my $some_patches = stat_exists 'debian/patches/series'; + + print STDERR "Evaluating possible commits corresponding to upstream:\n"; + + my $result; + foreach my $u (@upstreams) { + my $work = $head; + fresh_workarea(); + in_workarea sub { + runcmd @git, qw(reset --quiet), $u->{Commit}, qw(-- .); + runcmd @git, qw(checkout), $u->{Commit}, qw(-- .); + runcmd @git, qw(clean -xdff); + runcmd @git, qw(checkout), $head, qw(-- debian); + if ($some_patches) { + rm_subdir_cached 'debian/patches'; + $work = make_commit [ $work ], [ + 'git-debrebase convert-from-dgit-view: drop upstream changes from breakwater', + "Drop upstream changes, and delete debian/patches, as part of converting\n". + "to git-debrebase format. Upstream changes will appear as commits.", + '[git-debrebase convert-from-dgit-view: drop patches from tree]' + ]; + } + $work = make_commit [ $work, $u->{Commit} ], [ + 'git-debrebase convert-from-dgit-view: declare upstream', + '(Re)constructed breakwater merge.', + '[git-debrebase anchor: declare upstream]' + ]; + runcmd @git, qw(checkout --quiet -b mk), $work; + if ($some_patches) { + runcmd @git, qw(checkout), $head, qw(-- debian/patches); + runcmd @git, qw(reset --quiet); + my @gbp_cmd = (qw(gbp pq import)); + if (!$diagnose) { + my $gbp_err = "../gbp-pq-err"; + @gbp_cmd = shell_cmd "exec >$gbp_err 2>&1", @gbp_cmd; + } + my $r = system @gbp_cmd; + if ($r) { + printf STDERR + " %s: couldn't apply patches: gbp pq %s", + $u->{Source}, waitstatusmsg(); + return; + } + } + my $work = git_rev_parse qw(HEAD); + my $diffout = cmdoutput @git, qw(diff-tree --stat HEAD), $work; + if (length $diffout) { + print STDERR + " $u->{Source}: applying patches gives different tree\n"; + print STDERR $diffout if $diagnose; + return; + } + # OMG! + $u->{Result} = $work; + $result = $u; + }; + last if $result; + } + + if (!$result) { + fail <{Source}; + + ffq_check $result->{Result}; + snags_maybe_bail(); + update_head_checkout $head, $result->{Result}, + 'convert-from-dgit-view'; +} + sub cmd_downstream_rebase_launder_v0 () { badusage "needs 1 argument, the baseline" unless @ARGV==1; my ($base) = @ARGV; @@ -1682,10 +2025,13 @@ sub cmd_downstream_rebase_launder_v0 () { } } -GetOptions("D+" => \$debuglevel, +getoptions_main + ("bad options\n", + "D+" => \$debuglevel, 'noop-ok', => \$opt_noop_ok, 'f=s' => \@snag_force_opts, 'anchor=s' => \@opt_anchors, + '--dgit=s' => \($dgit[0]), 'force!', '-i:s' => sub { my ($opt,$val) = @_; @@ -1698,7 +2044,10 @@ GetOptions("D+" => \$debuglevel, # approach. '-i=s{0,}' does not work with bundling. push @$opt_defaultcmd_interactive, @ARGV; @ARGV=(); - }) or die badusage "bad options\n"; + }, + 'help' => sub { print $usage_message or die $!; finish 0; }, + ); + initdebug('git-debrebase '); enabledebug if $debuglevel;