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 int read_properties(const char *cmd, int separator, int (*read)(char *, int, char *, int));
67 static void set_nonblocking_input(bool loading);
68 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
70 #define ABS(x) ((x) >= 0 ? (x) : -(x))
71 #define MIN(x, y) ((x) < (y) ? (x) : (y))
73 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
74 #define STRING_SIZE(x) (sizeof(x) - 1)
76 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
77 #define SIZEOF_CMD 1024 /* Size of command buffer. */
79 /* This color name can be used to refer to the default term colors. */
80 #define COLOR_DEFAULT (-1)
82 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
84 /* The format and size of the date column in the main view. */
85 #define DATE_FORMAT "%Y-%m-%d %H:%M"
86 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
88 #define AUTHOR_COLS 20
90 /* The default interval between line numbers. */
91 #define NUMBER_INTERVAL 1
95 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
97 /* Some ascii-shorthands fitted into the ncurses namespace. */
99 #define KEY_RETURN '\r'
103 /* User action requests. */
105 /* Offset all requests to avoid conflicts with ncurses getch values. */
106 REQ_OFFSET = KEY_MAX + 1,
108 /* XXX: Keep the view request first and in sync with views[]. */
123 REQ_TOGGLE_LINE_NUMBERS,
137 REQ_SCROLL_LINE_DOWN,
139 REQ_SCROLL_PAGE_DOWN,
143 char *name; /* Ref name; tag or head names are shortened. */
144 char id[41]; /* Commit SHA1 ID */
145 unsigned int tag:1; /* Is it a tag? */
146 unsigned int next:1; /* For ref lists: are there more refs? */
149 static struct ref **get_refs(char *id);
157 string_ncopy(char *dst, const char *src, int dstlen)
159 strncpy(dst, src, dstlen - 1);
164 /* Shorthand for safely copying into a fixed buffer. */
165 #define string_copy(dst, src) \
166 string_ncopy(dst, src, sizeof(dst))
171 * NOTE: The following is a slightly modified copy of the git project's shell
172 * quoting routines found in the quote.c file.
174 * Help to copy the thing properly quoted for the shell safety. any single
175 * quote is replaced with '\'', any exclamation point is replaced with '\!',
176 * and the whole thing is enclosed in a
179 * original sq_quote result
180 * name ==> name ==> 'name'
181 * a b ==> a b ==> 'a b'
182 * a'b ==> a'\''b ==> 'a'\''b'
183 * a!b ==> a'\!'b ==> 'a'\!'b'
187 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
191 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
194 while ((c = *src++)) {
195 if (c == '\'' || c == '!') {
215 static const char usage[] =
216 VERSION " (" __DATE__ ")\n"
218 "Usage: tig [options]\n"
219 " or: tig [options] [--] [git log options]\n"
220 " or: tig [options] log [git log options]\n"
221 " or: tig [options] diff [git diff options]\n"
222 " or: tig [options] show [git show options]\n"
223 " or: tig [options] < [git command output]\n"
226 " -l Start up in log view\n"
227 " -d Start up in diff view\n"
228 " -n[I], --line-number[=I] Show line numbers with given interval\n"
229 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
230 " -- Mark end of tig options\n"
231 " -v, --version Show version and exit\n"
232 " -h, --help Show help message and exit\n";
234 /* Option and state variables. */
235 static bool opt_line_number = FALSE;
236 static int opt_num_interval = NUMBER_INTERVAL;
237 static int opt_tab_size = TABSIZE;
238 static enum request opt_request = REQ_VIEW_MAIN;
239 static char opt_cmd[SIZEOF_CMD] = "";
240 static char opt_encoding[20] = "";
241 static bool opt_utf8 = TRUE;
242 static FILE *opt_pipe = NULL;
244 /* Returns the index of log or diff command or -1 to exit. */
246 parse_options(int argc, char *argv[])
250 for (i = 1; i < argc; i++) {
255 * Start up in log view using the internal log command.
257 if (!strcmp(opt, "-l")) {
258 opt_request = REQ_VIEW_LOG;
264 * Start up in diff view using the internal diff command.
266 if (!strcmp(opt, "-d")) {
267 opt_request = REQ_VIEW_DIFF;
272 * -n[INTERVAL], --line-number[=INTERVAL]::
273 * Prefix line numbers in log and diff view.
274 * Optionally, with interval different than each line.
276 if (!strncmp(opt, "-n", 2) ||
277 !strncmp(opt, "--line-number", 13)) {
283 } else if (opt[STRING_SIZE("--line-number")] == '=') {
284 num = opt + STRING_SIZE("--line-number=");
288 opt_num_interval = atoi(num);
290 opt_line_number = TRUE;
295 * -t[NSPACES], --tab-size[=NSPACES]::
296 * Set the number of spaces tabs should be expanded to.
298 if (!strncmp(opt, "-t", 2) ||
299 !strncmp(opt, "--tab-size", 10)) {
305 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
306 num = opt + STRING_SIZE("--tab-size=");
310 opt_tab_size = MIN(atoi(num), TABSIZE);
316 * Show version and exit.
318 if (!strcmp(opt, "-v") ||
319 !strcmp(opt, "--version")) {
320 printf("tig version %s\n", VERSION);
326 * Show help message and exit.
328 if (!strcmp(opt, "-h") ||
329 !strcmp(opt, "--help")) {
336 * End of tig(1) options. Useful when specifying command
337 * options for the main view. Example:
339 * $ tig -- --since=1.month
341 if (!strcmp(opt, "--")) {
347 * log [git log options]::
348 * Open log view using the given git log options.
350 * diff [git diff options]::
351 * Open diff view using the given git diff options.
353 * show [git show options]::
354 * Open diff view using the given git show options.
356 if (!strcmp(opt, "log") ||
357 !strcmp(opt, "diff") ||
358 !strcmp(opt, "show")) {
359 opt_request = opt[0] == 'l'
360 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
365 * [git log options]::
366 * tig(1) will stop the option parsing when the first
367 * command line parameter not starting with "-" is
368 * encountered. All options including this one will be
369 * passed to git log when loading the main view.
370 * This makes it possible to say:
372 * $ tig tag-1.0..HEAD
374 if (opt[0] && opt[0] != '-')
377 die("unknown command '%s'", opt);
380 if (!isatty(STDIN_FILENO)) {
384 * If stdin is a pipe, any log or diff options will be ignored and the
385 * pager view will be opened loading data from stdin. The pager mode
386 * can be used for colorizing output from various git commands.
388 * Example on how to colorize the output of git-show(1):
392 opt_request = REQ_VIEW_PAGER;
395 } else if (i < argc) {
399 * Git command options
400 * ~~~~~~~~~~~~~~~~~~~
401 * All git command options specified on the command line will
402 * be passed to the given command and all will be shell quoted
403 * before they are passed to the shell.
405 * NOTE: If you specify options for the main view, you should
406 * not use the `--pretty` option as this option will be set
407 * automatically to the format expected by the main view.
409 * Example on how to open the log view and show both author and
410 * committer information:
412 * $ tig log --pretty=fuller
414 * See the <<refspec, "Specifying revisions">> section below
415 * for an introduction to revision options supported by the git
416 * commands. For details on specific git command options, refer
417 * to the man page of the command in question.
420 if (opt_request == REQ_VIEW_MAIN)
421 /* XXX: This is vulnerable to the user overriding
422 * options required for the main view parser. */
423 string_copy(opt_cmd, "git log --stat --pretty=raw");
425 string_copy(opt_cmd, "git");
426 buf_size = strlen(opt_cmd);
428 while (buf_size < sizeof(opt_cmd) && i < argc) {
429 opt_cmd[buf_size++] = ' ';
430 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
433 if (buf_size >= sizeof(opt_cmd))
434 die("command too long");
436 opt_cmd[buf_size] = 0;
440 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
448 * ENVIRONMENT VARIABLES
449 * ---------------------
450 * Several options related to the interface with git can be configured
451 * via environment options.
453 * Repository references
454 * ~~~~~~~~~~~~~~~~~~~~~
455 * Commits that are referenced by tags and branch heads will be marked
456 * by the reference name surrounded by '[' and ']':
458 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
460 * If you want to filter out certain directories under `.git/refs/`, say
461 * `tmp` you can do it by setting the following variable:
463 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
465 * Or set the variable permanently in your environment.
468 * Set command for retrieving all repository references. The command
469 * should output data in the same format as git-ls-remote(1).
472 #define TIG_LS_REMOTE \
473 "git ls-remote . 2>/dev/null"
479 * It is possible to alter which commands are used for the different views.
480 * If for example you prefer commits in the main view to be sorted by date
481 * and only show 500 commits, use:
483 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
485 * Or set the variable permanently in your environment.
487 * Notice, how `%s` is used to specify the commit reference. There can
488 * be a maximum of 5 `%s` ref specifications.
491 * The command used for the diff view. By default, git show is used
495 * The command used for the log view. If you prefer to have both
496 * author and committer shown in the log view be sure to pass
497 * `--pretty=fuller` to git log.
500 * The command used for the main view. Note, you must always specify
501 * the option: `--pretty=raw` since the main view parser expects to
505 #define TIG_DIFF_CMD \
506 "git show --patch-with-stat --find-copies-harder -B -C %s"
508 #define TIG_LOG_CMD \
509 "git log --cc --stat -n100 %s"
511 #define TIG_MAIN_CMD \
512 "git log --topo-order --stat --pretty=raw %s"
514 /* ... silently ignore that the following are also exported. */
516 #define TIG_HELP_CMD \
517 "man tig 2>/dev/null"
519 #define TIG_PAGER_CMD \
524 * Line-oriented content detection.
528 /* Line type String to match Foreground Background Attributes
529 * --------- --------------- ---------- ---------- ---------- */ \
531 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
532 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
533 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
534 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
535 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
536 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
537 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
538 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
539 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
540 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
541 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
542 /* Pretty print commit header */ \
543 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
544 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
545 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
546 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
547 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
548 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
549 /* Raw commit header */ \
550 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
551 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
552 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
553 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
554 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
556 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
557 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
559 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
560 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
561 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
562 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
563 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
564 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
565 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
566 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
567 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
568 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
569 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
572 #define LINE(type, line, fg, bg, attr) \
579 const char *line; /* The start of line to match. */
580 int linelen; /* Size of string to match. */
581 int fg, bg, attr; /* Color and text attributes for the lines. */
584 static struct line_info line_info[] = {
585 #define LINE(type, line, fg, bg, attr) \
586 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
591 static enum line_type
592 get_line_type(char *line)
594 int linelen = strlen(line);
597 for (type = 0; type < ARRAY_SIZE(line_info); type++)
598 /* Case insensitive search matches Signed-off-by lines better. */
599 if (linelen >= line_info[type].linelen &&
600 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
607 get_line_attr(enum line_type type)
609 assert(type < ARRAY_SIZE(line_info));
610 return COLOR_PAIR(type) | line_info[type].attr;
616 int default_bg = COLOR_BLACK;
617 int default_fg = COLOR_WHITE;
622 if (use_default_colors() != ERR) {
627 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
628 struct line_info *info = &line_info[type];
629 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
630 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
632 init_pair(type, fg, bg);
638 void *data; /* User data */
645 * The display consists of a status window on the last line of the screen and
646 * one or more views. The default is to only show one view at the time but it
647 * is possible to split both the main and log view to also show the commit
650 * If you are in the log view and press 'Enter' when the current line is a
651 * commit line, such as:
653 * commit 4d55caff4cc89335192f3e566004b4ceef572521
655 * You will split the view so that the log view is displayed in the top window
656 * and the diff view in the bottom window. You can switch between the two
657 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
663 /* The display array of active views and the index of the current view. */
664 static struct view *display[2];
665 static unsigned int current_view;
667 #define foreach_view(view, i) \
668 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
670 #define displayed_views() (display[1] != NULL ? 2 : 1)
673 * Current head and commit ID
674 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
675 * The viewer keeps track of both what head and commit ID you are currently
676 * viewing. The commit ID will follow the cursor line and change everytime time
677 * you highlight a different commit. Whenever you reopen the diff view it
678 * will be reloaded, if the commit ID changed.
680 * The head ID is used when opening the main and log view to indicate from
681 * what revision to show history.
684 static char ref_commit[SIZEOF_REF] = "HEAD";
685 static char ref_head[SIZEOF_REF] = "HEAD";
688 const char *name; /* View name */
689 const char *cmd_fmt; /* Default command line format */
690 const char *cmd_env; /* Command line set via environment */
691 const char *id; /* Points to either of ref_{head,commit} */
693 struct view_ops *ops; /* View operations */
695 char cmd[SIZEOF_CMD]; /* Command buffer */
696 char ref[SIZEOF_REF]; /* Hovered commit reference */
697 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
699 int height, width; /* The width and height of the main window */
700 WINDOW *win; /* The main window */
701 WINDOW *title; /* The title window living below the main window */
704 unsigned long offset; /* Offset of the window top */
705 unsigned long lineno; /* Current line number */
707 /* If non-NULL, points to the view that opened this view. If this view
708 * is closed tig will switch back to the parent view. */
712 unsigned long lines; /* Total number of lines */
713 struct line *line; /* Line index */
714 unsigned int digits; /* Number of digits in the lines member. */
722 /* What type of content being displayed. Used in the title bar. */
724 /* Draw one line; @lineno must be < view->height. */
725 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
726 /* Read one line; updates view->line. */
727 bool (*read)(struct view *view, struct line *prev, char *data);
728 /* Depending on view, change display based on current line. */
729 bool (*enter)(struct view *view, struct line *line);
732 static struct view_ops pager_ops;
733 static struct view_ops main_ops;
735 #define VIEW_STR(name, cmd, env, ref, ops) \
736 { name, cmd, #env, ref, ops }
738 #define VIEW_(id, name, ops, ref) \
739 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
744 * tig(1) presents various 'views' of a repository. Each view is based on output
745 * from an external command, most often 'git log', 'git diff', or 'git show'.
748 * Is the default view, and it shows a one line summary of each commit
749 * in the chosen list of revisions. The summary includes commit date,
750 * author, and the first line of the log message. Additionally, any
751 * repository references, such as tags, will be shown.
754 * Presents a more rich view of the revision log showing the whole log
755 * message and the diffstat.
758 * Shows either the diff of the current working tree, that is, what
759 * has changed since the last commit, or the commit diff complete
760 * with log message, diffstat and diff.
763 * Is used for displaying both input from stdin and output from git
764 * commands entered in the internal prompt.
767 * Displays the information from the tig(1) man page. For the help view
768 * to work you need to have the tig(1) man page installed.
771 static struct view views[] = {
772 VIEW_(MAIN, "main", &main_ops, ref_head),
773 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
774 VIEW_(LOG, "log", &pager_ops, ref_head),
775 VIEW_(HELP, "help", &pager_ops, "static"),
776 VIEW_(PAGER, "pager", &pager_ops, "static"),
779 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
783 draw_view_line(struct view *view, unsigned int lineno)
785 if (view->offset + lineno >= view->lines)
788 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
792 redraw_view_from(struct view *view, int lineno)
794 assert(0 <= lineno && lineno < view->height);
796 for (; lineno < view->height; lineno++) {
797 if (!draw_view_line(view, lineno))
801 redrawwin(view->win);
806 redraw_view(struct view *view)
809 redraw_view_from(view, 0);
816 * Each view has a title window which shows the name of the view, current
817 * commit ID if available, and where the view is positioned:
819 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
821 * By default, the title of the current view is highlighted using bold font.
825 update_view_title(struct view *view)
827 if (view == display[current_view])
828 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
830 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
833 wmove(view->title, 0, 0);
836 wprintw(view->title, "[%s] %s", view->name, view->ref);
838 wprintw(view->title, "[%s]", view->name);
840 if (view->lines || view->pipe) {
841 unsigned int lines = view->lines
842 ? (view->lineno + 1) * 100 / view->lines
845 wprintw(view->title, " - %s %d of %d (%d%%)",
853 time_t secs = time(NULL) - view->start_time;
855 /* Three git seconds are a long time ... */
857 wprintw(view->title, " %lds", secs);
861 wrefresh(view->title);
868 struct view *base = display[0];
869 struct view *view = display[1] ? display[1] : display[0];
871 /* Setup window dimensions */
873 getmaxyx(stdscr, base->height, base->width);
875 /* Make room for the status window. */
879 /* Horizontal split. */
880 view->width = base->width;
881 view->height = SCALE_SPLIT_VIEW(base->height);
882 base->height -= view->height;
884 /* Make room for the title bar. */
888 /* Make room for the title bar. */
893 foreach_view (view, i) {
895 view->win = newwin(view->height, 0, offset, 0);
897 die("Failed to create %s view", view->name);
899 scrollok(view->win, TRUE);
901 view->title = newwin(1, 0, offset + view->height, 0);
903 die("Failed to create title window");
906 wresize(view->win, view->height, view->width);
907 mvwin(view->win, offset, 0);
908 mvwin(view->title, offset + view->height, 0);
911 offset += view->height + 1;
921 foreach_view (view, i) {
923 update_view_title(view);
928 update_display_cursor(void)
930 struct view *view = display[current_view];
932 /* Move the cursor to the right-most column of the cursor line.
934 * XXX: This could turn out to be a bit expensive, but it ensures that
935 * the cursor does not jump around. */
937 wmove(view->win, view->lineno - view->offset, view->width - 1);
946 /* Scrolling backend */
948 do_scroll_view(struct view *view, int lines, bool redraw)
950 /* The rendering expects the new offset. */
951 view->offset += lines;
953 assert(0 <= view->offset && view->offset < view->lines);
956 /* Redraw the whole screen if scrolling is pointless. */
957 if (view->height < ABS(lines)) {
961 int line = lines > 0 ? view->height - lines : 0;
962 int end = line + ABS(lines);
964 wscrl(view->win, lines);
966 for (; line < end; line++) {
967 if (!draw_view_line(view, line))
972 /* Move current line into the view. */
973 if (view->lineno < view->offset) {
974 view->lineno = view->offset;
975 draw_view_line(view, 0);
977 } else if (view->lineno >= view->offset + view->height) {
978 if (view->lineno == view->offset + view->height) {
979 /* Clear the hidden line so it doesn't show if the view
981 wmove(view->win, view->height, 0);
982 wclrtoeol(view->win);
984 view->lineno = view->offset + view->height - 1;
985 draw_view_line(view, view->lineno - view->offset);
988 assert(view->offset <= view->lineno && view->lineno < view->lines);
993 redrawwin(view->win);
998 /* Scroll frontend */
1000 scroll_view(struct view *view, enum request request)
1005 case REQ_SCROLL_PAGE_DOWN:
1006 lines = view->height;
1007 case REQ_SCROLL_LINE_DOWN:
1008 if (view->offset + lines > view->lines)
1009 lines = view->lines - view->offset;
1011 if (lines == 0 || view->offset + view->height >= view->lines) {
1012 report("Cannot scroll beyond the last line");
1017 case REQ_SCROLL_PAGE_UP:
1018 lines = view->height;
1019 case REQ_SCROLL_LINE_UP:
1020 if (lines > view->offset)
1021 lines = view->offset;
1024 report("Cannot scroll beyond the first line");
1032 die("request %d not handled in switch", request);
1035 do_scroll_view(view, lines, TRUE);
1040 move_view(struct view *view, enum request request, bool redraw)
1045 case REQ_MOVE_FIRST_LINE:
1046 steps = -view->lineno;
1049 case REQ_MOVE_LAST_LINE:
1050 steps = view->lines - view->lineno - 1;
1053 case REQ_MOVE_PAGE_UP:
1054 steps = view->height > view->lineno
1055 ? -view->lineno : -view->height;
1058 case REQ_MOVE_PAGE_DOWN:
1059 steps = view->lineno + view->height >= view->lines
1060 ? view->lines - view->lineno - 1 : view->height;
1072 die("request %d not handled in switch", request);
1075 if (steps <= 0 && view->lineno == 0) {
1076 report("Cannot move beyond the first line");
1079 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1080 report("Cannot move beyond the last line");
1084 /* Move the current line */
1085 view->lineno += steps;
1086 assert(0 <= view->lineno && view->lineno < view->lines);
1088 /* Repaint the old "current" line if we be scrolling */
1089 if (ABS(steps) < view->height) {
1090 int prev_lineno = view->lineno - steps - view->offset;
1092 wmove(view->win, prev_lineno, 0);
1093 wclrtoeol(view->win);
1094 draw_view_line(view, prev_lineno);
1097 /* Check whether the view needs to be scrolled */
1098 if (view->lineno < view->offset ||
1099 view->lineno >= view->offset + view->height) {
1100 if (steps < 0 && -steps > view->offset) {
1101 steps = -view->offset;
1103 } else if (steps > 0) {
1104 if (view->lineno == view->lines - 1 &&
1105 view->lines > view->height) {
1106 steps = view->lines - view->offset - 1;
1107 if (steps >= view->height)
1108 steps -= view->height - 1;
1112 do_scroll_view(view, steps, redraw);
1116 /* Draw the current line */
1117 draw_view_line(view, view->lineno - view->offset);
1122 redrawwin(view->win);
1123 wrefresh(view->win);
1129 * Incremental updating
1133 end_update(struct view *view)
1137 set_nonblocking_input(FALSE);
1138 if (view->pipe == stdin)
1146 begin_update(struct view *view)
1148 const char *id = view->id;
1154 string_copy(view->cmd, opt_cmd);
1156 /* When running random commands, the view ref could have become
1157 * invalid so clear it. */
1160 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1162 if (snprintf(view->cmd, sizeof(view->cmd), format,
1163 id, id, id, id, id) >= sizeof(view->cmd))
1167 /* Special case for the pager view. */
1169 view->pipe = opt_pipe;
1172 view->pipe = popen(view->cmd, "r");
1178 set_nonblocking_input(TRUE);
1183 string_copy(view->vid, id);
1188 for (i = 0; i < view->lines; i++)
1189 if (view->line[i].data)
1190 free(view->line[i].data);
1196 view->start_time = time(NULL);
1202 update_view(struct view *view)
1204 char buffer[BUFSIZ];
1207 /* The number of lines to read. If too low it will cause too much
1208 * redrawing (and possible flickering), if too high responsiveness
1210 unsigned long lines = view->height;
1211 int redraw_from = -1;
1216 /* Only redraw if lines are visible. */
1217 if (view->offset + view->height >= view->lines)
1218 redraw_from = view->lines - view->offset;
1220 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1226 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1227 int linelen = strlen(line);
1229 struct line *prev = view->lines
1230 ? &view->line[view->lines - 1]
1234 line[linelen - 1] = 0;
1236 if (!view->ops->read(view, prev, line))
1246 lines = view->lines;
1247 for (digits = 0; lines; digits++)
1250 /* Keep the displayed view in sync with line number scaling. */
1251 if (digits != view->digits) {
1252 view->digits = digits;
1257 if (redraw_from >= 0) {
1258 /* If this is an incremental update, redraw the previous line
1259 * since for commits some members could have changed when
1260 * loading the main view. */
1261 if (redraw_from > 0)
1264 /* Incrementally draw avoids flickering. */
1265 redraw_view_from(view, redraw_from);
1268 /* Update the title _after_ the redraw so that if the redraw picks up a
1269 * commit reference in view->ref it'll be available here. */
1270 update_view_title(view);
1272 if (ferror(view->pipe)) {
1273 report("Failed to read: %s", strerror(errno));
1276 } else if (feof(view->pipe)) {
1277 if (view == VIEW(REQ_VIEW_HELP)) {
1278 const char *msg = TIG_HELP;
1280 if (view->lines == 0) {
1281 /* Slightly ugly, but abusing view->ref keeps
1282 * the error message. */
1283 string_copy(view->ref, "No help available");
1284 msg = "The tig(1) manpage is not installed";
1298 report("Allocation failure");
1306 OPEN_DEFAULT = 0, /* Use default view switching. */
1307 OPEN_SPLIT = 1, /* Split current view. */
1308 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1309 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1313 open_view(struct view *prev, enum request request, enum open_flags flags)
1315 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1316 bool split = !!(flags & OPEN_SPLIT);
1317 bool reload = !!(flags & OPEN_RELOAD);
1318 struct view *view = VIEW(request);
1319 int nviews = displayed_views();
1320 struct view *base_view = display[0];
1322 if (view == prev && nviews == 1 && !reload) {
1323 report("Already in %s view", view->name);
1327 if ((reload || strcmp(view->vid, view->id)) &&
1328 !begin_update(view)) {
1329 report("Failed to load %s view", view->name);
1334 display[current_view + 1] = view;
1338 /* Maximize the current view. */
1339 memset(display, 0, sizeof(display));
1341 display[current_view] = view;
1344 /* Resize the view when switching between split- and full-screen,
1345 * or when switching between two different full-screen views. */
1346 if (nviews != displayed_views() ||
1347 (nviews == 1 && base_view != display[0]))
1350 if (split && prev->lineno - prev->offset >= prev->height) {
1351 /* Take the title line into account. */
1352 int lines = prev->lineno - prev->offset - prev->height + 1;
1354 /* Scroll the view that was split if the current line is
1355 * outside the new limited view. */
1356 do_scroll_view(prev, lines, TRUE);
1359 if (prev && view != prev) {
1360 if (split && !backgrounded) {
1361 /* "Blur" the previous view. */
1362 update_view_title(prev);
1365 view->parent = prev;
1368 if (view->pipe && view->lines == 0) {
1369 /* Clear the old view and let the incremental updating refill
1375 if (view == VIEW(REQ_VIEW_HELP))
1376 report("%s", TIG_HELP);
1381 /* If the view is backgrounded the above calls to report()
1382 * won't redraw the view title. */
1384 update_view_title(view);
1389 * User request switch noodle
1393 view_driver(struct view *view, enum request request)
1400 case REQ_MOVE_PAGE_UP:
1401 case REQ_MOVE_PAGE_DOWN:
1402 case REQ_MOVE_FIRST_LINE:
1403 case REQ_MOVE_LAST_LINE:
1404 move_view(view, request, TRUE);
1407 case REQ_SCROLL_LINE_DOWN:
1408 case REQ_SCROLL_LINE_UP:
1409 case REQ_SCROLL_PAGE_DOWN:
1410 case REQ_SCROLL_PAGE_UP:
1411 scroll_view(view, request);
1418 case REQ_VIEW_PAGER:
1419 open_view(view, request, OPEN_DEFAULT);
1424 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1426 if (view == VIEW(REQ_VIEW_DIFF) &&
1427 view->parent == VIEW(REQ_VIEW_MAIN)) {
1428 bool redraw = display[1] == view;
1430 view = view->parent;
1431 move_view(view, request, redraw);
1433 update_view_title(view);
1435 move_view(view, request, TRUE);
1442 report("Nothing to enter");
1445 return view->ops->enter(view, &view->line[view->lineno]);
1449 int nviews = displayed_views();
1450 int next_view = (current_view + 1) % nviews;
1452 if (next_view == current_view) {
1453 report("Only one view is displayed");
1457 current_view = next_view;
1458 /* Blur out the title of the previous view. */
1459 update_view_title(view);
1463 case REQ_TOGGLE_LINE_NUMBERS:
1464 opt_line_number = !opt_line_number;
1469 /* Always reload^Wrerun commands from the prompt. */
1470 open_view(view, opt_request, OPEN_RELOAD);
1473 case REQ_STOP_LOADING:
1474 foreach_view (view, i) {
1476 report("Stopped loaded the %s view", view->name),
1481 case REQ_SHOW_VERSION:
1482 report("%s (built %s)", VERSION, __DATE__);
1485 case REQ_SCREEN_RESIZE:
1488 case REQ_SCREEN_REDRAW:
1492 case REQ_SCREEN_UPDATE:
1496 case REQ_VIEW_CLOSE:
1498 memset(display, 0, sizeof(display));
1500 display[current_view] = view->parent;
1501 view->parent = NULL;
1511 /* An unknown key will show most commonly used commands. */
1512 report("Unknown key, press 'h' for help");
1525 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1527 char *text = line->data;
1528 enum line_type type = line->type;
1529 int textlen = strlen(text);
1532 wmove(view->win, lineno, 0);
1534 if (view->offset + lineno == view->lineno) {
1535 if (type == LINE_COMMIT) {
1536 string_copy(view->ref, text + 7);
1537 string_copy(ref_commit, view->ref);
1541 wchgat(view->win, -1, 0, type, NULL);
1544 attr = get_line_attr(type);
1545 wattrset(view->win, attr);
1547 if (opt_line_number || opt_tab_size < TABSIZE) {
1548 static char spaces[] = " ";
1549 int col_offset = 0, col = 0;
1551 if (opt_line_number) {
1552 unsigned long real_lineno = view->offset + lineno + 1;
1554 if (real_lineno == 1 ||
1555 (real_lineno % opt_num_interval) == 0) {
1556 wprintw(view->win, "%.*d", view->digits, real_lineno);
1559 waddnstr(view->win, spaces,
1560 MIN(view->digits, STRING_SIZE(spaces)));
1562 waddstr(view->win, ": ");
1563 col_offset = view->digits + 2;
1566 while (text && col_offset + col < view->width) {
1567 int cols_max = view->width - col_offset - col;
1571 if (*text == '\t') {
1573 assert(sizeof(spaces) > TABSIZE);
1575 cols = opt_tab_size - (col % opt_tab_size);
1578 text = strchr(text, '\t');
1579 cols = line ? text - pos : strlen(pos);
1582 waddnstr(view->win, pos, MIN(cols, cols_max));
1587 int col = 0, pos = 0;
1589 for (; pos < textlen && col < view->width; pos++, col++)
1590 if (text[pos] == '\t')
1591 col += TABSIZE - (col % TABSIZE) - 1;
1593 waddnstr(view->win, text, pos);
1600 pager_read(struct view *view, struct line *prev, char *line)
1602 /* Compress empty lines in the help view. */
1603 if (view == VIEW(REQ_VIEW_HELP) &&
1604 !*line && prev && !*((char *) prev->data))
1607 view->line[view->lines].data = strdup(line);
1608 if (!view->line[view->lines].data)
1611 view->line[view->lines].type = get_line_type(line);
1618 pager_enter(struct view *view, struct line *line)
1622 if (line->type == LINE_COMMIT &&
1623 (view == VIEW(REQ_VIEW_LOG) ||
1624 view == VIEW(REQ_VIEW_PAGER))) {
1625 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1629 /* Always scroll the view even if it was split. That way
1630 * you can use Enter to scroll through the log view and
1631 * split open each commit diff. */
1632 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1634 /* FIXME: A minor workaround. Scrolling the view will call report("")
1635 * but if we are scrolling a non-current view this won't properly
1636 * update the view title. */
1638 update_view_title(view);
1643 static struct view_ops pager_ops = {
1656 char id[41]; /* SHA1 ID. */
1657 char title[75]; /* The first line of the commit message. */
1658 char author[75]; /* The author of the commit. */
1659 struct tm time; /* Date from the author ident. */
1660 struct ref **refs; /* Repository references; tags & branch heads. */
1664 main_draw(struct view *view, struct line *line, unsigned int lineno)
1666 char buf[DATE_COLS + 1];
1667 struct commit *commit = line->data;
1668 enum line_type type;
1674 if (!*commit->author)
1677 wmove(view->win, lineno, col);
1679 if (view->offset + lineno == view->lineno) {
1680 string_copy(view->ref, commit->id);
1681 string_copy(ref_commit, view->ref);
1683 wattrset(view->win, get_line_attr(type));
1684 wchgat(view->win, -1, 0, type, NULL);
1687 type = LINE_MAIN_COMMIT;
1688 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1691 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1692 waddnstr(view->win, buf, timelen);
1693 waddstr(view->win, " ");
1696 wmove(view->win, lineno, col);
1697 if (type != LINE_CURSOR)
1698 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1701 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1703 authorlen = strlen(commit->author);
1704 if (authorlen > AUTHOR_COLS - 2) {
1705 authorlen = AUTHOR_COLS - 2;
1711 waddnstr(view->win, commit->author, authorlen);
1712 if (type != LINE_CURSOR)
1713 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1714 waddch(view->win, '~');
1716 waddstr(view->win, commit->author);
1720 if (type != LINE_CURSOR)
1721 wattrset(view->win, A_NORMAL);
1723 mvwaddch(view->win, lineno, col, ACS_LTEE);
1724 wmove(view->win, lineno, col + 2);
1731 if (type == LINE_CURSOR)
1733 else if (commit->refs[i]->tag)
1734 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1736 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1737 waddstr(view->win, "[");
1738 waddstr(view->win, commit->refs[i]->name);
1739 waddstr(view->win, "]");
1740 if (type != LINE_CURSOR)
1741 wattrset(view->win, A_NORMAL);
1742 waddstr(view->win, " ");
1743 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1744 } while (commit->refs[i++]->next);
1747 if (type != LINE_CURSOR)
1748 wattrset(view->win, get_line_attr(type));
1751 int titlelen = strlen(commit->title);
1753 if (col + titlelen > view->width)
1754 titlelen = view->width - col;
1756 waddnstr(view->win, commit->title, titlelen);
1762 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1764 main_read(struct view *view, struct line *prev, char *line)
1766 enum line_type type = get_line_type(line);
1767 struct commit *commit;
1771 commit = calloc(1, sizeof(struct commit));
1775 line += STRING_SIZE("commit ");
1777 view->line[view->lines++].data = commit;
1778 string_copy(commit->id, line);
1779 commit->refs = get_refs(commit->id);
1784 char *ident = line + STRING_SIZE("author ");
1785 char *end = strchr(ident, '<');
1790 commit = prev->data;
1793 for (; end > ident && isspace(end[-1]); end--) ;
1797 string_copy(commit->author, ident);
1799 /* Parse epoch and timezone */
1801 char *secs = strchr(end + 1, '>');
1805 if (!secs || secs[1] != ' ')
1809 time = (time_t) atol(secs);
1810 zone = strchr(secs, ' ');
1811 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1815 tz = ('0' - zone[1]) * 60 * 60 * 10;
1816 tz += ('0' - zone[2]) * 60 * 60;
1817 tz += ('0' - zone[3]) * 60;
1818 tz += ('0' - zone[4]) * 60;
1825 gmtime_r(&time, &commit->time);
1833 commit = prev->data;
1835 /* Fill in the commit title if it has not already been set. */
1836 if (commit->title[0])
1839 /* Require titles to start with a non-space character at the
1840 * offset used by git log. */
1841 /* FIXME: More gracefull handling of titles; append "..." to
1842 * shortened titles, etc. */
1843 if (strncmp(line, " ", 4) ||
1847 string_copy(commit->title, line + 4);
1854 main_enter(struct view *view, struct line *line)
1856 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1858 open_view(view, REQ_VIEW_DIFF, flags);
1862 static struct view_ops main_ops = {
1873 * Below the default key bindings are shown.
1881 static struct keymap keymap[] = {
1886 * Switch to main view.
1888 * Switch to diff view.
1890 * Switch to log view.
1892 * Switch to pager view.
1896 { 'm', REQ_VIEW_MAIN },
1897 { 'd', REQ_VIEW_DIFF },
1898 { 'l', REQ_VIEW_LOG },
1899 { 'p', REQ_VIEW_PAGER },
1900 { 'h', REQ_VIEW_HELP },
1906 * Close view, if multiple views are open it will jump back to the
1907 * previous view in the view stack. If it is the last open view it
1908 * will quit. Use 'Q' to quit all views at once.
1910 * This key is "context sensitive" depending on what view you are
1911 * currently in. When in log view on a commit line or in the main
1912 * view, split the view and show the commit diff. In the diff view
1913 * pressing Enter will simply scroll the view one line down.
1915 * Switch to next view.
1917 * This key is "context sensitive" and will move the cursor one
1918 * line up. However, uf you opened a diff view from the main view
1919 * (split- or full-screen) it will change the cursor to point to
1920 * the previous commit in the main view and update the diff view
1923 * Similar to 'Up' but will move down.
1925 { 'q', REQ_VIEW_CLOSE },
1926 { KEY_TAB, REQ_VIEW_NEXT },
1927 { KEY_RETURN, REQ_ENTER },
1928 { KEY_UP, REQ_PREVIOUS },
1929 { KEY_DOWN, REQ_NEXT },
1935 * Move cursor one line up.
1937 * Move cursor one line down.
1941 * Move cursor one page up.
1944 * Move cursor one page down.
1946 * Jump to first line.
1948 * Jump to last line.
1950 { 'k', REQ_MOVE_UP },
1951 { 'j', REQ_MOVE_DOWN },
1952 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1953 { KEY_END, REQ_MOVE_LAST_LINE },
1954 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1955 { ' ', REQ_MOVE_PAGE_DOWN },
1956 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1957 { 'b', REQ_MOVE_PAGE_UP },
1958 { '-', REQ_MOVE_PAGE_UP },
1964 * Scroll view one line up.
1966 * Scroll view one line down.
1968 * Scroll view one page up.
1970 * Scroll view one page down.
1972 { KEY_IC, REQ_SCROLL_LINE_UP },
1973 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1974 { 'w', REQ_SCROLL_PAGE_UP },
1975 { 's', REQ_SCROLL_PAGE_DOWN },
1985 * Stop all background loading. This can be useful if you use
1986 * tig(1) in a repository with a long history without limiting
1991 * Toggle line numbers on/off.
1993 * Open prompt. This allows you to specify what git command
1999 { 'z', REQ_STOP_LOADING },
2000 { 'v', REQ_SHOW_VERSION },
2001 { 'r', REQ_SCREEN_REDRAW },
2002 { 'n', REQ_TOGGLE_LINE_NUMBERS },
2003 { ':', REQ_PROMPT },
2005 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2006 { ERR, REQ_SCREEN_UPDATE },
2008 /* Use the ncurses SIGWINCH handler. */
2009 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2013 get_request(int key)
2017 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2018 if (keymap[i].alias == key)
2019 return keymap[i].request;
2021 return (enum request) key;
2026 * Unicode / UTF-8 handling
2028 * NOTE: Much of the following code for dealing with unicode is derived from
2029 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2030 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2033 /* I've (over)annotated a lot of code snippets because I am not entirely
2034 * confident that the approach taken by this small UTF-8 interface is correct.
2038 unicode_width(unsigned long c)
2041 (c <= 0x115f /* Hangul Jamo */
2044 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2046 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2047 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2048 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2049 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2050 || (c >= 0xffe0 && c <= 0xffe6)
2051 || (c >= 0x20000 && c <= 0x2fffd)
2052 || (c >= 0x30000 && c <= 0x3fffd)))
2058 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2059 * Illegal bytes are set one. */
2060 static const unsigned char utf8_bytes[256] = {
2061 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,
2062 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,
2063 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,
2064 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,
2065 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,
2066 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,
2067 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,
2068 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,
2071 /* Decode UTF-8 multi-byte representation into a unicode character. */
2072 static inline unsigned long
2073 utf8_to_unicode(const char *string, size_t length)
2075 unsigned long unicode;
2079 unicode = string[0];
2082 unicode = (string[0] & 0x1f) << 6;
2083 unicode += (string[1] & 0x3f);
2086 unicode = (string[0] & 0x0f) << 12;
2087 unicode += ((string[1] & 0x3f) << 6);
2088 unicode += (string[2] & 0x3f);
2091 unicode = (string[0] & 0x0f) << 18;
2092 unicode += ((string[1] & 0x3f) << 12);
2093 unicode += ((string[2] & 0x3f) << 6);
2094 unicode += (string[3] & 0x3f);
2097 unicode = (string[0] & 0x0f) << 24;
2098 unicode += ((string[1] & 0x3f) << 18);
2099 unicode += ((string[2] & 0x3f) << 12);
2100 unicode += ((string[3] & 0x3f) << 6);
2101 unicode += (string[4] & 0x3f);
2104 unicode = (string[0] & 0x01) << 30;
2105 unicode += ((string[1] & 0x3f) << 24);
2106 unicode += ((string[2] & 0x3f) << 18);
2107 unicode += ((string[3] & 0x3f) << 12);
2108 unicode += ((string[4] & 0x3f) << 6);
2109 unicode += (string[5] & 0x3f);
2112 die("Invalid unicode length");
2115 /* Invalid characters could return the special 0xfffd value but NUL
2116 * should be just as good. */
2117 return unicode > 0xffff ? 0 : unicode;
2120 /* Calculates how much of string can be shown within the given maximum width
2121 * and sets trimmed parameter to non-zero value if all of string could not be
2124 * Additionally, adds to coloffset how many many columns to move to align with
2125 * the expected position. Takes into account how multi-byte and double-width
2126 * characters will effect the cursor position.
2128 * Returns the number of bytes to output from string to satisfy max_width. */
2130 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2132 const char *start = string;
2133 const char *end = strchr(string, '\0');
2139 while (string < end) {
2140 int c = *(unsigned char *) string;
2141 unsigned char bytes = utf8_bytes[c];
2143 unsigned long unicode;
2145 if (string + bytes > end)
2148 /* Change representation to figure out whether
2149 * it is a single- or double-width character. */
2151 unicode = utf8_to_unicode(string, bytes);
2152 /* FIXME: Graceful handling of invalid unicode character. */
2156 ucwidth = unicode_width(unicode);
2158 if (width > max_width) {
2163 /* The column offset collects the differences between the
2164 * number of bytes encoding a character and the number of
2165 * columns will be used for rendering said character.
2167 * So if some character A is encoded in 2 bytes, but will be
2168 * represented on the screen using only 1 byte this will and up
2169 * adding 1 to the multi-byte column offset.
2171 * Assumes that no double-width character can be encoding in
2172 * less than two bytes. */
2173 if (bytes > ucwidth)
2174 mbwidth += bytes - ucwidth;
2179 *coloffset += mbwidth;
2181 return string - start;
2189 /* Whether or not the curses interface has been initialized. */
2190 static bool cursed = FALSE;
2192 /* The status window is used for polling keystrokes. */
2193 static WINDOW *status_win;
2195 /* Update status and title window. */
2197 report(const char *msg, ...)
2199 static bool empty = TRUE;
2200 struct view *view = display[current_view];
2202 if (!empty || *msg) {
2205 va_start(args, msg);
2208 wmove(status_win, 0, 0);
2210 vwprintw(status_win, msg, args);
2215 wrefresh(status_win);
2220 update_view_title(view);
2221 update_display_cursor();
2224 /* Controls when nodelay should be in effect when polling user input. */
2226 set_nonblocking_input(bool loading)
2228 static unsigned int loading_views;
2230 if ((loading == FALSE && loading_views-- == 1) ||
2231 (loading == TRUE && loading_views++ == 0))
2232 nodelay(status_win, loading);
2240 /* Initialize the curses library */
2241 if (isatty(STDIN_FILENO)) {
2242 cursed = !!initscr();
2244 /* Leave stdin and stdout alone when acting as a pager. */
2245 FILE *io = fopen("/dev/tty", "r+");
2247 cursed = !!newterm(NULL, io, io);
2251 die("Failed to initialize curses");
2253 nonl(); /* Tell curses not to do NL->CR/NL on output */
2254 cbreak(); /* Take input chars one at a time, no wait for \n */
2255 noecho(); /* Don't echo input */
2256 leaveok(stdscr, TRUE);
2261 getmaxyx(stdscr, y, x);
2262 status_win = newwin(1, 0, y - 1, 0);
2264 die("Failed to create status window");
2266 /* Enable keyboard mapping */
2267 keypad(status_win, TRUE);
2268 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2273 * Repository references
2276 static struct ref *refs;
2277 static size_t refs_size;
2279 /* Id <-> ref store */
2280 static struct ref ***id_refs;
2281 static size_t id_refs_size;
2283 static struct ref **
2286 struct ref ***tmp_id_refs;
2287 struct ref **ref_list = NULL;
2288 size_t ref_list_size = 0;
2291 for (i = 0; i < id_refs_size; i++)
2292 if (!strcmp(id, id_refs[i][0]->id))
2295 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2299 id_refs = tmp_id_refs;
2301 for (i = 0; i < refs_size; i++) {
2304 if (strcmp(id, refs[i].id))
2307 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2315 if (ref_list_size > 0)
2316 ref_list[ref_list_size - 1]->next = 1;
2317 ref_list[ref_list_size] = &refs[i];
2319 /* XXX: The properties of the commit chains ensures that we can
2320 * safely modify the shared ref. The repo references will
2321 * always be similar for the same id. */
2322 ref_list[ref_list_size]->next = 0;
2327 id_refs[id_refs_size++] = ref_list;
2333 read_ref(char *id, int idlen, char *name, int namelen)
2337 bool tag_commit = FALSE;
2339 /* Commits referenced by tags has "^{}" appended. */
2340 if (name[namelen - 1] == '}') {
2341 while (namelen > 0 && name[namelen] != '^')
2348 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2351 name += STRING_SIZE("refs/tags/");
2354 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2355 name += STRING_SIZE("refs/heads/");
2357 } else if (!strcmp(name, "HEAD")) {
2361 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2365 ref = &refs[refs_size++];
2366 ref->name = strdup(name);
2371 string_copy(ref->id, id);
2379 const char *cmd_env = getenv("TIG_LS_REMOTE");
2380 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2382 return read_properties(cmd, '\t', read_ref);
2386 read_config_option(char *name, int namelen, char *value, int valuelen)
2388 if (!strcmp(name, "i18n.commitencoding")) {
2389 string_copy(opt_encoding, value);
2398 return read_properties("git repo-config --list", '=',
2399 read_config_option);
2403 read_properties(const char *cmd, int separator,
2404 int (*read_property)(char *, int, char *, int))
2406 FILE *pipe = popen(cmd, "r");
2407 char buffer[BUFSIZ];
2414 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2415 char *value = strchr(name, separator);
2420 namelen = value - name;
2422 valuelen = strlen(value);
2424 value[valuelen - 1] = 0;
2427 namelen = strlen(name);
2433 state = read_property(name, namelen, value, valuelen);
2436 if (state != ERR && ferror(pipe))
2450 #define __NORETURN __attribute__((__noreturn__))
2455 static void __NORETURN
2458 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2464 static void __NORETURN
2465 die(const char *err, ...)
2471 va_start(args, err);
2472 fputs("tig: ", stderr);
2473 vfprintf(stderr, err, args);
2474 fputs("\n", stderr);
2481 main(int argc, char *argv[])
2484 enum request request;
2487 signal(SIGINT, quit);
2489 /* Load the repo config file first so options can be overwritten from
2490 * the command line. */
2491 if (load_config() == ERR)
2492 die("Failed to load repo config.");
2494 if (!parse_options(argc, argv))
2497 if (load_refs() == ERR)
2498 die("Failed to load refs.");
2500 /* Require a git repository unless when running in pager mode. */
2501 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2502 die("Not a git repository");
2504 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2505 view->cmd_env = getenv(view->cmd_env);
2507 request = opt_request;
2511 while (view_driver(display[current_view], request)) {
2515 foreach_view (view, i)
2518 /* Refresh, accept single keystroke of input */
2519 key = wgetch(status_win);
2520 request = get_request(key);
2522 /* Some low-level request handling. This keeps access to
2523 * status_win restricted. */
2527 /* Temporarily switch to line-oriented and echoed
2532 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2533 memcpy(opt_cmd, "git ", 4);
2534 opt_request = REQ_VIEW_PAGER;
2543 case REQ_SCREEN_RESIZE:
2547 getmaxyx(stdscr, height, width);
2549 /* Resize the status view and let the view driver take
2550 * care of resizing the displayed views. */
2551 wresize(status_win, 1, width);
2552 mvwin(status_win, height - 1, 0);
2553 wrefresh(status_win);
2568 * Revision specification
2569 * ----------------------
2570 * This section describes various ways to specify what revisions to display
2571 * or otherwise limit the view to. tig(1) does not itself parse the described
2572 * revision options so refer to the relevant git man pages for futher
2573 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2576 * You can tune the interaction with git by making use of the options
2577 * explained in this section. For example, by configuring the environment
2578 * variables described in the <<view-commands, "View commands">> section.
2580 * Limit by path name
2581 * ~~~~~~~~~~~~~~~~~~
2582 * If you are interested only in those revisions that made changes to a
2583 * specific file (or even several files) list the files like this:
2585 * $ tig log Makefile README
2587 * To avoid ambiguity with repository references such as tag name, be sure
2588 * to separate file names from other git options using "\--". So if you
2589 * have a file named 'master' it will clash with the reference named
2590 * 'master', and thus you will have to use:
2592 * $ tig log -- master
2594 * NOTE: For the main view, avoiding ambiguity will in some cases require
2595 * you to specify two "\--" options. The first will make tig(1) stop
2596 * option processing and the latter will be passed to git log.
2598 * Limit by date or number
2599 * ~~~~~~~~~~~~~~~~~~~~~~~
2600 * To speed up interaction with git, you can limit the amount of commits
2601 * to show both for the log and main view. Either limit by date using
2602 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2604 * If you are only interested in changed that happened between two dates
2607 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2609 * NOTE: If you want to avoid having to quote dates containing spaces you
2610 * can use "." instead, e.g. `--after=May.5th`.
2612 * Limiting by commit ranges
2613 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2614 * Alternatively, commits can be limited to a specific range, such as
2615 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2617 * $ tig log tag-1.0..tag-2.0
2619 * This way of commit limiting makes it trivial to only browse the commits
2620 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2621 * upstream remote branch, using:
2623 * $ tig log origin..HEAD
2625 * will list what will be pushed to the remote branch. Optionally, the ending
2626 * 'HEAD' can be left out since it is implied.
2628 * Limiting by reachability
2629 * ~~~~~~~~~~~~~~~~~~~~~~~~
2630 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2631 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2632 * Where reachability refers to what commits are ancestors (or part of the
2633 * history) of the branch or tagged revision in question.
2635 * If you prefer to specify which commit to preview in this way use the
2638 * $ tig log tag-2.0 ^tag-1.0
2640 * You can think of '^' as a negation operator. Using this alternate syntax,
2641 * it is possible to further prune commits by specifying multiple branch
2644 * Combining revisions specification
2645 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2646 * Revisions options can to some degree be combined, which makes it possible
2647 * to say "show at most 20 commits from within the last month that changed
2648 * files under the Documentation/ directory."
2650 * $ tig -- --since=1.month -n20 -- Documentation/
2652 * Examining all repository references
2653 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2654 * In some cases, it can be useful to query changes across all references
2655 * in a repository. An example is to ask "did any line of development in
2656 * this repository change a particular file within the last week". This
2657 * can be accomplished using:
2659 * $ tig -- --all --since=1.week -- Makefile
2663 * Known bugs and problems:
2665 * - In it's current state tig is pretty much UTF-8 only.
2667 * - If the screen width is very small the main view can draw
2668 * outside the current view causing bad wrapping. Same goes
2669 * for title and status windows.
2671 * - The cursor can wrap-around on the last line and cause the
2676 * Features that should be explored.
2684 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2686 * This program is free software; you can redistribute it and/or modify
2687 * it under the terms of the GNU General Public License as published by
2688 * the Free Software Foundation; either version 2 of the License, or
2689 * (at your option) any later version.
2693 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2694 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2696 * Other git repository browsers: