X-Git-Url: https://git.distorted.org.uk/~mdw/tig/blobdiff_plain/e15ec88e61da8a2f67fa1e2212ebb7e60694552f..2463b4ea11714543dcb091f83f6dedfa00bae938:/tig.c diff --git a/tig.c b/tig.c index affbcec..dde4369 100644 --- a/tig.c +++ b/tig.c @@ -12,7 +12,7 @@ */ #ifndef VERSION -#define VERSION "tig-0.5.git" +#define VERSION "tig-0.6.git" #endif #ifndef DEBUG @@ -60,6 +60,15 @@ static size_t utf8_length(const char *string, size_t max_width, int *coloffset, #define SIZEOF_STR 1024 /* Default string size. */ #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */ #define SIZEOF_REV 41 /* Holds a SHA-1 and an ending NUL */ + +/* Revision graph */ + +#define REVGRAPH_INIT 'I' +#define REVGRAPH_MERGE 'M' +#define REVGRAPH_BRANCH '+' +#define REVGRAPH_COMMIT '*' +#define REVGRAPH_LINE '|' + #define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */ /* This color name can be used to refer to the default term colors. */ @@ -164,6 +173,9 @@ string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen) #define string_ncopy(dst, src, srclen) \ string_ncopy_do(dst, sizeof(dst), src, srclen) +#define string_copy_rev(dst, src) \ + string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1) + static char * chomp_string(char *name) { @@ -260,6 +272,9 @@ sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src) } BUFPUT('\''); + if (bufsize < SIZEOF_STR) + buf[bufsize] = 0; + return bufsize; } @@ -387,7 +402,7 @@ VERSION " (" __DATE__ ")\n" /* Option and state variables. */ static bool opt_line_number = FALSE; -static bool opt_rev_graph = TRUE; +static bool opt_rev_graph = FALSE; static int opt_num_interval = NUMBER_INTERVAL; static int opt_tab_size = TABSIZE; static enum request opt_request = REQ_VIEW_MAIN; @@ -858,7 +873,7 @@ get_key(enum request request) static char buf[BUFSIZ]; static char key_char[] = "'X'"; size_t pos = 0; - char *sep = " "; + char *sep = ""; int i; buf[pos] = 0; @@ -1249,8 +1264,8 @@ static struct view views[] = { VIEW_(LOG, "log", &pager_ops, ref_head), VIEW_(TREE, "tree", &tree_ops, ref_commit), VIEW_(BLOB, "blob", &blob_ops, ref_blob), - VIEW_(HELP, "help", &pager_ops, "static"), - VIEW_(PAGER, "pager", &pager_ops, "static"), + VIEW_(HELP, "help", &pager_ops, ""), + VIEW_(PAGER, "pager", &pager_ops, ""), }; #define VIEW(req) (&views[(req) - REQ_OFFSET - 1]) @@ -1613,7 +1628,8 @@ move_view(struct view *view, enum request request) } if (!view_is_displayed(view)) { - view->offset += steps; + view->offset += scroll_steps; + assert(0 <= view->offset && view->offset < view->lines); view->ops->select(view, &view->line[view->lineno]); return; } @@ -1770,17 +1786,21 @@ begin_update(struct view *view) if (opt_cmd[0]) { string_copy(view->cmd, opt_cmd); opt_cmd[0] = 0; - /* When running random commands, the view ref could have become - * invalid so clear it. */ - view->ref[0] = 0; + /* When running random commands, initially show the + * command in the title. However, it maybe later be + * overwritten if a commit line is selected. */ + string_copy(view->ref, view->cmd); } else if (view == VIEW(REQ_VIEW_TREE)) { const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt; + char path[SIZEOF_STR]; if (strcmp(view->vid, view->id)) - opt_path[0] = 0; + opt_path[0] = path[0] = 0; + else if (sq_quote(path, 0, opt_path) >= sizeof(path)) + return FALSE; - if (!string_format(view->cmd, format, id, opt_path)) + if (!string_format(view->cmd, format, id, path)) return FALSE; } else { @@ -1788,6 +1808,12 @@ begin_update(struct view *view) if (!string_format(view->cmd, format, id, id, id, id, id)) return FALSE; + + /* Put the current ref_* value to the view title ref + * member. This is needed by the blob view. Most other + * views sets it automatically after loading because the + * first line is a commit line. */ + string_copy(view->ref, id); } /* Special case for the pager view. */ @@ -1806,7 +1832,7 @@ begin_update(struct view *view) view->offset = 0; view->lines = 0; view->lineno = 0; - string_copy(view->vid, id); + string_copy_rev(view->vid, id); if (view->line) { int i; @@ -1918,6 +1944,12 @@ update_view(struct view *view) if (redraw_from > 0) redraw_from--; + /* Since revision graph visualization requires knowledge + * about the parent commit, it causes a further one-off + * needed to be redrawn for incremental updates. */ + if (redraw_from > 0 && opt_rev_graph) + redraw_from--; + /* Incrementally draw avoids flickering. */ redraw_view_from(view, redraw_from); } @@ -1942,10 +1974,29 @@ alloc_error: report("Allocation failure"); end: + view->ops->read(view, NULL); end_update(view); return FALSE; } +static struct line * +add_line_text(struct view *view, char *data, enum line_type type) +{ + struct line *line = &view->line[view->lines]; + + if (!data) + return NULL; + + line->data = strdup(data); + if (!line->data) + return NULL; + + line->type = type; + view->lines++; + + return line; +} + /* * View opening @@ -1970,22 +2021,22 @@ static void open_help_view(struct view *view) return; } - view->ops->read(view, "Quick reference for tig keybindings:"); + add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT); for (i = 0; i < ARRAY_SIZE(req_info); i++) { char *key; if (!req_info[i].request) { - view->ops->read(view, ""); - view->ops->read(view, req_info[i].help); + add_line_text(view, "", LINE_DEFAULT); + add_line_text(view, req_info[i].help, LINE_DEFAULT); continue; } key = get_key(req_info[i].request); - if (!string_format(buf, "%-25s %s", key, req_info[i].help)) + if (!string_format(buf, " %-25s %s", key, req_info[i].help)) continue; - view->ops->read(view, buf); + add_line_text(view, buf, LINE_DEFAULT); } } @@ -2100,16 +2151,27 @@ view_driver(struct view *view, enum request request) case REQ_VIEW_BLOB: if (!ref_blob[0]) { - report("No file chosen, press 't' to open tree view"); + report("No file chosen, press %s to open tree view", + get_key(REQ_VIEW_TREE)); break; } - /* Fall-through */ + open_view(view, request, OPEN_DEFAULT); + break; + + case REQ_VIEW_PAGER: + if (!VIEW(REQ_VIEW_PAGER)->lines) { + report("No pager content, press %s to run command from prompt", + get_key(REQ_PROMPT)); + break; + } + open_view(view, request, OPEN_DEFAULT); + break; + case REQ_VIEW_MAIN: case REQ_VIEW_DIFF: case REQ_VIEW_LOG: case REQ_VIEW_TREE: case REQ_VIEW_HELP: - case REQ_VIEW_PAGER: open_view(view, request, OPEN_DEFAULT); break; @@ -2377,26 +2439,20 @@ try_add_describe_ref: if (!realloc_lines(view, view->line_size + 1)) return; - line = &view->line[view->lines]; - line->data = strdup(buf); - if (!line->data) - return; - - line->type = LINE_PP_REFS; - view->lines++; + add_line_text(view, buf, LINE_PP_REFS); } static bool pager_read(struct view *view, char *data) { - struct line *line = &view->line[view->lines]; + struct line *line; - line->data = strdup(data); - if (!line->data) - return FALSE; + if (!data) + return TRUE; - line->type = get_line_type(line->data); - view->lines++; + line = add_line_text(view, data, get_line_type(data)); + if (!line) + return FALSE; if (line->type == LINE_COMMIT && (view == VIEW(REQ_VIEW_DIFF) || @@ -2451,10 +2507,11 @@ static void pager_select(struct view *view, struct line *line) { if (line->type == LINE_COMMIT) { - char *text = line->data; + char *text = line->data + STRING_SIZE("commit "); - string_copy(view->ref, text + STRING_SIZE("commit ")); - string_copy(ref_commit, view->ref); + if (view != VIEW(REQ_VIEW_PAGER)) + string_copy_rev(view->ref, text); + string_copy_rev(ref_commit, text); } } @@ -2501,7 +2558,7 @@ tree_compare_entry(enum line_type type1, char *name1, static bool tree_read(struct view *view, char *text) { - size_t textlen = strlen(text); + size_t textlen = text ? strlen(text) : 0; char buf[SIZEOF_STR]; unsigned long pos; enum line_type type; @@ -2515,21 +2572,18 @@ tree_read(struct view *view, char *text) if (first_read) { /* Add path info line */ - if (string_format(buf, "Directory path /%s", opt_path) && - realloc_lines(view, view->line_size + 1) && - pager_read(view, buf)) - view->line[view->lines - 1].type = LINE_DEFAULT; - else + if (!string_format(buf, "Directory path /%s", opt_path) || + !realloc_lines(view, view->line_size + 1) || + !add_line_text(view, buf, LINE_DEFAULT)) return FALSE; /* Insert "link" to parent directory. */ - if (*opt_path && - string_format(buf, TREE_UP_FORMAT, view->ref) && - realloc_lines(view, view->line_size + 1) && - pager_read(view, buf)) - view->line[view->lines - 1].type = LINE_TREE_DIR; - else if (*opt_path) - return FALSE; + if (*opt_path) { + if (!string_format(buf, TREE_UP_FORMAT, view->ref) || + !realloc_lines(view, view->line_size + 1) || + !add_line_text(view, buf, LINE_TREE_DIR)) + return FALSE; + } } /* Strip the path part ... */ @@ -2568,14 +2622,13 @@ tree_read(struct view *view, char *text) return TRUE; } - if (!pager_read(view, text)) + if (!add_line_text(view, text, type)) return FALSE; /* Move the current line to the first tree entry. */ if (first_read) view->lineno++; - view->line[view->lines - 1].type = type; return TRUE; } @@ -2633,21 +2686,16 @@ tree_enter(struct view *view, struct line *line) static void tree_select(struct view *view, struct line *line) { - char *text = line->data; - - text += STRING_SIZE("100644 blob "); + char *text = line->data + STRING_SIZE("100644 blob "); if (line->type == LINE_TREE_FILE) { - string_ncopy(ref_blob, text, 40); - /* Also update the blob view's ref, since all there must always - * be in sync. */ - string_copy(VIEW(REQ_VIEW_BLOB)->ref, ref_blob); + string_copy_rev(ref_blob, text); } else if (line->type != LINE_TREE_DIR) { return; } - string_ncopy(view->ref, text, 40); + string_copy_rev(view->ref, text); } static struct view_ops tree_ops = { @@ -2662,12 +2710,7 @@ static struct view_ops tree_ops = { static bool blob_read(struct view *view, char *line) { - bool state = pager_read(view, line); - - if (state == TRUE) - view->line[view->lines - 1].type = LINE_DEFAULT; - - return state; + return add_line_text(view, line, LINE_DEFAULT); } static struct view_ops blob_ops = { @@ -2681,7 +2724,7 @@ static struct view_ops blob_ops = { /* - * Main view backend + * Revision graph */ struct commit { @@ -2694,6 +2737,198 @@ struct commit { size_t graph_size; /* The width of the graph array. */ }; +/* Size of rev graph with no "padding" columns */ +#define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2)) + +struct rev_graph { + struct rev_graph *prev, *next, *parents; + char rev[SIZEOF_REVITEMS][SIZEOF_REV]; + size_t size; + struct commit *commit; + size_t pos; +}; + +/* Parents of the commit being visualized. */ +static struct rev_graph graph_parents[4]; + +/* The current stack of revisions on the graph. */ +static struct rev_graph graph_stacks[4] = { + { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] }, + { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] }, + { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] }, + { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] }, +}; + +static inline bool +graph_parent_is_merge(struct rev_graph *graph) +{ + return graph->parents->size > 1; +} + +static inline void +append_to_rev_graph(struct rev_graph *graph, chtype symbol) +{ + struct commit *commit = graph->commit; + + if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1) + commit->graph[commit->graph_size++] = symbol; +} + +static void +done_rev_graph(struct rev_graph *graph) +{ + if (graph_parent_is_merge(graph) && + graph->pos < graph->size - 1 && + graph->next->size == graph->size + graph->parents->size - 1) { + size_t i = graph->pos + graph->parents->size - 1; + + graph->commit->graph_size = i * 2; + while (i < graph->next->size - 1) { + append_to_rev_graph(graph, ' '); + append_to_rev_graph(graph, '\\'); + i++; + } + } + + graph->size = graph->pos = 0; + graph->commit = NULL; + memset(graph->parents, 0, sizeof(*graph->parents)); +} + +static void +push_rev_graph(struct rev_graph *graph, char *parent) +{ + int i; + + /* "Collapse" duplicate parents lines. + * + * FIXME: This needs to also update update the drawn graph but + * for now it just serves as a method for pruning graph lines. */ + for (i = 0; i < graph->size; i++) + if (!strncmp(graph->rev[i], parent, SIZEOF_REV)) + return; + + if (graph->size < SIZEOF_REVITEMS) { + string_ncopy(graph->rev[graph->size++], parent, SIZEOF_REV); + } +} + +static chtype +get_rev_graph_symbol(struct rev_graph *graph) +{ + chtype symbol; + + if (graph->parents->size == 0) + symbol = REVGRAPH_INIT; + else if (graph_parent_is_merge(graph)) + symbol = REVGRAPH_MERGE; + else if (graph->pos >= graph->size) + symbol = REVGRAPH_BRANCH; + else + symbol = REVGRAPH_COMMIT; + + return symbol; +} + +static void +draw_rev_graph(struct rev_graph *graph) +{ + struct rev_filler { + chtype separator, line; + }; + enum { DEFAULT, RSHARP, RDIAG, LDIAG }; + static struct rev_filler fillers[] = { + { ' ', REVGRAPH_LINE }, + { '`', '.' }, + { '\'', ' ' }, + { '/', ' ' }, + }; + chtype symbol = get_rev_graph_symbol(graph); + struct rev_filler *filler; + size_t i; + + filler = &fillers[DEFAULT]; + + for (i = 0; i < graph->pos; i++) { + append_to_rev_graph(graph, filler->line); + if (graph_parent_is_merge(graph->prev) && + graph->prev->pos == i) + filler = &fillers[RSHARP]; + + append_to_rev_graph(graph, filler->separator); + } + + /* Place the symbol for this revision. */ + append_to_rev_graph(graph, symbol); + + if (graph->prev->size > graph->size) + filler = &fillers[RDIAG]; + else + filler = &fillers[DEFAULT]; + + i++; + + for (; i < graph->size; i++) { + append_to_rev_graph(graph, filler->separator); + append_to_rev_graph(graph, filler->line); + if (graph_parent_is_merge(graph->prev) && + i < graph->prev->pos + graph->parents->size) + filler = &fillers[RSHARP]; + if (graph->prev->size > graph->size) + filler = &fillers[LDIAG]; + } + + if (graph->prev->size > graph->size) { + append_to_rev_graph(graph, filler->separator); + if (filler->line != ' ') + append_to_rev_graph(graph, filler->line); + } +} + +/* Prepare the next rev graph */ +static void +prepare_rev_graph(struct rev_graph *graph) +{ + size_t i; + + /* First, traverse all lines of revisions up to the active one. */ + for (graph->pos = 0; graph->pos < graph->size; graph->pos++) { + if (!strcmp(graph->rev[graph->pos], graph->commit->id)) + break; + + push_rev_graph(graph->next, graph->rev[graph->pos]); + } + + /* Interleave the new revision parent(s). */ + for (i = 0; i < graph->parents->size; i++) + push_rev_graph(graph->next, graph->parents->rev[i]); + + /* Lastly, put any remaining revisions. */ + for (i = graph->pos + 1; i < graph->size; i++) + push_rev_graph(graph->next, graph->rev[i]); +} + +static void +update_rev_graph(struct rev_graph *graph) +{ + /* If this is the finalizing update ... */ + if (graph->commit) + prepare_rev_graph(graph); + + /* Graph visualization needs a one rev look-ahead, + * so the first update doesn't visualize anything. */ + if (!graph->prev->commit) + return; + + draw_rev_graph(graph->prev); + done_rev_graph(graph->prev->prev); +} + + +/* + * Main view backend + */ + static bool main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected) { @@ -2761,6 +2996,7 @@ main_draw(struct view *view, struct line *line, unsigned int lineno, bool select for (i = 0; i < commit->graph_size; i++) waddch(view->win, commit->graph[i]); + waddch(view->win, ' '); col += commit->graph_size + 1; } @@ -2807,10 +3043,18 @@ main_draw(struct view *view, struct line *line, unsigned int lineno, bool select static bool main_read(struct view *view, char *line) { - enum line_type type = get_line_type(line); + static struct rev_graph *graph = graph_stacks; + enum line_type type; struct commit *commit = view->lines ? view->line[view->lines - 1].data : NULL; + if (!line) { + update_rev_graph(graph); + return TRUE; + } + + type = get_line_type(line); + switch (type) { case LINE_COMMIT: commit = calloc(1, sizeof(struct commit)); @@ -2820,9 +3064,16 @@ main_read(struct view *view, char *line) line += STRING_SIZE("commit "); view->line[view->lines++].data = commit; - string_copy(commit->id, line); + string_copy_rev(commit->id, line); commit->refs = get_refs(commit->id); - commit->graph[commit->graph_size++] = ACS_LTEE; + graph->commit = commit; + break; + + case LINE_PARENT: + if (commit) { + line += STRING_SIZE("parent "); + push_rev_graph(graph->parents, line); + } break; case LINE_AUTHOR: @@ -2837,6 +3088,9 @@ main_read(struct view *view, char *line) if (!commit || !nameend || !emailend) break; + update_rev_graph(graph); + graph = graph->next; + *nameend = *emailend = 0; ident = chomp_string(ident); if (!*ident) { @@ -2945,8 +3199,8 @@ main_select(struct view *view, struct line *line) { struct commit *commit = line->data; - string_copy(view->ref, commit->id); - string_copy(ref_commit, view->ref); + string_copy_rev(view->ref, commit->id); + string_copy_rev(ref_commit, view->ref); } static struct view_ops main_ops = { @@ -3383,7 +3637,7 @@ read_ref(char *id, int idlen, char *name, int namelen) ref->name[namelen] = 0; ref->tag = tag; ref->remote = remote; - string_copy(ref->id, id); + string_copy_rev(ref->id, id); return OK; }