graph API: Use horizontal lines for more compact graphs

Use horizontal lines instead of long diagonal lines during the
collapsing state of graph rendering.  For example what used to be:

| | | | |
| | | |/
| | |/|
| |/| |
|/| | |
| | | |

is now

| | | | |
| |_|_|/
|/| | |
| | | |

This results in more compact and legible graphs.

Signed-off-by: Allan Caffee <allan.caffee@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/graph.c b/graph.c
index d4571cf31db0ff759689d9c3fa4fa10551be52b7..47bce05c987e04ac7a1617867ff9aab896330c47 100644 (file)
--- a/graph.c
+++ b/graph.c
@@ -47,20 +47,6 @@ static void graph_show_strbuf(struct git_graph *graph, struct strbuf const *sb);
  * - Limit the number of columns, similar to the way gitk does.
  *   If we reach more than a specified number of columns, omit
  *   sections of some columns.
  * - Limit the number of columns, similar to the way gitk does.
  *   If we reach more than a specified number of columns, omit
  *   sections of some columns.

- *
- * - The output during the GRAPH_PRE_COMMIT and GRAPH_COLLAPSING states
- *   could be made more compact by printing horizontal lines, instead of
- *   long diagonal lines.  For example, during collapsing, something like
- *   this:          instead of this:
- *   | | | | |      | | | | |
- *   | |_|_|/       | | | |/
- *   |/| | |        | | |/|
- *   | | | |        | |/| |
- *                  |/| | |
- *                  | | | |
- *
- *   If there are several parallel diagonal lines, they will need to be
- *   replaced with horizontal lines on subsequent rows.

  */
 
 struct column {
  */
 
 struct column {


@@ -982,6 +968,9 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
 {
        int i;
        int *tmp_mapping;
 {
        int i;
        int *tmp_mapping;

+       short used_horizontal = 0;
+       int horizontal_edge = -1;
+       int horizontal_edge_target = -1;

 
        /*
         * Clear out the new_mapping array
 
        /*
         * Clear out the new_mapping array


@@ -1019,6 +1008,23 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
                         * Move to the left by one
                         */
                        graph->new_mapping[i - 1] = target;
                         * Move to the left by one
                         */
                        graph->new_mapping[i - 1] = target;

+                       /*
+                        * If there isn't already an edge moving horizontally
+                        * select this one.
+                        */
+                       if (horizontal_edge == -1) {
+                               int j;
+                               horizontal_edge = i;
+                               horizontal_edge_target = target;
+                               /*
+                                * The variable target is the index of the graph
+                                * column, and therefore target*2+3 is the
+                                * actual screen column of the first horizontal
+                                * line.
+                                */
+                               for (j = (target * 2)+3; j < (i - 2); j += 2)
+                                       graph->new_mapping[j] = target;
+                       }

                } else if (graph->new_mapping[i - 1] == target) {
                        /*
                         * There is a branch line to our left
                } else if (graph->new_mapping[i - 1] == target) {
                        /*
                         * There is a branch line to our left


@@ -1039,10 +1045,21 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
                         *
                         * The space just to the left of this
                         * branch should always be empty.
                         *
                         * The space just to the left of this
                         * branch should always be empty.

+                        *
+                        * The branch to the left of that space
+                        * should be our eventual target.

                         */
                        assert(graph->new_mapping[i - 1] > target);
                        assert(graph->new_mapping[i - 2] < 0);
                         */
                        assert(graph->new_mapping[i - 1] > target);
                        assert(graph->new_mapping[i - 2] < 0);

+                       assert(graph->new_mapping[i - 3] == target);

                        graph->new_mapping[i - 2] = target;
                        graph->new_mapping[i - 2] = target;

+                       /*
+                        * Mark this branch as the horizontal edge to
+                        * prevent any other edges from moving
+                        * horizontally.
+                        */
+                       if (horizontal_edge == -1)
+                               horizontal_edge = i;

                }
        }
 
                }
        }
 


@@ -1061,8 +1078,23 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
                        strbuf_addch(sb, ' ');
                else if (target * 2 == i)
                        strbuf_write_column(sb, &graph->new_columns[target], '|');
                        strbuf_addch(sb, ' ');
                else if (target * 2 == i)
                        strbuf_write_column(sb, &graph->new_columns[target], '|');

-               else
+               else if (target == horizontal_edge_target &&
+                        i != horizontal_edge - 1) {
+                               /*
+                                * Set the mappings for all but the
+                                * first segment to -1 so that they
+                                * won't continue into the next line.
+                                */
+                               if (i != (target * 2)+3)
+                                       graph->new_mapping[i] = -1;
+                               used_horizontal = 1;
+                       strbuf_write_column(sb, &graph->new_columns[target], '_');
+               } else {
+                       if (used_horizontal && i < horizontal_edge)
+                               graph->new_mapping[i] = -1;

                        strbuf_write_column(sb, &graph->new_columns[target], '/');
                        strbuf_write_column(sb, &graph->new_columns[target], '/');

+
+               }

        }
 
        graph_pad_horizontally(graph, sb, graph->mapping_size);
        }
 
        graph_pad_horizontally(graph, sb, graph->mapping_size);

diff --git a/t/t4202-log.sh b/t/t4202-log.sh
index b98619035c58d1b5c617c6e9998e7ae07ab3f27f..a3b0cb88d182f70d91b8e7a555e767e3b7f78837 100755 (executable)
--- a/t/t4202-log.sh
+++ b/t/t4202-log.sh
@@ -298,14 +298,12 @@ cat > expect <<\EOF
 * | | |   Merge branch 'side'
 |\ \ \ \
 | * | | | side-2
 * | | |   Merge branch 'side'
 |\ \ \ \
 | * | | | side-2

-| | | |/
-| | |/|
+| | |_|/

 | |/| |
 | * | | side-1
 * | | | Second
 * | | | sixth
 | |/| |
 | * | | side-1
 * | | | Second
 * | | | sixth

-| | |/
-| |/|
+| |_|/

 |/| |
 * | | fifth
 * | | fourth
 |/| |
 * | | fifth
 * | | fourth