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;
444 * ENVIRONMENT VARIABLES
445 * ---------------------
446 * Several options related to the interface with git can be configured
447 * via environment options.
449 * Repository references
450 * ~~~~~~~~~~~~~~~~~~~~~
451 * Commits that are referenced by tags and branch heads will be marked
452 * by the reference name surrounded by '[' and ']':
454 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
456 * If you want to filter out certain directories under `.git/refs/`, say
457 * `tmp` you can do it by setting the following variable:
459 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
461 * Or set the variable permanently in your environment.
464 * Set command for retrieving all repository references. The command
465 * should output data in the same format as git-ls-remote(1).
468 #define TIG_LS_REMOTE \
469 "git ls-remote . 2>/dev/null"
475 * It is possible to alter which commands are used for the different views.
476 * If for example you prefer commits in the main view to be sorted by date
477 * and only show 500 commits, use:
479 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
481 * Or set the variable permanently in your environment.
483 * Notice, how `%s` is used to specify the commit reference. There can
484 * be a maximum of 5 `%s` ref specifications.
487 * The command used for the diff view. By default, git show is used
491 * The command used for the log view. If you prefer to have both
492 * author and committer shown in the log view be sure to pass
493 * `--pretty=fuller` to git log.
496 * The command used for the main view. Note, you must always specify
497 * the option: `--pretty=raw` since the main view parser expects to
501 #define TIG_DIFF_CMD \
502 "git show --patch-with-stat --find-copies-harder -B -C %s"
504 #define TIG_LOG_CMD \
505 "git log --cc --stat -n100 %s"
507 #define TIG_MAIN_CMD \
508 "git log --topo-order --stat --pretty=raw %s"
510 /* ... silently ignore that the following are also exported. */
512 #define TIG_HELP_CMD \
513 "man tig 2>/dev/null"
515 #define TIG_PAGER_CMD \
520 * Line-oriented content detection.
524 /* Line type String to match Foreground Background Attributes
525 * --------- --------------- ---------- ---------- ---------- */ \
527 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
528 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
529 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
530 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
531 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
532 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
533 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
534 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
535 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
536 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
537 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
538 /* Pretty print commit header */ \
539 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
540 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
541 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
542 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
543 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
544 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
545 /* Raw commit header */ \
546 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
547 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
548 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
549 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
550 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
552 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
553 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
555 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
556 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
557 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
558 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
559 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
560 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
561 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
562 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
563 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
564 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
565 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
568 #define LINE(type, line, fg, bg, attr) \
575 const char *line; /* The start of line to match. */
576 int linelen; /* Size of string to match. */
577 int fg, bg, attr; /* Color and text attributes for the lines. */
580 static struct line_info line_info[] = {
581 #define LINE(type, line, fg, bg, attr) \
582 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
587 static enum line_type
588 get_line_type(char *line)
590 int linelen = strlen(line);
593 for (type = 0; type < ARRAY_SIZE(line_info); type++)
594 /* Case insensitive search matches Signed-off-by lines better. */
595 if (linelen >= line_info[type].linelen &&
596 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
603 get_line_attr(enum line_type type)
605 assert(type < ARRAY_SIZE(line_info));
606 return COLOR_PAIR(type) | line_info[type].attr;
612 int default_bg = COLOR_BLACK;
613 int default_fg = COLOR_WHITE;
618 if (use_default_colors() != ERR) {
623 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
624 struct line_info *info = &line_info[type];
625 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
626 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
628 init_pair(type, fg, bg);
634 void *data; /* User data */
641 * The display consists of a status window on the last line of the screen and
642 * one or more views. The default is to only show one view at the time but it
643 * is possible to split both the main and log view to also show the commit
646 * If you are in the log view and press 'Enter' when the current line is a
647 * commit line, such as:
649 * commit 4d55caff4cc89335192f3e566004b4ceef572521
651 * You will split the view so that the log view is displayed in the top window
652 * and the diff view in the bottom window. You can switch between the two
653 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
659 /* The display array of active views and the index of the current view. */
660 static struct view *display[2];
661 static unsigned int current_view;
663 #define foreach_view(view, i) \
664 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
666 #define displayed_views() (display[1] != NULL ? 2 : 1)
669 * Current head and commit ID
670 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
671 * The viewer keeps track of both what head and commit ID you are currently
672 * viewing. The commit ID will follow the cursor line and change everytime time
673 * you highlight a different commit. Whenever you reopen the diff view it
674 * will be reloaded, if the commit ID changed.
676 * The head ID is used when opening the main and log view to indicate from
677 * what revision to show history.
680 static char ref_commit[SIZEOF_REF] = "HEAD";
681 static char ref_head[SIZEOF_REF] = "HEAD";
684 const char *name; /* View name */
685 const char *cmd_fmt; /* Default command line format */
686 const char *cmd_env; /* Command line set via environment */
687 const char *id; /* Points to either of ref_{head,commit} */
689 struct view_ops *ops; /* View operations */
691 char cmd[SIZEOF_CMD]; /* Command buffer */
692 char ref[SIZEOF_REF]; /* Hovered commit reference */
693 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
695 int height, width; /* The width and height of the main window */
696 WINDOW *win; /* The main window */
697 WINDOW *title; /* The title window living below the main window */
700 unsigned long offset; /* Offset of the window top */
701 unsigned long lineno; /* Current line number */
703 /* If non-NULL, points to the view that opened this view. If this view
704 * is closed tig will switch back to the parent view. */
708 unsigned long lines; /* Total number of lines */
709 struct line *line; /* Line index */
710 unsigned int digits; /* Number of digits in the lines member. */
718 /* What type of content being displayed. Used in the title bar. */
720 /* Draw one line; @lineno must be < view->height. */
721 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
722 /* Read one line; updates view->line. */
723 bool (*read)(struct view *view, struct line *prev, char *data);
724 /* Depending on view, change display based on current line. */
725 bool (*enter)(struct view *view, struct line *line);
728 static struct view_ops pager_ops;
729 static struct view_ops main_ops;
731 #define VIEW_STR(name, cmd, env, ref, ops) \
732 { name, cmd, #env, ref, ops }
734 #define VIEW_(id, name, ops, ref) \
735 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
740 * tig(1) presents various 'views' of a repository. Each view is based on output
741 * from an external command, most often 'git log', 'git diff', or 'git show'.
744 * Is the default view, and it shows a one line summary of each commit
745 * in the chosen list of revisions. The summary includes commit date,
746 * author, and the first line of the log message. Additionally, any
747 * repository references, such as tags, will be shown.
750 * Presents a more rich view of the revision log showing the whole log
751 * message and the diffstat.
754 * Shows either the diff of the current working tree, that is, what
755 * has changed since the last commit, or the commit diff complete
756 * with log message, diffstat and diff.
759 * Is used for displaying both input from stdin and output from git
760 * commands entered in the internal prompt.
763 * Displays the information from the tig(1) man page. For the help view
764 * to work you need to have the tig(1) man page installed.
767 static struct view views[] = {
768 VIEW_(MAIN, "main", &main_ops, ref_head),
769 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
770 VIEW_(LOG, "log", &pager_ops, ref_head),
771 VIEW_(HELP, "help", &pager_ops, "static"),
772 VIEW_(PAGER, "pager", &pager_ops, "static"),
775 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
779 draw_view_line(struct view *view, unsigned int lineno)
781 if (view->offset + lineno >= view->lines)
784 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
788 redraw_view_from(struct view *view, int lineno)
790 assert(0 <= lineno && lineno < view->height);
792 for (; lineno < view->height; lineno++) {
793 if (!draw_view_line(view, lineno))
797 redrawwin(view->win);
802 redraw_view(struct view *view)
805 redraw_view_from(view, 0);
812 * Each view has a title window which shows the name of the view, current
813 * commit ID if available, and where the view is positioned:
815 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
817 * By default, the title of the current view is highlighted using bold font.
821 update_view_title(struct view *view)
823 if (view == display[current_view])
824 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
826 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
829 wmove(view->title, 0, 0);
832 wprintw(view->title, "[%s] %s", view->name, view->ref);
834 wprintw(view->title, "[%s]", view->name);
836 if (view->lines || view->pipe) {
837 unsigned int lines = view->lines
838 ? (view->lineno + 1) * 100 / view->lines
841 wprintw(view->title, " - %s %d of %d (%d%%)",
849 time_t secs = time(NULL) - view->start_time;
851 /* Three git seconds are a long time ... */
853 wprintw(view->title, " %lds", secs);
857 wrefresh(view->title);
864 struct view *base = display[0];
865 struct view *view = display[1] ? display[1] : display[0];
867 /* Setup window dimensions */
869 getmaxyx(stdscr, base->height, base->width);
871 /* Make room for the status window. */
875 /* Horizontal split. */
876 view->width = base->width;
877 view->height = SCALE_SPLIT_VIEW(base->height);
878 base->height -= view->height;
880 /* Make room for the title bar. */
884 /* Make room for the title bar. */
889 foreach_view (view, i) {
891 view->win = newwin(view->height, 0, offset, 0);
893 die("Failed to create %s view", view->name);
895 scrollok(view->win, TRUE);
897 view->title = newwin(1, 0, offset + view->height, 0);
899 die("Failed to create title window");
902 wresize(view->win, view->height, view->width);
903 mvwin(view->win, offset, 0);
904 mvwin(view->title, offset + view->height, 0);
908 offset += view->height + 1;
918 foreach_view (view, i) {
920 update_view_title(view);
929 /* Scrolling backend */
931 do_scroll_view(struct view *view, int lines, bool redraw)
933 /* The rendering expects the new offset. */
934 view->offset += lines;
936 assert(0 <= view->offset && view->offset < view->lines);
939 /* Redraw the whole screen if scrolling is pointless. */
940 if (view->height < ABS(lines)) {
944 int line = lines > 0 ? view->height - lines : 0;
945 int end = line + ABS(lines);
947 wscrl(view->win, lines);
949 for (; line < end; line++) {
950 if (!draw_view_line(view, line))
955 /* Move current line into the view. */
956 if (view->lineno < view->offset) {
957 view->lineno = view->offset;
958 draw_view_line(view, 0);
960 } else if (view->lineno >= view->offset + view->height) {
961 if (view->lineno == view->offset + view->height) {
962 /* Clear the hidden line so it doesn't show if the view
964 wmove(view->win, view->height, 0);
965 wclrtoeol(view->win);
967 view->lineno = view->offset + view->height - 1;
968 draw_view_line(view, view->lineno - view->offset);
971 assert(view->offset <= view->lineno && view->lineno < view->lines);
976 redrawwin(view->win);
981 /* Scroll frontend */
983 scroll_view(struct view *view, enum request request)
988 case REQ_SCROLL_PAGE_DOWN:
989 lines = view->height;
990 case REQ_SCROLL_LINE_DOWN:
991 if (view->offset + lines > view->lines)
992 lines = view->lines - view->offset;
994 if (lines == 0 || view->offset + view->height >= view->lines) {
995 report("Cannot scroll beyond the last line");
1000 case REQ_SCROLL_PAGE_UP:
1001 lines = view->height;
1002 case REQ_SCROLL_LINE_UP:
1003 if (lines > view->offset)
1004 lines = view->offset;
1007 report("Cannot scroll beyond the first line");
1015 die("request %d not handled in switch", request);
1018 do_scroll_view(view, lines, TRUE);
1023 move_view(struct view *view, enum request request, bool redraw)
1028 case REQ_MOVE_FIRST_LINE:
1029 steps = -view->lineno;
1032 case REQ_MOVE_LAST_LINE:
1033 steps = view->lines - view->lineno - 1;
1036 case REQ_MOVE_PAGE_UP:
1037 steps = view->height > view->lineno
1038 ? -view->lineno : -view->height;
1041 case REQ_MOVE_PAGE_DOWN:
1042 steps = view->lineno + view->height >= view->lines
1043 ? view->lines - view->lineno - 1 : view->height;
1055 die("request %d not handled in switch", request);
1058 if (steps <= 0 && view->lineno == 0) {
1059 report("Cannot move beyond the first line");
1062 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1063 report("Cannot move beyond the last line");
1067 /* Move the current line */
1068 view->lineno += steps;
1069 assert(0 <= view->lineno && view->lineno < view->lines);
1071 /* Repaint the old "current" line if we be scrolling */
1072 if (ABS(steps) < view->height) {
1073 int prev_lineno = view->lineno - steps - view->offset;
1075 wmove(view->win, prev_lineno, 0);
1076 wclrtoeol(view->win);
1077 draw_view_line(view, prev_lineno);
1080 /* Check whether the view needs to be scrolled */
1081 if (view->lineno < view->offset ||
1082 view->lineno >= view->offset + view->height) {
1083 if (steps < 0 && -steps > view->offset) {
1084 steps = -view->offset;
1086 } else if (steps > 0) {
1087 if (view->lineno == view->lines - 1 &&
1088 view->lines > view->height) {
1089 steps = view->lines - view->offset - 1;
1090 if (steps >= view->height)
1091 steps -= view->height - 1;
1095 do_scroll_view(view, steps, redraw);
1099 /* Draw the current line */
1100 draw_view_line(view, view->lineno - view->offset);
1105 redrawwin(view->win);
1106 wrefresh(view->win);
1112 * Incremental updating
1116 end_update(struct view *view)
1120 set_nonblocking_input(FALSE);
1121 if (view->pipe == stdin)
1129 begin_update(struct view *view)
1131 const char *id = view->id;
1137 string_copy(view->cmd, opt_cmd);
1139 /* When running random commands, the view ref could have become
1140 * invalid so clear it. */
1143 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1145 if (snprintf(view->cmd, sizeof(view->cmd), format,
1146 id, id, id, id, id) >= sizeof(view->cmd))
1150 /* Special case for the pager view. */
1152 view->pipe = opt_pipe;
1155 view->pipe = popen(view->cmd, "r");
1161 set_nonblocking_input(TRUE);
1166 string_copy(view->vid, id);
1171 for (i = 0; i < view->lines; i++)
1172 if (view->line[i].data)
1173 free(view->line[i].data);
1179 view->start_time = time(NULL);
1185 update_view(struct view *view)
1187 char buffer[BUFSIZ];
1190 /* The number of lines to read. If too low it will cause too much
1191 * redrawing (and possible flickering), if too high responsiveness
1193 unsigned long lines = view->height;
1194 int redraw_from = -1;
1199 /* Only redraw if lines are visible. */
1200 if (view->offset + view->height >= view->lines)
1201 redraw_from = view->lines - view->offset;
1203 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1209 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1210 int linelen = strlen(line);
1212 struct line *prev = view->lines
1213 ? &view->line[view->lines - 1]
1217 line[linelen - 1] = 0;
1219 if (!view->ops->read(view, prev, line))
1229 lines = view->lines;
1230 for (digits = 0; lines; digits++)
1233 /* Keep the displayed view in sync with line number scaling. */
1234 if (digits != view->digits) {
1235 view->digits = digits;
1240 if (redraw_from >= 0) {
1241 /* If this is an incremental update, redraw the previous line
1242 * since for commits some members could have changed when
1243 * loading the main view. */
1244 if (redraw_from > 0)
1247 /* Incrementally draw avoids flickering. */
1248 redraw_view_from(view, redraw_from);
1251 /* Update the title _after_ the redraw so that if the redraw picks up a
1252 * commit reference in view->ref it'll be available here. */
1253 update_view_title(view);
1255 if (ferror(view->pipe)) {
1256 report("Failed to read: %s", strerror(errno));
1259 } else if (feof(view->pipe)) {
1260 if (view == VIEW(REQ_VIEW_HELP)) {
1261 const char *msg = TIG_HELP;
1263 if (view->lines == 0) {
1264 /* Slightly ugly, but abusing view->ref keeps
1265 * the error message. */
1266 string_copy(view->ref, "No help available");
1267 msg = "The tig(1) manpage is not installed";
1281 report("Allocation failure");
1289 OPEN_DEFAULT = 0, /* Use default view switching. */
1290 OPEN_SPLIT = 1, /* Split current view. */
1291 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1292 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1296 open_view(struct view *prev, enum request request, enum open_flags flags)
1298 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1299 bool split = !!(flags & OPEN_SPLIT);
1300 bool reload = !!(flags & OPEN_RELOAD);
1301 struct view *view = VIEW(request);
1302 int nviews = displayed_views();
1303 struct view *base_view = display[0];
1305 if (view == prev && nviews == 1 && !reload) {
1306 report("Already in %s view", view->name);
1310 if ((reload || strcmp(view->vid, view->id)) &&
1311 !begin_update(view)) {
1312 report("Failed to load %s view", view->name);
1317 display[current_view + 1] = view;
1321 /* Maximize the current view. */
1322 memset(display, 0, sizeof(display));
1324 display[current_view] = view;
1327 /* Resize the view when switching between split- and full-screen,
1328 * or when switching between two different full-screen views. */
1329 if (nviews != displayed_views() ||
1330 (nviews == 1 && base_view != display[0]))
1333 if (split && prev->lineno - prev->offset >= prev->height) {
1334 /* Take the title line into account. */
1335 int lines = prev->lineno - prev->offset - prev->height + 1;
1337 /* Scroll the view that was split if the current line is
1338 * outside the new limited view. */
1339 do_scroll_view(prev, lines, TRUE);
1342 if (prev && view != prev) {
1343 /* Continue loading split views in the background. */
1346 else if (!backgrounded)
1347 /* "Blur" the previous view. */
1348 update_view_title(prev);
1350 view->parent = prev;
1354 /* Clear the old view and let the incremental updating refill
1360 if (view == VIEW(REQ_VIEW_HELP))
1361 report("%s", TIG_HELP);
1366 /* If the view is backgrounded the above calls to report()
1367 * won't redraw the view title. */
1369 update_view_title(view);
1374 * User request switch noodle
1378 view_driver(struct view *view, enum request request)
1385 case REQ_MOVE_PAGE_UP:
1386 case REQ_MOVE_PAGE_DOWN:
1387 case REQ_MOVE_FIRST_LINE:
1388 case REQ_MOVE_LAST_LINE:
1389 move_view(view, request, TRUE);
1392 case REQ_SCROLL_LINE_DOWN:
1393 case REQ_SCROLL_LINE_UP:
1394 case REQ_SCROLL_PAGE_DOWN:
1395 case REQ_SCROLL_PAGE_UP:
1396 scroll_view(view, request);
1403 case REQ_VIEW_PAGER:
1404 open_view(view, request, OPEN_DEFAULT);
1409 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1411 if (view == VIEW(REQ_VIEW_DIFF) &&
1412 view->parent == VIEW(REQ_VIEW_MAIN)) {
1413 bool redraw = display[1] == view;
1415 view = view->parent;
1416 move_view(view, request, redraw);
1418 update_view_title(view);
1420 move_view(view, request, TRUE);
1427 report("Nothing to enter");
1430 return view->ops->enter(view, &view->line[view->lineno]);
1434 int nviews = displayed_views();
1435 int next_view = (current_view + 1) % nviews;
1437 if (next_view == current_view) {
1438 report("Only one view is displayed");
1442 current_view = next_view;
1443 /* Blur out the title of the previous view. */
1444 update_view_title(view);
1448 case REQ_TOGGLE_LINE_NUMBERS:
1449 opt_line_number = !opt_line_number;
1454 /* Always reload^Wrerun commands from the prompt. */
1455 open_view(view, opt_request, OPEN_RELOAD);
1458 case REQ_STOP_LOADING:
1459 foreach_view (view, i) {
1461 report("Stopped loaded the %s view", view->name),
1466 case REQ_SHOW_VERSION:
1467 report("%s (built %s)", VERSION, __DATE__);
1470 case REQ_SCREEN_RESIZE:
1473 case REQ_SCREEN_REDRAW:
1477 case REQ_SCREEN_UPDATE:
1481 case REQ_VIEW_CLOSE:
1483 memset(display, 0, sizeof(display));
1485 display[current_view] = view->parent;
1486 view->parent = NULL;
1496 /* An unknown key will show most commonly used commands. */
1497 report("Unknown key, press 'h' for help");
1510 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1512 char *text = line->data;
1513 enum line_type type = line->type;
1514 int textlen = strlen(text);
1517 wmove(view->win, lineno, 0);
1519 if (view->offset + lineno == view->lineno) {
1520 if (type == LINE_COMMIT) {
1521 string_copy(view->ref, text + 7);
1522 string_copy(ref_commit, view->ref);
1526 wchgat(view->win, -1, 0, type, NULL);
1529 attr = get_line_attr(type);
1530 wattrset(view->win, attr);
1532 if (opt_line_number || opt_tab_size < TABSIZE) {
1533 static char spaces[] = " ";
1534 int col_offset = 0, col = 0;
1536 if (opt_line_number) {
1537 unsigned long real_lineno = view->offset + lineno + 1;
1539 if (real_lineno == 1 ||
1540 (real_lineno % opt_num_interval) == 0) {
1541 wprintw(view->win, "%.*d", view->digits, real_lineno);
1544 waddnstr(view->win, spaces,
1545 MIN(view->digits, STRING_SIZE(spaces)));
1547 waddstr(view->win, ": ");
1548 col_offset = view->digits + 2;
1551 while (text && col_offset + col < view->width) {
1552 int cols_max = view->width - col_offset - col;
1556 if (*text == '\t') {
1558 assert(sizeof(spaces) > TABSIZE);
1560 cols = opt_tab_size - (col % opt_tab_size);
1563 text = strchr(text, '\t');
1564 cols = line ? text - pos : strlen(pos);
1567 waddnstr(view->win, pos, MIN(cols, cols_max));
1572 int col = 0, pos = 0;
1574 for (; pos < textlen && col < view->width; pos++, col++)
1575 if (text[pos] == '\t')
1576 col += TABSIZE - (col % TABSIZE) - 1;
1578 waddnstr(view->win, text, pos);
1585 pager_read(struct view *view, struct line *prev, char *line)
1587 /* Compress empty lines in the help view. */
1588 if (view == VIEW(REQ_VIEW_HELP) &&
1589 !*line && prev && !*((char *) prev->data))
1592 view->line[view->lines].data = strdup(line);
1593 if (!view->line[view->lines].data)
1596 view->line[view->lines].type = get_line_type(line);
1603 pager_enter(struct view *view, struct line *line)
1607 if (line->type == LINE_COMMIT &&
1608 (view == VIEW(REQ_VIEW_LOG) ||
1609 view == VIEW(REQ_VIEW_PAGER))) {
1610 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1614 /* Always scroll the view even if it was split. That way
1615 * you can use Enter to scroll through the log view and
1616 * split open each commit diff. */
1617 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1619 /* FIXME: A minor workaround. Scrolling the view will call report("")
1620 * but if we are scolling a non-current view this won't properly update
1621 * the view title. */
1623 update_view_title(view);
1628 static struct view_ops pager_ops = {
1641 char id[41]; /* SHA1 ID. */
1642 char title[75]; /* The first line of the commit message. */
1643 char author[75]; /* The author of the commit. */
1644 struct tm time; /* Date from the author ident. */
1645 struct ref **refs; /* Repository references; tags & branch heads. */
1649 main_draw(struct view *view, struct line *line, unsigned int lineno)
1651 char buf[DATE_COLS + 1];
1652 struct commit *commit = line->data;
1653 enum line_type type;
1659 if (!*commit->author)
1662 wmove(view->win, lineno, col);
1664 if (view->offset + lineno == view->lineno) {
1665 string_copy(view->ref, commit->id);
1666 string_copy(ref_commit, view->ref);
1668 wattrset(view->win, get_line_attr(type));
1669 wchgat(view->win, -1, 0, type, NULL);
1672 type = LINE_MAIN_COMMIT;
1673 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1676 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1677 waddnstr(view->win, buf, timelen);
1678 waddstr(view->win, " ");
1681 wmove(view->win, lineno, col);
1682 if (type != LINE_CURSOR)
1683 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1686 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1688 authorlen = strlen(commit->author);
1689 if (authorlen > AUTHOR_COLS - 2) {
1690 authorlen = AUTHOR_COLS - 2;
1696 waddnstr(view->win, commit->author, authorlen);
1697 if (type != LINE_CURSOR)
1698 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1699 waddch(view->win, '~');
1701 waddstr(view->win, commit->author);
1705 if (type != LINE_CURSOR)
1706 wattrset(view->win, A_NORMAL);
1708 mvwaddch(view->win, lineno, col, ACS_LTEE);
1709 wmove(view->win, lineno, col + 2);
1716 if (type == LINE_CURSOR)
1718 else if (commit->refs[i]->tag)
1719 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1721 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1722 waddstr(view->win, "[");
1723 waddstr(view->win, commit->refs[i]->name);
1724 waddstr(view->win, "]");
1725 if (type != LINE_CURSOR)
1726 wattrset(view->win, A_NORMAL);
1727 waddstr(view->win, " ");
1728 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1729 } while (commit->refs[i++]->next);
1732 if (type != LINE_CURSOR)
1733 wattrset(view->win, get_line_attr(type));
1736 int titlelen = strlen(commit->title);
1738 if (col + titlelen > view->width)
1739 titlelen = view->width - col;
1741 waddnstr(view->win, commit->title, titlelen);
1747 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1749 main_read(struct view *view, struct line *prev, char *line)
1751 enum line_type type = get_line_type(line);
1752 struct commit *commit;
1756 commit = calloc(1, sizeof(struct commit));
1760 line += STRING_SIZE("commit ");
1762 view->line[view->lines++].data = commit;
1763 string_copy(commit->id, line);
1764 commit->refs = get_refs(commit->id);
1769 char *ident = line + STRING_SIZE("author ");
1770 char *end = strchr(ident, '<');
1775 commit = prev->data;
1778 for (; end > ident && isspace(end[-1]); end--) ;
1782 string_copy(commit->author, ident);
1784 /* Parse epoch and timezone */
1786 char *secs = strchr(end + 1, '>');
1790 if (!secs || secs[1] != ' ')
1794 time = (time_t) atol(secs);
1795 zone = strchr(secs, ' ');
1796 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1800 tz = ('0' - zone[1]) * 60 * 60 * 10;
1801 tz += ('0' - zone[2]) * 60 * 60;
1802 tz += ('0' - zone[3]) * 60;
1803 tz += ('0' - zone[4]) * 60;
1810 gmtime_r(&time, &commit->time);
1818 commit = prev->data;
1820 /* Fill in the commit title if it has not already been set. */
1821 if (commit->title[0])
1824 /* Require titles to start with a non-space character at the
1825 * offset used by git log. */
1826 /* FIXME: More gracefull handling of titles; append "..." to
1827 * shortened titles, etc. */
1828 if (strncmp(line, " ", 4) ||
1832 string_copy(commit->title, line + 4);
1839 main_enter(struct view *view, struct line *line)
1841 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1843 open_view(view, REQ_VIEW_DIFF, flags);
1847 static struct view_ops main_ops = {
1858 * Below the default key bindings are shown.
1866 static struct keymap keymap[] = {
1871 * Switch to main view.
1873 * Switch to diff view.
1875 * Switch to log view.
1877 * Switch to pager view.
1881 { 'm', REQ_VIEW_MAIN },
1882 { 'd', REQ_VIEW_DIFF },
1883 { 'l', REQ_VIEW_LOG },
1884 { 'p', REQ_VIEW_PAGER },
1885 { 'h', REQ_VIEW_HELP },
1891 * Close view, if multiple views are open it will jump back to the
1892 * previous view in the view stack. If it is the last open view it
1893 * will quit. Use 'Q' to quit all views at once.
1895 * This key is "context sensitive" depending on what view you are
1896 * currently in. When in log view on a commit line or in the main
1897 * view, split the view and show the commit diff. In the diff view
1898 * pressing Enter will simply scroll the view one line down.
1900 * Switch to next view.
1902 * This key is "context sensitive" and will move the cursor one
1903 * line up. However, uf you opened a diff view from the main view
1904 * (split- or full-screen) it will change the cursor to point to
1905 * the previous commit in the main view and update the diff view
1908 * Similar to 'Up' but will move down.
1910 { 'q', REQ_VIEW_CLOSE },
1911 { KEY_TAB, REQ_VIEW_NEXT },
1912 { KEY_RETURN, REQ_ENTER },
1913 { KEY_UP, REQ_PREVIOUS },
1914 { KEY_DOWN, REQ_NEXT },
1920 * Move cursor one line up.
1922 * Move cursor one line down.
1926 * Move cursor one page up.
1929 * Move cursor one page down.
1931 * Jump to first line.
1933 * Jump to last line.
1935 { 'k', REQ_MOVE_UP },
1936 { 'j', REQ_MOVE_DOWN },
1937 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1938 { KEY_END, REQ_MOVE_LAST_LINE },
1939 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1940 { ' ', REQ_MOVE_PAGE_DOWN },
1941 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1942 { 'b', REQ_MOVE_PAGE_UP },
1943 { '-', REQ_MOVE_PAGE_UP },
1949 * Scroll view one line up.
1951 * Scroll view one line down.
1953 * Scroll view one page up.
1955 * Scroll view one page down.
1957 { KEY_IC, REQ_SCROLL_LINE_UP },
1958 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1959 { 'w', REQ_SCROLL_PAGE_UP },
1960 { 's', REQ_SCROLL_PAGE_DOWN },
1970 * Stop all background loading. This can be useful if you use
1971 * tig(1) in a repository with a long history without limiting
1976 * Toggle line numbers on/off.
1978 * Open prompt. This allows you to specify what git command
1984 { 'z', REQ_STOP_LOADING },
1985 { 'v', REQ_SHOW_VERSION },
1986 { 'r', REQ_SCREEN_REDRAW },
1987 { 'n', REQ_TOGGLE_LINE_NUMBERS },
1988 { ':', REQ_PROMPT },
1990 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1991 { ERR, REQ_SCREEN_UPDATE },
1993 /* Use the ncurses SIGWINCH handler. */
1994 { KEY_RESIZE, REQ_SCREEN_RESIZE },
1998 get_request(int key)
2002 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2003 if (keymap[i].alias == key)
2004 return keymap[i].request;
2006 return (enum request) key;
2011 * Unicode / UTF-8 handling
2013 * NOTE: Much of the following code for dealing with unicode is derived from
2014 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2015 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2018 /* I've (over)annotated a lot of code snippets because I am not entirely
2019 * confident that the approach taken by this small UTF-8 interface is correct.
2023 unicode_width(unsigned long c)
2026 (c <= 0x115f /* Hangul Jamo */
2029 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2031 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2032 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2033 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2034 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2035 || (c >= 0xffe0 && c <= 0xffe6)
2036 || (c >= 0x20000 && c <= 0x2fffd)
2037 || (c >= 0x30000 && c <= 0x3fffd)))
2043 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2044 * Illegal bytes are set one. */
2045 static const unsigned char utf8_bytes[256] = {
2046 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,
2047 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,
2048 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,
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 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,
2053 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,
2056 /* Decode UTF-8 multi-byte representation into a unicode character. */
2057 static inline unsigned long
2058 utf8_to_unicode(const char *string, size_t length)
2060 unsigned long unicode;
2064 unicode = string[0];
2067 unicode = (string[0] & 0x1f) << 6;
2068 unicode += (string[1] & 0x3f);
2071 unicode = (string[0] & 0x0f) << 12;
2072 unicode += ((string[1] & 0x3f) << 6);
2073 unicode += (string[2] & 0x3f);
2076 unicode = (string[0] & 0x0f) << 18;
2077 unicode += ((string[1] & 0x3f) << 12);
2078 unicode += ((string[2] & 0x3f) << 6);
2079 unicode += (string[3] & 0x3f);
2082 unicode = (string[0] & 0x0f) << 24;
2083 unicode += ((string[1] & 0x3f) << 18);
2084 unicode += ((string[2] & 0x3f) << 12);
2085 unicode += ((string[3] & 0x3f) << 6);
2086 unicode += (string[4] & 0x3f);
2089 unicode = (string[0] & 0x01) << 30;
2090 unicode += ((string[1] & 0x3f) << 24);
2091 unicode += ((string[2] & 0x3f) << 18);
2092 unicode += ((string[3] & 0x3f) << 12);
2093 unicode += ((string[4] & 0x3f) << 6);
2094 unicode += (string[5] & 0x3f);
2097 die("Invalid unicode length");
2100 /* Invalid characters could return the special 0xfffd value but NUL
2101 * should be just as good. */
2102 return unicode > 0xffff ? 0 : unicode;
2105 /* Calculates how much of string can be shown within the given maximum width
2106 * and sets trimmed parameter to non-zero value if all of string could not be
2109 * Additionally, adds to coloffset how many many columns to move to align with
2110 * the expected position. Takes into account how multi-byte and double-width
2111 * characters will effect the cursor position.
2113 * Returns the number of bytes to output from string to satisfy max_width. */
2115 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2117 const char *start = string;
2118 const char *end = strchr(string, '\0');
2124 while (string < end) {
2125 int c = *(unsigned char *) string;
2126 unsigned char bytes = utf8_bytes[c];
2128 unsigned long unicode;
2130 if (string + bytes > end)
2133 /* Change representation to figure out whether
2134 * it is a single- or double-width character. */
2136 unicode = utf8_to_unicode(string, bytes);
2137 /* FIXME: Graceful handling of invalid unicode character. */
2141 ucwidth = unicode_width(unicode);
2143 if (width > max_width) {
2148 /* The column offset collects the differences between the
2149 * number of bytes encoding a character and the number of
2150 * columns will be used for rendering said character.
2152 * So if some character A is encoded in 2 bytes, but will be
2153 * represented on the screen using only 1 byte this will and up
2154 * adding 1 to the multi-byte column offset.
2156 * Assumes that no double-width character can be encoding in
2157 * less than two bytes. */
2158 if (bytes > ucwidth)
2159 mbwidth += bytes - ucwidth;
2164 *coloffset += mbwidth;
2166 return string - start;
2174 /* Whether or not the curses interface has been initialized. */
2175 static bool cursed = FALSE;
2177 /* The status window is used for polling keystrokes. */
2178 static WINDOW *status_win;
2180 /* Update status and title window. */
2182 report(const char *msg, ...)
2184 static bool empty = TRUE;
2185 struct view *view = display[current_view];
2187 if (!empty || *msg) {
2190 va_start(args, msg);
2193 wmove(status_win, 0, 0);
2195 vwprintw(status_win, msg, args);
2200 wrefresh(status_win);
2205 update_view_title(view);
2207 /* Move the cursor to the right-most column of the cursor line.
2209 * XXX: This could turn out to be a bit expensive, but it ensures that
2210 * the cursor does not jump around. */
2212 wmove(view->win, view->lineno - view->offset, view->width - 1);
2213 wrefresh(view->win);
2217 /* Controls when nodelay should be in effect when polling user input. */
2219 set_nonblocking_input(bool loading)
2221 static unsigned int loading_views;
2223 if ((loading == FALSE && loading_views-- == 1) ||
2224 (loading == TRUE && loading_views++ == 0))
2225 nodelay(status_win, loading);
2233 /* Initialize the curses library */
2234 if (isatty(STDIN_FILENO)) {
2235 cursed = !!initscr();
2237 /* Leave stdin and stdout alone when acting as a pager. */
2238 FILE *io = fopen("/dev/tty", "r+");
2240 cursed = !!newterm(NULL, io, io);
2244 die("Failed to initialize curses");
2246 nonl(); /* Tell curses not to do NL->CR/NL on output */
2247 cbreak(); /* Take input chars one at a time, no wait for \n */
2248 noecho(); /* Don't echo input */
2249 leaveok(stdscr, TRUE);
2254 getmaxyx(stdscr, y, x);
2255 status_win = newwin(1, 0, y - 1, 0);
2257 die("Failed to create status window");
2259 /* Enable keyboard mapping */
2260 keypad(status_win, TRUE);
2261 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2266 * Repository references
2269 static struct ref *refs;
2270 static size_t refs_size;
2272 /* Id <-> ref store */
2273 static struct ref ***id_refs;
2274 static size_t id_refs_size;
2276 static struct ref **
2279 struct ref ***tmp_id_refs;
2280 struct ref **ref_list = NULL;
2281 size_t ref_list_size = 0;
2284 for (i = 0; i < id_refs_size; i++)
2285 if (!strcmp(id, id_refs[i][0]->id))
2288 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2292 id_refs = tmp_id_refs;
2294 for (i = 0; i < refs_size; i++) {
2297 if (strcmp(id, refs[i].id))
2300 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2308 if (ref_list_size > 0)
2309 ref_list[ref_list_size - 1]->next = 1;
2310 ref_list[ref_list_size] = &refs[i];
2312 /* XXX: The properties of the commit chains ensures that we can
2313 * safely modify the shared ref. The repo references will
2314 * always be similar for the same id. */
2315 ref_list[ref_list_size]->next = 0;
2320 id_refs[id_refs_size++] = ref_list;
2328 const char *cmd_env = getenv("TIG_LS_REMOTE");
2329 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2330 FILE *pipe = popen(cmd, "r");
2331 char buffer[BUFSIZ];
2337 while ((line = fgets(buffer, sizeof(buffer), pipe))) {
2338 char *name = strchr(line, '\t');
2342 bool tag_commit = FALSE;
2348 namelen = strlen(name) - 1;
2350 /* Commits referenced by tags has "^{}" appended. */
2351 if (name[namelen - 1] == '}') {
2352 while (namelen > 0 && name[namelen] != '^')
2359 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2362 name += STRING_SIZE("refs/tags/");
2365 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2366 name += STRING_SIZE("refs/heads/");
2368 } else if (!strcmp(name, "HEAD")) {
2372 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2376 ref = &refs[refs_size++];
2378 ref->name = strdup(name);
2382 string_copy(ref->id, line);
2396 FILE *pipe = popen("git repo-config --list", "r");
2397 char buffer[BUFSIZ];
2403 while ((name = fgets(buffer, sizeof(buffer), pipe))) {
2404 char *value = strchr(name, '=');
2405 int valuelen, namelen;
2407 /* No boolean options, yet */
2411 namelen = value - name;
2414 valuelen = strlen(value);
2416 value[valuelen - 1] = 0;
2418 if (!strcmp(name, "i18n.commitencoding")) {
2419 string_copy(opt_encoding, value);
2436 #define __NORETURN __attribute__((__noreturn__))
2441 static void __NORETURN
2444 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2450 static void __NORETURN
2451 die(const char *err, ...)
2457 va_start(args, err);
2458 fputs("tig: ", stderr);
2459 vfprintf(stderr, err, args);
2460 fputs("\n", stderr);
2467 main(int argc, char *argv[])
2470 enum request request;
2473 signal(SIGINT, quit);
2475 if (!parse_options(argc, argv))
2478 if (load_refs() == ERR)
2479 die("Failed to load refs.");
2481 /* Require a git repository unless when running in pager mode. */
2482 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2483 die("Not a git repository");
2485 if (load_config() == ERR)
2486 die("Failed to load repo config.");
2488 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2489 view->cmd_env = getenv(view->cmd_env);
2491 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
2494 request = opt_request;
2498 while (view_driver(display[current_view], request)) {
2502 foreach_view (view, i)
2505 /* Refresh, accept single keystroke of input */
2506 key = wgetch(status_win);
2507 request = get_request(key);
2509 /* Some low-level request handling. This keeps access to
2510 * status_win restricted. */
2514 /* Temporarily switch to line-oriented and echoed
2519 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2520 memcpy(opt_cmd, "git ", 4);
2521 opt_request = REQ_VIEW_PAGER;
2530 case REQ_SCREEN_RESIZE:
2534 getmaxyx(stdscr, height, width);
2536 /* Resize the status view and let the view driver take
2537 * care of resizing the displayed views. */
2538 wresize(status_win, 1, width);
2539 mvwin(status_win, height - 1, 0);
2540 wrefresh(status_win);
2555 * Revision specification
2556 * ----------------------
2557 * This section describes various ways to specify what revisions to display
2558 * or otherwise limit the view to. tig(1) does not itself parse the described
2559 * revision options so refer to the relevant git man pages for futher
2560 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2563 * You can tune the interaction with git by making use of the options
2564 * explained in this section. For example, by configuring the environment
2565 * variables described in the <<view-commands, "View commands">> section.
2567 * Limit by path name
2568 * ~~~~~~~~~~~~~~~~~~
2569 * If you are interested only in those revisions that made changes to a
2570 * specific file (or even several files) list the files like this:
2572 * $ tig log Makefile README
2574 * To avoid ambiguity with repository references such as tag name, be sure
2575 * to separate file names from other git options using "\--". So if you
2576 * have a file named 'master' it will clash with the reference named
2577 * 'master', and thus you will have to use:
2579 * $ tig log -- master
2581 * NOTE: For the main view, avoiding ambiguity will in some cases require
2582 * you to specify two "\--" options. The first will make tig(1) stop
2583 * option processing and the latter will be passed to git log.
2585 * Limit by date or number
2586 * ~~~~~~~~~~~~~~~~~~~~~~~
2587 * To speed up interaction with git, you can limit the amount of commits
2588 * to show both for the log and main view. Either limit by date using
2589 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2591 * If you are only interested in changed that happened between two dates
2594 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2596 * NOTE: If you want to avoid having to quote dates containing spaces you
2597 * can use "." instead, e.g. `--after=May.5th`.
2599 * Limiting by commit ranges
2600 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2601 * Alternatively, commits can be limited to a specific range, such as
2602 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2604 * $ tig log tag-1.0..tag-2.0
2606 * This way of commit limiting makes it trivial to only browse the commits
2607 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2608 * upstream remote branch, using:
2610 * $ tig log origin..HEAD
2612 * will list what will be pushed to the remote branch. Optionally, the ending
2613 * 'HEAD' can be left out since it is implied.
2615 * Limiting by reachability
2616 * ~~~~~~~~~~~~~~~~~~~~~~~~
2617 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2618 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2619 * Where reachability refers to what commits are ancestors (or part of the
2620 * history) of the branch or tagged revision in question.
2622 * If you prefer to specify which commit to preview in this way use the
2625 * $ tig log tag-2.0 ^tag-1.0
2627 * You can think of '^' as a negation operator. Using this alternate syntax,
2628 * it is possible to further prune commits by specifying multiple branch
2631 * Combining revisions specification
2632 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2633 * Revisions options can to some degree be combined, which makes it possible
2634 * to say "show at most 20 commits from within the last month that changed
2635 * files under the Documentation/ directory."
2637 * $ tig -- --since=1.month -n20 -- Documentation/
2639 * Examining all repository references
2640 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2641 * In some cases, it can be useful to query changes across all references
2642 * in a repository. An example is to ask "did any line of development in
2643 * this repository change a particular file within the last week". This
2644 * can be accomplished using:
2646 * $ tig -- --all --since=1.week -- Makefile
2650 * Known bugs and problems:
2652 * - In it's current state tig is pretty much UTF-8 only.
2654 * - If the screen width is very small the main view can draw
2655 * outside the current view causing bad wrapping. Same goes
2656 * for title and status windows.
2658 * - The cursor can wrap-around on the last line and cause the
2663 * Features that should be explored.
2671 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2673 * This program is free software; you can redistribute it and/or modify
2674 * it under the terms of the GNU General Public License as published by
2675 * the Free Software Foundation; either version 2 of the License, or
2676 * (at your option) any later version.
2680 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2681 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2683 * Other git repository browsers: