fill_tree_descriptor(): mark error message for translation
[git/gitster.git] / graph.c
blob1ca34770ee8139f25e0a2476c5aa3cd8b06fb89c
1 #include "git-compat-util.h"
2 #include "gettext.h"
3 #include "config.h"
4 #include "commit.h"
5 #include "color.h"
6 #include "graph.h"
7 #include "revision.h"
8 #include "strvec.h"
10 /* Internal API */
13 * Output a padding line in the graph.
14 * This is similar to graph_next_line(). However, it is guaranteed to
15 * never print the current commit line. Instead, if the commit line is
16 * next, it will simply output a line of vertical padding, extending the
17 * branch lines downwards, but leaving them otherwise unchanged.
19 static void graph_padding_line(struct git_graph *graph, struct strbuf *sb);
22 * Print a strbuf. If the graph is non-NULL, all lines but the first will be
23 * prefixed with the graph output.
25 * If the strbuf ends with a newline, the output will end after this
26 * newline. A new graph line will not be printed after the final newline.
27 * If the strbuf is empty, no output will be printed.
29 * Since the first line will not include the graph output, the caller is
30 * responsible for printing this line's graph (perhaps via
31 * graph_show_commit() or graph_show_oneline()) before calling
32 * graph_show_strbuf().
34 * Note that unlike some other graph display functions, you must pass the file
35 * handle directly. It is assumed that this is the same file handle as the
36 * file specified by the graph diff options. This is necessary so that
37 * graph_show_strbuf can be called even with a NULL graph.
38 * If a NULL graph is supplied, the strbuf is printed as-is.
40 static void graph_show_strbuf(struct git_graph *graph,
41 FILE *file,
42 struct strbuf const *sb);
45 * TODO:
46 * - Limit the number of columns, similar to the way gitk does.
47 * If we reach more than a specified number of columns, omit
48 * sections of some columns.
51 struct column {
53 * The parent commit of this column.
55 struct commit *commit;
57 * The color to (optionally) print this column in. This is an
58 * index into column_colors.
60 unsigned short color;
63 enum graph_state {
64 GRAPH_PADDING,
65 GRAPH_SKIP,
66 GRAPH_PRE_COMMIT,
67 GRAPH_COMMIT,
68 GRAPH_POST_MERGE,
69 GRAPH_COLLAPSING
72 static void graph_show_line_prefix(const struct diff_options *diffopt)
74 if (!diffopt || !diffopt->line_prefix)
75 return;
77 fwrite(diffopt->line_prefix,
78 sizeof(char),
79 diffopt->line_prefix_length,
80 diffopt->file);
83 static const char **column_colors;
84 static unsigned short column_colors_max;
86 static void parse_graph_colors_config(struct strvec *colors, const char *string)
88 const char *end, *start;
90 start = string;
91 end = string + strlen(string);
92 while (start < end) {
93 const char *comma = strchrnul(start, ',');
94 char color[COLOR_MAXLEN];
96 if (!color_parse_mem(start, comma - start, color))
97 strvec_push(colors, color);
98 else
99 warning(_("ignored invalid color '%.*s' in log.graphColors"),
100 (int)(comma - start), start);
101 start = comma + 1;
103 strvec_push(colors, GIT_COLOR_RESET);
106 void graph_set_column_colors(const char **colors, unsigned short colors_max)
108 column_colors = colors;
109 column_colors_max = colors_max;
112 static const char *column_get_color_code(unsigned short color)
114 return column_colors[color];
117 struct graph_line {
118 struct strbuf *buf;
119 size_t width;
122 static inline void graph_line_addch(struct graph_line *line, int c)
124 strbuf_addch(line->buf, c);
125 line->width++;
128 static inline void graph_line_addchars(struct graph_line *line, int c, size_t n)
130 strbuf_addchars(line->buf, c, n);
131 line->width += n;
134 static inline void graph_line_addstr(struct graph_line *line, const char *s)
136 strbuf_addstr(line->buf, s);
137 line->width += strlen(s);
140 static inline void graph_line_addcolor(struct graph_line *line, unsigned short color)
142 strbuf_addstr(line->buf, column_get_color_code(color));
145 static void graph_line_write_column(struct graph_line *line, const struct column *c,
146 char col_char)
148 if (c->color < column_colors_max)
149 graph_line_addcolor(line, c->color);
150 graph_line_addch(line, col_char);
151 if (c->color < column_colors_max)
152 graph_line_addcolor(line, column_colors_max);
155 struct git_graph {
157 * The commit currently being processed
159 struct commit *commit;
160 /* The rev-info used for the current traversal */
161 struct rev_info *revs;
163 * The number of interesting parents that this commit has.
165 * Note that this is not the same as the actual number of parents.
166 * This count excludes parents that won't be printed in the graph
167 * output, as determined by graph_is_interesting().
169 int num_parents;
171 * The width of the graph output for this commit.
172 * All rows for this commit are padded to this width, so that
173 * messages printed after the graph output are aligned.
175 int width;
177 * The next expansion row to print
178 * when state is GRAPH_PRE_COMMIT
180 int expansion_row;
182 * The current output state.
183 * This tells us what kind of line graph_next_line() should output.
185 enum graph_state state;
187 * The output state for the previous line of output.
188 * This is primarily used to determine how the first merge line
189 * should appear, based on the last line of the previous commit.
191 enum graph_state prev_state;
193 * The index of the column that refers to this commit.
195 * If none of the incoming columns refer to this commit,
196 * this will be equal to num_columns.
198 int commit_index;
200 * The commit_index for the previously displayed commit.
202 * This is used to determine how the first line of a merge
203 * graph output should appear, based on the last line of the
204 * previous commit.
206 int prev_commit_index;
208 * Which layout variant to use to display merge commits. If the
209 * commit's first parent is known to be in a column to the left of the
210 * merge, then this value is 0 and we use the layout on the left.
211 * Otherwise, the value is 1 and the layout on the right is used. This
212 * field tells us how many columns the first parent occupies.
214 * 0) 1)
216 * | | | *-. | | *---.
217 * | |_|/|\ \ | | |\ \ \
218 * |/| | | | | | | | | | *
220 int merge_layout;
222 * The number of columns added to the graph by the current commit. For
223 * 2-way and octopus merges, this is usually one less than the
224 * number of parents:
226 * | | | | | \
227 * | * | | *---. \
228 * | |\ \ | |\ \ \ \
229 * | | | | | | | | | |
231 * num_parents: 2 num_parents: 4
232 * edges_added: 1 edges_added: 3
234 * For left-skewed merges, the first parent fuses with its neighbor and
235 * so one less column is added:
237 * | | | | | \
238 * | * | | *-. \
239 * |/| | |/|\ \ \
240 * | | | | | | | |
242 * num_parents: 2 num_parents: 4
243 * edges_added: 0 edges_added: 2
245 * This number determines how edges to the right of the merge are
246 * displayed in commit and post-merge lines; if no columns have been
247 * added then a vertical line should be used where a right-tracking
248 * line would otherwise be used.
250 * | * \ | * |
251 * | |\ \ |/| |
252 * | | * \ | * |
254 int edges_added;
256 * The number of columns added by the previous commit, which is used to
257 * smooth edges appearing to the right of a commit in a commit line
258 * following a post-merge line.
260 int prev_edges_added;
262 * The maximum number of columns that can be stored in the columns
263 * and new_columns arrays. This is also half the number of entries
264 * that can be stored in the mapping and old_mapping arrays.
266 int column_capacity;
268 * The number of columns (also called "branch lines" in some places)
270 int num_columns;
272 * The number of columns in the new_columns array
274 int num_new_columns;
276 * The number of entries in the mapping array
278 int mapping_size;
280 * The column state before we output the current commit.
282 struct column *columns;
284 * The new column state after we output the current commit.
285 * Only valid when state is GRAPH_COLLAPSING.
287 struct column *new_columns;
289 * An array that tracks the current state of each
290 * character in the output line during state GRAPH_COLLAPSING.
291 * Each entry is -1 if this character is empty, or a non-negative
292 * integer if the character contains a branch line. The value of
293 * the integer indicates the target position for this branch line.
294 * (I.e., this array maps the current column positions to their
295 * desired positions.)
297 * The maximum capacity of this array is always
298 * sizeof(int) * 2 * column_capacity.
300 int *mapping;
302 * A copy of the contents of the mapping array from the last commit,
303 * which we use to improve the display of columns that are tracking
304 * from right to left through a commit line. We also use this to
305 * avoid allocating a fresh array when we compute the next mapping.
307 int *old_mapping;
309 * The current default column color being used. This is
310 * stored as an index into the array column_colors.
312 unsigned short default_column_color;
315 static struct strbuf *diff_output_prefix_callback(struct diff_options *opt, void *data)
317 struct git_graph *graph = data;
318 static struct strbuf msgbuf = STRBUF_INIT;
320 assert(opt);
322 strbuf_reset(&msgbuf);
323 if (opt->line_prefix)
324 strbuf_add(&msgbuf, opt->line_prefix,
325 opt->line_prefix_length);
326 if (graph)
327 graph_padding_line(graph, &msgbuf);
328 return &msgbuf;
331 static const struct diff_options *default_diffopt;
333 void graph_setup_line_prefix(struct diff_options *diffopt)
335 default_diffopt = diffopt;
337 /* setup an output prefix callback if necessary */
338 if (diffopt && !diffopt->output_prefix)
339 diffopt->output_prefix = diff_output_prefix_callback;
342 struct git_graph *graph_init(struct rev_info *opt)
344 struct git_graph *graph = xmalloc(sizeof(struct git_graph));
346 if (!column_colors) {
347 char *string;
348 if (git_config_get_string("log.graphcolors", &string)) {
349 /* not configured -- use default */
350 graph_set_column_colors(column_colors_ansi,
351 column_colors_ansi_max);
352 } else {
353 static struct strvec custom_colors = STRVEC_INIT;
354 strvec_clear(&custom_colors);
355 parse_graph_colors_config(&custom_colors, string);
356 free(string);
357 /* graph_set_column_colors takes a max-index, not a count */
358 graph_set_column_colors(custom_colors.v,
359 custom_colors.nr - 1);
363 graph->commit = NULL;
364 graph->revs = opt;
365 graph->num_parents = 0;
366 graph->expansion_row = 0;
367 graph->state = GRAPH_PADDING;
368 graph->prev_state = GRAPH_PADDING;
369 graph->commit_index = 0;
370 graph->prev_commit_index = 0;
371 graph->merge_layout = 0;
372 graph->edges_added = 0;
373 graph->prev_edges_added = 0;
374 graph->num_columns = 0;
375 graph->num_new_columns = 0;
376 graph->mapping_size = 0;
378 * Start the column color at the maximum value, since we'll
379 * always increment it for the first commit we output.
380 * This way we start at 0 for the first commit.
382 graph->default_column_color = column_colors_max - 1;
385 * Allocate a reasonably large default number of columns
386 * We'll automatically grow columns later if we need more room.
388 graph->column_capacity = 30;
389 ALLOC_ARRAY(graph->columns, graph->column_capacity);
390 ALLOC_ARRAY(graph->new_columns, graph->column_capacity);
391 ALLOC_ARRAY(graph->mapping, 2 * graph->column_capacity);
392 ALLOC_ARRAY(graph->old_mapping, 2 * graph->column_capacity);
395 * The diff output prefix callback, with this we can make
396 * all the diff output to align with the graph lines.
398 opt->diffopt.output_prefix = diff_output_prefix_callback;
399 opt->diffopt.output_prefix_data = graph;
401 return graph;
404 void graph_clear(struct git_graph *graph)
406 if (!graph)
407 return;
409 free(graph->columns);
410 free(graph->new_columns);
411 free(graph->mapping);
412 free(graph->old_mapping);
413 free(graph);
416 static void graph_update_state(struct git_graph *graph, enum graph_state s)
418 graph->prev_state = graph->state;
419 graph->state = s;
422 static void graph_ensure_capacity(struct git_graph *graph, int num_columns)
424 if (graph->column_capacity >= num_columns)
425 return;
427 do {
428 graph->column_capacity *= 2;
429 } while (graph->column_capacity < num_columns);
431 REALLOC_ARRAY(graph->columns, graph->column_capacity);
432 REALLOC_ARRAY(graph->new_columns, graph->column_capacity);
433 REALLOC_ARRAY(graph->mapping, graph->column_capacity * 2);
434 REALLOC_ARRAY(graph->old_mapping, graph->column_capacity * 2);
438 * Returns 1 if the commit will be printed in the graph output,
439 * and 0 otherwise.
441 static int graph_is_interesting(struct git_graph *graph, struct commit *commit)
444 * If revs->boundary is set, commits whose children have
445 * been shown are always interesting, even if they have the
446 * UNINTERESTING or TREESAME flags set.
448 if (graph->revs && graph->revs->boundary) {
449 if (commit->object.flags & CHILD_SHOWN)
450 return 1;
454 * Otherwise, use get_commit_action() to see if this commit is
455 * interesting
457 return get_commit_action(graph->revs, commit) == commit_show;
460 static struct commit_list *next_interesting_parent(struct git_graph *graph,
461 struct commit_list *orig)
463 struct commit_list *list;
466 * If revs->first_parent_only is set, only the first
467 * parent is interesting. None of the others are.
469 if (graph->revs->first_parent_only)
470 return NULL;
473 * Return the next interesting commit after orig
475 for (list = orig->next; list; list = list->next) {
476 if (graph_is_interesting(graph, list->item))
477 return list;
480 return NULL;
483 static struct commit_list *first_interesting_parent(struct git_graph *graph)
485 struct commit_list *parents = graph->commit->parents;
488 * If this commit has no parents, ignore it
490 if (!parents)
491 return NULL;
494 * If the first parent is interesting, return it
496 if (graph_is_interesting(graph, parents->item))
497 return parents;
500 * Otherwise, call next_interesting_parent() to get
501 * the next interesting parent
503 return next_interesting_parent(graph, parents);
506 static unsigned short graph_get_current_column_color(const struct git_graph *graph)
508 if (!want_color(graph->revs->diffopt.use_color))
509 return column_colors_max;
510 return graph->default_column_color;
514 * Update the graph's default column color.
516 static void graph_increment_column_color(struct git_graph *graph)
518 graph->default_column_color = (graph->default_column_color + 1) %
519 column_colors_max;
522 static unsigned short graph_find_commit_color(const struct git_graph *graph,
523 const struct commit *commit)
525 int i;
526 for (i = 0; i < graph->num_columns; i++) {
527 if (graph->columns[i].commit == commit)
528 return graph->columns[i].color;
530 return graph_get_current_column_color(graph);
533 static int graph_find_new_column_by_commit(struct git_graph *graph,
534 struct commit *commit)
536 int i;
537 for (i = 0; i < graph->num_new_columns; i++) {
538 if (graph->new_columns[i].commit == commit)
539 return i;
541 return -1;
544 static void graph_insert_into_new_columns(struct git_graph *graph,
545 struct commit *commit,
546 int idx)
548 int i = graph_find_new_column_by_commit(graph, commit);
549 int mapping_idx;
552 * If the commit is not already in the new_columns array, then add it
553 * and record it as being in the final column.
555 if (i < 0) {
556 i = graph->num_new_columns++;
557 graph->new_columns[i].commit = commit;
558 graph->new_columns[i].color = graph_find_commit_color(graph, commit);
561 if (graph->num_parents > 1 && idx > -1 && graph->merge_layout == -1) {
563 * If this is the first parent of a merge, choose a layout for
564 * the merge line based on whether the parent appears in a
565 * column to the left of the merge
567 int dist, shift;
569 dist = idx - i;
570 shift = (dist > 1) ? 2 * dist - 3 : 1;
572 graph->merge_layout = (dist > 0) ? 0 : 1;
573 graph->edges_added = graph->num_parents + graph->merge_layout - 2;
575 mapping_idx = graph->width + (graph->merge_layout - 1) * shift;
576 graph->width += 2 * graph->merge_layout;
578 } else if (graph->edges_added > 0 && i == graph->mapping[graph->width - 2]) {
580 * If some columns have been added by a merge, but this commit
581 * was found in the last existing column, then adjust the
582 * numbers so that the two edges immediately join, i.e.:
584 * * | * |
585 * |\ \ => |\|
586 * | |/ | *
587 * | *
589 mapping_idx = graph->width - 2;
590 graph->edges_added = -1;
591 } else {
592 mapping_idx = graph->width;
593 graph->width += 2;
596 graph->mapping[mapping_idx] = i;
599 static void graph_update_columns(struct git_graph *graph)
601 struct commit_list *parent;
602 int max_new_columns;
603 int i, seen_this, is_commit_in_columns;
606 * Swap graph->columns with graph->new_columns
607 * graph->columns contains the state for the previous commit,
608 * and new_columns now contains the state for our commit.
610 * We'll re-use the old columns array as storage to compute the new
611 * columns list for the commit after this one.
613 SWAP(graph->columns, graph->new_columns);
614 graph->num_columns = graph->num_new_columns;
615 graph->num_new_columns = 0;
618 * Now update new_columns and mapping with the information for the
619 * commit after this one.
621 * First, make sure we have enough room. At most, there will
622 * be graph->num_columns + graph->num_parents columns for the next
623 * commit.
625 max_new_columns = graph->num_columns + graph->num_parents;
626 graph_ensure_capacity(graph, max_new_columns);
629 * Clear out graph->mapping
631 graph->mapping_size = 2 * max_new_columns;
632 for (i = 0; i < graph->mapping_size; i++)
633 graph->mapping[i] = -1;
635 graph->width = 0;
636 graph->prev_edges_added = graph->edges_added;
637 graph->edges_added = 0;
640 * Populate graph->new_columns and graph->mapping
642 * Some of the parents of this commit may already be in
643 * graph->columns. If so, graph->new_columns should only contain a
644 * single entry for each such commit. graph->mapping should
645 * contain information about where each current branch line is
646 * supposed to end up after the collapsing is performed.
648 seen_this = 0;
649 is_commit_in_columns = 1;
650 for (i = 0; i <= graph->num_columns; i++) {
651 struct commit *col_commit;
652 if (i == graph->num_columns) {
653 if (seen_this)
654 break;
655 is_commit_in_columns = 0;
656 col_commit = graph->commit;
657 } else {
658 col_commit = graph->columns[i].commit;
661 if (col_commit == graph->commit) {
662 seen_this = 1;
663 graph->commit_index = i;
664 graph->merge_layout = -1;
665 for (parent = first_interesting_parent(graph);
666 parent;
667 parent = next_interesting_parent(graph, parent)) {
669 * If this is a merge, or the start of a new
670 * childless column, increment the current
671 * color.
673 if (graph->num_parents > 1 ||
674 !is_commit_in_columns) {
675 graph_increment_column_color(graph);
677 graph_insert_into_new_columns(graph, parent->item, i);
680 * We always need to increment graph->width by at
681 * least 2, even if it has no interesting parents.
682 * The current commit always takes up at least 2
683 * spaces.
685 if (graph->num_parents == 0)
686 graph->width += 2;
687 } else {
688 graph_insert_into_new_columns(graph, col_commit, -1);
693 * Shrink mapping_size to be the minimum necessary
695 while (graph->mapping_size > 1 &&
696 graph->mapping[graph->mapping_size - 1] < 0)
697 graph->mapping_size--;
700 static int graph_num_dashed_parents(struct git_graph *graph)
702 return graph->num_parents + graph->merge_layout - 3;
705 static int graph_num_expansion_rows(struct git_graph *graph)
708 * Normally, we need two expansion rows for each dashed parent line from
709 * an octopus merge:
711 * | *
712 * | |\
713 * | | \
714 * | | \
715 * | *-. \
716 * | |\ \ \
718 * If the merge is skewed to the left, then its parents occupy one less
719 * column, and we don't need as many expansion rows to route around it;
720 * in some cases that means we don't need any expansion rows at all:
722 * | *
723 * | |\
724 * | * \
725 * |/|\ \
727 return graph_num_dashed_parents(graph) * 2;
730 static int graph_needs_pre_commit_line(struct git_graph *graph)
732 return graph->num_parents >= 3 &&
733 graph->commit_index < (graph->num_columns - 1) &&
734 graph->expansion_row < graph_num_expansion_rows(graph);
737 void graph_update(struct git_graph *graph, struct commit *commit)
739 struct commit_list *parent;
742 * Set the new commit
744 graph->commit = commit;
747 * Count how many interesting parents this commit has
749 graph->num_parents = 0;
750 for (parent = first_interesting_parent(graph);
751 parent;
752 parent = next_interesting_parent(graph, parent))
754 graph->num_parents++;
758 * Store the old commit_index in prev_commit_index.
759 * graph_update_columns() will update graph->commit_index for this
760 * commit.
762 graph->prev_commit_index = graph->commit_index;
765 * Call graph_update_columns() to update
766 * columns, new_columns, and mapping.
768 graph_update_columns(graph);
770 graph->expansion_row = 0;
773 * Update graph->state.
774 * Note that we don't call graph_update_state() here, since
775 * we don't want to update graph->prev_state. No line for
776 * graph->state was ever printed.
778 * If the previous commit didn't get to the GRAPH_PADDING state,
779 * it never finished its output. Goto GRAPH_SKIP, to print out
780 * a line to indicate that portion of the graph is missing.
782 * If there are 3 or more parents, we may need to print extra rows
783 * before the commit, to expand the branch lines around it and make
784 * room for it. We need to do this only if there is a branch row
785 * (or more) to the right of this commit.
787 * If there are less than 3 parents, we can immediately print the
788 * commit line.
790 if (graph->state != GRAPH_PADDING)
791 graph->state = GRAPH_SKIP;
792 else if (graph_needs_pre_commit_line(graph))
793 graph->state = GRAPH_PRE_COMMIT;
794 else
795 graph->state = GRAPH_COMMIT;
798 static int graph_is_mapping_correct(struct git_graph *graph)
800 int i;
803 * The mapping is up to date if each entry is at its target,
804 * or is 1 greater than its target.
805 * (If it is 1 greater than the target, '/' will be printed, so it
806 * will look correct on the next row.)
808 for (i = 0; i < graph->mapping_size; i++) {
809 int target = graph->mapping[i];
810 if (target < 0)
811 continue;
812 if (target == (i / 2))
813 continue;
814 return 0;
817 return 1;
820 static void graph_pad_horizontally(struct git_graph *graph, struct graph_line *line)
823 * Add additional spaces to the end of the strbuf, so that all
824 * lines for a particular commit have the same width.
826 * This way, fields printed to the right of the graph will remain
827 * aligned for the entire commit.
829 if (line->width < graph->width)
830 graph_line_addchars(line, ' ', graph->width - line->width);
833 static void graph_output_padding_line(struct git_graph *graph,
834 struct graph_line *line)
836 int i;
839 * Output a padding row, that leaves all branch lines unchanged
841 for (i = 0; i < graph->num_new_columns; i++) {
842 graph_line_write_column(line, &graph->new_columns[i], '|');
843 graph_line_addch(line, ' ');
848 int graph_width(struct git_graph *graph)
850 return graph->width;
854 static void graph_output_skip_line(struct git_graph *graph, struct graph_line *line)
857 * Output an ellipsis to indicate that a portion
858 * of the graph is missing.
860 graph_line_addstr(line, "...");
862 if (graph_needs_pre_commit_line(graph))
863 graph_update_state(graph, GRAPH_PRE_COMMIT);
864 else
865 graph_update_state(graph, GRAPH_COMMIT);
868 static void graph_output_pre_commit_line(struct git_graph *graph,
869 struct graph_line *line)
871 int i, seen_this;
874 * This function formats a row that increases the space around a commit
875 * with multiple parents, to make room for it. It should only be
876 * called when there are 3 or more parents.
878 * We need 2 extra rows for every parent over 2.
880 assert(graph->num_parents >= 3);
883 * graph->expansion_row tracks the current expansion row we are on.
884 * It should be in the range [0, num_expansion_rows - 1]
886 assert(0 <= graph->expansion_row &&
887 graph->expansion_row < graph_num_expansion_rows(graph));
890 * Output the row
892 seen_this = 0;
893 for (i = 0; i < graph->num_columns; i++) {
894 struct column *col = &graph->columns[i];
895 if (col->commit == graph->commit) {
896 seen_this = 1;
897 graph_line_write_column(line, col, '|');
898 graph_line_addchars(line, ' ', graph->expansion_row);
899 } else if (seen_this && (graph->expansion_row == 0)) {
901 * This is the first line of the pre-commit output.
902 * If the previous commit was a merge commit and
903 * ended in the GRAPH_POST_MERGE state, all branch
904 * lines after graph->prev_commit_index were
905 * printed as "\" on the previous line. Continue
906 * to print them as "\" on this line. Otherwise,
907 * print the branch lines as "|".
909 if (graph->prev_state == GRAPH_POST_MERGE &&
910 graph->prev_commit_index < i)
911 graph_line_write_column(line, col, '\\');
912 else
913 graph_line_write_column(line, col, '|');
914 } else if (seen_this && (graph->expansion_row > 0)) {
915 graph_line_write_column(line, col, '\\');
916 } else {
917 graph_line_write_column(line, col, '|');
919 graph_line_addch(line, ' ');
923 * Increment graph->expansion_row,
924 * and move to state GRAPH_COMMIT if necessary
926 graph->expansion_row++;
927 if (!graph_needs_pre_commit_line(graph))
928 graph_update_state(graph, GRAPH_COMMIT);
931 static void graph_output_commit_char(struct git_graph *graph, struct graph_line *line)
934 * For boundary commits, print 'o'
935 * (We should only see boundary commits when revs->boundary is set.)
937 if (graph->commit->object.flags & BOUNDARY) {
938 assert(graph->revs->boundary);
939 graph_line_addch(line, 'o');
940 return;
944 * get_revision_mark() handles all other cases without assert()
946 graph_line_addstr(line, get_revision_mark(graph->revs, graph->commit));
950 * Draw the horizontal dashes of an octopus merge.
952 static void graph_draw_octopus_merge(struct git_graph *graph, struct graph_line *line)
955 * The parents of a merge commit can be arbitrarily reordered as they
956 * are mapped onto display columns, for example this is a valid merge:
958 * | | *---.
959 * | | |\ \ \
960 * | | |/ / /
961 * | |/| | /
962 * | |_|_|/
963 * |/| | |
964 * 3 1 0 2
966 * The numbers denote which parent of the merge each visual column
967 * corresponds to; we can't assume that the parents will initially
968 * display in the order given by new_columns.
970 * To find the right color for each dash, we need to consult the
971 * mapping array, starting from the column 2 places to the right of the
972 * merge commit, and use that to find out which logical column each
973 * edge will collapse to.
975 * Commits are rendered once all edges have collapsed to their correct
976 * logcial column, so commit_index gives us the right visual offset for
977 * the merge commit.
980 int i, j;
981 struct column *col;
983 int dashed_parents = graph_num_dashed_parents(graph);
985 for (i = 0; i < dashed_parents; i++) {
986 j = graph->mapping[(graph->commit_index + i + 2) * 2];
987 col = &graph->new_columns[j];
989 graph_line_write_column(line, col, '-');
990 graph_line_write_column(line, col, (i == dashed_parents - 1) ? '.' : '-');
993 return;
996 static void graph_output_commit_line(struct git_graph *graph, struct graph_line *line)
998 int seen_this = 0;
999 int i;
1002 * Output the row containing this commit
1003 * Iterate up to and including graph->num_columns,
1004 * since the current commit may not be in any of the existing
1005 * columns. (This happens when the current commit doesn't have any
1006 * children that we have already processed.)
1008 seen_this = 0;
1009 for (i = 0; i <= graph->num_columns; i++) {
1010 struct column *col = &graph->columns[i];
1011 struct commit *col_commit;
1012 if (i == graph->num_columns) {
1013 if (seen_this)
1014 break;
1015 col_commit = graph->commit;
1016 } else {
1017 col_commit = graph->columns[i].commit;
1020 if (col_commit == graph->commit) {
1021 seen_this = 1;
1022 graph_output_commit_char(graph, line);
1024 if (graph->num_parents > 2)
1025 graph_draw_octopus_merge(graph, line);
1026 } else if (seen_this && (graph->edges_added > 1)) {
1027 graph_line_write_column(line, col, '\\');
1028 } else if (seen_this && (graph->edges_added == 1)) {
1030 * This is either a right-skewed 2-way merge
1031 * commit, or a left-skewed 3-way merge.
1032 * There is no GRAPH_PRE_COMMIT stage for such
1033 * merges, so this is the first line of output
1034 * for this commit. Check to see what the previous
1035 * line of output was.
1037 * If it was GRAPH_POST_MERGE, the branch line
1038 * coming into this commit may have been '\',
1039 * and not '|' or '/'. If so, output the branch
1040 * line as '\' on this line, instead of '|'. This
1041 * makes the output look nicer.
1043 if (graph->prev_state == GRAPH_POST_MERGE &&
1044 graph->prev_edges_added > 0 &&
1045 graph->prev_commit_index < i)
1046 graph_line_write_column(line, col, '\\');
1047 else
1048 graph_line_write_column(line, col, '|');
1049 } else if (graph->prev_state == GRAPH_COLLAPSING &&
1050 graph->old_mapping[2 * i + 1] == i &&
1051 graph->mapping[2 * i] < i) {
1052 graph_line_write_column(line, col, '/');
1053 } else {
1054 graph_line_write_column(line, col, '|');
1056 graph_line_addch(line, ' ');
1060 * Update graph->state
1062 if (graph->num_parents > 1)
1063 graph_update_state(graph, GRAPH_POST_MERGE);
1064 else if (graph_is_mapping_correct(graph))
1065 graph_update_state(graph, GRAPH_PADDING);
1066 else
1067 graph_update_state(graph, GRAPH_COLLAPSING);
1070 static const char merge_chars[] = {'/', '|', '\\'};
1072 static void graph_output_post_merge_line(struct git_graph *graph, struct graph_line *line)
1074 int seen_this = 0;
1075 int i, j;
1077 struct commit_list *first_parent = first_interesting_parent(graph);
1078 struct column *parent_col = NULL;
1081 * Output the post-merge row
1083 for (i = 0; i <= graph->num_columns; i++) {
1084 struct column *col = &graph->columns[i];
1085 struct commit *col_commit;
1086 if (i == graph->num_columns) {
1087 if (seen_this)
1088 break;
1089 col_commit = graph->commit;
1090 } else {
1091 col_commit = col->commit;
1094 if (col_commit == graph->commit) {
1096 * Since the current commit is a merge find
1097 * the columns for the parent commits in
1098 * new_columns and use those to format the
1099 * edges.
1101 struct commit_list *parents = first_parent;
1102 int par_column;
1103 int idx = graph->merge_layout;
1104 char c;
1105 seen_this = 1;
1107 for (j = 0; j < graph->num_parents; j++) {
1108 par_column = graph_find_new_column_by_commit(graph, parents->item);
1109 assert(par_column >= 0);
1111 c = merge_chars[idx];
1112 graph_line_write_column(line, &graph->new_columns[par_column], c);
1113 if (idx == 2) {
1114 if (graph->edges_added > 0 || j < graph->num_parents - 1)
1115 graph_line_addch(line, ' ');
1116 } else {
1117 idx++;
1119 parents = next_interesting_parent(graph, parents);
1121 if (graph->edges_added == 0)
1122 graph_line_addch(line, ' ');
1124 } else if (seen_this) {
1125 if (graph->edges_added > 0)
1126 graph_line_write_column(line, col, '\\');
1127 else
1128 graph_line_write_column(line, col, '|');
1129 graph_line_addch(line, ' ');
1130 } else {
1131 graph_line_write_column(line, col, '|');
1132 if (graph->merge_layout != 0 || i != graph->commit_index - 1) {
1133 if (parent_col)
1134 graph_line_write_column(
1135 line, parent_col, '_');
1136 else
1137 graph_line_addch(line, ' ');
1141 if (col_commit == first_parent->item)
1142 parent_col = col;
1146 * Update graph->state
1148 if (graph_is_mapping_correct(graph))
1149 graph_update_state(graph, GRAPH_PADDING);
1150 else
1151 graph_update_state(graph, GRAPH_COLLAPSING);
1154 static void graph_output_collapsing_line(struct git_graph *graph, struct graph_line *line)
1156 int i;
1157 short used_horizontal = 0;
1158 int horizontal_edge = -1;
1159 int horizontal_edge_target = -1;
1162 * Swap the mapping and old_mapping arrays
1164 SWAP(graph->mapping, graph->old_mapping);
1167 * Clear out the mapping array
1169 for (i = 0; i < graph->mapping_size; i++)
1170 graph->mapping[i] = -1;
1172 for (i = 0; i < graph->mapping_size; i++) {
1173 int target = graph->old_mapping[i];
1174 if (target < 0)
1175 continue;
1178 * Since update_columns() always inserts the leftmost
1179 * column first, each branch's target location should
1180 * always be either its current location or to the left of
1181 * its current location.
1183 * We never have to move branches to the right. This makes
1184 * the graph much more legible, since whenever branches
1185 * cross, only one is moving directions.
1187 assert(target * 2 <= i);
1189 if (target * 2 == i) {
1191 * This column is already in the
1192 * correct place
1194 assert(graph->mapping[i] == -1);
1195 graph->mapping[i] = target;
1196 } else if (graph->mapping[i - 1] < 0) {
1198 * Nothing is to the left.
1199 * Move to the left by one
1201 graph->mapping[i - 1] = target;
1203 * If there isn't already an edge moving horizontally
1204 * select this one.
1206 if (horizontal_edge == -1) {
1207 int j;
1208 horizontal_edge = i;
1209 horizontal_edge_target = target;
1211 * The variable target is the index of the graph
1212 * column, and therefore target*2+3 is the
1213 * actual screen column of the first horizontal
1214 * line.
1216 for (j = (target * 2)+3; j < (i - 2); j += 2)
1217 graph->mapping[j] = target;
1219 } else if (graph->mapping[i - 1] == target) {
1221 * There is a branch line to our left
1222 * already, and it is our target. We
1223 * combine with this line, since we share
1224 * the same parent commit.
1226 * We don't have to add anything to the
1227 * output or mapping, since the
1228 * existing branch line has already taken
1229 * care of it.
1231 } else {
1233 * There is a branch line to our left,
1234 * but it isn't our target. We need to
1235 * cross over it.
1237 * The space just to the left of this
1238 * branch should always be empty.
1240 assert(graph->mapping[i - 1] > target);
1241 assert(graph->mapping[i - 2] < 0);
1242 graph->mapping[i - 2] = target;
1244 * Mark this branch as the horizontal edge to
1245 * prevent any other edges from moving
1246 * horizontally.
1248 if (horizontal_edge == -1) {
1249 int j;
1250 horizontal_edge_target = target;
1251 horizontal_edge = i - 1;
1253 for (j = (target * 2) + 3; j < (i - 2); j += 2)
1254 graph->mapping[j] = target;
1260 * Copy the current mapping array into old_mapping
1262 COPY_ARRAY(graph->old_mapping, graph->mapping, graph->mapping_size);
1265 * The new mapping may be 1 smaller than the old mapping
1267 if (graph->mapping[graph->mapping_size - 1] < 0)
1268 graph->mapping_size--;
1271 * Output out a line based on the new mapping info
1273 for (i = 0; i < graph->mapping_size; i++) {
1274 int target = graph->mapping[i];
1275 if (target < 0)
1276 graph_line_addch(line, ' ');
1277 else if (target * 2 == i)
1278 graph_line_write_column(line, &graph->new_columns[target], '|');
1279 else if (target == horizontal_edge_target &&
1280 i != horizontal_edge - 1) {
1282 * Set the mappings for all but the
1283 * first segment to -1 so that they
1284 * won't continue into the next line.
1286 if (i != (target * 2)+3)
1287 graph->mapping[i] = -1;
1288 used_horizontal = 1;
1289 graph_line_write_column(line, &graph->new_columns[target], '_');
1290 } else {
1291 if (used_horizontal && i < horizontal_edge)
1292 graph->mapping[i] = -1;
1293 graph_line_write_column(line, &graph->new_columns[target], '/');
1299 * If graph->mapping indicates that all of the branch lines
1300 * are already in the correct positions, we are done.
1301 * Otherwise, we need to collapse some branch lines together.
1303 if (graph_is_mapping_correct(graph))
1304 graph_update_state(graph, GRAPH_PADDING);
1307 int graph_next_line(struct git_graph *graph, struct strbuf *sb)
1309 int shown_commit_line = 0;
1310 struct graph_line line = { .buf = sb, .width = 0 };
1313 * We could conceivable be called with a NULL commit
1314 * if our caller has a bug, and invokes graph_next_line()
1315 * immediately after graph_init(), without first calling
1316 * graph_update(). Return without outputting anything in this
1317 * case.
1319 if (!graph->commit)
1320 return -1;
1322 switch (graph->state) {
1323 case GRAPH_PADDING:
1324 graph_output_padding_line(graph, &line);
1325 break;
1326 case GRAPH_SKIP:
1327 graph_output_skip_line(graph, &line);
1328 break;
1329 case GRAPH_PRE_COMMIT:
1330 graph_output_pre_commit_line(graph, &line);
1331 break;
1332 case GRAPH_COMMIT:
1333 graph_output_commit_line(graph, &line);
1334 shown_commit_line = 1;
1335 break;
1336 case GRAPH_POST_MERGE:
1337 graph_output_post_merge_line(graph, &line);
1338 break;
1339 case GRAPH_COLLAPSING:
1340 graph_output_collapsing_line(graph, &line);
1341 break;
1344 graph_pad_horizontally(graph, &line);
1345 return shown_commit_line;
1348 static void graph_padding_line(struct git_graph *graph, struct strbuf *sb)
1350 int i;
1351 struct graph_line line = { .buf = sb, .width = 0 };
1353 if (graph->state != GRAPH_COMMIT) {
1354 graph_next_line(graph, sb);
1355 return;
1359 * Output the row containing this commit
1360 * Iterate up to and including graph->num_columns,
1361 * since the current commit may not be in any of the existing
1362 * columns. (This happens when the current commit doesn't have any
1363 * children that we have already processed.)
1365 for (i = 0; i < graph->num_columns; i++) {
1366 struct column *col = &graph->columns[i];
1368 graph_line_write_column(&line, col, '|');
1370 if (col->commit == graph->commit && graph->num_parents > 2) {
1371 int len = (graph->num_parents - 2) * 2;
1372 graph_line_addchars(&line, ' ', len);
1373 } else {
1374 graph_line_addch(&line, ' ');
1378 graph_pad_horizontally(graph, &line);
1381 * Update graph->prev_state since we have output a padding line
1383 graph->prev_state = GRAPH_PADDING;
1386 int graph_is_commit_finished(struct git_graph const *graph)
1388 return (graph->state == GRAPH_PADDING);
1391 void graph_show_commit(struct git_graph *graph)
1393 struct strbuf msgbuf = STRBUF_INIT;
1394 int shown_commit_line = 0;
1396 graph_show_line_prefix(default_diffopt);
1398 if (!graph)
1399 return;
1402 * When showing a diff of a merge against each of its parents, we
1403 * are called once for each parent without graph_update having been
1404 * called. In this case, simply output a single padding line.
1406 if (graph_is_commit_finished(graph)) {
1407 graph_show_padding(graph);
1408 shown_commit_line = 1;
1411 while (!shown_commit_line && !graph_is_commit_finished(graph)) {
1412 shown_commit_line = graph_next_line(graph, &msgbuf);
1413 fwrite(msgbuf.buf, sizeof(char), msgbuf.len,
1414 graph->revs->diffopt.file);
1415 if (!shown_commit_line) {
1416 putc('\n', graph->revs->diffopt.file);
1417 graph_show_line_prefix(&graph->revs->diffopt);
1419 strbuf_setlen(&msgbuf, 0);
1422 strbuf_release(&msgbuf);
1425 void graph_show_oneline(struct git_graph *graph)
1427 struct strbuf msgbuf = STRBUF_INIT;
1429 graph_show_line_prefix(default_diffopt);
1431 if (!graph)
1432 return;
1434 graph_next_line(graph, &msgbuf);
1435 fwrite(msgbuf.buf, sizeof(char), msgbuf.len, graph->revs->diffopt.file);
1436 strbuf_release(&msgbuf);
1439 void graph_show_padding(struct git_graph *graph)
1441 struct strbuf msgbuf = STRBUF_INIT;
1443 graph_show_line_prefix(default_diffopt);
1445 if (!graph)
1446 return;
1448 graph_padding_line(graph, &msgbuf);
1449 fwrite(msgbuf.buf, sizeof(char), msgbuf.len, graph->revs->diffopt.file);
1450 strbuf_release(&msgbuf);
1453 int graph_show_remainder(struct git_graph *graph)
1455 struct strbuf msgbuf = STRBUF_INIT;
1456 int shown = 0;
1458 graph_show_line_prefix(default_diffopt);
1460 if (!graph)
1461 return 0;
1463 if (graph_is_commit_finished(graph))
1464 return 0;
1466 for (;;) {
1467 graph_next_line(graph, &msgbuf);
1468 fwrite(msgbuf.buf, sizeof(char), msgbuf.len,
1469 graph->revs->diffopt.file);
1470 strbuf_setlen(&msgbuf, 0);
1471 shown = 1;
1473 if (!graph_is_commit_finished(graph)) {
1474 putc('\n', graph->revs->diffopt.file);
1475 graph_show_line_prefix(&graph->revs->diffopt);
1476 } else {
1477 break;
1480 strbuf_release(&msgbuf);
1482 return shown;
1485 static void graph_show_strbuf(struct git_graph *graph,
1486 FILE *file,
1487 struct strbuf const *sb)
1489 char *p;
1492 * Print the strbuf line by line,
1493 * and display the graph info before each line but the first.
1495 p = sb->buf;
1496 while (p) {
1497 size_t len;
1498 char *next_p = strchr(p, '\n');
1499 if (next_p) {
1500 next_p++;
1501 len = next_p - p;
1502 } else {
1503 len = (sb->buf + sb->len) - p;
1505 fwrite(p, sizeof(char), len, file);
1506 if (next_p && *next_p != '\0')
1507 graph_show_oneline(graph);
1508 p = next_p;
1512 void graph_show_commit_msg(struct git_graph *graph,
1513 FILE *file,
1514 struct strbuf const *sb)
1516 int newline_terminated;
1519 * Show the commit message
1521 graph_show_strbuf(graph, file, sb);
1523 if (!graph)
1524 return;
1526 newline_terminated = (sb->len && sb->buf[sb->len - 1] == '\n');
1529 * If there is more output needed for this commit, show it now
1531 if (!graph_is_commit_finished(graph)) {
1533 * If sb doesn't have a terminating newline, print one now,
1534 * so we can start the remainder of the graph output on a
1535 * new line.
1537 if (!newline_terminated)
1538 putc('\n', file);
1540 graph_show_remainder(graph);
1543 * If sb ends with a newline, our output should too.
1545 if (newline_terminated)
1546 putc('\n', file);