1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
18 * tig - text-mode interface for git
24 * tig [options] [--] [git log options]
25 * tig [options] log [git log options]
26 * tig [options] diff [git diff options]
27 * tig [options] show [git show options]
28 * tig [options] < [git command output]
32 * Browse changes in a git repository. Additionally, tig(1) can also act
33 * as a pager for output of various git commands.
35 * When browsing repositories, tig(1) uses the underlying git commands
36 * to present the user with various views, such as summarized commit log
37 * and showing the commit with the log message, diffstat, and the diff.
39 * Using tig(1) as a pager, it will display input from stdin and try
44 #define VERSION "tig-0.3"
64 static void die(const char *err, ...);
65 static void report(const char *msg, ...);
66 static void set_nonblocking_input(bool loading);
67 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
69 #define ABS(x) ((x) >= 0 ? (x) : -(x))
70 #define MIN(x, y) ((x) < (y) ? (x) : (y))
72 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
73 #define STRING_SIZE(x) (sizeof(x) - 1)
75 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
76 #define SIZEOF_CMD 1024 /* Size of command buffer. */
78 /* This color name can be used to refer to the default term colors. */
79 #define COLOR_DEFAULT (-1)
81 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
83 /* The format and size of the date column in the main view. */
84 #define DATE_FORMAT "%Y-%m-%d %H:%M"
85 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
87 #define AUTHOR_COLS 20
89 /* The default interval between line numbers. */
90 #define NUMBER_INTERVAL 1
94 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
96 /* Some ascii-shorthands fitted into the ncurses namespace. */
98 #define KEY_RETURN '\r'
102 /* User action requests. */
104 /* Offset all requests to avoid conflicts with ncurses getch values. */
105 REQ_OFFSET = KEY_MAX + 1,
107 /* XXX: Keep the view request first and in sync with views[]. */
122 REQ_TOGGLE_LINE_NUMBERS,
136 REQ_SCROLL_LINE_DOWN,
138 REQ_SCROLL_PAGE_DOWN,
142 char *name; /* Ref name; tag or head names are shortened. */
143 char id[41]; /* Commit SHA1 ID */
144 unsigned int tag:1; /* Is it a tag? */
145 unsigned int next:1; /* For ref lists: are there more refs? */
148 static struct ref **get_refs(char *id);
156 string_ncopy(char *dst, const char *src, int dstlen)
158 strncpy(dst, src, dstlen - 1);
163 /* Shorthand for safely copying into a fixed buffer. */
164 #define string_copy(dst, src) \
165 string_ncopy(dst, src, sizeof(dst))
170 * NOTE: The following is a slightly modified copy of the git project's shell
171 * quoting routines found in the quote.c file.
173 * Help to copy the thing properly quoted for the shell safety. any single
174 * quote is replaced with '\'', any exclamation point is replaced with '\!',
175 * and the whole thing is enclosed in a
178 * original sq_quote result
179 * name ==> name ==> 'name'
180 * a b ==> a b ==> 'a b'
181 * a'b ==> a'\''b ==> 'a'\''b'
182 * a!b ==> a'\!'b ==> 'a'\!'b'
186 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
190 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
193 while ((c = *src++)) {
194 if (c == '\'' || c == '!') {
214 static const char usage[] =
215 VERSION " (" __DATE__ ")\n"
217 "Usage: tig [options]\n"
218 " or: tig [options] [--] [git log options]\n"
219 " or: tig [options] log [git log options]\n"
220 " or: tig [options] diff [git diff options]\n"
221 " or: tig [options] show [git show options]\n"
222 " or: tig [options] < [git command output]\n"
225 " -l Start up in log view\n"
226 " -d Start up in diff view\n"
227 " -n[I], --line-number[=I] Show line numbers with given interval\n"
228 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
229 " -- Mark end of tig options\n"
230 " -v, --version Show version and exit\n"
231 " -h, --help Show help message and exit\n";
233 /* Option and state variables. */
234 static bool opt_line_number = FALSE;
235 static int opt_num_interval = NUMBER_INTERVAL;
236 static int opt_tab_size = TABSIZE;
237 static enum request opt_request = REQ_VIEW_MAIN;
238 static char opt_cmd[SIZEOF_CMD] = "";
239 static char opt_encoding[20] = "";
240 static bool opt_utf8 = TRUE;
241 static FILE *opt_pipe = NULL;
243 /* Returns the index of log or diff command or -1 to exit. */
245 parse_options(int argc, char *argv[])
249 for (i = 1; i < argc; i++) {
254 * Start up in log view using the internal log command.
256 if (!strcmp(opt, "-l")) {
257 opt_request = REQ_VIEW_LOG;
263 * Start up in diff view using the internal diff command.
265 if (!strcmp(opt, "-d")) {
266 opt_request = REQ_VIEW_DIFF;
271 * -n[INTERVAL], --line-number[=INTERVAL]::
272 * Prefix line numbers in log and diff view.
273 * Optionally, with interval different than each line.
275 if (!strncmp(opt, "-n", 2) ||
276 !strncmp(opt, "--line-number", 13)) {
282 } else if (opt[STRING_SIZE("--line-number")] == '=') {
283 num = opt + STRING_SIZE("--line-number=");
287 opt_num_interval = atoi(num);
289 opt_line_number = TRUE;
294 * -t[NSPACES], --tab-size[=NSPACES]::
295 * Set the number of spaces tabs should be expanded to.
297 if (!strncmp(opt, "-t", 2) ||
298 !strncmp(opt, "--tab-size", 10)) {
304 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
305 num = opt + STRING_SIZE("--tab-size=");
309 opt_tab_size = MIN(atoi(num), TABSIZE);
315 * Show version and exit.
317 if (!strcmp(opt, "-v") ||
318 !strcmp(opt, "--version")) {
319 printf("tig version %s\n", VERSION);
325 * Show help message and exit.
327 if (!strcmp(opt, "-h") ||
328 !strcmp(opt, "--help")) {
335 * End of tig(1) options. Useful when specifying command
336 * options for the main view. Example:
338 * $ tig -- --since=1.month
340 if (!strcmp(opt, "--")) {
346 * log [git log options]::
347 * Open log view using the given git log options.
349 * diff [git diff options]::
350 * Open diff view using the given git diff options.
352 * show [git show options]::
353 * Open diff view using the given git show options.
355 if (!strcmp(opt, "log") ||
356 !strcmp(opt, "diff") ||
357 !strcmp(opt, "show")) {
358 opt_request = opt[0] == 'l'
359 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
364 * [git log options]::
365 * tig(1) will stop the option parsing when the first
366 * command line parameter not starting with "-" is
367 * encountered. All options including this one will be
368 * passed to git log when loading the main view.
369 * This makes it possible to say:
371 * $ tig tag-1.0..HEAD
373 if (opt[0] && opt[0] != '-')
376 die("unknown command '%s'", opt);
379 if (!isatty(STDIN_FILENO)) {
383 * If stdin is a pipe, any log or diff options will be ignored and the
384 * pager view will be opened loading data from stdin. The pager mode
385 * can be used for colorizing output from various git commands.
387 * Example on how to colorize the output of git-show(1):
391 opt_request = REQ_VIEW_PAGER;
394 } else if (i < argc) {
398 * Git command options
399 * ~~~~~~~~~~~~~~~~~~~
400 * All git command options specified on the command line will
401 * be passed to the given command and all will be shell quoted
402 * before they are passed to the shell.
404 * NOTE: If you specify options for the main view, you should
405 * not use the `--pretty` option as this option will be set
406 * automatically to the format expected by the main view.
408 * Example on how to open the log view and show both author and
409 * committer information:
411 * $ tig log --pretty=fuller
413 * See the <<refspec, "Specifying revisions">> section below
414 * for an introduction to revision options supported by the git
415 * commands. For details on specific git command options, refer
416 * to the man page of the command in question.
419 if (opt_request == REQ_VIEW_MAIN)
420 /* XXX: This is vulnerable to the user overriding
421 * options required for the main view parser. */
422 string_copy(opt_cmd, "git log --stat --pretty=raw");
424 string_copy(opt_cmd, "git");
425 buf_size = strlen(opt_cmd);
427 while (buf_size < sizeof(opt_cmd) && i < argc) {
428 opt_cmd[buf_size++] = ' ';
429 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
432 if (buf_size >= sizeof(opt_cmd))
433 die("command too long");
435 opt_cmd[buf_size] = 0;
439 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
447 * ENVIRONMENT VARIABLES
448 * ---------------------
449 * Several options related to the interface with git can be configured
450 * via environment options.
452 * Repository references
453 * ~~~~~~~~~~~~~~~~~~~~~
454 * Commits that are referenced by tags and branch heads will be marked
455 * by the reference name surrounded by '[' and ']':
457 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
459 * If you want to filter out certain directories under `.git/refs/`, say
460 * `tmp` you can do it by setting the following variable:
462 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
464 * Or set the variable permanently in your environment.
467 * Set command for retrieving all repository references. The command
468 * should output data in the same format as git-ls-remote(1).
471 #define TIG_LS_REMOTE \
472 "git ls-remote . 2>/dev/null"
478 * It is possible to alter which commands are used for the different views.
479 * If for example you prefer commits in the main view to be sorted by date
480 * and only show 500 commits, use:
482 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
484 * Or set the variable permanently in your environment.
486 * Notice, how `%s` is used to specify the commit reference. There can
487 * be a maximum of 5 `%s` ref specifications.
490 * The command used for the diff view. By default, git show is used
494 * The command used for the log view. If you prefer to have both
495 * author and committer shown in the log view be sure to pass
496 * `--pretty=fuller` to git log.
499 * The command used for the main view. Note, you must always specify
500 * the option: `--pretty=raw` since the main view parser expects to
504 #define TIG_DIFF_CMD \
505 "git show --patch-with-stat --find-copies-harder -B -C %s"
507 #define TIG_LOG_CMD \
508 "git log --cc --stat -n100 %s"
510 #define TIG_MAIN_CMD \
511 "git log --topo-order --stat --pretty=raw %s"
513 /* ... silently ignore that the following are also exported. */
515 #define TIG_HELP_CMD \
516 "man tig 2>/dev/null"
518 #define TIG_PAGER_CMD \
523 * Line-oriented content detection.
527 /* Line type String to match Foreground Background Attributes
528 * --------- --------------- ---------- ---------- ---------- */ \
530 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
531 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
532 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
533 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
534 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
535 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
536 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
537 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
538 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
539 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
540 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
541 /* Pretty print commit header */ \
542 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
543 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
544 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
545 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
546 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
547 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
548 /* Raw commit header */ \
549 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
550 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
551 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
552 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
553 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
555 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
556 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
558 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
559 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
560 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
561 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
562 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
563 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
564 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
565 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
566 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
567 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
568 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
571 #define LINE(type, line, fg, bg, attr) \
578 const char *line; /* The start of line to match. */
579 int linelen; /* Size of string to match. */
580 int fg, bg, attr; /* Color and text attributes for the lines. */
583 static struct line_info line_info[] = {
584 #define LINE(type, line, fg, bg, attr) \
585 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
590 static enum line_type
591 get_line_type(char *line)
593 int linelen = strlen(line);
596 for (type = 0; type < ARRAY_SIZE(line_info); type++)
597 /* Case insensitive search matches Signed-off-by lines better. */
598 if (linelen >= line_info[type].linelen &&
599 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
606 get_line_attr(enum line_type type)
608 assert(type < ARRAY_SIZE(line_info));
609 return COLOR_PAIR(type) | line_info[type].attr;
615 int default_bg = COLOR_BLACK;
616 int default_fg = COLOR_WHITE;
621 if (use_default_colors() != ERR) {
626 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
627 struct line_info *info = &line_info[type];
628 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
629 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
631 init_pair(type, fg, bg);
637 void *data; /* User data */
644 * The display consists of a status window on the last line of the screen and
645 * one or more views. The default is to only show one view at the time but it
646 * is possible to split both the main and log view to also show the commit
649 * If you are in the log view and press 'Enter' when the current line is a
650 * commit line, such as:
652 * commit 4d55caff4cc89335192f3e566004b4ceef572521
654 * You will split the view so that the log view is displayed in the top window
655 * and the diff view in the bottom window. You can switch between the two
656 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
662 /* The display array of active views and the index of the current view. */
663 static struct view *display[2];
664 static unsigned int current_view;
666 #define foreach_view(view, i) \
667 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
669 #define displayed_views() (display[1] != NULL ? 2 : 1)
672 * Current head and commit ID
673 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
674 * The viewer keeps track of both what head and commit ID you are currently
675 * viewing. The commit ID will follow the cursor line and change everytime time
676 * you highlight a different commit. Whenever you reopen the diff view it
677 * will be reloaded, if the commit ID changed.
679 * The head ID is used when opening the main and log view to indicate from
680 * what revision to show history.
683 static char ref_commit[SIZEOF_REF] = "HEAD";
684 static char ref_head[SIZEOF_REF] = "HEAD";
687 const char *name; /* View name */
688 const char *cmd_fmt; /* Default command line format */
689 const char *cmd_env; /* Command line set via environment */
690 const char *id; /* Points to either of ref_{head,commit} */
692 struct view_ops *ops; /* View operations */
694 char cmd[SIZEOF_CMD]; /* Command buffer */
695 char ref[SIZEOF_REF]; /* Hovered commit reference */
696 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
698 int height, width; /* The width and height of the main window */
699 WINDOW *win; /* The main window */
700 WINDOW *title; /* The title window living below the main window */
703 unsigned long offset; /* Offset of the window top */
704 unsigned long lineno; /* Current line number */
706 /* If non-NULL, points to the view that opened this view. If this view
707 * is closed tig will switch back to the parent view. */
711 unsigned long lines; /* Total number of lines */
712 struct line *line; /* Line index */
713 unsigned int digits; /* Number of digits in the lines member. */
721 /* What type of content being displayed. Used in the title bar. */
723 /* Draw one line; @lineno must be < view->height. */
724 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
725 /* Read one line; updates view->line. */
726 bool (*read)(struct view *view, struct line *prev, char *data);
727 /* Depending on view, change display based on current line. */
728 bool (*enter)(struct view *view, struct line *line);
731 static struct view_ops pager_ops;
732 static struct view_ops main_ops;
734 #define VIEW_STR(name, cmd, env, ref, ops) \
735 { name, cmd, #env, ref, ops }
737 #define VIEW_(id, name, ops, ref) \
738 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
743 * tig(1) presents various 'views' of a repository. Each view is based on output
744 * from an external command, most often 'git log', 'git diff', or 'git show'.
747 * Is the default view, and it shows a one line summary of each commit
748 * in the chosen list of revisions. The summary includes commit date,
749 * author, and the first line of the log message. Additionally, any
750 * repository references, such as tags, will be shown.
753 * Presents a more rich view of the revision log showing the whole log
754 * message and the diffstat.
757 * Shows either the diff of the current working tree, that is, what
758 * has changed since the last commit, or the commit diff complete
759 * with log message, diffstat and diff.
762 * Is used for displaying both input from stdin and output from git
763 * commands entered in the internal prompt.
766 * Displays the information from the tig(1) man page. For the help view
767 * to work you need to have the tig(1) man page installed.
770 static struct view views[] = {
771 VIEW_(MAIN, "main", &main_ops, ref_head),
772 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
773 VIEW_(LOG, "log", &pager_ops, ref_head),
774 VIEW_(HELP, "help", &pager_ops, "static"),
775 VIEW_(PAGER, "pager", &pager_ops, "static"),
778 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
782 draw_view_line(struct view *view, unsigned int lineno)
784 if (view->offset + lineno >= view->lines)
787 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
791 redraw_view_from(struct view *view, int lineno)
793 assert(0 <= lineno && lineno < view->height);
795 for (; lineno < view->height; lineno++) {
796 if (!draw_view_line(view, lineno))
800 redrawwin(view->win);
805 redraw_view(struct view *view)
808 redraw_view_from(view, 0);
815 * Each view has a title window which shows the name of the view, current
816 * commit ID if available, and where the view is positioned:
818 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
820 * By default, the title of the current view is highlighted using bold font.
824 update_view_title(struct view *view)
826 if (view == display[current_view])
827 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
829 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
832 wmove(view->title, 0, 0);
835 wprintw(view->title, "[%s] %s", view->name, view->ref);
837 wprintw(view->title, "[%s]", view->name);
839 if (view->lines || view->pipe) {
840 unsigned int lines = view->lines
841 ? (view->lineno + 1) * 100 / view->lines
844 wprintw(view->title, " - %s %d of %d (%d%%)",
852 time_t secs = time(NULL) - view->start_time;
854 /* Three git seconds are a long time ... */
856 wprintw(view->title, " %lds", secs);
860 wrefresh(view->title);
867 struct view *base = display[0];
868 struct view *view = display[1] ? display[1] : display[0];
870 /* Setup window dimensions */
872 getmaxyx(stdscr, base->height, base->width);
874 /* Make room for the status window. */
878 /* Horizontal split. */
879 view->width = base->width;
880 view->height = SCALE_SPLIT_VIEW(base->height);
881 base->height -= view->height;
883 /* Make room for the title bar. */
887 /* Make room for the title bar. */
892 foreach_view (view, i) {
894 view->win = newwin(view->height, 0, offset, 0);
896 die("Failed to create %s view", view->name);
898 scrollok(view->win, TRUE);
900 view->title = newwin(1, 0, offset + view->height, 0);
902 die("Failed to create title window");
905 wresize(view->win, view->height, view->width);
906 mvwin(view->win, offset, 0);
907 mvwin(view->title, offset + view->height, 0);
911 offset += view->height + 1;
921 foreach_view (view, i) {
923 update_view_title(view);
932 /* Scrolling backend */
934 do_scroll_view(struct view *view, int lines, bool redraw)
936 /* The rendering expects the new offset. */
937 view->offset += lines;
939 assert(0 <= view->offset && view->offset < view->lines);
942 /* Redraw the whole screen if scrolling is pointless. */
943 if (view->height < ABS(lines)) {
947 int line = lines > 0 ? view->height - lines : 0;
948 int end = line + ABS(lines);
950 wscrl(view->win, lines);
952 for (; line < end; line++) {
953 if (!draw_view_line(view, line))
958 /* Move current line into the view. */
959 if (view->lineno < view->offset) {
960 view->lineno = view->offset;
961 draw_view_line(view, 0);
963 } else if (view->lineno >= view->offset + view->height) {
964 if (view->lineno == view->offset + view->height) {
965 /* Clear the hidden line so it doesn't show if the view
967 wmove(view->win, view->height, 0);
968 wclrtoeol(view->win);
970 view->lineno = view->offset + view->height - 1;
971 draw_view_line(view, view->lineno - view->offset);
974 assert(view->offset <= view->lineno && view->lineno < view->lines);
979 redrawwin(view->win);
984 /* Scroll frontend */
986 scroll_view(struct view *view, enum request request)
991 case REQ_SCROLL_PAGE_DOWN:
992 lines = view->height;
993 case REQ_SCROLL_LINE_DOWN:
994 if (view->offset + lines > view->lines)
995 lines = view->lines - view->offset;
997 if (lines == 0 || view->offset + view->height >= view->lines) {
998 report("Cannot scroll beyond the last line");
1003 case REQ_SCROLL_PAGE_UP:
1004 lines = view->height;
1005 case REQ_SCROLL_LINE_UP:
1006 if (lines > view->offset)
1007 lines = view->offset;
1010 report("Cannot scroll beyond the first line");
1018 die("request %d not handled in switch", request);
1021 do_scroll_view(view, lines, TRUE);
1026 move_view(struct view *view, enum request request, bool redraw)
1031 case REQ_MOVE_FIRST_LINE:
1032 steps = -view->lineno;
1035 case REQ_MOVE_LAST_LINE:
1036 steps = view->lines - view->lineno - 1;
1039 case REQ_MOVE_PAGE_UP:
1040 steps = view->height > view->lineno
1041 ? -view->lineno : -view->height;
1044 case REQ_MOVE_PAGE_DOWN:
1045 steps = view->lineno + view->height >= view->lines
1046 ? view->lines - view->lineno - 1 : view->height;
1058 die("request %d not handled in switch", request);
1061 if (steps <= 0 && view->lineno == 0) {
1062 report("Cannot move beyond the first line");
1065 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1066 report("Cannot move beyond the last line");
1070 /* Move the current line */
1071 view->lineno += steps;
1072 assert(0 <= view->lineno && view->lineno < view->lines);
1074 /* Repaint the old "current" line if we be scrolling */
1075 if (ABS(steps) < view->height) {
1076 int prev_lineno = view->lineno - steps - view->offset;
1078 wmove(view->win, prev_lineno, 0);
1079 wclrtoeol(view->win);
1080 draw_view_line(view, prev_lineno);
1083 /* Check whether the view needs to be scrolled */
1084 if (view->lineno < view->offset ||
1085 view->lineno >= view->offset + view->height) {
1086 if (steps < 0 && -steps > view->offset) {
1087 steps = -view->offset;
1089 } else if (steps > 0) {
1090 if (view->lineno == view->lines - 1 &&
1091 view->lines > view->height) {
1092 steps = view->lines - view->offset - 1;
1093 if (steps >= view->height)
1094 steps -= view->height - 1;
1098 do_scroll_view(view, steps, redraw);
1102 /* Draw the current line */
1103 draw_view_line(view, view->lineno - view->offset);
1108 redrawwin(view->win);
1109 wrefresh(view->win);
1115 * Incremental updating
1119 end_update(struct view *view)
1123 set_nonblocking_input(FALSE);
1124 if (view->pipe == stdin)
1132 begin_update(struct view *view)
1134 const char *id = view->id;
1140 string_copy(view->cmd, opt_cmd);
1142 /* When running random commands, the view ref could have become
1143 * invalid so clear it. */
1146 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1148 if (snprintf(view->cmd, sizeof(view->cmd), format,
1149 id, id, id, id, id) >= sizeof(view->cmd))
1153 /* Special case for the pager view. */
1155 view->pipe = opt_pipe;
1158 view->pipe = popen(view->cmd, "r");
1164 set_nonblocking_input(TRUE);
1169 string_copy(view->vid, id);
1174 for (i = 0; i < view->lines; i++)
1175 if (view->line[i].data)
1176 free(view->line[i].data);
1182 view->start_time = time(NULL);
1188 update_view(struct view *view)
1190 char buffer[BUFSIZ];
1193 /* The number of lines to read. If too low it will cause too much
1194 * redrawing (and possible flickering), if too high responsiveness
1196 unsigned long lines = view->height;
1197 int redraw_from = -1;
1202 /* Only redraw if lines are visible. */
1203 if (view->offset + view->height >= view->lines)
1204 redraw_from = view->lines - view->offset;
1206 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1212 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1213 int linelen = strlen(line);
1215 struct line *prev = view->lines
1216 ? &view->line[view->lines - 1]
1220 line[linelen - 1] = 0;
1222 if (!view->ops->read(view, prev, line))
1232 lines = view->lines;
1233 for (digits = 0; lines; digits++)
1236 /* Keep the displayed view in sync with line number scaling. */
1237 if (digits != view->digits) {
1238 view->digits = digits;
1243 if (redraw_from >= 0) {
1244 /* If this is an incremental update, redraw the previous line
1245 * since for commits some members could have changed when
1246 * loading the main view. */
1247 if (redraw_from > 0)
1250 /* Incrementally draw avoids flickering. */
1251 redraw_view_from(view, redraw_from);
1254 /* Update the title _after_ the redraw so that if the redraw picks up a
1255 * commit reference in view->ref it'll be available here. */
1256 update_view_title(view);
1258 if (ferror(view->pipe)) {
1259 report("Failed to read: %s", strerror(errno));
1262 } else if (feof(view->pipe)) {
1263 if (view == VIEW(REQ_VIEW_HELP)) {
1264 const char *msg = TIG_HELP;
1266 if (view->lines == 0) {
1267 /* Slightly ugly, but abusing view->ref keeps
1268 * the error message. */
1269 string_copy(view->ref, "No help available");
1270 msg = "The tig(1) manpage is not installed";
1284 report("Allocation failure");
1292 OPEN_DEFAULT = 0, /* Use default view switching. */
1293 OPEN_SPLIT = 1, /* Split current view. */
1294 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1295 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1299 open_view(struct view *prev, enum request request, enum open_flags flags)
1301 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1302 bool split = !!(flags & OPEN_SPLIT);
1303 bool reload = !!(flags & OPEN_RELOAD);
1304 struct view *view = VIEW(request);
1305 int nviews = displayed_views();
1306 struct view *base_view = display[0];
1308 if (view == prev && nviews == 1 && !reload) {
1309 report("Already in %s view", view->name);
1313 if ((reload || strcmp(view->vid, view->id)) &&
1314 !begin_update(view)) {
1315 report("Failed to load %s view", view->name);
1320 display[current_view + 1] = view;
1324 /* Maximize the current view. */
1325 memset(display, 0, sizeof(display));
1327 display[current_view] = view;
1330 /* Resize the view when switching between split- and full-screen,
1331 * or when switching between two different full-screen views. */
1332 if (nviews != displayed_views() ||
1333 (nviews == 1 && base_view != display[0]))
1336 if (split && prev->lineno - prev->offset >= prev->height) {
1337 /* Take the title line into account. */
1338 int lines = prev->lineno - prev->offset - prev->height + 1;
1340 /* Scroll the view that was split if the current line is
1341 * outside the new limited view. */
1342 do_scroll_view(prev, lines, TRUE);
1345 if (prev && view != prev) {
1346 /* Continue loading split views in the background. */
1349 else if (!backgrounded)
1350 /* "Blur" the previous view. */
1351 update_view_title(prev);
1353 view->parent = prev;
1357 /* Clear the old view and let the incremental updating refill
1363 if (view == VIEW(REQ_VIEW_HELP))
1364 report("%s", TIG_HELP);
1369 /* If the view is backgrounded the above calls to report()
1370 * won't redraw the view title. */
1372 update_view_title(view);
1377 * User request switch noodle
1381 view_driver(struct view *view, enum request request)
1388 case REQ_MOVE_PAGE_UP:
1389 case REQ_MOVE_PAGE_DOWN:
1390 case REQ_MOVE_FIRST_LINE:
1391 case REQ_MOVE_LAST_LINE:
1392 move_view(view, request, TRUE);
1395 case REQ_SCROLL_LINE_DOWN:
1396 case REQ_SCROLL_LINE_UP:
1397 case REQ_SCROLL_PAGE_DOWN:
1398 case REQ_SCROLL_PAGE_UP:
1399 scroll_view(view, request);
1406 case REQ_VIEW_PAGER:
1407 open_view(view, request, OPEN_DEFAULT);
1412 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1414 if (view == VIEW(REQ_VIEW_DIFF) &&
1415 view->parent == VIEW(REQ_VIEW_MAIN)) {
1416 bool redraw = display[1] == view;
1418 view = view->parent;
1419 move_view(view, request, redraw);
1421 update_view_title(view);
1423 move_view(view, request, TRUE);
1430 report("Nothing to enter");
1433 return view->ops->enter(view, &view->line[view->lineno]);
1437 int nviews = displayed_views();
1438 int next_view = (current_view + 1) % nviews;
1440 if (next_view == current_view) {
1441 report("Only one view is displayed");
1445 current_view = next_view;
1446 /* Blur out the title of the previous view. */
1447 update_view_title(view);
1451 case REQ_TOGGLE_LINE_NUMBERS:
1452 opt_line_number = !opt_line_number;
1457 /* Always reload^Wrerun commands from the prompt. */
1458 open_view(view, opt_request, OPEN_RELOAD);
1461 case REQ_STOP_LOADING:
1462 foreach_view (view, i) {
1464 report("Stopped loaded the %s view", view->name),
1469 case REQ_SHOW_VERSION:
1470 report("%s (built %s)", VERSION, __DATE__);
1473 case REQ_SCREEN_RESIZE:
1476 case REQ_SCREEN_REDRAW:
1480 case REQ_SCREEN_UPDATE:
1484 case REQ_VIEW_CLOSE:
1486 memset(display, 0, sizeof(display));
1488 display[current_view] = view->parent;
1489 view->parent = NULL;
1499 /* An unknown key will show most commonly used commands. */
1500 report("Unknown key, press 'h' for help");
1513 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1515 char *text = line->data;
1516 enum line_type type = line->type;
1517 int textlen = strlen(text);
1520 wmove(view->win, lineno, 0);
1522 if (view->offset + lineno == view->lineno) {
1523 if (type == LINE_COMMIT) {
1524 string_copy(view->ref, text + 7);
1525 string_copy(ref_commit, view->ref);
1529 wchgat(view->win, -1, 0, type, NULL);
1532 attr = get_line_attr(type);
1533 wattrset(view->win, attr);
1535 if (opt_line_number || opt_tab_size < TABSIZE) {
1536 static char spaces[] = " ";
1537 int col_offset = 0, col = 0;
1539 if (opt_line_number) {
1540 unsigned long real_lineno = view->offset + lineno + 1;
1542 if (real_lineno == 1 ||
1543 (real_lineno % opt_num_interval) == 0) {
1544 wprintw(view->win, "%.*d", view->digits, real_lineno);
1547 waddnstr(view->win, spaces,
1548 MIN(view->digits, STRING_SIZE(spaces)));
1550 waddstr(view->win, ": ");
1551 col_offset = view->digits + 2;
1554 while (text && col_offset + col < view->width) {
1555 int cols_max = view->width - col_offset - col;
1559 if (*text == '\t') {
1561 assert(sizeof(spaces) > TABSIZE);
1563 cols = opt_tab_size - (col % opt_tab_size);
1566 text = strchr(text, '\t');
1567 cols = line ? text - pos : strlen(pos);
1570 waddnstr(view->win, pos, MIN(cols, cols_max));
1575 int col = 0, pos = 0;
1577 for (; pos < textlen && col < view->width; pos++, col++)
1578 if (text[pos] == '\t')
1579 col += TABSIZE - (col % TABSIZE) - 1;
1581 waddnstr(view->win, text, pos);
1588 pager_read(struct view *view, struct line *prev, char *line)
1590 /* Compress empty lines in the help view. */
1591 if (view == VIEW(REQ_VIEW_HELP) &&
1592 !*line && prev && !*((char *) prev->data))
1595 view->line[view->lines].data = strdup(line);
1596 if (!view->line[view->lines].data)
1599 view->line[view->lines].type = get_line_type(line);
1606 pager_enter(struct view *view, struct line *line)
1610 if (line->type == LINE_COMMIT &&
1611 (view == VIEW(REQ_VIEW_LOG) ||
1612 view == VIEW(REQ_VIEW_PAGER))) {
1613 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1617 /* Always scroll the view even if it was split. That way
1618 * you can use Enter to scroll through the log view and
1619 * split open each commit diff. */
1620 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1622 /* FIXME: A minor workaround. Scrolling the view will call report("")
1623 * but if we are scolling a non-current view this won't properly update
1624 * the view title. */
1626 update_view_title(view);
1631 static struct view_ops pager_ops = {
1644 char id[41]; /* SHA1 ID. */
1645 char title[75]; /* The first line of the commit message. */
1646 char author[75]; /* The author of the commit. */
1647 struct tm time; /* Date from the author ident. */
1648 struct ref **refs; /* Repository references; tags & branch heads. */
1652 main_draw(struct view *view, struct line *line, unsigned int lineno)
1654 char buf[DATE_COLS + 1];
1655 struct commit *commit = line->data;
1656 enum line_type type;
1662 if (!*commit->author)
1665 wmove(view->win, lineno, col);
1667 if (view->offset + lineno == view->lineno) {
1668 string_copy(view->ref, commit->id);
1669 string_copy(ref_commit, view->ref);
1671 wattrset(view->win, get_line_attr(type));
1672 wchgat(view->win, -1, 0, type, NULL);
1675 type = LINE_MAIN_COMMIT;
1676 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1679 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1680 waddnstr(view->win, buf, timelen);
1681 waddstr(view->win, " ");
1684 wmove(view->win, lineno, col);
1685 if (type != LINE_CURSOR)
1686 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1689 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1691 authorlen = strlen(commit->author);
1692 if (authorlen > AUTHOR_COLS - 2) {
1693 authorlen = AUTHOR_COLS - 2;
1699 waddnstr(view->win, commit->author, authorlen);
1700 if (type != LINE_CURSOR)
1701 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1702 waddch(view->win, '~');
1704 waddstr(view->win, commit->author);
1708 if (type != LINE_CURSOR)
1709 wattrset(view->win, A_NORMAL);
1711 mvwaddch(view->win, lineno, col, ACS_LTEE);
1712 wmove(view->win, lineno, col + 2);
1719 if (type == LINE_CURSOR)
1721 else if (commit->refs[i]->tag)
1722 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1724 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1725 waddstr(view->win, "[");
1726 waddstr(view->win, commit->refs[i]->name);
1727 waddstr(view->win, "]");
1728 if (type != LINE_CURSOR)
1729 wattrset(view->win, A_NORMAL);
1730 waddstr(view->win, " ");
1731 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1732 } while (commit->refs[i++]->next);
1735 if (type != LINE_CURSOR)
1736 wattrset(view->win, get_line_attr(type));
1739 int titlelen = strlen(commit->title);
1741 if (col + titlelen > view->width)
1742 titlelen = view->width - col;
1744 waddnstr(view->win, commit->title, titlelen);
1750 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1752 main_read(struct view *view, struct line *prev, char *line)
1754 enum line_type type = get_line_type(line);
1755 struct commit *commit;
1759 commit = calloc(1, sizeof(struct commit));
1763 line += STRING_SIZE("commit ");
1765 view->line[view->lines++].data = commit;
1766 string_copy(commit->id, line);
1767 commit->refs = get_refs(commit->id);
1772 char *ident = line + STRING_SIZE("author ");
1773 char *end = strchr(ident, '<');
1778 commit = prev->data;
1781 for (; end > ident && isspace(end[-1]); end--) ;
1785 string_copy(commit->author, ident);
1787 /* Parse epoch and timezone */
1789 char *secs = strchr(end + 1, '>');
1793 if (!secs || secs[1] != ' ')
1797 time = (time_t) atol(secs);
1798 zone = strchr(secs, ' ');
1799 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1803 tz = ('0' - zone[1]) * 60 * 60 * 10;
1804 tz += ('0' - zone[2]) * 60 * 60;
1805 tz += ('0' - zone[3]) * 60;
1806 tz += ('0' - zone[4]) * 60;
1813 gmtime_r(&time, &commit->time);
1821 commit = prev->data;
1823 /* Fill in the commit title if it has not already been set. */
1824 if (commit->title[0])
1827 /* Require titles to start with a non-space character at the
1828 * offset used by git log. */
1829 /* FIXME: More gracefull handling of titles; append "..." to
1830 * shortened titles, etc. */
1831 if (strncmp(line, " ", 4) ||
1835 string_copy(commit->title, line + 4);
1842 main_enter(struct view *view, struct line *line)
1844 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1846 open_view(view, REQ_VIEW_DIFF, flags);
1850 static struct view_ops main_ops = {
1861 * Below the default key bindings are shown.
1869 static struct keymap keymap[] = {
1874 * Switch to main view.
1876 * Switch to diff view.
1878 * Switch to log view.
1880 * Switch to pager view.
1884 { 'm', REQ_VIEW_MAIN },
1885 { 'd', REQ_VIEW_DIFF },
1886 { 'l', REQ_VIEW_LOG },
1887 { 'p', REQ_VIEW_PAGER },
1888 { 'h', REQ_VIEW_HELP },
1894 * Close view, if multiple views are open it will jump back to the
1895 * previous view in the view stack. If it is the last open view it
1896 * will quit. Use 'Q' to quit all views at once.
1898 * This key is "context sensitive" depending on what view you are
1899 * currently in. When in log view on a commit line or in the main
1900 * view, split the view and show the commit diff. In the diff view
1901 * pressing Enter will simply scroll the view one line down.
1903 * Switch to next view.
1905 * This key is "context sensitive" and will move the cursor one
1906 * line up. However, uf you opened a diff view from the main view
1907 * (split- or full-screen) it will change the cursor to point to
1908 * the previous commit in the main view and update the diff view
1911 * Similar to 'Up' but will move down.
1913 { 'q', REQ_VIEW_CLOSE },
1914 { KEY_TAB, REQ_VIEW_NEXT },
1915 { KEY_RETURN, REQ_ENTER },
1916 { KEY_UP, REQ_PREVIOUS },
1917 { KEY_DOWN, REQ_NEXT },
1923 * Move cursor one line up.
1925 * Move cursor one line down.
1929 * Move cursor one page up.
1932 * Move cursor one page down.
1934 * Jump to first line.
1936 * Jump to last line.
1938 { 'k', REQ_MOVE_UP },
1939 { 'j', REQ_MOVE_DOWN },
1940 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1941 { KEY_END, REQ_MOVE_LAST_LINE },
1942 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1943 { ' ', REQ_MOVE_PAGE_DOWN },
1944 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1945 { 'b', REQ_MOVE_PAGE_UP },
1946 { '-', REQ_MOVE_PAGE_UP },
1952 * Scroll view one line up.
1954 * Scroll view one line down.
1956 * Scroll view one page up.
1958 * Scroll view one page down.
1960 { KEY_IC, REQ_SCROLL_LINE_UP },
1961 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1962 { 'w', REQ_SCROLL_PAGE_UP },
1963 { 's', REQ_SCROLL_PAGE_DOWN },
1973 * Stop all background loading. This can be useful if you use
1974 * tig(1) in a repository with a long history without limiting
1979 * Toggle line numbers on/off.
1981 * Open prompt. This allows you to specify what git command
1987 { 'z', REQ_STOP_LOADING },
1988 { 'v', REQ_SHOW_VERSION },
1989 { 'r', REQ_SCREEN_REDRAW },
1990 { 'n', REQ_TOGGLE_LINE_NUMBERS },
1991 { ':', REQ_PROMPT },
1993 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1994 { ERR, REQ_SCREEN_UPDATE },
1996 /* Use the ncurses SIGWINCH handler. */
1997 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2001 get_request(int key)
2005 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2006 if (keymap[i].alias == key)
2007 return keymap[i].request;
2009 return (enum request) key;
2014 * Unicode / UTF-8 handling
2016 * NOTE: Much of the following code for dealing with unicode is derived from
2017 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2018 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2021 /* I've (over)annotated a lot of code snippets because I am not entirely
2022 * confident that the approach taken by this small UTF-8 interface is correct.
2026 unicode_width(unsigned long c)
2029 (c <= 0x115f /* Hangul Jamo */
2032 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2034 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2035 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2036 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2037 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2038 || (c >= 0xffe0 && c <= 0xffe6)
2039 || (c >= 0x20000 && c <= 0x2fffd)
2040 || (c >= 0x30000 && c <= 0x3fffd)))
2046 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2047 * Illegal bytes are set one. */
2048 static const unsigned char utf8_bytes[256] = {
2049 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2050 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2051 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2052 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2053 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2054 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2055 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,
2056 3,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, 4,4,4,4,4,4,4,4, 5,5,5,5,6,6,1,1,
2059 /* Decode UTF-8 multi-byte representation into a unicode character. */
2060 static inline unsigned long
2061 utf8_to_unicode(const char *string, size_t length)
2063 unsigned long unicode;
2067 unicode = string[0];
2070 unicode = (string[0] & 0x1f) << 6;
2071 unicode += (string[1] & 0x3f);
2074 unicode = (string[0] & 0x0f) << 12;
2075 unicode += ((string[1] & 0x3f) << 6);
2076 unicode += (string[2] & 0x3f);
2079 unicode = (string[0] & 0x0f) << 18;
2080 unicode += ((string[1] & 0x3f) << 12);
2081 unicode += ((string[2] & 0x3f) << 6);
2082 unicode += (string[3] & 0x3f);
2085 unicode = (string[0] & 0x0f) << 24;
2086 unicode += ((string[1] & 0x3f) << 18);
2087 unicode += ((string[2] & 0x3f) << 12);
2088 unicode += ((string[3] & 0x3f) << 6);
2089 unicode += (string[4] & 0x3f);
2092 unicode = (string[0] & 0x01) << 30;
2093 unicode += ((string[1] & 0x3f) << 24);
2094 unicode += ((string[2] & 0x3f) << 18);
2095 unicode += ((string[3] & 0x3f) << 12);
2096 unicode += ((string[4] & 0x3f) << 6);
2097 unicode += (string[5] & 0x3f);
2100 die("Invalid unicode length");
2103 /* Invalid characters could return the special 0xfffd value but NUL
2104 * should be just as good. */
2105 return unicode > 0xffff ? 0 : unicode;
2108 /* Calculates how much of string can be shown within the given maximum width
2109 * and sets trimmed parameter to non-zero value if all of string could not be
2112 * Additionally, adds to coloffset how many many columns to move to align with
2113 * the expected position. Takes into account how multi-byte and double-width
2114 * characters will effect the cursor position.
2116 * Returns the number of bytes to output from string to satisfy max_width. */
2118 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2120 const char *start = string;
2121 const char *end = strchr(string, '\0');
2127 while (string < end) {
2128 int c = *(unsigned char *) string;
2129 unsigned char bytes = utf8_bytes[c];
2131 unsigned long unicode;
2133 if (string + bytes > end)
2136 /* Change representation to figure out whether
2137 * it is a single- or double-width character. */
2139 unicode = utf8_to_unicode(string, bytes);
2140 /* FIXME: Graceful handling of invalid unicode character. */
2144 ucwidth = unicode_width(unicode);
2146 if (width > max_width) {
2151 /* The column offset collects the differences between the
2152 * number of bytes encoding a character and the number of
2153 * columns will be used for rendering said character.
2155 * So if some character A is encoded in 2 bytes, but will be
2156 * represented on the screen using only 1 byte this will and up
2157 * adding 1 to the multi-byte column offset.
2159 * Assumes that no double-width character can be encoding in
2160 * less than two bytes. */
2161 if (bytes > ucwidth)
2162 mbwidth += bytes - ucwidth;
2167 *coloffset += mbwidth;
2169 return string - start;
2177 /* Whether or not the curses interface has been initialized. */
2178 static bool cursed = FALSE;
2180 /* The status window is used for polling keystrokes. */
2181 static WINDOW *status_win;
2183 /* Update status and title window. */
2185 report(const char *msg, ...)
2187 static bool empty = TRUE;
2188 struct view *view = display[current_view];
2190 if (!empty || *msg) {
2193 va_start(args, msg);
2196 wmove(status_win, 0, 0);
2198 vwprintw(status_win, msg, args);
2203 wrefresh(status_win);
2208 update_view_title(view);
2210 /* Move the cursor to the right-most column of the cursor line.
2212 * XXX: This could turn out to be a bit expensive, but it ensures that
2213 * the cursor does not jump around. */
2215 wmove(view->win, view->lineno - view->offset, view->width - 1);
2216 wrefresh(view->win);
2220 /* Controls when nodelay should be in effect when polling user input. */
2222 set_nonblocking_input(bool loading)
2224 static unsigned int loading_views;
2226 if ((loading == FALSE && loading_views-- == 1) ||
2227 (loading == TRUE && loading_views++ == 0))
2228 nodelay(status_win, loading);
2236 /* Initialize the curses library */
2237 if (isatty(STDIN_FILENO)) {
2238 cursed = !!initscr();
2240 /* Leave stdin and stdout alone when acting as a pager. */
2241 FILE *io = fopen("/dev/tty", "r+");
2243 cursed = !!newterm(NULL, io, io);
2247 die("Failed to initialize curses");
2249 nonl(); /* Tell curses not to do NL->CR/NL on output */
2250 cbreak(); /* Take input chars one at a time, no wait for \n */
2251 noecho(); /* Don't echo input */
2252 leaveok(stdscr, TRUE);
2257 getmaxyx(stdscr, y, x);
2258 status_win = newwin(1, 0, y - 1, 0);
2260 die("Failed to create status window");
2262 /* Enable keyboard mapping */
2263 keypad(status_win, TRUE);
2264 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2269 * Repository references
2272 static struct ref *refs;
2273 static size_t refs_size;
2275 /* Id <-> ref store */
2276 static struct ref ***id_refs;
2277 static size_t id_refs_size;
2279 static struct ref **
2282 struct ref ***tmp_id_refs;
2283 struct ref **ref_list = NULL;
2284 size_t ref_list_size = 0;
2287 for (i = 0; i < id_refs_size; i++)
2288 if (!strcmp(id, id_refs[i][0]->id))
2291 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2295 id_refs = tmp_id_refs;
2297 for (i = 0; i < refs_size; i++) {
2300 if (strcmp(id, refs[i].id))
2303 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2311 if (ref_list_size > 0)
2312 ref_list[ref_list_size - 1]->next = 1;
2313 ref_list[ref_list_size] = &refs[i];
2315 /* XXX: The properties of the commit chains ensures that we can
2316 * safely modify the shared ref. The repo references will
2317 * always be similar for the same id. */
2318 ref_list[ref_list_size]->next = 0;
2323 id_refs[id_refs_size++] = ref_list;
2331 const char *cmd_env = getenv("TIG_LS_REMOTE");
2332 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2333 FILE *pipe = popen(cmd, "r");
2334 char buffer[BUFSIZ];
2340 while ((line = fgets(buffer, sizeof(buffer), pipe))) {
2341 char *name = strchr(line, '\t');
2345 bool tag_commit = FALSE;
2351 namelen = strlen(name) - 1;
2353 /* Commits referenced by tags has "^{}" appended. */
2354 if (name[namelen - 1] == '}') {
2355 while (namelen > 0 && name[namelen] != '^')
2362 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2365 name += STRING_SIZE("refs/tags/");
2368 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2369 name += STRING_SIZE("refs/heads/");
2371 } else if (!strcmp(name, "HEAD")) {
2375 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2379 ref = &refs[refs_size++];
2381 ref->name = strdup(name);
2385 string_copy(ref->id, line);
2399 FILE *pipe = popen("git repo-config --list", "r");
2400 char buffer[BUFSIZ];
2406 while ((name = fgets(buffer, sizeof(buffer), pipe))) {
2407 char *value = strchr(name, '=');
2408 int valuelen, namelen;
2410 /* No boolean options, yet */
2414 namelen = value - name;
2417 valuelen = strlen(value);
2419 value[valuelen - 1] = 0;
2421 if (!strcmp(name, "i18n.commitencoding")) {
2422 string_copy(opt_encoding, value);
2439 #define __NORETURN __attribute__((__noreturn__))
2444 static void __NORETURN
2447 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2453 static void __NORETURN
2454 die(const char *err, ...)
2460 va_start(args, err);
2461 fputs("tig: ", stderr);
2462 vfprintf(stderr, err, args);
2463 fputs("\n", stderr);
2470 main(int argc, char *argv[])
2473 enum request request;
2476 signal(SIGINT, quit);
2478 /* Load the repo config file first so options can be overwritten from
2479 * the command line. */
2480 if (load_config() == ERR)
2481 die("Failed to load repo config.");
2483 if (!parse_options(argc, argv))
2486 if (load_refs() == ERR)
2487 die("Failed to load refs.");
2489 /* Require a git repository unless when running in pager mode. */
2490 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2491 die("Not a git repository");
2493 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2494 view->cmd_env = getenv(view->cmd_env);
2496 request = opt_request;
2500 while (view_driver(display[current_view], request)) {
2504 foreach_view (view, i)
2507 /* Refresh, accept single keystroke of input */
2508 key = wgetch(status_win);
2509 request = get_request(key);
2511 /* Some low-level request handling. This keeps access to
2512 * status_win restricted. */
2516 /* Temporarily switch to line-oriented and echoed
2521 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2522 memcpy(opt_cmd, "git ", 4);
2523 opt_request = REQ_VIEW_PAGER;
2532 case REQ_SCREEN_RESIZE:
2536 getmaxyx(stdscr, height, width);
2538 /* Resize the status view and let the view driver take
2539 * care of resizing the displayed views. */
2540 wresize(status_win, 1, width);
2541 mvwin(status_win, height - 1, 0);
2542 wrefresh(status_win);
2557 * Revision specification
2558 * ----------------------
2559 * This section describes various ways to specify what revisions to display
2560 * or otherwise limit the view to. tig(1) does not itself parse the described
2561 * revision options so refer to the relevant git man pages for futher
2562 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2565 * You can tune the interaction with git by making use of the options
2566 * explained in this section. For example, by configuring the environment
2567 * variables described in the <<view-commands, "View commands">> section.
2569 * Limit by path name
2570 * ~~~~~~~~~~~~~~~~~~
2571 * If you are interested only in those revisions that made changes to a
2572 * specific file (or even several files) list the files like this:
2574 * $ tig log Makefile README
2576 * To avoid ambiguity with repository references such as tag name, be sure
2577 * to separate file names from other git options using "\--". So if you
2578 * have a file named 'master' it will clash with the reference named
2579 * 'master', and thus you will have to use:
2581 * $ tig log -- master
2583 * NOTE: For the main view, avoiding ambiguity will in some cases require
2584 * you to specify two "\--" options. The first will make tig(1) stop
2585 * option processing and the latter will be passed to git log.
2587 * Limit by date or number
2588 * ~~~~~~~~~~~~~~~~~~~~~~~
2589 * To speed up interaction with git, you can limit the amount of commits
2590 * to show both for the log and main view. Either limit by date using
2591 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2593 * If you are only interested in changed that happened between two dates
2596 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2598 * NOTE: If you want to avoid having to quote dates containing spaces you
2599 * can use "." instead, e.g. `--after=May.5th`.
2601 * Limiting by commit ranges
2602 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2603 * Alternatively, commits can be limited to a specific range, such as
2604 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2606 * $ tig log tag-1.0..tag-2.0
2608 * This way of commit limiting makes it trivial to only browse the commits
2609 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2610 * upstream remote branch, using:
2612 * $ tig log origin..HEAD
2614 * will list what will be pushed to the remote branch. Optionally, the ending
2615 * 'HEAD' can be left out since it is implied.
2617 * Limiting by reachability
2618 * ~~~~~~~~~~~~~~~~~~~~~~~~
2619 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2620 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2621 * Where reachability refers to what commits are ancestors (or part of the
2622 * history) of the branch or tagged revision in question.
2624 * If you prefer to specify which commit to preview in this way use the
2627 * $ tig log tag-2.0 ^tag-1.0
2629 * You can think of '^' as a negation operator. Using this alternate syntax,
2630 * it is possible to further prune commits by specifying multiple branch
2633 * Combining revisions specification
2634 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2635 * Revisions options can to some degree be combined, which makes it possible
2636 * to say "show at most 20 commits from within the last month that changed
2637 * files under the Documentation/ directory."
2639 * $ tig -- --since=1.month -n20 -- Documentation/
2641 * Examining all repository references
2642 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2643 * In some cases, it can be useful to query changes across all references
2644 * in a repository. An example is to ask "did any line of development in
2645 * this repository change a particular file within the last week". This
2646 * can be accomplished using:
2648 * $ tig -- --all --since=1.week -- Makefile
2652 * Known bugs and problems:
2654 * - In it's current state tig is pretty much UTF-8 only.
2656 * - If the screen width is very small the main view can draw
2657 * outside the current view causing bad wrapping. Same goes
2658 * for title and status windows.
2660 * - The cursor can wrap-around on the last line and cause the
2665 * Features that should be explored.
2673 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2675 * This program is free software; you can redistribute it and/or modify
2676 * it under the terms of the GNU General Public License as published by
2677 * the Free Software Foundation; either version 2 of the License, or
2678 * (at your option) any later version.
2682 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2683 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2685 * Other git repository browsers: