diff --color-moved=zebra: be stricter with color alternation

Currently when using --color-moved=zebra the color of moved blocks
depends on the number of lines separating them. This means that adding
an odd number of unmoved lines between blocks that are already separated
by one or more unmoved lines will change the color of subsequent moved
blocks. This does not make much sense as the blocks were already
separated by unmoved lines and causes problems when adding lines to test
cases.

Fix this by only using the alternate colors for adjacent moved blocks.

Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
Reviewed-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/diff.c b/diff.c
index 8c0778ddb797eda0b66f7392e3071d593e173868..b648f67413d31766332eece7ebec522ab0d9b237 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -1040,14 +1040,17 @@ static int shrink_potential_moved_blocks(struct moved_block *pmb,
  * The last block consists of the (n - block_length)'th line up to but not
  * including the nth line.
  *
  * The last block consists of the (n - block_length)'th line up to but not
  * including the nth line.
  *

+ * Returns 0 if the last block is empty or is unset by this function, non zero
+ * otherwise.
+ *

  * NEEDSWORK: This uses the same heuristic as blame_entry_score() in blame.c.
  * Think of a way to unify them.
  */
  * NEEDSWORK: This uses the same heuristic as blame_entry_score() in blame.c.
  * Think of a way to unify them.
  */

-static void adjust_last_block(struct diff_options *o, int n, int block_length)
+static int adjust_last_block(struct diff_options *o, int n, int block_length)

 {
        int i, alnum_count = 0;
        if (o->color_moved == COLOR_MOVED_PLAIN)
 {
        int i, alnum_count = 0;
        if (o->color_moved == COLOR_MOVED_PLAIN)

-               return;
+               return block_length;

        for (i = 1; i < block_length + 1; i++) {
                const char *c = o->emitted_symbols->buf[n - i].line;
                for (; *c; c++) {
        for (i = 1; i < block_length + 1; i++) {
                const char *c = o->emitted_symbols->buf[n - i].line;
                for (; *c; c++) {


@@ -1055,11 +1058,12 @@ static void adjust_last_block(struct diff_options *o, int n, int block_length)
                                continue;
                        alnum_count++;
                        if (alnum_count >= COLOR_MOVED_MIN_ALNUM_COUNT)
                                continue;
                        alnum_count++;
                        if (alnum_count >= COLOR_MOVED_MIN_ALNUM_COUNT)

-                               return;
+                               return 1;

                }
        }
        for (i = 1; i < block_length + 1; i++)
                o->emitted_symbols->buf[n - i].flags &= ~DIFF_SYMBOL_MOVED_LINE;
                }
        }
        for (i = 1; i < block_length + 1; i++)
                o->emitted_symbols->buf[n - i].flags &= ~DIFF_SYMBOL_MOVED_LINE;

+       return 0;

 }
 
 /* Find blocks of moved code, delegate actual coloring decision to helper */
 }
 
 /* Find blocks of moved code, delegate actual coloring decision to helper */


@@ -1069,7 +1073,7 @@ static void mark_color_as_moved(struct diff_options *o,
 {
        struct moved_block *pmb = NULL; /* potentially moved blocks */
        int pmb_nr = 0, pmb_alloc = 0;
 {
        struct moved_block *pmb = NULL; /* potentially moved blocks */
        int pmb_nr = 0, pmb_alloc = 0;

-       int n, flipped_block = 1, block_length = 0;
+       int n, flipped_block = 0, block_length = 0;

 
 
        for (n = 0; n < o->emitted_symbols->nr; n++) {
 
 
        for (n = 0; n < o->emitted_symbols->nr; n++) {


@@ -1077,6 +1081,7 @@ static void mark_color_as_moved(struct diff_options *o,
                struct moved_entry *key;
                struct moved_entry *match = NULL;
                struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];
                struct moved_entry *key;
                struct moved_entry *match = NULL;
                struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];

+               enum diff_symbol last_symbol = 0;

 
                switch (l->s) {
                case DIFF_SYMBOL_PLUS:
 
                switch (l->s) {
                case DIFF_SYMBOL_PLUS:


@@ -1092,7 +1097,7 @@ static void mark_color_as_moved(struct diff_options *o,
                        free(key);
                        break;
                default:
                        free(key);
                        break;
                default:

-                       flipped_block = 1;
+                       flipped_block = 0;

                }
 
                if (!match) {
                }
 
                if (!match) {


@@ -1103,10 +1108,13 @@ static void mark_color_as_moved(struct diff_options *o,
                                moved_block_clear(&pmb[i]);
                        pmb_nr = 0;
                        block_length = 0;
                                moved_block_clear(&pmb[i]);
                        pmb_nr = 0;
                        block_length = 0;

+                       flipped_block = 0;
+                       last_symbol = l->s;

                        continue;
                }
 
                if (o->color_moved == COLOR_MOVED_PLAIN) {
                        continue;
                }
 
                if (o->color_moved == COLOR_MOVED_PLAIN) {

+                       last_symbol = l->s;

                        l->flags |= DIFF_SYMBOL_MOVED_LINE;
                        continue;
                }
                        l->flags |= DIFF_SYMBOL_MOVED_LINE;
                        continue;
                }


@@ -1137,19 +1145,22 @@ static void mark_color_as_moved(struct diff_options *o,
                                }
                        }
 
                                }
                        }
 

-                       flipped_block = (flipped_block + 1) % 2;
+                       if (adjust_last_block(o, n, block_length) &&
+                           pmb_nr && last_symbol != l->s)
+                               flipped_block = (flipped_block + 1) % 2;
+                       else
+                               flipped_block = 0;

 
 

-                       adjust_last_block(o, n, block_length);

                        block_length = 0;
                }
 
                if (pmb_nr) {
                        block_length++;
                        block_length = 0;
                }
 
                if (pmb_nr) {
                        block_length++;

-

                        l->flags |= DIFF_SYMBOL_MOVED_LINE;
                        if (flipped_block && o->color_moved != COLOR_MOVED_BLOCKS)
                                l->flags |= DIFF_SYMBOL_MOVED_LINE_ALT;
                }
                        l->flags |= DIFF_SYMBOL_MOVED_LINE;
                        if (flipped_block && o->color_moved != COLOR_MOVED_BLOCKS)
                                l->flags |= DIFF_SYMBOL_MOVED_LINE_ALT;
                }

+               last_symbol = l->s;

        }
        adjust_last_block(o, n, block_length);
 
        }
        adjust_last_block(o, n, block_length);
 

diff --git a/t/t4015-diff-whitespace.sh b/t/t4015-diff-whitespace.sh
index eee81a1987984105e5e16e98649f73bf36597c7c..fe8a2ab06e041373df616f251c5fe73835c0b0e0 100755 (executable)
--- a/t/t4015-diff-whitespace.sh
+++ b/t/t4015-diff-whitespace.sh
@@ -1802,14 +1802,14 @@ test_expect_success 'only move detection ignores white spaces' '
        <BOLD;MAGENTA>-a long line to exceed per-line minimum<RESET>
        <BOLD;MAGENTA>-another long line to exceed per-line minimum<RESET>
        <RED>-original file<RESET>
        <BOLD;MAGENTA>-a long line to exceed per-line minimum<RESET>
        <BOLD;MAGENTA>-another long line to exceed per-line minimum<RESET>
        <RED>-original file<RESET>

-       <BOLD;YELLOW>+<RESET>Q<BOLD;YELLOW>a long line to exceed per-line minimum<RESET>
-       <BOLD;YELLOW>+<RESET>Q<BOLD;YELLOW>another long line to exceed per-line minimum<RESET>
+       <BOLD;CYAN>+<RESET>Q<BOLD;CYAN>a long line to exceed per-line minimum<RESET>
+       <BOLD;CYAN>+<RESET>Q<BOLD;CYAN>another long line to exceed per-line minimum<RESET>

        <GREEN>+<RESET><GREEN>new file<RESET>
        EOF
        test_cmp expected actual
 '
 
        <GREEN>+<RESET><GREEN>new file<RESET>
        EOF
        test_cmp expected actual
 '
 

-test_expect_failure 'compare whitespace delta across moved blocks' '
+test_expect_success 'compare whitespace delta across moved blocks' '

 
        git reset --hard &&
        q_to_tab <<-\EOF >text.txt &&
 
        git reset --hard &&
        q_to_tab <<-\EOF >text.txt &&