git-debrebase: test suite: spot any pointless pseudomerges

[dgit.git] / git-debrebase

diff --git a/git-debrebase b/git-debrebase
index b9f36ca5d3cab9a146d9bc1d247f62626c10e984..c32f257a5f0543d1d73c5c477aedb4ddd01aecf9 100755 (executable)
--- a/git-debrebase
+++ b/git-debrebase
@@ -29,8 +29,8 @@
 #    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>]
@@ -402,13 +402,36 @@ sub classify ($) {
        return $r;
     };
 
-    my $claims_to_be_anchor =
-       $r->{Msg} =~ m{^\[git-debrebase anchor.*\]$}m;
+    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;
+
+    if ($r->{Msg} =~ m{^\[git-debrebase anchor.*\]$}m) {
+       # multi-orig upstreams are represented with an anchor merge
+       # from a single upstream commit which combines the orig tarballs
+
+       my $badanchor = sub { $unknown->("git-debrebase \`anchor' but @_"); };
+       @p == 2 or return $badanchor->("has other than two parents");
+       $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
+       # already an easy rune to look for debian/ history anyway (git log
+       # debian/) so debian breakwater branch should be 1st parent; that
+       # way also there's also an easy rune to look for the upstream
+       # patches (--topo-order).
+
+       $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");
+
+       return $classify->(qw(Anchor),
+                          OrigParents => [ $p[1] ]);
+    }
 
     if (@p == 1) {
-       if ($claims_to_be_anchor) {
-           return $unknown->("single-parent git-debrebase anchor \`merge'");
-       }
        my $d = $r->{Parents}[0]{Differs};
        if ($d == D_PAT_ADD) {
            return $classify->(qw(AddPatches));
@@ -441,11 +464,7 @@ sub classify ($) {
        return $unknown->("origin commit");
     }
 
-    my @identical = grep { !$_->{Differs} } @p;
-    if (@p == 2 && @identical == 1 && !$claims_to_be_anchor
-       # anchor merges can look like pseudomerges, if they are
-       # "declare" commits (ie, there are no upstream changes)
-       ) {
+    if (@p == 2 && @identical == 1) {
        my @overwritten = grep { $_->{Differs} } @p;
        confess "internal error $objid ?" unless @overwritten==1;
        return $classify->(qw(Pseudomerge),
@@ -487,38 +506,6 @@ sub classify ($) {
                           OrigParents => \@orig_ps);
     }
 
-    my ($stype, $series) = git_cat_file "$t:debian/patches/series";
-    my $haspatches = $stype ne 'missing' && $series =~ m/^\s*[^#\n\t ]/m;
-
-    # How to decide about l/r ordering of anchors ?  git
-    # --topo-order prefers to expand 2nd parent first.  There's
-    # already an easy rune to look for debian/ history anyway (git log
-    # debian/) so debian breakwater branch should be 1st parent; that
-    # 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.
-
-    foreach my $prevbrw (qw(0 1)) {
-       if (@p == 2 &&
-           !$haspatches &&
-           !$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] ]);
-       }
-    }
-
-    # multi-orig upstreams are represented with an anchor merge
-    # from a single upstream commit which combines the orig tarballs
-
     return $unknown->("complex merge");
 }
 
@@ -870,8 +857,8 @@ sub update_head_postlaunder ($$$) {
     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';