2 * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <sys/queue.h>
20 #define _XOPEN_SOURCE_EXTENDED
22 #undef _XOPEN_SOURCE_EXTENDED
35 #include "got_error.h"
36 #include "got_object.h"
37 #include "got_reference.h"
38 #include "got_repository.h"
40 #include "got_opentemp.h"
41 #include "got_commit_graph.h"
45 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
49 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
54 const struct got_error *(*cmd_main)(int, char *[]);
55 void (*cmd_usage)(void);
59 __dead static void usage(void);
60 __dead static void usage_log(void);
61 __dead static void usage_diff(void);
62 __dead static void usage_blame(void);
64 static const struct got_error* cmd_log(int, char *[]);
65 static const struct got_error* cmd_diff(int, char *[]);
66 static const struct got_error* cmd_blame(int, char *[]);
68 static struct tog_cmd tog_commands[] = {
69 { "log", cmd_log, usage_log,
70 "show repository history" },
71 { "diff", cmd_diff, usage_diff,
72 "compare files and directories" },
73 { "blame", cmd_blame, usage_blame,
74 "show line-by-line file history" },
77 static struct tog_view {
80 } tog_log_view, tog_diff_view;
82 static const struct got_error *
83 show_diff_view(struct got_object *, struct got_object *,
84 struct got_repository *);
85 static const struct got_error *
86 show_log_view(struct got_object_id *, struct got_repository *);
92 fprintf(stderr, "usage: %s log [-c commit] [repository-path]\n",
97 /* Create newly allocated wide-character string equivalent to a byte string. */
98 static const struct got_error *
99 mbs2ws(wchar_t **ws, size_t *wlen, const char *s)
102 const struct got_error *err = NULL;
105 *wlen = mbstowcs(NULL, s, 0);
106 if (*wlen == (size_t)-1) {
109 return got_error_from_errno();
111 /* byte string invalid in current encoding; try to "fix" it */
112 err = got_mbsavis(&vis, &vislen, s);
115 *wlen = mbstowcs(NULL, vis, 0);
116 if (*wlen == (size_t)-1)
117 return got_error_from_errno(); /* give up */
120 *ws = calloc(*wlen + 1, sizeof(*ws));
122 return got_error_from_errno();
124 if (mbstowcs(*ws, vis ? vis : s, *wlen) != *wlen)
125 err = got_error_from_errno();
136 /* Format a line for display, ensuring that it won't overflow a width limit. */
137 static const struct got_error *
138 format_line(wchar_t **wlinep, int *widthp, char *line, int wlimit)
140 const struct got_error *err = NULL;
142 wchar_t *wline = NULL;
148 err = mbs2ws(&wline, &wlen, line);
153 while (i < wlen && cols <= wlimit) {
154 int width = wcwidth(wline[i]);
163 if (wline[i] == L'\t')
167 err = got_error_from_errno();
185 static const struct got_error *
186 draw_commit(struct got_commit_object *commit, struct got_object_id *id)
188 const struct got_error *err = NULL;
189 char *logmsg0 = NULL, *logmsg = NULL;
190 char *author0 = NULL, *author = NULL;
191 wchar_t *wlogmsg = NULL, *wauthor = NULL;
192 int author_width, logmsg_width;
193 char *newline, *smallerthan;
198 static const size_t id_display_cols = 8;
199 static const size_t author_display_cols = 16;
200 const int avail = COLS;
202 err = got_object_id_str(&id_str, id);
205 id_len = strlen(id_str);
206 if (avail < id_display_cols) {
207 limit = MIN(id_len, avail);
208 waddnstr(tog_log_view.window, id_str, limit);
210 limit = MIN(id_display_cols, id_len);
211 waddnstr(tog_log_view.window, id_str, limit);
214 while (col <= avail && col < id_display_cols + 2) {
215 waddch(tog_log_view.window, ' ');
221 author0 = strdup(commit->author);
222 if (author0 == NULL) {
223 err = got_error_from_errno();
227 smallerthan = strchr(author, '<');
231 char *at = strchr(author, '@');
235 limit = MIN(avail, author_display_cols);
236 err = format_line(&wauthor, &author_width, author, limit);
239 waddwstr(tog_log_view.window, wauthor);
241 while (col <= avail && author_width < author_display_cols + 1) {
242 waddch(tog_log_view.window, ' ');
249 logmsg0 = strdup(commit->logmsg);
250 if (logmsg0 == NULL) {
251 err = got_error_from_errno();
255 while (*logmsg == '\n')
257 newline = strchr(logmsg, '\n');
261 err = format_line(&wlogmsg, &logmsg_width, logmsg, limit);
264 waddwstr(tog_log_view.window, wlogmsg);
266 while (col <= avail) {
267 waddch(tog_log_view.window, ' ');
280 struct commit_queue_entry {
281 TAILQ_ENTRY(commit_queue_entry) entry;
282 struct got_object_id *id;
283 struct got_commit_object *commit;
285 TAILQ_HEAD(commit_queue, commit_queue_entry);
287 static struct commit_queue_entry *
288 alloc_commit_queue_entry(struct got_commit_object *commit,
289 struct got_object_id *id)
291 struct commit_queue_entry *entry;
293 entry = calloc(1, sizeof(*entry));
298 entry->commit = commit;
303 pop_commit(struct commit_queue *commits)
305 struct commit_queue_entry *entry;
307 entry = TAILQ_FIRST(commits);
308 TAILQ_REMOVE(commits, entry, entry);
309 got_object_commit_close(entry->commit);
310 /* Don't free entry->id! It is owned by the commit graph. */
315 free_commits(struct commit_queue *commits)
317 while (!TAILQ_EMPTY(commits))
321 static const struct got_error *
322 queue_commits(struct got_commit_graph *graph, struct commit_queue *commits,
323 struct got_object_id *start_id, struct got_repository *repo)
325 const struct got_error *err = NULL;
326 struct got_object_id *id;
327 struct commit_queue_entry *entry;
329 err = got_commit_graph_iter_start(graph, start_id);
333 entry = TAILQ_LAST(commits, commit_queue);
334 if (entry && got_object_id_cmp(entry->id, start_id) == 0) {
337 /* Start ID's commit is already on the queue; skip over it. */
338 err = got_commit_graph_iter_next(&id, graph);
339 if (err && err->code != GOT_ERR_ITER_NEED_MORE)
342 err = got_commit_graph_fetch_commits(&nfetched, graph, 1, repo);
348 struct got_commit_object *commit;
350 err = got_commit_graph_iter_next(&id, graph);
352 if (err->code == GOT_ERR_ITER_NEED_MORE)
357 err = got_object_open_as_commit(&commit, repo, id);
361 entry = alloc_commit_queue_entry(commit, id);
363 err = got_error_from_errno();
367 TAILQ_INSERT_TAIL(commits, entry, entry);
373 static const struct got_error *
374 fetch_next_commit(struct commit_queue_entry **pentry,
375 struct commit_queue_entry *entry, struct commit_queue *commits,
376 struct got_commit_graph *graph, struct got_repository *repo)
378 const struct got_error *err = NULL;
379 struct got_object_qid *qid;
383 /* Populate commit graph with entry's parent commits. */
384 SIMPLEQ_FOREACH(qid, &entry->commit->parent_ids, entry) {
386 err = got_commit_graph_fetch_commits_up_to(&nfetched,
387 graph, qid->id, repo);
392 /* Append outstanding commits to queue in graph sort order. */
393 err = queue_commits(graph, commits, entry->id, repo);
395 if (err->code == GOT_ERR_ITER_COMPLETED)
400 /* Next entry to display should now be available. */
401 *pentry = TAILQ_NEXT(entry, entry);
403 return got_error(GOT_ERR_NO_OBJ);
408 static const struct got_error *
409 get_head_commit_id(struct got_object_id **head_id, struct got_repository *repo)
411 const struct got_error *err = NULL;
412 struct got_reference *head_ref;
416 err = got_ref_open(&head_ref, repo, GOT_REF_HEAD);
420 err = got_ref_resolve(head_id, repo, head_ref);
421 got_ref_close(head_ref);
430 static const struct got_error *
431 draw_commits(struct commit_queue_entry **last, struct commit_queue_entry **selected,
432 struct commit_queue_entry *first, int selected_idx, int limit)
434 const struct got_error *err = NULL;
435 struct commit_queue_entry *entry;
438 werase(tog_log_view.window);
443 if (ncommits == limit)
445 if (ncommits == selected_idx) {
446 wstandout(tog_log_view.window);
449 err = draw_commit(entry->commit, entry->id);
450 if (ncommits == selected_idx)
451 wstandend(tog_log_view.window);
456 entry = TAILQ_NEXT(entry, entry);
466 scroll_up(struct commit_queue_entry **first_displayed_entry, int maxscroll,
467 struct commit_queue *commits)
469 struct commit_queue_entry *entry;
472 entry = TAILQ_FIRST(commits);
473 if (*first_displayed_entry == entry)
476 entry = *first_displayed_entry;
477 while (entry && nscrolled < maxscroll) {
478 entry = TAILQ_PREV(entry, commit_queue, entry);
480 *first_displayed_entry = entry;
486 static const struct got_error *
487 scroll_down(struct commit_queue_entry **first_displayed_entry, int maxscroll,
488 struct commit_queue_entry *last_displayed_entry,
489 struct commit_queue *commits, struct got_commit_graph *graph,
490 struct got_repository *repo)
492 const struct got_error *err = NULL;
493 struct commit_queue_entry *pentry;
497 pentry = TAILQ_NEXT(last_displayed_entry, entry);
498 if (pentry == NULL) {
499 err = fetch_next_commit(&pentry, last_displayed_entry,
500 commits, graph, repo);
501 if (err || pentry == NULL)
504 last_displayed_entry = pentry;
506 pentry = TAILQ_NEXT(*first_displayed_entry, entry);
509 *first_displayed_entry = pentry;
510 } while (++nscrolled < maxscroll);
516 num_parents(struct commit_queue_entry *entry)
521 entry = TAILQ_NEXT(entry, entry);
528 static const struct got_error *
529 show_commit(struct commit_queue_entry *entry, struct got_repository *repo)
531 const struct got_error *err;
532 struct got_object *obj1 = NULL, *obj2 = NULL;
533 struct got_object_qid *parent_id;
535 err = got_object_open(&obj2, repo, entry->id);
539 parent_id = SIMPLEQ_FIRST(&entry->commit->parent_ids);
541 err = got_object_open(&obj1, repo, parent_id->id);
546 err = show_diff_view(obj1, obj2, repo);
549 got_object_close(obj1);
551 got_object_close(obj2);
555 static const struct got_error *
556 show_log_view(struct got_object_id *start_id, struct got_repository *repo)
558 const struct got_error *err = NULL;
559 struct got_object_id *head_id = NULL;
560 int ch, done = 0, selected = 0, nparents, nfetched;
561 struct got_commit_graph *graph;
562 struct commit_queue commits;
563 struct commit_queue_entry *entry = NULL;
564 struct commit_queue_entry *first_displayed_entry = NULL;
565 struct commit_queue_entry *last_displayed_entry = NULL;
566 struct commit_queue_entry *selected_entry = NULL;
568 if (tog_log_view.window == NULL) {
569 tog_log_view.window = newwin(0, 0, 0, 0);
570 if (tog_log_view.window == NULL)
571 return got_error_from_errno();
572 keypad(tog_log_view.window, TRUE);
574 if (tog_log_view.panel == NULL) {
575 tog_log_view.panel = new_panel(tog_log_view.window);
576 if (tog_log_view.panel == NULL)
577 return got_error_from_errno();
579 show_panel(tog_log_view.panel);
581 err = get_head_commit_id(&head_id, repo);
585 TAILQ_INIT(&commits);
587 err = got_commit_graph_open(&graph, head_id, repo);
591 /* Populate commit graph with a sufficient number of commits. */
592 err = got_commit_graph_fetch_commits_up_to(&nfetched, graph, start_id,
596 err = got_commit_graph_fetch_commits(&nfetched, graph, LINES, repo);
601 * Open the initial batch of commits, sorted in commit graph order.
602 * We keep all commits open throughout the lifetime of the log view
603 * in order to avoid having to re-fetch commits from disk while
604 * updating the display.
606 err = queue_commits(graph, &commits, head_id, repo);
607 if (err && err->code != GOT_ERR_ITER_COMPLETED)
610 /* Find entry corresponding to the first commit to display. */
611 TAILQ_FOREACH(entry, &commits, entry) {
612 if (got_object_id_cmp(entry->id, start_id) == 0) {
613 first_displayed_entry = entry;
617 if (first_displayed_entry == NULL) {
618 err = got_error(GOT_ERR_NO_OBJ);
623 err = draw_commits(&last_displayed_entry, &selected_entry,
624 first_displayed_entry, selected, LINES);
628 nodelay(stdscr, FALSE);
629 ch = wgetch(tog_log_view.window);
630 nodelay(stdscr, TRUE);
634 err = got_error_from_errno();
647 scroll_up(&first_displayed_entry, 1, &commits);
650 if (TAILQ_FIRST(&commits) ==
651 first_displayed_entry) {
655 scroll_up(&first_displayed_entry, LINES,
660 nparents = num_parents(first_displayed_entry);
661 if (selected < LINES - 1 &&
662 selected < nparents - 1) {
666 err = scroll_down(&first_displayed_entry, 1,
667 last_displayed_entry, &commits, graph,
673 err = scroll_down(&first_displayed_entry, LINES,
674 last_displayed_entry, &commits, graph,
678 if (last_displayed_entry->commit->nparents > 0)
680 /* can't scroll any further; move cursor down */
681 nparents = num_parents(first_displayed_entry);
682 if (selected < LINES - 1 ||
683 selected < nparents - 1)
684 selected = MIN(LINES - 1, nparents - 1);
687 if (selected > LINES)
688 selected = LINES - 1;
692 err = show_commit(selected_entry, repo);
695 show_panel(tog_log_view.panel);
704 got_commit_graph_close(graph);
705 free_commits(&commits);
709 static const struct got_error *
710 cmd_log(int argc, char *argv[])
712 const struct got_error *error;
713 struct got_repository *repo;
714 struct got_object_id *start_id = NULL;
715 char *repo_path = NULL;
716 char *start_commit = NULL;
720 if (pledge("stdio rpath wpath cpath flock proc tty", NULL) == -1)
724 while ((ch = getopt(argc, argv, "c:")) != -1) {
727 start_commit = optarg;
739 repo_path = getcwd(NULL, 0);
740 if (repo_path == NULL)
741 return got_error_from_errno();
742 } else if (argc == 1) {
743 repo_path = realpath(argv[0], NULL);
744 if (repo_path == NULL)
745 return got_error_from_errno();
749 error = got_repo_open(&repo, repo_path);
754 if (start_commit == NULL) {
755 error = get_head_commit_id(&start_id, repo);
759 struct got_object *obj;
760 error = got_object_open_by_id_str(&obj, repo, start_commit);
762 start_id = got_object_get_id(obj);
763 if (start_id == NULL)
764 error = got_error_from_errno();
769 error = show_log_view(start_id, repo);
771 got_repo_close(repo);
779 fprintf(stderr, "usage: %s diff [repository-path] object1 object2\n",
785 parse_next_line(FILE *f, size_t *len)
790 const char delim[3] = { '\0', '\0', '\0'};
792 line = fparseln(f, &linelen, &lineno, delim, 0);
798 static const struct got_error *
799 draw_diff(FILE *f, int *first_displayed_line, int *last_displayed_line,
800 int *eof, int max_lines)
802 const struct got_error *err;
803 int nlines = 0, nprinted = 0;
810 werase(tog_diff_view.window);
813 while (nprinted < max_lines) {
814 line = parse_next_line(f, &len);
819 if (++nlines < *first_displayed_line) {
824 err = format_line(&wline, &width, line, COLS);
829 waddwstr(tog_diff_view.window, wline);
831 waddch(tog_diff_view.window, '\n');
833 *first_displayed_line = nlines;
836 *last_displayed_line = nlines;
844 static const struct got_error *
845 show_diff_view(struct got_object *obj1, struct got_object *obj2,
846 struct got_repository *repo)
848 const struct got_error *err;
850 int ch, done = 0, first_displayed_line = 1, last_displayed_line = LINES;
853 if (obj1 != NULL && obj2 != NULL &&
854 got_object_get_type(obj1) != got_object_get_type(obj2))
855 return got_error(GOT_ERR_OBJ_TYPE);
859 return got_error_from_errno();
861 switch (got_object_get_type(obj1 ? obj1 : obj2)) {
862 case GOT_OBJ_TYPE_BLOB:
863 err = got_diff_objects_as_blobs(obj1, obj2, repo, f);
865 case GOT_OBJ_TYPE_TREE:
866 err = got_diff_objects_as_trees(obj1, obj2, repo, f);
868 case GOT_OBJ_TYPE_COMMIT:
869 err = got_diff_objects_as_commits(obj1, obj2, repo, f);
872 return got_error(GOT_ERR_OBJ_TYPE);
877 if (tog_diff_view.window == NULL) {
878 tog_diff_view.window = newwin(0, 0, 0, 0);
879 if (tog_diff_view.window == NULL)
880 return got_error_from_errno();
881 keypad(tog_diff_view.window, TRUE);
883 if (tog_diff_view.panel == NULL) {
884 tog_diff_view.panel = new_panel(tog_diff_view.window);
885 if (tog_diff_view.panel == NULL)
886 return got_error_from_errno();
888 show_panel(tog_diff_view.panel);
891 err = draw_diff(f, &first_displayed_line, &last_displayed_line,
895 nodelay(stdscr, FALSE);
896 ch = wgetch(tog_diff_view.window);
897 nodelay(stdscr, TRUE);
905 if (first_displayed_line > 1)
906 first_displayed_line--;
910 while (i++ < LINES - 1 &&
911 first_displayed_line > 1)
912 first_displayed_line--;
919 first_displayed_line++;
924 while (!eof && i++ < LINES - 1) {
925 char *line = parse_next_line(f, NULL);
926 first_displayed_line++;
939 static const struct got_error *
940 cmd_diff(int argc, char *argv[])
942 const struct got_error *error = NULL;
943 struct got_repository *repo = NULL;
944 struct got_object *obj1 = NULL, *obj2 = NULL;
945 char *repo_path = NULL;
946 char *obj_id_str1 = NULL, *obj_id_str2 = NULL;
950 if (pledge("stdio rpath wpath cpath flock proc tty", NULL) == -1)
954 while ((ch = getopt(argc, argv, "")) != -1) {
966 usage_diff(); /* TODO show local worktree changes */
967 } else if (argc == 2) {
968 repo_path = getcwd(NULL, 0);
969 if (repo_path == NULL)
970 return got_error_from_errno();
971 obj_id_str1 = argv[0];
972 obj_id_str2 = argv[1];
973 } else if (argc == 3) {
974 repo_path = realpath(argv[0], NULL);
975 if (repo_path == NULL)
976 return got_error_from_errno();
977 obj_id_str1 = argv[1];
978 obj_id_str2 = argv[2];
982 error = got_repo_open(&repo, repo_path);
987 error = got_object_open_by_id_str(&obj1, repo, obj_id_str1);
991 error = got_object_open_by_id_str(&obj2, repo, obj_id_str2);
995 error = show_diff_view(obj1, obj2, repo);
997 got_repo_close(repo);
999 got_object_close(obj1);
1001 got_object_close(obj2);
1009 fprintf(stderr, "usage: %s blame [repository-path] blob-object\n",
1014 static const struct got_error *
1015 cmd_blame(int argc, char *argv[])
1017 return got_error(GOT_ERR_NOT_IMPL);
1027 intrflush(stdscr, FALSE);
1028 keypad(stdscr, TRUE);
1037 fprintf(stderr, "usage: %s [-h] [command] [arg ...]\n\n"
1038 "Available commands:\n", getprogname());
1039 for (i = 0; i < nitems(tog_commands); i++) {
1040 struct tog_cmd *cmd = &tog_commands[i];
1041 fprintf(stderr, " %s: %s\n", cmd->name, cmd->descr);
1047 make_argv(const char *arg0, const char *arg1)
1050 int argc = (arg1 == NULL ? 1 : 2);
1052 argv = calloc(argc, sizeof(char *));
1055 argv[0] = strdup(arg0);
1056 if (argv[0] == NULL)
1059 argv[1] = strdup(arg1);
1060 if (argv[1] == NULL)
1068 main(int argc, char *argv[])
1070 const struct got_error *error = NULL;
1071 struct tog_cmd *cmd = NULL;
1073 char **cmd_argv = NULL;
1075 setlocale(LC_ALL, "");
1077 while ((ch = getopt(argc, argv, "h")) != -1) {
1094 /* Build an argument vector which runs a default command. */
1095 cmd = &tog_commands[0];
1096 cmd_argv = make_argv(cmd->name, NULL);
1101 /* Did the user specific a command? */
1102 for (i = 0; i < nitems(tog_commands); i++) {
1103 if (strncmp(tog_commands[i].name, argv[0],
1104 strlen(argv[0])) == 0) {
1105 cmd = &tog_commands[i];
1107 tog_commands[i].cmd_usage();
1112 /* Did the user specify a repository? */
1113 char *repo_path = realpath(argv[0], NULL);
1115 struct got_repository *repo;
1116 error = got_repo_open(&repo, repo_path);
1118 got_repo_close(repo);
1120 error = got_error_from_errno();
1122 fprintf(stderr, "%s: '%s' is neither a known "
1123 "command nor a path to a repository\n",
1124 getprogname(), argv[0]);
1128 cmd = &tog_commands[0];
1129 cmd_argv = make_argv(cmd->name, repo_path);
1137 error = cmd->cmd_main(argc, cmd_argv ? cmd_argv : argv);
1144 fprintf(stderr, "%s: %s\n", getprogname(), error->msg);