X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=b015e885a2bb195cec1418c0123ae366cd5e41b4;hp=a2a14ca654eaaef818a7081f773d4eac5ba10ed1;hb=9d98fd69e8abee17a59d27023e87215d55eb9385;hpb=32302c566f46426687ae9dcccec2f16ddeb56e4b

diff --git a/git-debrebase b/git-debrebase
index a2a14ca6..b015e885 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -114,6 +114,7 @@ our $rd;
 our $workarea;
 
 our @git = qw(git);
+our @dgit = qw(dgit);
 
 sub in_workarea ($) {
     my ($sub) = @_;
@@ -254,6 +255,20 @@ sub read_tree_subdir ($$) {
     runcmd @git, qw(read-tree), "--prefix=$subdir/", $new_tree_object;
 }
 
+sub read_tree_debian ($) {
+    my ($treeish) = @_;
+    read_tree_subdir 'debian', "$treeish:debian";
+    rm_subdir_cached 'debian/patches';
+}
+
+sub read_tree_upstream ($;$) {
+    my ($treeish, $keep_patches) = @_;
+    my $save = cmdoutput @git, qw(write-tree --prefix=debian/);
+    runcmd @git, qw(read-tree), $treeish;
+    read_tree_subdir 'debian', $save;
+    rm_subdir_cached 'debian/patches' unless $keep_patches;
+};
+
 sub make_commit ($$) {
     my ($parents, $message_paras) = @_;
     my $tree = cmdoutput @git, qw(write-tree);
@@ -309,6 +324,197 @@ sub any_snags () {
     return $snags_forced || $snags_tripped;
 }
 
+sub gbp_pq_export ($$$) {
+    my ($bname, $base, $tip) = @_;
+    # must be run in a workarea.  $bname and patch-queue/$bname
+    # ought not to exist.  Leaves you on patch-queue/$bname with
+    # the patches staged but not committed.
+    runcmd @git, qw(checkout -q -b), $bname, $base;
+    runcmd @git, qw(checkout -q -b), "patch-queue/$bname", $tip;
+    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);
+}
+
+
+# xxx allow merge separately from laundering
+#
+# xxx docs highlight forbidden things
+# xxx docs list allowable things ?
+# xxx docs explicitly forbid some rebase
+#
+# xxx provide a way for the user to help
+# xxx (eg, provide wreckage provide way to continue)
+
+# later/rework?
+#  use git-format-patch?
+#  our own patch identification algorithm?
+#  this is an alternative strategy
+
+sub merge_series ($$;@) {
+    my ($newbase, $base_q, @input_qs) = @_;
+    # $base_q{SeriesBase}  $input_qs[]{SeriesBase}
+    # $base_q{SeriesTip}   $input_qs[]{SeriesTip}
+    # ^ specifies several patch series (currently we only support exactly 2)
+    # return value is a commit which is the result of
+    # merging the two versions of the same topic branch
+    #   $input_q[0] and $input_q[1]
+    # with respect to the old version
+    #   $base_q
+    # all onto $newbase.
+
+    # Creates, in *_q, a key MR for its private use
+
+    $input_qs[$_]{MR}{S} = $_ foreach (0..$#input_qs);
+    $base_q->{MR}{S} = 'base';
+
+    my %prereq;
+    # $prereq{<patch filename>}{<possible prereq}{<S>} = 1 or absent
+    # $prereq{<patch filename>}{<possible prereq}  exists or not (later)
+    # $prereq{<patch filename>}               exists or not (even later)
+
+    my $result;
+
+    local $workarea = fresh_playground "$playprefix/merge";
+    my $seriesfile = "debian/patches/series";
+    in_workarea sub {
+	playtree_setup();
+	foreach my $q ($base_q, reverse @input_qs) {
+	    my $s = $q->{MR}{S};
+	    gbp_pq_export "p-$s", $q->{SeriesBase}, $q->{SeriesTip};
+	    if (open S, $seriesfile) {
+		my @earlier;
+		while (my $patch = <S>) {
+		    chomp $patch or die $!;
+		    foreach my $earlier (@earlier) {
+			$prereq{$patch}{$earlier}{$s}++ and die;
+		    }
+		    push @earlier, $patch;
+		    stat "debian/patches/$patch" or die "$patch ?";
+		}
+		S->error and die "$seriesfile $!";
+		close S;
+	    } else {
+		die "$seriesfile $!" unless $!==ENOENT;
+	    }
+	    read_tree_upstream $newbase, 1;
+	    my $pec = make_commit [ grep { defined } $base_q->{MR}{PEC} ], [
+                "Convert $s to patch queue for merging",
+                "[git-debrebase merge-innards patch-queue import:".
+                " $q->{SeriesTip}]"
+            ];
+	    runcmd @git, qw(rm -q --cached), $seriesfile;
+	    $pec = make_commit [ $pec ], [
+                "Drop series file from $s to avoid merge trouble",
+                "[git-debrebase merge-innards patch-queue prep:".
+                " $q->{SeriesTip}]"
+            ];
+            runcmd @git, qw(reset -q --hard), $pec;
+	    $q->{MR}{PEC} = $pec;
+	}
+	# now, because of reverse, we are on $input_q->{MR}{OQC}
+	runcmd @git, qw(checkout -q -b merge);
+	my @mergecmd = (@git, qw(merge --quiet --no-edit), "p-1");
+	debugcmd '+', @mergecmd;
+	$!=0; $?=-1;
+	if (system @mergecmd) {
+	    failedcmd @mergecmd;
+	}
+
+	# We need to construct a new series file
+	# Firstly, resolve prereq
+	foreach my $f (keys %prereq) {
+	    if (!stat_exists "debian/patches/$f") {
+		# git merge deleted it; that's how we tell it's not wanted
+		delete $prereq{$f};
+		next;
+	    }
+	    foreach my $g (keys %{ $prereq{$f} }) {
+		my $gfp = $prereq{$f}{$g};
+		next unless
+		    # want to keep it
+		    !!$gfp->{0} == !!$gfp->{1}
+		    ? $gfp->{0}
+		    : !$gfp->{base}
+		    ;
+		delete $prereq{$f}{$g};
+	    }
+	}
+
+	my $unsat = sub {
+	    my ($f) = @_;
+	    return scalar keys %{ $prereq{$f} };
+	};
+
+	my $nodate = time + 1;
+	my %authordate;
+	# $authordate{<patch filename>};
+	my $authordate = sub {
+	    my ($f) = @_;
+	    $authordate{$f} //= do {
+		open PF, "<", "debian/patches/$f" or die "$f $!";
+		while (<PF>) {
+		    return $nodate if m/^$/;
+		    last if s{^Date: }{};
+		}
+		chomp;
+		return cmdoutput qw(date +%s -d), $_;
+	    };
+	};
+
+	open NS, '>', $seriesfile or die $!;
+
+	while (keys %prereq) {
+	    my $best;
+	    foreach my $try (sort keys %prereq) {
+		if ($best) {
+		    next if (
+			     $unsat->($try) <=> $unsat->($best) or
+			     $authordate->($try) <=> $authordate->($best) or
+			     $try cmp $best
+			    ) >= 0;
+		}
+		$best = $try;
+	    }
+	    print NS "$best\n" or die $!;
+	    delete $prereq{$best};
+	    foreach my $gp (values %prereq) {
+		delete $gp->{$best};
+	    }
+	}
+
+	runcmd @git, qw(add), $seriesfile;
+	runcmd @git, qw(commit --quiet -m), 'Merged series';
+
+	runcmd qw(gbp pq import);
+
+	# OK now we are on patch-queue/merge, and we need to rebase
+	# onto the intended parent and drop the patches from each one
+
+	my $build = $newbase;
+	my @lcmd = (@git, qw(rev-list --reverse merge..patch-queue/merge));
+	foreach my $c (grep /./, split /\n/, cmdoutput @lcmd) {
+	    my $commit = git_cat_file $c, 'commit';
+	    read_tree_upstream $c;
+	    my $tree = cmdoutput @git, qw(write-tree);
+	    $commit =~ s{^parent (\S+)$}{parent $build}m or confess;
+	    $commit =~ s{^tree (\S+)$}{tree $tree}m      or confess;
+	    open C, ">", "../mcommit" or die $!;
+	    print C $commit or die $!;
+	    close C or die $!;
+	    $build = cmdoutput @git, qw(hash-object -w -t commit ../mcommit);
+	}
+	$result = $build;
+	runcmd @git, qw(update-ref refs/heads/result), $result;
+    };
+    printdebug "merge_series returns $result\n";
+    return $result;
+}
+
 # classify returns an info hash like this
 #   CommitId => $objid
 #   Hdr => # commit headers, including 1 final newline
@@ -566,7 +772,23 @@ sub classify ($) {
 			   OrigParents => \@orig_ps);
     }
 
-    return $unknown->("complex merge");
+    if (@p == 2 and
+	$r->{Msg} =~ m{^\[git-debrebase merged-breakwater.*\]$}m) {
+	# xxx ^ metadata tag needs adding to (5)
+	return $classify->("MergedBreakwaters");
+    }
+    if ($r->{Msg} =~ m{^\[(git-debrebase|dgit)[: ].*\]$}m) {
+	return $unknown->("unknown kind of merge from $1");
+    }
+    if (@p > 2) {
+	return $unknown->("octopus merge");
+    }
+
+    if (!$ENV{GIT_DEBREBASE_EXPERIMENTAL_MERGE}) {
+	return $unknown->("general two-parent merge");
+    }
+
+    return $classify->("VanillaMerge");
 }
 
 sub keycommits ($;$$$$) {
@@ -649,6 +871,10 @@ sub keycommits ($;$$$$) {
 		     " ($head)");
 		return (undef,undef);
 	    }
+	} elsif ($ty eq 'VanillaMerge') {
+	    $x->($trouble, 'vanillamerge',
+		 "found vanilla merge"," ($head)");
+	    return (undef,undef);
 	} else {
 	    $x->($fatal, 'unprocessable',
 		 "found unprocessable commit, cannot cope: $cl->{Why}",
@@ -660,14 +886,15 @@ sub keycommits ($;$$$$) {
     return ($anchor, $breakwater);
 }
 
-sub walk ($;$$);
-sub walk ($;$$) {
+sub walk ($;$$$);
+sub walk ($;$$$) {
     my ($input,
-	$nogenerate,$report) = @_;
+	$nogenerate,$report, $report_lprefix) = @_;
     # => ($tip, $breakwater_tip, $last_anchor)
     # (or nothing, if $nogenerate)
 
     printdebug "*** WALK $input ".($nogenerate//0)." ".($report//'-')."\n";
+    $report_lprefix //= '';
 
     # go through commits backwards
     # we generate two lists of commits to apply:
@@ -699,7 +926,7 @@ sub walk ($;$$) {
 
     my $prline = sub {
 	return unless $report;
-	print $report $prdelim, @_;
+	print $report $prdelim, $report_lprefix, @_;
 	$prdelim = "\n";
     };
 
@@ -710,8 +937,8 @@ sub walk ($;$$) {
 	if ($nogenerate) {
 	    return (undef,undef);
 	}
-	fail "found unprocessable commit, cannot cope:".
-	    (defined $cl->{Why} ? "; $cl->{Why}": '').
+	fail "found unprocessable commit, cannot cope".
+	    (defined $cl->{Why} ? "; $cl->{Why}:": ':').
 	    " (commit $cur) (d.".
 	    (join ' ', map { sprintf "%#x", $_->{Differs} }
 	     @{ $cl->{Parents} }).
@@ -728,6 +955,10 @@ sub walk ($;$$) {
 	no warnings qw(exiting); last;
     };
 
+    my $nomerge = sub {
+	fail "something useful about failed merge attempt @_ xxx".Dumper($cl);
+    };
+
     my $last_anchor;
 
     for (;;) {
@@ -831,6 +1062,139 @@ sub walk ($;$$) {
 		return $bomb->();
 	    }
 	    die "$ty ?";
+	} elsif ($ty eq 'VanillaMerge' or $ty eq 'MergedBreakwaters') {
+	    # xxx need to handle ffq if one side was unstitched
+	    # wait both of them may be!
+	    my $ok=1;
+	    my $best_anchor;
+	    # We expect to find a dominating anchor amongst the
+	    # inputs' anchors.  That will be the new anchor.
+	    #
+	    # More complicated is finding a merge base for the
+	    # breakwaters.  We need a merge base that is a breakwater
+	    # commit.  The ancestors of breakwater commits are more
+	    # breakwater commits and possibly upstream commits and the
+	    # ancestors of those upstream.  Upstreams might have
+	    # arbitrary ancestors.  But any upstream commit U is
+	    # either included in both anchors, in which case the
+	    # earlier anchor is a better merge base than any of U's
+	    # ancestors; or U is not included in the older anchor, in
+	    # which case U is not an ancestor of the vanilla merge at
+	    # all.  So no upstream commit, nor any ancestor thereof,
+	    # is a best merge base.  As for non-breakwater Debian
+	    # commits: these are never ancestors of any breakwater.
+	    #
+	    # So any best merge base as found by git-merge-base
+	    # is a suitable breakwater anchor.  Usually there will
+	    # be only one.
+
+	    printdebug "*** MERGE\n";
+
+	    # xxx avoid calling walk without nogenerate when
+	    # we have a MergedBreakwater; instead call keycommits ?
+
+	    my @bwbcmd = (@git, qw(merge-base));
+	    my @ibcmd = (@git, qw(merge-base --all));
+	    my $might_be_in_bw = 1;
+
+	    my $ps = $cl->{Parents};
+
+	    foreach my $p (@$ps) {
+		$prline->(" VanillaMerge ".$p->{Ix});
+		$prprdelim->();
+		my ($ptip, $pbw, $panchor) =
+		    walk $p->{CommitId}, 0, $report,
+		         $report_lprefix.'  ';
+		$p->{Laundered} = $p->{SeriesTip} = $ptip;
+		$p->{Breakwater} = $p->{SeriesBase} = $pbw;
+		$p->{Anchor} = $panchor;
+
+		$best_anchor = $panchor if
+		    !defined $best_anchor or
+		    is_fast_fwd $best_anchor, $panchor;
+
+		printdebug " MERGE BA best=".($best_anchor//'-').
+		    " p=$panchor\n";
+	    }
+
+	    foreach my $p (@$ps) {
+		$prline->(" VanillaMerge ".$p->{Ix});
+		if (!is_fast_fwd $p->{Anchor}, $best_anchor) {
+		    $nomerge->('DivergentAnchor');
+		} elsif ($p->{Anchor} eq $best_anchor) {
+		    print $report " SameAnchor" if $report;
+		} else {
+		    print $report " SupersededAnchor" if $report;
+		}
+		if ($p->{Breakwater} eq $p->{CommitId}) {
+		    # this parent commit was its own breakwater,
+		    # ie it is part of the breakwater
+		    print $report " Breakwater" if $report;
+		} else {
+		    $might_be_in_bw = 0;
+		}
+		push @bwbcmd, $p->{Breakwater};
+		push @ibcmd, $p->{CommitId};
+	    }
+
+	    if ($ok && $might_be_in_bw) {
+		$prline->(" VanillaMerge MergedBreakwaters");
+		$last_anchor = $best_anchor;
+		$build_start->('MergedBreakwaters', $cur);
+	    }
+
+	    $nomerge->("alleged merged-breakwater is not a breakwater")
+		unless $ty eq 'VanillaMerge';
+
+	    my $bwb = cmdoutput @bwbcmd;
+
+	    # OK, now we have a breakwater base, but we need the merge
+	    # base for the interchange branch because we need the delta
+	    # queue.
+	    #
+	    # This a the best merge base of our inputs which has the
+	    # breakwater merge base as an ancestor.
+
+	    my @ibs =
+		grep { is_fast_fwd $bwb, $_ }
+		grep /./,
+		split /\n/,
+		cmdoutput @ibcmd;
+	    my ($ib) = @ibs
+		or $nomerge->("no suitable interchange merge base");
+
+	    $prline->("  VanillaMerge Base");
+	    $prprdelim->();
+	    my ($btip, $bbw, $banchor) =
+		walk $ib, 0, $report, $report_lprefix.'  ';
+
+	    my $ibinfo = { SeriesTip => $btip,
+			   SeriesBase => $bbw,
+			   Anchor => $banchor };
+	    $bbw eq $bwb
+		or $nomerge->("interchange merge-base ($ib)'s".
+			      " breakwater ($bbw)".
+			      " != breakwaters' merge-base ($bwb)");
+	    grep { $_->{Anchor} eq $ibinfo->{Anchor} } @$ps
+		 or $nomerge->("interchange merge-base ($ib)'s".
+			       " anchor ($ibinfo->{SeriesBase})".
+			       " != any merge input's anchor (".
+			       (join ' ', map { $_->{Anchor} } @$ps).
+			       ")");
+
+
+	    $cl->{MergeInterchangeBaseInfo} = $ibinfo;
+	    $cl->{MergeBestAnchor} = $best_anchor;
+	    push @brw_cl, {
+                %$cl,
+                SpecialMethod => 'MergeCreateMergedBreakwaters',
+                $xmsg->('construct merged breakwater from vanilla merge'),
+            };
+	    push @upp_cl, {
+                %$cl,
+                SpecialMethod => 'MergeMergeSeries',
+            };
+	    $build_start->('MergeBreakwaters', $cur);
         } else {
             printdebug "*** WALK BOMB unrecognised\n";
 	    return $bomb->();
@@ -849,17 +1213,6 @@ sub walk ($;$$) {
 
     my $rewriting = 0;
 
-    my $read_tree_debian = sub {
-	my ($treeish) = @_;
-	read_tree_subdir 'debian', "$treeish:debian";
-        rm_subdir_cached 'debian/patches';
-    };
-    my $read_tree_upstream = sub {
-	my ($treeish) = @_;
-	runcmd @git, qw(read-tree), $treeish;
-	$read_tree_debian->($build);
-    };
-
     $#upp_cl = $upp_limit if defined $upp_limit;
  
     my $committer_authline = calculate_committer_authline();
@@ -885,9 +1238,9 @@ sub walk ($;$$) {
 	    printdebug "WALK BUILD ".($cltree//'undef').
 		" $method (rewriting=$rewriting)\n";
 	    if ($method eq 'Debian') {
-		$read_tree_debian->($cltree);
+		read_tree_debian($cltree);
 	    } elsif ($method eq 'Upstream') {
-		$read_tree_upstream->($cltree);
+		read_tree_upstream($cltree);
 	    } elsif ($method eq 'StartRewrite') {
 		$rewriting = 1;
 		next;
@@ -895,13 +1248,30 @@ sub walk ($;$$) {
 		$breakwater = $build;
 		next;
 	    } elsif ($method eq 'DgitImportDebianUpdate') {
-		$read_tree_debian->($cltree);
+		read_tree_debian($cltree);
 	    } elsif ($method eq 'DgitImportUpstreamUpdate') {
  		confess unless $rewriting;
 		my $differs = (get_differs $build, $cltree);
 		next unless $differs & D_UPS;
-		$read_tree_upstream->($cltree);
+		read_tree_upstream($cltree);
 		push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} };
+	    } elsif ($method eq 'MergeCreateMergedBreakwaters') {
+		print "Found a general merge, will try to tidy it up.\n";
+		$rewriting = 1;
+		read_tree_upstream($cl->{MergeBestAnchor});
+		read_tree_upstream($cl->{MergeBestAnchor});
+		read_tree_debian($cltree);
+		@parents = map { $_->{Breakwater} } @{ $cl->{Parents} };
+	    } elsif ($method eq 'MergeMergeSeries') {
+		print "Running merge resolution for $cl->{CommitId}...\n";
+		$build = merge_series
+		    $build,
+		    $cl->{MergeInterchangeBaseInfo},
+		    @{ $cl->{Parents} };
+		$last_anchor = $cl->{MergeBestAnchor};
+		# xxx need to check the tree somehow
+		print "Merge resolution successful.\n";
+		next;
 	    } else {
 		confess "$method ?";
 	    }
@@ -974,6 +1344,18 @@ sub update_head_postlaunder ($$$) {
     runcmd @git, qw(rm --quiet --ignore-unmatch -rf debian/patches);
 }
 
+sub currently_rebasing() {
+    foreach (qw(rebase-merge rebase-apply)) {
+	return 1 if stat_exists "$maindir_gitdir/$_";
+    }
+    return 0;
+}
+
+sub bail_if_rebasing() {
+    fail "you are in the middle of a git-rebase already"
+	if currently_rebasing();
+}
+
 sub do_launder_head ($) {
     my ($reflogmsg) = @_;
     my $old = get_head();
@@ -1113,6 +1495,7 @@ sub record_ffq_prev_deferred () {
     # if "deferred", will have added something about that to
     #   @deferred_update_messages, and also maybe printed (already)
     #   some messages about ff checks
+    bail_if_rebasing();
     my $currentval = get_head();
 
     my ($status,$message, $ffq_prev,$gdrlast) = ffq_check $currentval;
@@ -1122,7 +1505,7 @@ sub record_ffq_prev_deferred () {
 
     push @deferred_updates, "update $ffq_prev $currentval $git_null_obj";
     push @deferred_updates, "delete $gdrlast";
-    push @deferred_update_messages, "Recorded current head for preservation";
+    push @deferred_update_messages, "Recorded previous head for preservation";
     return ('deferred', undef);
 }
 
@@ -1136,6 +1519,7 @@ sub record_ffq_auto () {
 }
 
 sub ffq_prev_info () {
+    bail_if_rebasing();
     # => ($ffq_prev, $gdrlast, $ffq_prev_commitish)
     my ($status, $message, $current, $ffq_prev, $gdrlast)
 	= ffq_prev_branchinfo();
@@ -1546,6 +1930,7 @@ sub cmd_status () {
 	    print "  not git-debrebase (diverged since last stitch)\n"
 	}
     }
+    print "you are currently rebasing\n" if currently_rebasing();
 }
 
 sub cmd_stitch () {
@@ -1576,6 +1961,24 @@ sub cmd_conclude () {
     do_stitch 'quick';
 }
 
+sub cmd_scrap () {
+    if (currently_rebasing()) {
+	runcmd @git, qw(rebase --abort);
+    }
+    my ($ffq_prev, $gdrlast, $ffq_prev_commitish) = ffq_prev_info();
+    if (!$ffq_prev_commitish) {
+	fail "No ongoing git-debrebase session." unless $opt_noop_ok;
+	finish 0;
+    }
+    my $scrapping_head = get_head();
+    badusage "no arguments allowed" if @ARGV;
+    push @deferred_updates,
+	"update $gdrlast $ffq_prev_commitish $git_null_obj",
+	"update $ffq_prev $git_null_obj $ffq_prev_commitish";
+    snags_maybe_bail();
+    update_head_checkout $scrapping_head, $ffq_prev_commitish, "scrap";
+}
+
 sub make_patches_staged ($) {
     my ($head) = @_;
     # Produces the patches that would result from $head if it were
@@ -1583,15 +1986,7 @@ sub make_patches_staged ($) {
     my ($secret_head, $secret_bw, $last_anchor) = walk $head;
     fresh_workarea();
     in_workarea sub {
-	runcmd @git, qw(checkout -q -b bw), $secret_bw;
-	runcmd @git, qw(checkout -q -b patch-queue/bw), $secret_head;
-	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);
+	gbp_pq_export 'bw', $secret_bw, $secret_head;
     };
 }
 
@@ -1617,6 +2012,7 @@ sub cmd_make_patches () {
     getoptions("make-patches",
 	       'quiet-would-amend!', \$opt_quiet_would_amend);
     badusage "no arguments allowed" if @ARGV;
+    bail_if_rebasing();
     my $old_head = get_head();
     my $new = make_patches $old_head;
     my $d = get_differs $old_head, $new;
@@ -1787,6 +2183,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 <<END;
+$us: Branch already seems to be in git-debrebase format!
+$us: --always-convert-anyway would do the conversion operation anyway
+$us: but is probably a bad idea.  Probably, you wanted to do nothing.
+END
+	    fail "Branch already in git-debrebase format." unless $opt_noop_ok;
+	    finish 0;
+	}
+    }
+
+    snags_maybe_bail_early();
+
+    my $version = upstreamversion $clogp->{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 [], [ <<END, <<END,
+Import effective orig tree for upstream version $version
+END
+This includes the contents of the .orig(s), minus any debian/ directory.
+
+[git-debrebase import-from-dgit-view upstream-import-convert: $version]
+END
+						    ];
+		    push @upstreams, { 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 <<END;
+Could not find or construct a suitable upstream commit.
+Rerun adding --diagnose after convert-from-dgit-view, or pass a
+upstream commmit explicitly or provide suitable origs.
+END
+    }
+
+    printf STDERR "Yes, will base new branch on %s\n", $result->{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;
@@ -1842,6 +2426,7 @@ getoptions_main
 	   '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) = @_;