# usages:
#
-# git-debrebase [<options>] new-upstream-v0 \
-# <new-version> <orig-commitish> \
-# [<extra-orig-name> <extra-orig-commitish> ...] \
-# [<git-rebase options>...]
-#
-# git-debrebase [<options> --] [<git-rebase options...>]
# git-debrebase [<options>] analyse
-# git-debrebase [<options>] breakwater # prints breakwater tip only
-# git-debrebase [<options>] launder # prints breakwater tip etc.
-# git-debrebase [<options>] stitch [--prose=<for commit message>]
+# git-debrebase [<options>] launder-v0 # prints breakwater tip etc.
# git-debrebase [<options>] downstream-rebase-launder-v0 # experimental
#
-# git-debrebase [<options>] convert-from-gbp [<upstream-git-rev>]
# git-debrebase [<options>] convert-to-gbp
# problems / outstanding questions:
use Dpkg::Version;
use File::FnMatch qw(:fnmatch);
-our ($opt_force, $opt_noop_ok);
+our ($opt_force, $opt_noop_ok, @opt_anchors);
our $us = qw(git-debrebase);
in_workarea sub { playtree_setup };
}
+our @deferred_updates;
+our @deferred_update_messages;
+
+sub run_deferred_updates ($) {
+ my ($mrest) = @_;
+
+ my @upd_cmd = (@git, qw(update-ref --stdin -m), "debrebase: $mrest");
+ debugcmd '>|', @upd_cmd;
+ open U, "|-", @upd_cmd or die $!;
+ foreach (@deferred_updates) {
+ printdebug ">= ", $_, "\n";
+ print U $_, "\n" or die $!;
+ }
+ printdebug ">\$\n";
+ close U or failedcmd @upd_cmd;
+
+ print $_, "\n" foreach @deferred_update_messages;
+
+ @deferred_updates = ();
+ @deferred_update_messages = ();
+}
+
sub get_differs ($$) {
my ($x,$y) = @_;
# This resembles quiltify_trees_differ, in dgit, a bit.
# has additional entry in classification result
# OrigParents = [ subset of Parents ] # singleton list
#
+# TreatAsAnchor
+#
# BreakwaterStart
#
# Unknown
return $r;
};
+ if (grep { $_ eq $objid } @opt_anchors) {
+ return $classify->('TreatAsAnchor');
+ }
+
my @identical = grep { !$_->{Differs} } @p;
my ($stype, $series) = git_cat_file "$t:debian/patches/series";
my $haspatches = $stype ne 'missing' && $series =~ m/^\s*[^#\n\t ]/m;
# multi-orig upstreams are represented with an anchor merge
# from a single upstream commit which combines the orig tarballs
+ # Every anchor tagged this way must be a merge.
+ # We are relying on the
+ # [git-debrebase anchor: ...]
+ # commit message annotation in "declare" anchor merges (which
+ # do not have any upstream changes), to distinguish those
+ # anchor merges from ordinary pseudomerges (which we might
+ # just try to strip).
+ #
+ # However, the user is going to be doing git-rebase a lot. We
+ # really don't want them to rewrite an anchor commit.
+ # git-rebase trips up on merges, so that is a useful safety
+ # catch.
+ #
+ # BreakwaterStart commits are also anchors in the terminology
+ # of git-debrebase(5), but they are untagged (and always
+ # manually generated).
+
my $badanchor = sub { $unknown->("git-debrebase \`anchor' but @_"); };
@p == 2 or return $badanchor->("has other than two parents");
- $haspatches and return $unknown->("contains debian/patches");
+ $haspatches and return $badanchor->("contains debian/patches");
# How to decide about l/r ordering of anchors ? git
# --topo-order prefers to expand 2nd parent first. There's
# way also there's also an easy rune to look for the upstream
# patches (--topo-order).
- # The above tells us which way *we* will generate them. But we
- # might encounter ad-hoc anchor merges generated manually,
- # which might be the other way around. In principle, in some odd
- # situations, an anchor merge might have two identical parents.
- # In that case we guess which way round it is (ie, which parent
- # has the upstream history). The order of the 2-iteration loop
- # controls which guess we make.
-
- # XXX we are going to desupport non-git-debrebase-generated anchors
-
- foreach my $prevbrw (qw(0 1)) {
- if (!$p[$prevbrw]{IsOrigin} && # breakwater never starts with an origin
- !($p[!$prevbrw]{Differs} & ~DS_DEB) && # no non-debian changess
- !($p[$prevbrw]{Differs} & ~D_UPS)) { # no non-upstream changes
- return $classify->(qw(Anchor),
- OrigParents => [ $p[!$prevbrw] ]);
- }
- }
+ $p[0]{IsOrigin} and $badanchor->("is an origin commit");
+ $p[1]{Differs} & ~DS_DEB and
+ $badanchor->("upstream files differ from left parent");
+ $p[0]{Differs} & ~D_UPS and
+ $badanchor->("debian/ differs from right parent");
- $badanchor->("violation");
+ return $classify->(qw(Anchor),
+ OrigParents => [ $p[1] ]);
}
if (@p == 1) {
$ty eq 'Changelog') {
$breakwater //= $head;
} elsif ($ty eq 'Anchor' or
+ $ty eq 'TreatAsAnchor' or
$ty eq 'BreakwaterStart') {
$breakwater //= $head;
last;
return (Msg => $ms);
};
my $rewrite_from_here = sub {
+ my ($cl) = @_;
my $sp_cl = { SpecialMethod => 'StartRewrite' };
- push @brw_cl, $sp_cl;
+ push @$cl, $sp_cl;
push @processed, $sp_cl;
};
my $cur = $input;
my $p0 = @{ $cl->{Parents} }==1 ? $cl->{Parents}[0]{CommitId} : undef;
if ($ty eq 'AddPatches') {
$cur = $p0;
- $rewrite_from_here->();
+ $rewrite_from_here->(\@upp_cl);
next;
} elsif ($ty eq 'Packaging' or $ty eq 'Changelog') {
push @brw_cl, $cl;
};
$queue->(\@brw_cl, "debian");
$queue->(\@upp_cl, "upstream");
- $rewrite_from_here->();
+ $rewrite_from_here->(\@brw_cl);
$cur = $p0;
next;
} elsif ($ty eq 'Pseudomerge') {
my $contrib = $cl->{Contributor}{CommitId};
print $report " Contributor=$contrib" if $report;
push @pseudomerges, $cl;
- $rewrite_from_here->();
+ $rewrite_from_here->(\@upp_cl);
$cur = $contrib;
next;
- } elsif ($ty eq 'Anchor') {
+ } elsif ($ty eq 'Anchor' or $ty eq 'TreatAsAnchor') {
$last_anchor = $cur;
$build_start->("Anchor", $cur);
} elsif ($ty eq 'DgitImportUnpatched') {
" anchor")
};
$prline->(" Import");
- $rewrite_from_here->();
+ $rewrite_from_here->(\@brw_cl);
$upp_limit //= $#upp_cl; # further, deeper, patches discarded
$cur = $ovwr;
next;
sub update_head ($$$) {
my ($old, $new, $mrest) = @_;
- runcmd @git, qw(update-ref -m), "debrebase: $mrest", 'HEAD', $new, $old;
+ push @deferred_updates, "update HEAD $new $old";
+ run_deferred_updates $mrest;
}
sub update_head_checkout ($$$) {
runcmd @git, qw(rm --quiet --ignore-unmatch -rf debian/patches);
}
-sub cmd_launder () {
- badusage "no arguments to launder allowed" if @ARGV;
+sub cmd_launder_v0 () {
+ badusage "no arguments to launder-v0 allowed" if @ARGV;
my $old = get_head();
my ($tip,$breakwater,$last_anchor) = walk $old;
update_head_postlaunder $old, $tip, 'launder';
sub defaultcmd_rebase () {
my $old = get_head();
- my ($status, $message) = record_ffq_prev();
- if ($status eq 'written' || $status eq 'exists') {
- } else {
- fproblem $status, "could not record ffq-prev: $message";
- fproblems_maybe_bail();
- }
+ record_ffq_auto();
my ($tip,$breakwater) = walk $old;
update_head_postlaunder $old, $tip, 'launder for rebase';
runcmd @git, qw(rebase), @ARGV, $breakwater;
return ('branch', undef, $current, $ffq_prev);
}
-sub record_ffq_prev () {
+sub record_ffq_prev_deferred () {
# => ('status', "message")
# 'status' may be
- # written message is undef
+ # deferred message is undef
# exists
# detached
# weird-symref
# notbranch
# if not ff from some branch we should be ff from, is an fproblem
- # if "written", will have printed something about that to stdout,
- # and also some messages about ff checks
+ # if "deferred", will have added something about that to
+ # @deferred_update_messages, and also maybe printed (already)
+ # some messages about ff checks
my ($status, $message, $current, $ffq_prev) = ffq_prev_branchinfo();
return ($status, $message) unless $status eq 'branch';
}
fproblems_maybe_bail();
- runcmd @git, qw(update-ref -m), "record current head for preservation",
- $ffq_prev, $currentval, $git_null_obj;
- print "Recorded current head for preservation\n" or die $!;
- return ('written', undef);
+
+ push @deferred_updates, "update $ffq_prev $currentval $git_null_obj";
+ push @deferred_update_messages, "Recorded current head for preservation";
+ return ('deferred', undef);
+}
+
+sub record_ffq_auto () {
+ my ($status, $message) = record_ffq_prev_deferred();
+ if ($status eq 'deferred' || $status eq 'exists') {
+ } else {
+ fproblem $status, "could not record ffq-prev: $message";
+ fproblems_maybe_bail();
+ }
}
sub cmd_new_upstream_v0 () {
my %pieces;
- badusage "need NEW-VERSION UPS-COMMITTISH" unless @ARGV >= 2;
+ badusage "need NEW-VERSION [UPS-COMMITTISH]" unless @ARGV >= 1;
# parse args - low commitment
my $new_version = (new Dpkg::Version scalar(shift @ARGV), check => 1);
my $new_upstream_version = $new_version->version();
- my $new_upstream = git_rev_parse shift @ARGV;
+ my $new_upstream = git_rev_parse (shift @ARGV // 'upstream');
+
+ record_ffq_auto();
my $piece = sub {
my ($n, @x) = @_; # may be ''
# now we need to investigate the branch this generates the
# laundered version but we don't switch to it yet
my $old_head = get_head();
- my ($old_laundered_tip,$old_bw,$old_upstream_update) = walk $old_head;
+ my ($old_laundered_tip,$old_bw,$old_anchor) = walk $old_head;
my $old_bw_cl = classify $old_bw;
- my $old_upstream_update_cl = classify $old_upstream_update;
- confess unless $old_upstream_update_cl->{OrigParents};
- my $old_upstream = parsecommit
- $old_upstream_update_cl->{OrigParents}[0]{CommitId};
-
- $piece->('', Old => $old_upstream->{CommitId});
+ my $old_anchor_cl = classify $old_anchor;
+ my $old_upstream;
+ if (!$old_anchor_cl->{OrigParents}) {
+ fproblem 'anchor-treated',
+ 'old anchor is recognised due to --anchor, cannot check upstream';
+ } else {
+ $old_upstream = parsecommit
+ $old_anchor_cl->{OrigParents}[0]{CommitId};
+ $piece->('', Old => $old_upstream->{CommitId});
+ }
- if ($old_upstream->{Msg} =~ m{^\[git-debrebase }m) {
+ if ($old_upstream && $old_upstream->{Msg} =~ m{^\[git-debrebase }m) {
if ($old_upstream->{Msg} =~
m{^\[git-debrebase upstream-combine \.((?: $extra_orig_namepart_re)+)\:.*\]$}m
) {
}
foreach my $pc (values %pieces) {
- if (!$pc->{Old}) {
+ if (!$old_upstream) {
+ # we have complained already
+ } elsif (!$pc->{Old}) {
fproblem 'upstream-new-piece',
"introducing upstream piece \`$pc->{Name}'";
} elsif (!$pc->{New}) {
sub cmd_record_ffq_prev () {
badusage "no arguments allowed" if @ARGV;
- my ($status, $msg) = record_ffq_prev();
+ my ($status, $msg) = record_ffq_prev_deferred();
if ($status eq 'exists' && $opt_noop_ok) {
print "Previous head already recorded\n" or die $!;
- } elsif ($status eq 'written') {
+ } elsif ($status eq 'deferred') {
+ run_deferred_updates 'record-ffq-prev';
} else {
fail "Could not preserve: $msg";
}
if (!$prev) {
fail "No ffq-prev to stitch." unless $opt_noop_ok;
}
- fresh_workarea();
+ push @deferred_updates, "delete $ffq_prev $prev";
+
my $old_head = get_head();
+ if (is_fast_fwd $old_head, $prev) {
+ my $differs = get_differs $old_head, $prev;
+ unless ($differs & ~D_PAT_ADD) {
+ # ffq-prev is ahead of us, and the only tree changes it has
+ # are possibly addition of things in debian/patches/.
+ # Just wind forwards rather than making a pointless pseudomerge.
+ update_head_checkout $old_head, $prev, "stitch (fast forward)";
+ return;
+ }
+ }
+ fresh_workarea();
my $new_head = make_commit [ $old_head, $ffq_prev ], [
'Declare fast forward / record previous work',
"[git-debrebase pseudomerge: stitch$prose]",
];
- my @upd_cmd = (@git, qw(update-ref --stdin));
- debugcmd '>|', @upd_cmd;
- open U, "|-", @upd_cmd or die $!;
- my $u = <<END;
-update HEAD $new_head $old_head
-delete $ffq_prev $prev
-END
- printdebug ">= ", $_, "\n" foreach split /\n/, $u;
- print U $u;
- printdebug ">\$\n";
- close U or failedcmd @upd_cmd;
+ update_head $old_head, $new_head, "stitch";
}
sub cmd_convert_from_gbp () {
];
};
if (defined $ffq) {
- runcmd @git, qw(update-ref -m),
- "debrebase: converting corresponding main branch to gbp format",
- $ffq, $git_null_obj;
+ push @deferred_updates, "delete $ffq";
}
update_head_checkout $head, $out, "convert to gbp (v0)";
print <<END or die $!;
GetOptions("D+" => \$debuglevel,
'noop-ok', => \$opt_noop_ok,
'f=s' => \@fproblem_force_opts,
+ 'anchor=s' => \@opt_anchors,
'force!') or die badusage "bad options\n";
initdebug('git-debrebase ');
enabledebug if $debuglevel;
$rd = fresh_playground "$playprefix/misc";
+@opt_anchors = map { git_rev_parse $_ } @opt_anchors;
+
if (!@ARGV || $ARGV[0] =~ m{^-}) {
defaultcmd_rebase();
} else {