summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJunio C Hamano <gitster@pobox.com>2019-12-01 17:04:28 (GMT)
committerJunio C Hamano <gitster@pobox.com>2019-12-01 17:04:28 (GMT)
commit0be5caf97ce1ad5f3c10ac00875f9aaf4939339d (patch)
treea0c75fa674ccf24148004d8c98f415c058511c18
parent0e07c1cd83535cf3a20d3d961a41bb4a627ce4e5 (diff)
parentd784d978f68219774270f92f3672e0e064602c09 (diff)
downloadgit-0be5caf97ce1ad5f3c10ac00875f9aaf4939339d.zip
git-0be5caf97ce1ad5f3c10ac00875f9aaf4939339d.tar.gz
git-0be5caf97ce1ad5f3c10ac00875f9aaf4939339d.tar.bz2
Merge branch 'jc/log-graph-simplify'
The implementation of "git log --graph" got refactored and then its output got simplified. * jc/log-graph-simplify: t4215: use helper function to check output graph: fix coloring of octopus dashes graph: flatten edges that fuse with their right neighbor graph: smooth appearance of collapsing edges on commit lines graph: rename `new_mapping` to `old_mapping` graph: commit and post-merge lines for left-skewed merges graph: tidy up display of left-skewed merges graph: example of graph output that can be simplified graph: extract logic for moving to GRAPH_PRE_COMMIT state graph: remove `mapping_idx` and `graph_update_width()` graph: reduce duplication in `graph_insert_into_new_columns()` graph: reuse `find_new_column_by_commit()` graph: handle line padding in `graph_next_line()` graph: automatically track display width of graph lines
-rw-r--r--graph.c646
-rwxr-xr-xt/t3430-rebase-merges.sh2
-rwxr-xr-xt/t4202-log.sh2
-rwxr-xr-xt/t4214-log-graph-octopus.sh62
-rwxr-xr-xt/t4215-log-skewed-merges.sh243
-rwxr-xr-xt/t6016-rev-list-graph-simplify-history.sh30
6 files changed, 659 insertions, 326 deletions
diff --git a/graph.c b/graph.c
index f531354..e3fd0ea 100644
--- a/graph.c
+++ b/graph.c
@@ -112,14 +112,42 @@ static const char *column_get_color_code(unsigned short color)
return column_colors[color];
}
-static void strbuf_write_column(struct strbuf *sb, const struct column *c,
- char col_char)
+struct graph_line {
+ struct strbuf *buf;
+ size_t width;
+};
+
+static inline void graph_line_addch(struct graph_line *line, int c)
+{
+ strbuf_addch(line->buf, c);
+ line->width++;
+}
+
+static inline void graph_line_addchars(struct graph_line *line, int c, size_t n)
+{
+ strbuf_addchars(line->buf, c, n);
+ line->width += n;
+}
+
+static inline void graph_line_addstr(struct graph_line *line, const char *s)
+{
+ strbuf_addstr(line->buf, s);
+ line->width += strlen(s);
+}
+
+static inline void graph_line_addcolor(struct graph_line *line, unsigned short color)
+{
+ strbuf_addstr(line->buf, column_get_color_code(color));
+}
+
+static void graph_line_write_column(struct graph_line *line, const struct column *c,
+ char col_char)
{
if (c->color < column_colors_max)
- strbuf_addstr(sb, column_get_color_code(c->color));
- strbuf_addch(sb, col_char);
+ graph_line_addcolor(line, c->color);
+ graph_line_addch(line, col_char);
if (c->color < column_colors_max)
- strbuf_addstr(sb, column_get_color_code(column_colors_max));
+ graph_line_addcolor(line, column_colors_max);
}
struct git_graph {
@@ -175,9 +203,63 @@ struct git_graph {
*/
int prev_commit_index;
/*
+ * Which layout variant to use to display merge commits. If the
+ * commit's first parent is known to be in a column to the left of the
+ * merge, then this value is 0 and we use the layout on the left.
+ * Otherwise, the value is 1 and the layout on the right is used. This
+ * field tells us how many columns the first parent occupies.
+ *
+ * 0) 1)
+ *
+ * | | | *-. | | *---.
+ * | |_|/|\ \ | | |\ \ \
+ * |/| | | | | | | | | | *
+ */
+ int merge_layout;
+ /*
+ * The number of columns added to the graph by the current commit. For
+ * 2-way and octopus merges, this is is usually one less than the
+ * number of parents:
+ *
+ * | | | | | \
+ * | * | | *---. \
+ * | |\ \ | |\ \ \ \
+ * | | | | | | | | | |
+ *
+ * num_parents: 2 num_parents: 4
+ * edges_added: 1 edges_added: 3
+ *
+ * For left-skewed merges, the first parent fuses with its neighbor and
+ * so one less column is added:
+ *
+ * | | | | | \
+ * | * | | *-. \
+ * |/| | |/|\ \ \
+ * | | | | | | | |
+ *
+ * num_parents: 2 num_parents: 4
+ * edges_added: 0 edges_added: 2
+ *
+ * This number determines how edges to the right of the merge are
+ * displayed in commit and post-merge lines; if no columns have been
+ * added then a vertical line should be used where a right-tracking
+ * line would otherwise be used.
+ *
+ * | * \ | * |
+ * | |\ \ |/| |
+ * | | * \ | * |
+ */
+ int edges_added;
+ /*
+ * The number of columns added by the previous commit, which is used to
+ * smooth edges appearing to the right of a commit in a commit line
+ * following a post-merge line.
+ */
+ int prev_edges_added;
+ /*
* The maximum number of columns that can be stored in the columns
* and new_columns arrays. This is also half the number of entries
- * that can be stored in the mapping and new_mapping arrays.
+ * that can be stored in the mapping and old_mapping arrays.
*/
int column_capacity;
/*
@@ -215,12 +297,12 @@ struct git_graph {
*/
int *mapping;
/*
- * A temporary array for computing the next mapping state
- * while we are outputting a mapping line. This is stored as part
- * of the git_graph simply so we don't have to allocate a new
- * temporary array each time we have to output a collapsing line.
+ * A copy of the contents of the mapping array from the last commit,
+ * which we use to improve the display of columns that are tracking
+ * from right to left through a commit line. We also use this to
+ * avoid allocating a fresh array when we compute the next mapping.
*/
- int *new_mapping;
+ int *old_mapping;
/*
* The current default column color being used. This is
* stored as an index into the array column_colors.
@@ -285,6 +367,9 @@ struct git_graph *graph_init(struct rev_info *opt)
graph->prev_state = GRAPH_PADDING;
graph->commit_index = 0;
graph->prev_commit_index = 0;
+ graph->merge_layout = 0;
+ graph->edges_added = 0;
+ graph->prev_edges_added = 0;
graph->num_columns = 0;
graph->num_new_columns = 0;
graph->mapping_size = 0;
@@ -303,7 +388,7 @@ struct git_graph *graph_init(struct rev_info *opt)
ALLOC_ARRAY(graph->columns, graph->column_capacity);
ALLOC_ARRAY(graph->new_columns, graph->column_capacity);
ALLOC_ARRAY(graph->mapping, 2 * graph->column_capacity);
- ALLOC_ARRAY(graph->new_mapping, 2 * graph->column_capacity);
+ ALLOC_ARRAY(graph->old_mapping, 2 * graph->column_capacity);
/*
* The diff output prefix callback, with this we can make
@@ -333,7 +418,7 @@ static void graph_ensure_capacity(struct git_graph *graph, int num_columns)
REALLOC_ARRAY(graph->columns, graph->column_capacity);
REALLOC_ARRAY(graph->new_columns, graph->column_capacity);
REALLOC_ARRAY(graph->mapping, graph->column_capacity * 2);
- REALLOC_ARRAY(graph->new_mapping, graph->column_capacity * 2);
+ REALLOC_ARRAY(graph->old_mapping, graph->column_capacity * 2);
}
/*
@@ -432,74 +517,76 @@ static unsigned short graph_find_commit_color(const struct git_graph *graph,
return graph_get_current_column_color(graph);
}
-static void graph_insert_into_new_columns(struct git_graph *graph,
- struct commit *commit,
- int *mapping_index)
+static int graph_find_new_column_by_commit(struct git_graph *graph,
+ struct commit *commit)
{
int i;
-
- /*
- * If the commit is already in the new_columns list, we don't need to
- * add it. Just update the mapping correctly.
- */
for (i = 0; i < graph->num_new_columns; i++) {
- if (graph->new_columns[i].commit == commit) {
- graph->mapping[*mapping_index] = i;
- *mapping_index += 2;
- return;
- }
+ if (graph->new_columns[i].commit == commit)
+ return i;
}
-
- /*
- * This commit isn't already in new_columns. Add it.
- */
- graph->new_columns[graph->num_new_columns].commit = commit;
- graph->new_columns[graph->num_new_columns].color = graph_find_commit_color(graph, commit);
- graph->mapping[*mapping_index] = graph->num_new_columns;
- *mapping_index += 2;
- graph->num_new_columns++;
+ return -1;
}
-static void graph_update_width(struct git_graph *graph,
- int is_commit_in_existing_columns)
+static void graph_insert_into_new_columns(struct git_graph *graph,
+ struct commit *commit,
+ int idx)
{
- /*
- * Compute the width needed to display the graph for this commit.
- * This is the maximum width needed for any row. All other rows
- * will be padded to this width.
- *
- * Compute the number of columns in the widest row:
- * Count each existing column (graph->num_columns), and each new
- * column added by this commit.
- */
- int max_cols = graph->num_columns + graph->num_parents;
+ int i = graph_find_new_column_by_commit(graph, commit);
+ int mapping_idx;
/*
- * Even if the current commit has no parents to be printed, it
- * still takes up a column for itself.
+ * If the commit is not already in the new_columns array, then add it
+ * and record it as being in the final column.
*/
- if (graph->num_parents < 1)
- max_cols++;
+ if (i < 0) {
+ i = graph->num_new_columns++;
+ graph->new_columns[i].commit = commit;
+ graph->new_columns[i].color = graph_find_commit_color(graph, commit);
+ }
- /*
- * We added a column for the current commit as part of
- * graph->num_parents. If the current commit was already in
- * graph->columns, then we have double counted it.
- */
- if (is_commit_in_existing_columns)
- max_cols--;
+ if (graph->num_parents > 1 && idx > -1 && graph->merge_layout == -1) {
+ /*
+ * If this is the first parent of a merge, choose a layout for
+ * the merge line based on whether the parent appears in a
+ * column to the left of the merge
+ */
+ int dist, shift;
- /*
- * Each column takes up 2 spaces
- */
- graph->width = max_cols * 2;
+ dist = idx - i;
+ shift = (dist > 1) ? 2 * dist - 3 : 1;
+
+ graph->merge_layout = (dist > 0) ? 0 : 1;
+ graph->edges_added = graph->num_parents + graph->merge_layout - 2;
+
+ mapping_idx = graph->width + (graph->merge_layout - 1) * shift;
+ graph->width += 2 * graph->merge_layout;
+
+ } else if (graph->edges_added > 0 && i == graph->mapping[graph->width - 2]) {
+ /*
+ * If some columns have been added by a merge, but this commit
+ * was found in the last existing column, then adjust the
+ * numbers so that the two edges immediately join, i.e.:
+ *
+ * * | * |
+ * |\ \ => |\|
+ * | |/ | *
+ * | *
+ */
+ mapping_idx = graph->width - 2;
+ graph->edges_added = -1;
+ } else {
+ mapping_idx = graph->width;
+ graph->width += 2;
+ }
+
+ graph->mapping[mapping_idx] = i;
}
static void graph_update_columns(struct git_graph *graph)
{
struct commit_list *parent;
int max_new_columns;
- int mapping_idx;
int i, seen_this, is_commit_in_columns;
/*
@@ -532,6 +619,10 @@ static void graph_update_columns(struct git_graph *graph)
for (i = 0; i < graph->mapping_size; i++)
graph->mapping[i] = -1;
+ graph->width = 0;
+ graph->prev_edges_added = graph->edges_added;
+ graph->edges_added = 0;
+
/*
* Populate graph->new_columns and graph->mapping
*
@@ -542,7 +633,6 @@ static void graph_update_columns(struct git_graph *graph)
* supposed to end up after the collapsing is performed.
*/
seen_this = 0;
- mapping_idx = 0;
is_commit_in_columns = 1;
for (i = 0; i <= graph->num_columns; i++) {
struct commit *col_commit;
@@ -556,9 +646,9 @@ static void graph_update_columns(struct git_graph *graph)
}
if (col_commit == graph->commit) {
- int old_mapping_idx = mapping_idx;
seen_this = 1;
graph->commit_index = i;
+ graph->merge_layout = -1;
for (parent = first_interesting_parent(graph);
parent;
parent = next_interesting_parent(graph, parent)) {
@@ -571,21 +661,18 @@ static void graph_update_columns(struct git_graph *graph)
!is_commit_in_columns) {
graph_increment_column_color(graph);
}
- graph_insert_into_new_columns(graph,
- parent->item,
- &mapping_idx);
+ graph_insert_into_new_columns(graph, parent->item, i);
}
/*
- * We always need to increment mapping_idx by at
+ * We always need to increment graph->width by at
* least 2, even if it has no interesting parents.
* The current commit always takes up at least 2
* spaces.
*/
- if (mapping_idx == old_mapping_idx)
- mapping_idx += 2;
+ if (graph->num_parents == 0)
+ graph->width += 2;
} else {
- graph_insert_into_new_columns(graph, col_commit,
- &mapping_idx);
+ graph_insert_into_new_columns(graph, col_commit, -1);
}
}
@@ -595,11 +682,43 @@ static void graph_update_columns(struct git_graph *graph)
while (graph->mapping_size > 1 &&
graph->mapping[graph->mapping_size - 1] < 0)
graph->mapping_size--;
+}
+
+static int graph_num_dashed_parents(struct git_graph *graph)
+{
+ return graph->num_parents + graph->merge_layout - 3;
+}
+static int graph_num_expansion_rows(struct git_graph *graph)
+{
/*
- * Compute graph->width for this commit
+ * Normally, we need two expansion rows for each dashed parent line from
+ * an octopus merge:
+ *
+ * | *
+ * | |\
+ * | | \
+ * | | \
+ * | *-. \
+ * | |\ \ \
+ *
+ * If the merge is skewed to the left, then its parents occupy one less
+ * column, and we don't need as many expansion rows to route around it;
+ * in some cases that means we don't need any expansion rows at all:
+ *
+ * | *
+ * | |\
+ * | * \
+ * |/|\ \
*/
- graph_update_width(graph, is_commit_in_columns);
+ return graph_num_dashed_parents(graph) * 2;
+}
+
+static int graph_needs_pre_commit_line(struct git_graph *graph)
+{
+ return graph->num_parents >= 3 &&
+ graph->commit_index < (graph->num_columns - 1) &&
+ graph->expansion_row < graph_num_expansion_rows(graph);
}
void graph_update(struct git_graph *graph, struct commit *commit)
@@ -657,8 +776,7 @@ void graph_update(struct git_graph *graph, struct commit *commit)
*/
if (graph->state != GRAPH_PADDING)
graph->state = GRAPH_SKIP;
- else if (graph->num_parents >= 3 &&
- graph->commit_index < (graph->num_columns - 1))
+ else if (graph_needs_pre_commit_line(graph))
graph->state = GRAPH_PRE_COMMIT;
else
graph->state = GRAPH_COMMIT;
@@ -686,8 +804,7 @@ static int graph_is_mapping_correct(struct git_graph *graph)
return 1;
}
-static void graph_pad_horizontally(struct git_graph *graph, struct strbuf *sb,
- int chars_written)
+static void graph_pad_horizontally(struct git_graph *graph, struct graph_line *line)
{
/*
* Add additional spaces to the end of the strbuf, so that all
@@ -696,34 +813,22 @@ static void graph_pad_horizontally(struct git_graph *graph, struct strbuf *sb,
* This way, fields printed to the right of the graph will remain
* aligned for the entire commit.
*/
- if (chars_written < graph->width)
- strbuf_addchars(sb, ' ', graph->width - chars_written);
+ if (line->width < graph->width)
+ graph_line_addchars(line, ' ', graph->width - line->width);
}
static void graph_output_padding_line(struct git_graph *graph,
- struct strbuf *sb)
+ struct graph_line *line)
{
int i;
/*
- * We could conceivable be called with a NULL commit
- * if our caller has a bug, and invokes graph_next_line()
- * immediately after graph_init(), without first calling
- * graph_update(). Return without outputting anything in this
- * case.
- */
- if (!graph->commit)
- return;
-
- /*
* Output a padding row, that leaves all branch lines unchanged
*/
for (i = 0; i < graph->num_new_columns; i++) {
- strbuf_write_column(sb, &graph->new_columns[i], '|');
- strbuf_addch(sb, ' ');
+ graph_line_write_column(line, &graph->new_columns[i], '|');
+ graph_line_addch(line, ' ');
}
-
- graph_pad_horizontally(graph, sb, graph->num_new_columns * 2);
}
@@ -733,28 +838,24 @@ int graph_width(struct git_graph *graph)
}
-static void graph_output_skip_line(struct git_graph *graph, struct strbuf *sb)
+static void graph_output_skip_line(struct git_graph *graph, struct graph_line *line)
{
/*
* Output an ellipsis to indicate that a portion
* of the graph is missing.
*/
- strbuf_addstr(sb, "...");
- graph_pad_horizontally(graph, sb, 3);
+ graph_line_addstr(line, "...");
- if (graph->num_parents >= 3 &&
- graph->commit_index < (graph->num_columns - 1))
+ if (graph_needs_pre_commit_line(graph))
graph_update_state(graph, GRAPH_PRE_COMMIT);
else
graph_update_state(graph, GRAPH_COMMIT);
}
static void graph_output_pre_commit_line(struct git_graph *graph,
- struct strbuf *sb)
+ struct graph_line *line)
{
- int num_expansion_rows;
int i, seen_this;
- int chars_written;
/*
* This function formats a row that increases the space around a commit
@@ -764,27 +865,24 @@ static void graph_output_pre_commit_line(struct git_graph *graph,
* We need 2 extra rows for every parent over 2.
*/
assert(graph->num_parents >= 3);
- num_expansion_rows = (graph->num_parents - 2) * 2;
/*
* graph->expansion_row tracks the current expansion row we are on.
* It should be in the range [0, num_expansion_rows - 1]
*/
assert(0 <= graph->expansion_row &&
- graph->expansion_row < num_expansion_rows);
+ graph->expansion_row < graph_num_expansion_rows(graph));
/*
* Output the row
*/
seen_this = 0;
- chars_written = 0;
for (i = 0; i < graph->num_columns; i++) {
struct column *col = &graph->columns[i];
if (col->commit == graph->commit) {
seen_this = 1;
- strbuf_write_column(sb, col, '|');
- strbuf_addchars(sb, ' ', graph->expansion_row);
- chars_written += 1 + graph->expansion_row;
+ graph_line_write_column(line, col, '|');
+ graph_line_addchars(line, ' ', graph->expansion_row);
} else if (seen_this && (graph->expansion_row == 0)) {
/*
* This is the first line of the pre-commit output.
@@ -797,33 +895,27 @@ static void graph_output_pre_commit_line(struct git_graph *graph,
*/
if (graph->prev_state == GRAPH_POST_MERGE &&
graph->prev_commit_index < i)
- strbuf_write_column(sb, col, '\\');
+ graph_line_write_column(line, col, '\\');
else
- strbuf_write_column(sb, col, '|');
- chars_written++;
+ graph_line_write_column(line, col, '|');
} else if (seen_this && (graph->expansion_row > 0)) {
- strbuf_write_column(sb, col, '\\');
- chars_written++;
+ graph_line_write_column(line, col, '\\');
} else {
- strbuf_write_column(sb, col, '|');
- chars_written++;
+ graph_line_write_column(line, col, '|');
}
- strbuf_addch(sb, ' ');
- chars_written++;
+ graph_line_addch(line, ' ');
}
- graph_pad_horizontally(graph, sb, chars_written);
-
/*
* Increment graph->expansion_row,
* and move to state GRAPH_COMMIT if necessary
*/
graph->expansion_row++;
- if (graph->expansion_row >= num_expansion_rows)
+ if (!graph_needs_pre_commit_line(graph))
graph_update_state(graph, GRAPH_COMMIT);
}
-static void graph_output_commit_char(struct git_graph *graph, struct strbuf *sb)
+static void graph_output_commit_char(struct git_graph *graph, struct graph_line *line)
{
/*
* For boundary commits, print 'o'
@@ -831,72 +923,67 @@ static void graph_output_commit_char(struct git_graph *graph, struct strbuf *sb)
*/
if (graph->commit->object.flags & BOUNDARY) {
assert(graph->revs->boundary);
- strbuf_addch(sb, 'o');
+ graph_line_addch(line, 'o');
return;
}
/*
* get_revision_mark() handles all other cases without assert()
*/
- strbuf_addstr(sb, get_revision_mark(graph->revs, graph->commit));
+ graph_line_addstr(line, get_revision_mark(graph->revs, graph->commit));
}
/*
- * Draw the horizontal dashes of an octopus merge and return the number of
- * characters written.
+ * Draw the horizontal dashes of an octopus merge.
*/
-static int graph_draw_octopus_merge(struct git_graph *graph,
- struct strbuf *sb)
+static void graph_draw_octopus_merge(struct git_graph *graph, struct graph_line *line)
{
/*
- * Here dashless_parents represents the number of parents which don't
- * need to have dashes (the edges labeled "0" and "1"). And
- * dashful_parents are the remaining ones.
+ * The parents of a merge commit can be arbitrarily reordered as they
+ * are mapped onto display columns, for example this is a valid merge:
*
- * | *---.
- * | |\ \ \
- * | | | | |
- * x 0 1 2 3
+ * | | *---.
+ * | | |\ \ \
+ * | | |/ / /
+ * | |/| | /
+ * | |_|_|/
+ * |/| | |
+ * 3 1 0 2
*
- */
- const int dashless_parents = 2;
- int dashful_parents = graph->num_parents - dashless_parents;
-
- /*
- * Usually, we add one new column for each parent (like the diagram
- * above) but sometimes the first parent goes into an existing column,
- * like this:
+ * The numbers denote which parent of the merge each visual column
+ * corresponds to; we can't assume that the parents will initially
+ * display in the order given by new_columns.
*
- * | *---.
- * | |\ \ \
- * |/ / / /
- * x 0 1 2
+ * To find the right color for each dash, we need to consult the
+ * mapping array, starting from the column 2 places to the right of the
+ * merge commit, and use that to find out which logical column each
+ * edge will collapse to.
*
- * In which case the number of parents will be one greater than the
- * number of added columns.
+ * Commits are rendered once all edges have collapsed to their correct
+ * logcial column, so commit_index gives us the right visual offset for
+ * the merge commit.
*/
- int added_cols = (graph->num_new_columns - graph->num_columns);
- int parent_in_old_cols = graph->num_parents - added_cols;
- /*
- * In both cases, commit_index corresponds to the edge labeled "0".
- */
- int first_col = graph->commit_index + dashless_parents
- - parent_in_old_cols;
+ int i, j;
+ struct column *col;
- int i;
- for (i = 0; i < dashful_parents; i++) {
- strbuf_write_column(sb, &graph->new_columns[i+first_col], '-');
- strbuf_write_column(sb, &graph->new_columns[i+first_col],
- i == dashful_parents-1 ? '.' : '-');
+ int dashed_parents = graph_num_dashed_parents(graph);
+
+ for (i = 0; i < dashed_parents; i++) {
+ j = graph->mapping[(graph->commit_index + i + 2) * 2];
+ col = &graph->new_columns[j];
+
+ graph_line_write_column(line, col, '-');
+ graph_line_write_column(line, col, (i == dashed_parents - 1) ? '.' : '-');
}
- return 2 * dashful_parents;
+
+ return;
}
-static void graph_output_commit_line(struct git_graph *graph, struct strbuf *sb)
+static void graph_output_commit_line(struct git_graph *graph, struct graph_line *line)
{
int seen_this = 0;
- int i, chars_written;
+ int i;
/*
* Output the row containing this commit
@@ -906,7 +993,6 @@ static void graph_output_commit_line(struct git_graph *graph, struct strbuf *sb)
* children that we have already processed.)
*/
seen_this = 0;
- chars_written = 0;
for (i = 0; i <= graph->num_columns; i++) {
struct column *col = &graph->columns[i];
struct commit *col_commit;
@@ -920,19 +1006,17 @@ static void graph_output_commit_line(struct git_graph *graph, struct strbuf *sb)
if (col_commit == graph->commit) {
seen_this = 1;
- graph_output_commit_char(graph, sb);
- chars_written++;
+ graph_output_commit_char(graph, line);
if (graph->num_parents > 2)
- chars_written += graph_draw_octopus_merge(graph,
- sb);
- } else if (seen_this && (graph->num_parents > 2)) {
- strbuf_write_column(sb, col, '\\');
- chars_written++;
- } else if (seen_this && (graph->num_parents == 2)) {
+ graph_draw_octopus_merge(graph, line);
+ } else if (seen_this && (graph->edges_added > 1)) {
+ graph_line_write_column(line, col, '\\');
+ } else if (seen_this && (graph->edges_added == 1)) {
/*
- * This is a 2-way merge commit.
- * There is no GRAPH_PRE_COMMIT stage for 2-way
+ * This is either a right-skewed 2-way merge
+ * commit, or a left-skewed 3-way merge.
+ * There is no GRAPH_PRE_COMMIT stage for such
* merges, so this is the first line of output
* for this commit. Check to see what the previous
* line of output was.
@@ -944,21 +1028,21 @@ static void graph_output_commit_line(struct git_graph *graph, struct strbuf *sb)
* makes the output look nicer.
*/
if (graph->prev_state == GRAPH_POST_MERGE &&
+ graph->prev_edges_added > 0 &&
graph->prev_commit_index < i)
- strbuf_write_column(sb, col, '\\');
+ graph_line_write_column(line, col, '\\');
else
- strbuf_write_column(sb, col, '|');
- chars_written++;
+ graph_line_write_column(line, col, '|');
+ } else if (graph->prev_state == GRAPH_COLLAPSING &&
+ graph->old_mapping[2 * i + 1] == i &&
+ graph->mapping[2 * i] < i) {
+ graph_line_write_column(line, col, '/');
} else {
- strbuf_write_column(sb, col, '|');
- chars_written++;
+ graph_line_write_column(line, col, '|');
}
- strbuf_addch(sb, ' ');
- chars_written++;
+ graph_line_addch(line, ' ');
}
- graph_pad_horizontally(graph, sb, chars_written);
-
/*
* Update graph->state
*/
@@ -970,26 +1054,19 @@ static void graph_output_commit_line(struct git_graph *graph, struct strbuf *sb)
graph_update_state(graph, GRAPH_COLLAPSING);
}
-static struct column *find_new_column_by_commit(struct git_graph *graph,
- struct commit *commit)
-{
- int i;
- for (i = 0; i < graph->num_new_columns; i++) {
- if (graph->new_columns[i].commit == commit)
- return &graph->new_columns[i];
- }
- return NULL;
-}
+const char merge_chars[] = {'/', '|', '\\'};
-static void graph_output_post_merge_line(struct git_graph *graph, struct strbuf *sb)
+static void graph_output_post_merge_line(struct git_graph *graph, struct graph_line *line)
{
int seen_this = 0;
- int i, j, chars_written;
+ int i, j;
+
+ struct commit_list *first_parent = first_interesting_parent(graph);
+ int seen_parent = 0;
/*
* Output the post-merge row
*/
- chars_written = 0;
for (i = 0; i <= graph->num_columns; i++) {
struct column *col = &graph->columns[i];
struct commit *col_commit;
@@ -1008,37 +1085,44 @@ static void graph_output_post_merge_line(struct git_graph *graph, struct strbuf
* new_columns and use those to format the
* edges.
*/
- struct commit_list *parents = NULL;
- struct column *par_column;
+ struct commit_list *parents = first_parent;
+ int par_column;
+ int idx = graph->merge_layout;
+ char c;
seen_this = 1;
- parents = first_interesting_parent(graph);
- assert(parents);
- par_column = find_new_column_by_commit(graph, parents->item);
- assert(par_column);
-
- strbuf_write_column(sb, par_column, '|');
- chars_written++;
- for (j = 0; j < graph->num_parents - 1; j++) {
+
+ for (j = 0; j < graph->num_parents; j++) {
+ par_column = graph_find_new_column_by_commit(graph, parents->item);
+ assert(par_column >= 0);
+
+ c = merge_chars[idx];
+ graph_line_write_column(line, &graph->new_columns[par_column], c);
+ if (idx == 2) {
+ if (graph->edges_added > 0 || j < graph->num_parents - 1)
+ graph_line_addch(line, ' ');
+ } else {
+ idx++;
+ }
parents = next_interesting_parent(graph, parents);
- assert(parents);
- par_column = find_new_column_by_commit(graph, parents->item);
- assert(par_column);
- strbuf_write_column(sb, par_column, '\\');
- strbuf_addch(sb, ' ');
}
- chars_written += j * 2;
+ if (graph->edges_added == 0)
+ graph_line_addch(line, ' ');
+
} else if (seen_this) {
- strbuf_write_column(sb, col, '\\');
- strbuf_addch(sb, ' ');
- chars_written += 2;
+ if (graph->edges_added > 0)
+ graph_line_write_column(line, col, '\\');
+ else
+ graph_line_write_column(line, col, '|');
+ graph_line_addch(line, ' ');
} else {
- strbuf_write_column(sb, col, '|');
- strbuf_addch(sb, ' ');
- chars_written += 2;
+ graph_line_write_column(line, col, '|');
+ if (graph->merge_layout != 0 || i != graph->commit_index - 1)
+ graph_line_addch(line, seen_parent ? '_' : ' ');
}
- }
- graph_pad_horizontally(graph, sb, chars_written);
+ if (col_commit == first_parent->item)
+ seen_parent = 1;
+ }
/*
* Update graph->state
@@ -1049,7 +1133,7 @@ static void graph_output_post_merge_line(struct git_graph *graph, struct strbuf
graph_update_state(graph, GRAPH_COLLAPSING);
}
-static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf *sb)
+static void graph_output_collapsing_line(struct git_graph *graph, struct graph_line *line)
{
int i;
short used_horizontal = 0;
@@ -1057,13 +1141,18 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
int horizontal_edge_target = -1;
/*
- * Clear out the new_mapping array
+ * Swap the mapping and old_mapping arrays
+ */
+ SWAP(graph->mapping, graph->old_mapping);
+
+ /*
+ * Clear out the mapping array
*/
for (i = 0; i < graph->mapping_size; i++)
- graph->new_mapping[i] = -1;
+ graph->mapping[i] = -1;
for (i = 0; i < graph->mapping_size; i++) {
- int target = graph->mapping[i];
+ int target = graph->old_mapping[i];
if (target < 0)
continue;
@@ -1084,14 +1173,14 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
* This column is already in the
* correct place
*/
- assert(graph->new_mapping[i] == -1);
- graph->new_mapping[i] = target;
- } else if (graph->new_mapping[i - 1] < 0) {
+ assert(graph->mapping[i] == -1);
+ graph->mapping[i] = target;
+ } else if (graph->mapping[i - 1] < 0) {
/*
* Nothing is to the left.
* Move to the left by one
*/
- graph->new_mapping[i - 1] = target;
+ graph->mapping[i - 1] = target;
/*
* If there isn't already an edge moving horizontally
* select this one.
@@ -1107,9 +1196,9 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
* line.
*/
for (j = (target * 2)+3; j < (i - 2); j += 2)
- graph->new_mapping[j] = target;
+ graph->mapping[j] = target;
}
- } else if (graph->new_mapping[i - 1] == target) {
+ } else if (graph->mapping[i - 1] == target) {
/*
* There is a branch line to our left
* already, and it is our target. We
@@ -1117,7 +1206,7 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
* the same parent commit.
*
* We don't have to add anything to the
- * output or new_mapping, since the
+ * output or mapping, since the
* existing branch line has already taken
* care of it.
*/
@@ -1133,10 +1222,10 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
* 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 - 3] == target);
- graph->new_mapping[i - 2] = target;
+ assert(graph->mapping[i - 1] > target);
+ assert(graph->mapping[i - 2] < 0);
+ assert(graph->mapping[i - 3] == target);
+ graph->mapping[i - 2] = target;
/*
* Mark this branch as the horizontal edge to
* prevent any other edges from moving
@@ -1148,20 +1237,25 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
}
/*
+ * Copy the current mapping array into old_mapping
+ */
+ COPY_ARRAY(graph->old_mapping, graph->mapping, graph->mapping_size);
+
+ /*
* The new mapping may be 1 smaller than the old mapping
*/
- if (graph->new_mapping[graph->mapping_size - 1] < 0)
+ if (graph->mapping[graph->mapping_size - 1] < 0)
graph->mapping_size--;
/*
* Output out a line based on the new mapping info
*/
for (i = 0; i < graph->mapping_size; i++) {
- int target = graph->new_mapping[i];
+ int target = graph->mapping[i];
if (target < 0)
- strbuf_addch(sb, ' ');
+ graph_line_addch(line, ' ');
else if (target * 2 == i)
- strbuf_write_column(sb, &graph->new_columns[target], '|');
+ graph_line_write_column(line, &graph->new_columns[target], '|');
else if (target == horizontal_edge_target &&
i != horizontal_edge - 1) {
/*
@@ -1170,24 +1264,17 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
* won't continue into the next line.
*/
if (i != (target * 2)+3)
- graph->new_mapping[i] = -1;
+ graph->mapping[i] = -1;
used_horizontal = 1;
- strbuf_write_column(sb, &graph->new_columns[target], '_');
+ graph_line_write_column(line, &graph->new_columns[target], '_');
} else {
if (used_horizontal && i < horizontal_edge)
- graph->new_mapping[i] = -1;
- strbuf_write_column(sb, &graph->new_columns[target], '/');
+ graph->mapping[i] = -1;
+ graph_line_write_column(line, &graph->new_columns[target], '/');
}
}
- graph_pad_horizontally(graph, sb, graph->mapping_size);
-
- /*
- * Swap mapping and new_mapping
- */
- SWAP(graph->mapping, graph->new_mapping);
-
/*
* If graph->mapping indicates that all of the branch lines
* are already in the correct positions, we are done.
@@ -1199,35 +1286,49 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
int graph_next_line(struct git_graph *graph, struct strbuf *sb)
{
+ int shown_commit_line = 0;
+ struct graph_line line = { .buf = sb, .width = 0 };
+
+ /*
+ * We could conceivable be called with a NULL commit
+ * if our caller has a bug, and invokes graph_next_line()
+ * immediately after graph_init(), without first calling
+ * graph_update(). Return without outputting anything in this
+ * case.
+ */
+ if (!graph->commit)
+ return -1;
+
switch (graph->state) {
case GRAPH_PADDING:
- graph_output_padding_line(graph, sb);
- return 0;
+ graph_output_padding_line(graph, &line);
+ break;
case GRAPH_SKIP:
- graph_output_skip_line(graph, sb);
- return 0;
+ graph_output_skip_line(graph, &line);
+ break;
case GRAPH_PRE_COMMIT:
- graph_output_pre_commit_line(graph, sb);
- return 0;
+ graph_output_pre_commit_line(graph, &line);
+ break;
case GRAPH_COMMIT:
- graph_output_commit_line(graph, sb);
- return 1;
+ graph_output_commit_line(graph, &line);
+ shown_commit_line = 1;
+ break;
case GRAPH_POST_MERGE:
- graph_output_post_merge_line(graph, sb);
- return 0;
+ graph_output_post_merge_line(graph, &line);
+ break;
case GRAPH_COLLAPSING:
- graph_output_collapsing_line(graph, sb);
- return 0;
+ graph_output_collapsing_line(graph, &line);
+ break;
}
- assert(0);
- return 0;
+ graph_pad_horizontally(graph, &line);
+ return shown_commit_line;
}
static void graph_padding_line(struct git_graph *graph, struct strbuf *sb)
{
int i;
- int chars_written = 0;
+ struct graph_line line = { .buf = sb, .width = 0 };
if (graph->state != GRAPH_COMMIT) {
graph_next_line(graph, sb);
@@ -1244,20 +1345,17 @@ static void graph_padding_line(struct git_graph *graph, struct strbuf *sb)
for (i = 0; i < graph->num_columns; i++) {
struct column *col = &graph->columns[i];
- strbuf_write_column(sb, col, '|');
- chars_written++;
+ graph_line_write_column(&line, col, '|');
if (col->commit == graph->commit && graph->num_parents > 2) {
int len = (graph->num_parents - 2) * 2;
- strbuf_addchars(sb, ' ', len);
- chars_written += len;
+ graph_line_addchars(&line, ' ', len);
} else {
- strbuf_addch(sb, ' ');
- chars_written++;
+ graph_line_addch(&line, ' ');
}
}
- graph_pad_horizontally(graph, sb, chars_written);
+ graph_pad_horizontally(graph, &line);
/*
* Update graph->prev_state since we have output a padding line
diff --git a/t/t3430-rebase-merges.sh b/t/t3430-rebase-merges.sh
index 9efcf48..a30d27e 100755
--- a/t/t3430-rebase-merges.sh
+++ b/t/t3430-rebase-merges.sh
@@ -408,7 +408,7 @@ test_expect_success 'octopus merges' '
| | * three
| * | two
| |/
- * | one
+ * / one
|/
o before-octopus
EOF
diff --git a/t/t4202-log.sh b/t/t4202-log.sh
index e803ba4..ab0d021 100755
--- a/t/t4202-log.sh
+++ b/t/t4202-log.sh
@@ -667,7 +667,7 @@ cat > expect <<\EOF
* | | fifth
* | | fourth
|/ /
-* | third
+* / third
|/
* second
* initial
diff --git a/t/t4214-log-graph-octopus.sh b/t/t4214-log-graph-octopus.sh
index 3ae8e51..40d27db 100755
--- a/t/t4214-log-graph-octopus.sh
+++ b/t/t4214-log-graph-octopus.sh
@@ -26,15 +26,14 @@ test_expect_success 'set up merge history' '
test_expect_success 'log --graph with tricky octopus merge, no color' '
cat >expect.uncolored <<-\EOF &&
* left
- | *---. octopus-merge
- | |\ \ \
- |/ / / /
+ | *-. octopus-merge
+ |/|\ \
| | | * 4
| | * | 3
| | |/
- | * | 2
+ | * / 2
| |/
- * | 1
+ * / 1
|/
* initial
EOF
@@ -47,15 +46,14 @@ test_expect_success 'log --graph with tricky octopus merge with colors' '
test_config log.graphColors red,green,yellow,blue,magenta,cyan &&
cat >expect.colors <<-\EOF &&
* left
- <RED>|<RESET> *<BLUE>-<RESET><BLUE>-<RESET><MAGENTA>-<RESET><MAGENTA>.<RESET> octopus-merge
- <RED>|<RESET> <RED>|<RESET><YELLOW>\<RESET> <BLUE>\<RESET> <MAGENTA>\<RESET>
- <RED>|<RESET><RED>/<RESET> <YELLOW>/<RESET> <BLUE>/<RESET> <MAGENTA>/<RESET>
+ <RED>|<RESET> *<MAGENTA>-<RESET><MAGENTA>.<RESET> octopus-merge
+ <RED>|<RESET><RED>/<RESET><YELLOW>|<RESET><BLUE>\<RESET> <MAGENTA>\<RESET>
<RED>|<RESET> <YELLOW>|<RESET> <BLUE>|<RESET> * 4
<RED>|<RESET> <YELLOW>|<RESET> * <MAGENTA>|<RESET> 3
<RED>|<RESET> <YELLOW>|<RESET> <MAGENTA>|<RESET><MAGENTA>/<RESET>
- <RED>|<RESET> * <MAGENTA>|<RESET> 2
+ <RED>|<RESET> * <MAGENTA>/<RESET> 2
<RED>|<RESET> <MAGENTA>|<RESET><MAGENTA>/<RESET>
- * <MAGENTA>|<RESET> 1
+ * <MAGENTA>/<RESET> 1
<MAGENTA>|<RESET><MAGENTA>/<RESET>
* initial
EOF
@@ -74,9 +72,9 @@ test_expect_success 'log --graph with normal octopus merge, no color' '
| | | * 4
| | * | 3
| | |/
- | * | 2
+ | * / 2
| |/
- * | 1
+ * / 1
|/
* initial
EOF
@@ -92,9 +90,9 @@ test_expect_success 'log --graph with normal octopus merge with colors' '
<RED>|<RESET> <GREEN>|<RESET> <YELLOW>|<RESET> * 4
<RED>|<RESET> <GREEN>|<RESET> * <BLUE>|<RESET> 3
<RED>|<RESET> <GREEN>|<RESET> <BLUE>|<RESET><BLUE>/<RESET>
- <RED>|<RESET> * <BLUE>|<RESET> 2
+ <RED>|<RESET> * <BLUE>/<RESET> 2
<RED>|<RESET> <BLUE>|<RESET><BLUE>/<RESET>
- * <BLUE>|<RESET> 1
+ * <BLUE>/<RESET> 1
<BLUE>|<RESET><BLUE>/<RESET>
* initial
EOF
@@ -112,9 +110,9 @@ test_expect_success 'log --graph with normal octopus merge and child, no color'
| | | * 4
| | * | 3
| | |/
- | * | 2
+ | * / 2
| |/
- * | 1
+ * / 1
|/
* initial
EOF
@@ -123,7 +121,7 @@ test_expect_success 'log --graph with normal octopus merge and child, no color'
test_cmp expect.uncolored actual
'
-test_expect_failure 'log --graph with normal octopus and child merge with colors' '
+test_expect_success 'log --graph with normal octopus and child merge with colors' '
cat >expect.colors <<-\EOF &&
* after-merge
*<BLUE>-<RESET><BLUE>-<RESET><MAGENTA>-<RESET><MAGENTA>.<RESET> octopus-merge
@@ -131,9 +129,9 @@ test_expect_failure 'log --graph with normal octopus and child merge with colors
<GREEN>|<RESET> <YELLOW>|<RESET> <BLUE>|<RESET> * 4
<GREEN>|<RESET> <YELLOW>|<RESET> * <MAGENTA>|<RESET> 3
<GREEN>|<RESET> <YELLOW>|<RESET> <MAGENTA>|<RESET><MAGENTA>/<RESET>
- <GREEN>|<RESET> * <MAGENTA>|<RESET> 2
+ <GREEN>|<RESET> * <MAGENTA>/<RESET> 2
<GREEN>|<RESET> <MAGENTA>|<RESET><MAGENTA>/<RESET>
- * <MAGENTA>|<RESET> 1
+ * <MAGENTA>/<RESET> 1
<MAGENTA>|<RESET><MAGENTA>/<RESET>
* initial
EOF
@@ -147,15 +145,14 @@ test_expect_success 'log --graph with tricky octopus merge and its child, no col
cat >expect.uncolored <<-\EOF &&
* left
| * after-merge
- | *---. octopus-merge
- | |\ \ \
- |/ / / /
+ | *-. octopus-merge
+ |/|\ \
| | | * 4
| | * | 3
| | |/
- | * | 2
+ | * / 2
| |/
- * | 1
+ * / 1
|/
* initial
EOF
@@ -164,20 +161,19 @@ test_expect_success 'log --graph with tricky octopus merge and its child, no col
test_cmp expect.uncolored actual
'
-test_expect_failure 'log --graph with tricky octopus merge and its child with colors' '
+test_expect_success 'log --graph with tricky octopus merge and its child with colors' '
test_config log.graphColors red,green,yellow,blue,magenta,cyan &&
cat >expect.colors <<-\EOF &&
* left
<RED>|<RESET> * after-merge
- <RED>|<RESET> *<MAGENTA>-<RESET><MAGENTA>-<RESET><CYAN>-<RESET><CYAN>.<RESET> octopus-merge
- <RED>|<RESET> <RED>|<RESET><BLUE>\<RESET> <MAGENTA>\<RESET> <CYAN>\<RESET>
- <RED>|<RESET><RED>/<RESET> <BLUE>/<RESET> <MAGENTA>/<RESET> <CYAN>/<RESET>
+ <RED>|<RESET> *<CYAN>-<RESET><CYAN>.<RESET> octopus-merge
+ <RED>|<RESET><RED>/<RESET><BLUE>|<RESET><MAGENTA>\<RESET> <CYAN>\<RESET>
<RED>|<RESET> <BLUE>|<RESET> <MAGENTA>|<RESET> * 4
<RED>|<RESET> <BLUE>|<RESET> * <CYAN>|<RESET> 3
<RED>|<RESET> <BLUE>|<RESET> <CYAN>|<RESET><CYAN>/<RESET>
- <RED>|<RESET> * <CYAN>|<RESET> 2
+ <RED>|<RESET> * <CYAN>/<RESET> 2
<RED>|<RESET> <CYAN>|<RESET><CYAN>/<RESET>
- * <CYAN>|<RESET> 1
+ * <CYAN>/<RESET> 1
<CYAN>|<RESET><CYAN>/<RESET>
* initial
EOF
@@ -209,7 +205,7 @@ test_expect_success 'log --graph with crossover in octopus merge, no color' '
test_cmp expect.uncolored actual
'
-test_expect_failure 'log --graph with crossover in octopus merge with colors' '
+test_expect_success 'log --graph with crossover in octopus merge with colors' '
test_config log.graphColors red,green,yellow,blue,magenta,cyan &&
cat >expect.colors <<-\EOF &&
* after-4
@@ -257,7 +253,7 @@ test_expect_success 'log --graph with crossover in octopus merge and its child,
test_cmp expect.uncolored actual
'
-test_expect_failure 'log --graph with crossover in octopus merge and its child with colors' '
+test_expect_success 'log --graph with crossover in octopus merge and its child with colors' '
test_config log.graphColors red,green,yellow,blue,magenta,cyan &&
cat >expect.colors <<-\EOF &&
* after-4
@@ -353,7 +349,7 @@ test_expect_success 'log --graph with unrelated commit and octopus child, no col
test_cmp expect.uncolored actual
'
-test_expect_failure 'log --graph with unrelated commit and octopus child with colors' '
+test_expect_success 'log --graph with unrelated commit and octopus child with colors' '
test_config log.graphColors red,green,yellow,blue,magenta,cyan &&
cat >expect.colors <<-\EOF &&
* after-initial
diff --git a/t/t4215-log-skewed-merges.sh b/t/t4215-log-skewed-merges.sh
new file mode 100755
index 0000000..18709a7
--- /dev/null
+++ b/t/t4215-log-skewed-merges.sh
@@ -0,0 +1,243 @@
+#!/bin/sh
+
+test_description='git log --graph of skewed merges'
+
+. ./test-lib.sh
+
+check_graph () {
+ cat >expect &&
+ git log --graph --pretty=tformat:%s "$@" >actual.raw &&
+ sed "s/ *$//" actual.raw >actual &&
+ test_cmp expect actual
+}
+
+test_expect_success 'log --graph with merge fusing with its left and right neighbors' '
+ git checkout --orphan _p &&
+ test_commit A &&
+ test_commit B &&
+ git checkout -b _q @^ && test_commit C &&
+ git checkout -b _r @^ && test_commit D &&
+ git checkout _p && git merge --no-ff _q _r -m E &&
+ git checkout _r && test_commit F &&
+ git checkout _p && git merge --no-ff _r -m G &&
+ git checkout @^^ && git merge --no-ff _p -m H &&
+
+ check_graph <<-\EOF
+ * H
+ |\
+ | * G
+ | |\
+ | | * F
+ | * | E
+ |/|\|
+ | | * D
+ | * | C
+ | |/
+ * / B
+ |/
+ * A
+ EOF
+'
+
+test_expect_success 'log --graph with left-skewed merge' '
+ git checkout --orphan 0_p && test_commit 0_A &&
+ git checkout -b 0_q 0_p && test_commit 0_B &&
+ git checkout -b 0_r 0_p &&
+ test_commit 0_C &&
+ test_commit 0_D &&
+ git checkout -b 0_s 0_p && test_commit 0_E &&
+ git checkout -b 0_t 0_p && git merge --no-ff 0_r^ 0_s -m 0_F &&
+ git checkout 0_p && git merge --no-ff 0_s -m 0_G &&
+ git checkout @^ && git merge --no-ff 0_q 0_r 0_t 0_p -m 0_H &&
+
+ check_graph <<-\EOF
+ *-----. 0_H
+ |\ \ \ \
+ | | | | * 0_G
+ | |_|_|/|
+ |/| | | |
+ | | | * | 0_F
+ | |_|/|\|
+ |/| | | |
+ | | | | * 0_E
+ | |_|_|/
+ |/| | |
+ | | * | 0_D
+ | | |/
+ | | * 0_C
+ | |/
+ |/|
+ | * 0_B
+ |/
+ * 0_A
+ EOF
+'
+
+test_expect_success 'log --graph with nested left-skewed merge' '
+ git checkout --orphan 1_p &&
+ test_commit 1_A &&
+ test_commit 1_B &&
+ test_commit 1_C &&
+ git checkout -b 1_q @^ && test_commit 1_D &&
+ git checkout 1_p && git merge --no-ff 1_q -m 1_E &&
+ git checkout -b 1_r @~3 && test_commit 1_F &&
+ git checkout 1_p && git merge --no-ff 1_r -m 1_G &&
+ git checkout @^^ && git merge --no-ff 1_p -m 1_H &&
+
+ check_graph <<-\EOF
+ * 1_H
+ |\
+ | * 1_G
+ | |\
+ | | * 1_F
+ | * | 1_E
+ |/| |
+ | * | 1_D
+ * | | 1_C
+ |/ /
+ * / 1_B
+ |/
+ * 1_A
+ EOF
+'
+
+test_expect_success 'log --graph with nested left-skewed merge following normal merge' '
+ git checkout --orphan 2_p &&
+ test_commit 2_A &&
+ test_commit 2_B &&
+ test_commit 2_C &&
+ git checkout -b 2_q @^^ &&
+ test_commit 2_D &&
+ test_commit 2_E &&
+ git checkout -b 2_r @^ && test_commit 2_F &&
+ git checkout 2_q &&
+ git merge --no-ff 2_r -m 2_G &&
+ git merge --no-ff 2_p^ -m 2_H &&
+ git checkout -b 2_s @^^ && git merge --no-ff 2_q -m 2_J &&
+ git checkout 2_p && git merge --no-ff 2_s -m 2_K &&
+
+ check_graph <<-\EOF
+ * 2_K
+ |\
+ | * 2_J
+ | |\
+ | | * 2_H
+ | | |\
+ | | * | 2_G
+ | |/| |
+ | | * | 2_F
+ | * | | 2_E
+ | |/ /
+ | * | 2_D
+ * | | 2_C
+ | |/
+ |/|
+ * | 2_B
+ |/
+ * 2_A
+ EOF
+'
+
+test_expect_success 'log --graph with nested right-skewed merge following left-skewed merge' '
+ git checkout --orphan 3_p &&
+ test_commit 3_A &&
+ git checkout -b 3_q &&
+ test_commit 3_B &&
+ test_commit 3_C &&
+ git checkout -b 3_r @^ &&
+ test_commit 3_D &&
+ git checkout 3_q && git merge --no-ff 3_r -m 3_E &&
+ git checkout 3_p && git merge --no-ff 3_q -m 3_F &&
+ git checkout 3_r && test_commit 3_G &&
+ git checkout 3_p && git merge --no-ff 3_r -m 3_H &&
+ git checkout @^^ && git merge --no-ff 3_p -m 3_J &&
+
+ check_graph <<-\EOF
+ * 3_J
+ |\
+ | * 3_H
+ | |\
+ | | * 3_G
+ | * | 3_F
+ |/| |
+ | * | 3_E
+ | |\|
+ | | * 3_D
+ | * | 3_C
+ | |/
+ | * 3_B
+ |/
+ * 3_A
+ EOF
+'
+
+test_expect_success 'log --graph with right-skewed merge following a left-skewed one' '
+ git checkout --orphan 4_p &&
+ test_commit 4_A &&
+ test_commit 4_B &&
+ test_commit 4_C &&
+ git checkout -b 4_q @^^ && test_commit 4_D &&
+ git checkout -b 4_r 4_p^ && git merge --no-ff 4_q -m 4_E &&
+ git checkout -b 4_s 4_p^^ &&
+ git merge --no-ff 4_r -m 4_F &&
+ git merge --no-ff 4_p -m 4_G &&
+ git checkout @^^ && git merge --no-ff 4_s -m 4_H &&
+
+ check_graph --date-order <<-\EOF
+ * 4_H
+ |\
+ | * 4_G
+ | |\
+ | * | 4_F
+ |/| |
+ | * | 4_E
+ | |\ \
+ | | * | 4_D
+ | |/ /
+ |/| |
+ | | * 4_C
+ | |/
+ | * 4_B
+ |/
+ * 4_A
+ EOF
+'
+
+test_expect_success 'log --graph with octopus merge with column joining its penultimate parent' '
+ git checkout --orphan 5_p &&
+ test_commit 5_A &&
+ git branch 5_q &&
+ git branch 5_r &&
+ test_commit 5_B &&
+ git checkout 5_q && test_commit 5_C &&
+ git checkout 5_r && test_commit 5_D &&
+ git checkout 5_p &&
+ git merge --no-ff 5_q 5_r -m 5_E &&
+ git checkout 5_q && test_commit 5_F &&
+ git checkout -b 5_s 5_p^ &&
+ git merge --no-ff 5_p 5_q -m 5_G &&
+ git checkout 5_r &&
+ git merge --no-ff 5_s -m 5_H &&
+
+ check_graph <<-\EOF
+ * 5_H
+ |\
+ | *-. 5_G
+ | |\ \
+ | | | * 5_F
+ | | * | 5_E
+ | |/|\ \
+ | |_|/ /
+ |/| | /
+ | | |/
+ * | | 5_D
+ | | * 5_C
+ | |/
+ |/|
+ | * 5_B
+ |/
+ * 5_A
+ EOF
+'
+
+test_done
diff --git a/t/t6016-rev-list-graph-simplify-history.sh b/t/t6016-rev-list-graph-simplify-history.sh
index f7181d1..f5e6e92 100755
--- a/t/t6016-rev-list-graph-simplify-history.sh
+++ b/t/t6016-rev-list-graph-simplify-history.sh
@@ -67,11 +67,10 @@ test_expect_success '--graph --all' '
echo "| * $C4" >> expected &&
echo "| * $C3" >> expected &&
echo "* | $A5" >> expected &&
- echo "| | " >> expected &&
- echo "| \\ " >> expected &&
- echo "*-. \\ $A4" >> expected &&
- echo "|\\ \\ \\ " >> expected &&
- echo "| | |/ " >> expected &&
+ echo "| | " >> expected &&
+ echo "| \\ " >> expected &&
+ echo "*-. | $A4" >> expected &&
+ echo "|\\ \\| " >> expected &&
echo "| | * $C2" >> expected &&
echo "| | * $C1" >> expected &&
echo "| * | $B2" >> expected &&
@@ -97,11 +96,10 @@ test_expect_success '--graph --simplify-by-decoration' '
echo "| * $C4" >> expected &&
echo "| * $C3" >> expected &&
echo "* | $A5" >> expected &&
- echo "| | " >> expected &&
- echo "| \\ " >> expected &&
- echo "*-. \\ $A4" >> expected &&
- echo "|\\ \\ \\ " >> expected &&
- echo "| | |/ " >> expected &&
+ echo "| | " >> expected &&
+ echo "| \\ " >> expected &&
+ echo "*-. | $A4" >> expected &&
+ echo "|\\ \\| " >> expected &&
echo "| | * $C2" >> expected &&
echo "| | * $C1" >> expected &&
echo "| * | $B2" >> expected &&
@@ -131,9 +129,8 @@ test_expect_success '--graph --simplify-by-decoration prune branch B' '
echo "| * $C4" >> expected &&
echo "| * $C3" >> expected &&
echo "* | $A5" >> expected &&
- echo "* | $A4" >> expected &&
- echo "|\\ \\ " >> expected &&
- echo "| |/ " >> expected &&
+ echo "* | $A4" >> expected &&
+ echo "|\\| " >> expected &&
echo "| * $C2" >> expected &&
echo "| * $C1" >> expected &&
echo "* | $A3" >> expected &&
@@ -151,9 +148,8 @@ test_expect_success '--graph --full-history -- bar.txt' '
echo "|\\ " >> expected &&
echo "| * $C4" >> expected &&
echo "* | $A5" >> expected &&
- echo "* | $A4" >> expected &&
- echo "|\\ \\ " >> expected &&
- echo "| |/ " >> expected &&
+ echo "* | $A4" >> expected &&
+ echo "|\\| " >> expected &&
echo "* | $A3" >> expected &&
echo "|/ " >> expected &&
echo "* $A2" >> expected &&
@@ -255,7 +251,7 @@ test_expect_success '--graph --boundary ^C3' '
echo "* | | | $A3" >> expected &&
echo "o | | | $A2" >> expected &&
echo "|/ / / " >> expected &&
- echo "o | | $A1" >> expected &&
+ echo "o / / $A1" >> expected &&
echo " / / " >> expected &&
echo "| o $C3" >> expected &&
echo "|/ " >> expected &&