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);
912 offset += view->height + 1;
922 foreach_view (view, i) {
924 update_view_title(view);
933 /* Scrolling backend */
935 do_scroll_view(struct view *view, int lines, bool redraw)
937 /* The rendering expects the new offset. */
938 view->offset += lines;
940 assert(0 <= view->offset && view->offset < view->lines);
943 /* Redraw the whole screen if scrolling is pointless. */
944 if (view->height < ABS(lines)) {
948 int line = lines > 0 ? view->height - lines : 0;
949 int end = line + ABS(lines);
951 wscrl(view->win, lines);
953 for (; line < end; line++) {
954 if (!draw_view_line(view, line))
959 /* Move current line into the view. */
960 if (view->lineno < view->offset) {
961 view->lineno = view->offset;
962 draw_view_line(view, 0);
964 } else if (view->lineno >= view->offset + view->height) {
965 if (view->lineno == view->offset + view->height) {
966 /* Clear the hidden line so it doesn't show if the view
968 wmove(view->win, view->height, 0);
969 wclrtoeol(view->win);
971 view->lineno = view->offset + view->height - 1;
972 draw_view_line(view, view->lineno - view->offset);
975 assert(view->offset <= view->lineno && view->lineno < view->lines);
980 redrawwin(view->win);
985 /* Scroll frontend */
987 scroll_view(struct view *view, enum request request)
992 case REQ_SCROLL_PAGE_DOWN:
993 lines = view->height;
994 case REQ_SCROLL_LINE_DOWN:
995 if (view->offset + lines > view->lines)
996 lines = view->lines - view->offset;
998 if (lines == 0 || view->offset + view->height >= view->lines) {
999 report("Cannot scroll beyond the last line");
1004 case REQ_SCROLL_PAGE_UP:
1005 lines = view->height;
1006 case REQ_SCROLL_LINE_UP:
1007 if (lines > view->offset)
1008 lines = view->offset;
1011 report("Cannot scroll beyond the first line");
1019 die("request %d not handled in switch", request);
1022 do_scroll_view(view, lines, TRUE);
1027 move_view(struct view *view, enum request request, bool redraw)
1032 case REQ_MOVE_FIRST_LINE:
1033 steps = -view->lineno;
1036 case REQ_MOVE_LAST_LINE:
1037 steps = view->lines - view->lineno - 1;
1040 case REQ_MOVE_PAGE_UP:
1041 steps = view->height > view->lineno
1042 ? -view->lineno : -view->height;
1045 case REQ_MOVE_PAGE_DOWN:
1046 steps = view->lineno + view->height >= view->lines
1047 ? view->lines - view->lineno - 1 : view->height;
1059 die("request %d not handled in switch", request);
1062 if (steps <= 0 && view->lineno == 0) {
1063 report("Cannot move beyond the first line");
1066 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1067 report("Cannot move beyond the last line");
1071 /* Move the current line */
1072 view->lineno += steps;
1073 assert(0 <= view->lineno && view->lineno < view->lines);
1075 /* Repaint the old "current" line if we be scrolling */
1076 if (ABS(steps) < view->height) {
1077 int prev_lineno = view->lineno - steps - view->offset;
1079 wmove(view->win, prev_lineno, 0);
1080 wclrtoeol(view->win);
1081 draw_view_line(view, prev_lineno);
1084 /* Check whether the view needs to be scrolled */
1085 if (view->lineno < view->offset ||
1086 view->lineno >= view->offset + view->height) {
1087 if (steps < 0 && -steps > view->offset) {
1088 steps = -view->offset;
1090 } else if (steps > 0) {
1091 if (view->lineno == view->lines - 1 &&
1092 view->lines > view->height) {
1093 steps = view->lines - view->offset - 1;
1094 if (steps >= view->height)
1095 steps -= view->height - 1;
1099 do_scroll_view(view, steps, redraw);
1103 /* Draw the current line */
1104 draw_view_line(view, view->lineno - view->offset);
1109 redrawwin(view->win);
1110 wrefresh(view->win);
1116 * Incremental updating
1120 end_update(struct view *view)
1124 set_nonblocking_input(FALSE);
1125 if (view->pipe == stdin)
1133 begin_update(struct view *view)
1135 const char *id = view->id;
1141 string_copy(view->cmd, opt_cmd);
1143 /* When running random commands, the view ref could have become
1144 * invalid so clear it. */
1147 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1149 if (snprintf(view->cmd, sizeof(view->cmd), format,
1150 id, id, id, id, id) >= sizeof(view->cmd))
1154 /* Special case for the pager view. */
1156 view->pipe = opt_pipe;
1159 view->pipe = popen(view->cmd, "r");
1165 set_nonblocking_input(TRUE);
1170 string_copy(view->vid, id);
1175 for (i = 0; i < view->lines; i++)
1176 if (view->line[i].data)
1177 free(view->line[i].data);
1183 view->start_time = time(NULL);
1189 update_view(struct view *view)
1191 char buffer[BUFSIZ];
1194 /* The number of lines to read. If too low it will cause too much
1195 * redrawing (and possible flickering), if too high responsiveness
1197 unsigned long lines = view->height;
1198 int redraw_from = -1;
1203 /* Only redraw if lines are visible. */
1204 if (view->offset + view->height >= view->lines)
1205 redraw_from = view->lines - view->offset;
1207 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1213 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1214 int linelen = strlen(line);
1216 struct line *prev = view->lines
1217 ? &view->line[view->lines - 1]
1221 line[linelen - 1] = 0;
1223 if (!view->ops->read(view, prev, line))
1233 lines = view->lines;
1234 for (digits = 0; lines; digits++)
1237 /* Keep the displayed view in sync with line number scaling. */
1238 if (digits != view->digits) {
1239 view->digits = digits;
1244 if (redraw_from >= 0) {
1245 /* If this is an incremental update, redraw the previous line
1246 * since for commits some members could have changed when
1247 * loading the main view. */
1248 if (redraw_from > 0)
1251 /* Incrementally draw avoids flickering. */
1252 redraw_view_from(view, redraw_from);
1255 /* Update the title _after_ the redraw so that if the redraw picks up a
1256 * commit reference in view->ref it'll be available here. */
1257 update_view_title(view);
1259 if (ferror(view->pipe)) {
1260 report("Failed to read: %s", strerror(errno));
1263 } else if (feof(view->pipe)) {
1264 if (view == VIEW(REQ_VIEW_HELP)) {
1265 const char *msg = TIG_HELP;
1267 if (view->lines == 0) {
1268 /* Slightly ugly, but abusing view->ref keeps
1269 * the error message. */
1270 string_copy(view->ref, "No help available");
1271 msg = "The tig(1) manpage is not installed";
1285 report("Allocation failure");
1293 OPEN_DEFAULT = 0, /* Use default view switching. */
1294 OPEN_SPLIT = 1, /* Split current view. */
1295 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1296 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1300 open_view(struct view *prev, enum request request, enum open_flags flags)
1302 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1303 bool split = !!(flags & OPEN_SPLIT);
1304 bool reload = !!(flags & OPEN_RELOAD);
1305 struct view *view = VIEW(request);
1306 int nviews = displayed_views();
1307 struct view *base_view = display[0];
1309 if (view == prev && nviews == 1 && !reload) {
1310 report("Already in %s view", view->name);
1314 if ((reload || strcmp(view->vid, view->id)) &&
1315 !begin_update(view)) {
1316 report("Failed to load %s view", view->name);
1321 display[current_view + 1] = view;
1325 /* Maximize the current view. */
1326 memset(display, 0, sizeof(display));
1328 display[current_view] = view;
1331 /* Resize the view when switching between split- and full-screen,
1332 * or when switching between two different full-screen views. */
1333 if (nviews != displayed_views() ||
1334 (nviews == 1 && base_view != display[0]))
1337 if (split && prev->lineno - prev->offset >= prev->height) {
1338 /* Take the title line into account. */
1339 int lines = prev->lineno - prev->offset - prev->height + 1;
1341 /* Scroll the view that was split if the current line is
1342 * outside the new limited view. */
1343 do_scroll_view(prev, lines, TRUE);
1346 if (prev && view != prev) {
1347 if (!backgrounded) {
1348 /* "Blur" the previous view. */
1349 update_view_title(prev);
1352 view->parent = prev;
1355 if (view->pipe && view->lines == 0) {
1356 /* Clear the old view and let the incremental updating refill
1362 if (view == VIEW(REQ_VIEW_HELP))
1363 report("%s", TIG_HELP);
1368 /* If the view is backgrounded the above calls to report()
1369 * won't redraw the view title. */
1371 update_view_title(view);
1376 * User request switch noodle
1380 view_driver(struct view *view, enum request request)
1387 case REQ_MOVE_PAGE_UP:
1388 case REQ_MOVE_PAGE_DOWN:
1389 case REQ_MOVE_FIRST_LINE:
1390 case REQ_MOVE_LAST_LINE:
1391 move_view(view, request, TRUE);
1394 case REQ_SCROLL_LINE_DOWN:
1395 case REQ_SCROLL_LINE_UP:
1396 case REQ_SCROLL_PAGE_DOWN:
1397 case REQ_SCROLL_PAGE_UP:
1398 scroll_view(view, request);
1405 case REQ_VIEW_PAGER:
1406 open_view(view, request, OPEN_DEFAULT);
1411 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1413 if (view == VIEW(REQ_VIEW_DIFF) &&
1414 view->parent == VIEW(REQ_VIEW_MAIN)) {
1415 bool redraw = display[1] == view;
1417 view = view->parent;
1418 move_view(view, request, redraw);
1420 update_view_title(view);
1422 move_view(view, request, TRUE);
1429 report("Nothing to enter");
1432 return view->ops->enter(view, &view->line[view->lineno]);
1436 int nviews = displayed_views();
1437 int next_view = (current_view + 1) % nviews;
1439 if (next_view == current_view) {
1440 report("Only one view is displayed");
1444 current_view = next_view;
1445 /* Blur out the title of the previous view. */
1446 update_view_title(view);
1450 case REQ_TOGGLE_LINE_NUMBERS:
1451 opt_line_number = !opt_line_number;
1456 /* Always reload^Wrerun commands from the prompt. */
1457 open_view(view, opt_request, OPEN_RELOAD);
1460 case REQ_STOP_LOADING:
1461 foreach_view (view, i) {
1463 report("Stopped loaded the %s view", view->name),
1468 case REQ_SHOW_VERSION:
1469 report("%s (built %s)", VERSION, __DATE__);
1472 case REQ_SCREEN_RESIZE:
1475 case REQ_SCREEN_REDRAW:
1479 case REQ_SCREEN_UPDATE:
1483 case REQ_VIEW_CLOSE:
1485 memset(display, 0, sizeof(display));
1487 display[current_view] = view->parent;
1488 view->parent = NULL;
1498 /* An unknown key will show most commonly used commands. */
1499 report("Unknown key, press 'h' for help");
1512 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1514 char *text = line->data;
1515 enum line_type type = line->type;
1516 int textlen = strlen(text);
1519 wmove(view->win, lineno, 0);
1521 if (view->offset + lineno == view->lineno) {
1522 if (type == LINE_COMMIT) {
1523 string_copy(view->ref, text + 7);
1524 string_copy(ref_commit, view->ref);
1528 wchgat(view->win, -1, 0, type, NULL);
1531 attr = get_line_attr(type);
1532 wattrset(view->win, attr);
1534 if (opt_line_number || opt_tab_size < TABSIZE) {
1535 static char spaces[] = " ";
1536 int col_offset = 0, col = 0;
1538 if (opt_line_number) {
1539 unsigned long real_lineno = view->offset + lineno + 1;
1541 if (real_lineno == 1 ||
1542 (real_lineno % opt_num_interval) == 0) {
1543 wprintw(view->win, "%.*d", view->digits, real_lineno);
1546 waddnstr(view->win, spaces,
1547 MIN(view->digits, STRING_SIZE(spaces)));
1549 waddstr(view->win, ": ");
1550 col_offset = view->digits + 2;
1553 while (text && col_offset + col < view->width) {
1554 int cols_max = view->width - col_offset - col;
1558 if (*text == '\t') {
1560 assert(sizeof(spaces) > TABSIZE);
1562 cols = opt_tab_size - (col % opt_tab_size);
1565 text = strchr(text, '\t');
1566 cols = line ? text - pos : strlen(pos);
1569 waddnstr(view->win, pos, MIN(cols, cols_max));
1574 int col = 0, pos = 0;
1576 for (; pos < textlen && col < view->width; pos++, col++)
1577 if (text[pos] == '\t')
1578 col += TABSIZE - (col % TABSIZE) - 1;
1580 waddnstr(view->win, text, pos);
1587 pager_read(struct view *view, struct line *prev, char *line)
1589 /* Compress empty lines in the help view. */
1590 if (view == VIEW(REQ_VIEW_HELP) &&
1591 !*line && prev && !*((char *) prev->data))
1594 view->line[view->lines].data = strdup(line);
1595 if (!view->line[view->lines].data)
1598 view->line[view->lines].type = get_line_type(line);
1605 pager_enter(struct view *view, struct line *line)
1609 if (line->type == LINE_COMMIT &&
1610 (view == VIEW(REQ_VIEW_LOG) ||
1611 view == VIEW(REQ_VIEW_PAGER))) {
1612 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1616 /* Always scroll the view even if it was split. That way
1617 * you can use Enter to scroll through the log view and
1618 * split open each commit diff. */
1619 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1621 /* FIXME: A minor workaround. Scrolling the view will call report("")
1622 * but if we are scrolling a non-current view this won't properly
1623 * update the view title. */
1625 update_view_title(view);
1630 static struct view_ops pager_ops = {
1643 char id[41]; /* SHA1 ID. */
1644 char title[75]; /* The first line of the commit message. */
1645 char author[75]; /* The author of the commit. */
1646 struct tm time; /* Date from the author ident. */
1647 struct ref **refs; /* Repository references; tags & branch heads. */
1651 main_draw(struct view *view, struct line *line, unsigned int lineno)
1653 char buf[DATE_COLS + 1];
1654 struct commit *commit = line->data;
1655 enum line_type type;
1661 if (!*commit->author)
1664 wmove(view->win, lineno, col);
1666 if (view->offset + lineno == view->lineno) {
1667 string_copy(view->ref, commit->id);
1668 string_copy(ref_commit, view->ref);
1670 wattrset(view->win, get_line_attr(type));
1671 wchgat(view->win, -1, 0, type, NULL);
1674 type = LINE_MAIN_COMMIT;
1675 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1678 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1679 waddnstr(view->win, buf, timelen);
1680 waddstr(view->win, " ");
1683 wmove(view->win, lineno, col);
1684 if (type != LINE_CURSOR)
1685 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1688 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1690 authorlen = strlen(commit->author);
1691 if (authorlen > AUTHOR_COLS - 2) {
1692 authorlen = AUTHOR_COLS - 2;
1698 waddnstr(view->win, commit->author, authorlen);
1699 if (type != LINE_CURSOR)
1700 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1701 waddch(view->win, '~');
1703 waddstr(view->win, commit->author);
1707 if (type != LINE_CURSOR)
1708 wattrset(view->win, A_NORMAL);
1710 mvwaddch(view->win, lineno, col, ACS_LTEE);
1711 wmove(view->win, lineno, col + 2);
1718 if (type == LINE_CURSOR)
1720 else if (commit->refs[i]->tag)
1721 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1723 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1724 waddstr(view->win, "[");
1725 waddstr(view->win, commit->refs[i]->name);
1726 waddstr(view->win, "]");
1727 if (type != LINE_CURSOR)
1728 wattrset(view->win, A_NORMAL);
1729 waddstr(view->win, " ");
1730 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1731 } while (commit->refs[i++]->next);
1734 if (type != LINE_CURSOR)
1735 wattrset(view->win, get_line_attr(type));
1738 int titlelen = strlen(commit->title);
1740 if (col + titlelen > view->width)
1741 titlelen = view->width - col;
1743 waddnstr(view->win, commit->title, titlelen);
1749 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1751 main_read(struct view *view, struct line *prev, char *line)
1753 enum line_type type = get_line_type(line);
1754 struct commit *commit;
1758 commit = calloc(1, sizeof(struct commit));
1762 line += STRING_SIZE("commit ");
1764 view->line[view->lines++].data = commit;
1765 string_copy(commit->id, line);
1766 commit->refs = get_refs(commit->id);
1771 char *ident = line + STRING_SIZE("author ");
1772 char *end = strchr(ident, '<');
1777 commit = prev->data;
1780 for (; end > ident && isspace(end[-1]); end--) ;
1784 string_copy(commit->author, ident);
1786 /* Parse epoch and timezone */
1788 char *secs = strchr(end + 1, '>');
1792 if (!secs || secs[1] != ' ')
1796 time = (time_t) atol(secs);
1797 zone = strchr(secs, ' ');
1798 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1802 tz = ('0' - zone[1]) * 60 * 60 * 10;
1803 tz += ('0' - zone[2]) * 60 * 60;
1804 tz += ('0' - zone[3]) * 60;
1805 tz += ('0' - zone[4]) * 60;
1812 gmtime_r(&time, &commit->time);
1820 commit = prev->data;
1822 /* Fill in the commit title if it has not already been set. */
1823 if (commit->title[0])
1826 /* Require titles to start with a non-space character at the
1827 * offset used by git log. */
1828 /* FIXME: More gracefull handling of titles; append "..." to
1829 * shortened titles, etc. */
1830 if (strncmp(line, " ", 4) ||
1834 string_copy(commit->title, line + 4);
1841 main_enter(struct view *view, struct line *line)
1843 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1845 open_view(view, REQ_VIEW_DIFF, flags);
1849 static struct view_ops main_ops = {
1860 * Below the default key bindings are shown.
1868 static struct keymap keymap[] = {
1873 * Switch to main view.
1875 * Switch to diff view.
1877 * Switch to log view.
1879 * Switch to pager view.
1883 { 'm', REQ_VIEW_MAIN },
1884 { 'd', REQ_VIEW_DIFF },
1885 { 'l', REQ_VIEW_LOG },
1886 { 'p', REQ_VIEW_PAGER },
1887 { 'h', REQ_VIEW_HELP },
1893 * Close view, if multiple views are open it will jump back to the
1894 * previous view in the view stack. If it is the last open view it
1895 * will quit. Use 'Q' to quit all views at once.
1897 * This key is "context sensitive" depending on what view you are
1898 * currently in. When in log view on a commit line or in the main
1899 * view, split the view and show the commit diff. In the diff view
1900 * pressing Enter will simply scroll the view one line down.
1902 * Switch to next view.
1904 * This key is "context sensitive" and will move the cursor one
1905 * line up. However, uf you opened a diff view from the main view
1906 * (split- or full-screen) it will change the cursor to point to
1907 * the previous commit in the main view and update the diff view
1910 * Similar to 'Up' but will move down.
1912 { 'q', REQ_VIEW_CLOSE },
1913 { KEY_TAB, REQ_VIEW_NEXT },
1914 { KEY_RETURN, REQ_ENTER },
1915 { KEY_UP, REQ_PREVIOUS },
1916 { KEY_DOWN, REQ_NEXT },
1922 * Move cursor one line up.
1924 * Move cursor one line down.
1928 * Move cursor one page up.
1931 * Move cursor one page down.
1933 * Jump to first line.
1935 * Jump to last line.
1937 { 'k', REQ_MOVE_UP },
1938 { 'j', REQ_MOVE_DOWN },
1939 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1940 { KEY_END, REQ_MOVE_LAST_LINE },
1941 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1942 { ' ', REQ_MOVE_PAGE_DOWN },
1943 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1944 { 'b', REQ_MOVE_PAGE_UP },
1945 { '-', REQ_MOVE_PAGE_UP },
1951 * Scroll view one line up.
1953 * Scroll view one line down.
1955 * Scroll view one page up.
1957 * Scroll view one page down.
1959 { KEY_IC, REQ_SCROLL_LINE_UP },
1960 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1961 { 'w', REQ_SCROLL_PAGE_UP },
1962 { 's', REQ_SCROLL_PAGE_DOWN },
1972 * Stop all background loading. This can be useful if you use
1973 * tig(1) in a repository with a long history without limiting
1978 * Toggle line numbers on/off.
1980 * Open prompt. This allows you to specify what git command
1986 { 'z', REQ_STOP_LOADING },
1987 { 'v', REQ_SHOW_VERSION },
1988 { 'r', REQ_SCREEN_REDRAW },
1989 { 'n', REQ_TOGGLE_LINE_NUMBERS },
1990 { ':', REQ_PROMPT },
1992 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1993 { ERR, REQ_SCREEN_UPDATE },
1995 /* Use the ncurses SIGWINCH handler. */
1996 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2000 get_request(int key)
2004 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2005 if (keymap[i].alias == key)
2006 return keymap[i].request;
2008 return (enum request) key;
2013 * Unicode / UTF-8 handling
2015 * NOTE: Much of the following code for dealing with unicode is derived from
2016 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2017 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2020 /* I've (over)annotated a lot of code snippets because I am not entirely
2021 * confident that the approach taken by this small UTF-8 interface is correct.
2025 unicode_width(unsigned long c)
2028 (c <= 0x115f /* Hangul Jamo */
2031 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2033 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2034 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2035 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2036 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2037 || (c >= 0xffe0 && c <= 0xffe6)
2038 || (c >= 0x20000 && c <= 0x2fffd)
2039 || (c >= 0x30000 && c <= 0x3fffd)))
2045 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2046 * Illegal bytes are set one. */
2047 static const unsigned char utf8_bytes[256] = {
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 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2053 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2054 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,
2055 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,
2058 /* Decode UTF-8 multi-byte representation into a unicode character. */
2059 static inline unsigned long
2060 utf8_to_unicode(const char *string, size_t length)
2062 unsigned long unicode;
2066 unicode = string[0];
2069 unicode = (string[0] & 0x1f) << 6;
2070 unicode += (string[1] & 0x3f);
2073 unicode = (string[0] & 0x0f) << 12;
2074 unicode += ((string[1] & 0x3f) << 6);
2075 unicode += (string[2] & 0x3f);
2078 unicode = (string[0] & 0x0f) << 18;
2079 unicode += ((string[1] & 0x3f) << 12);
2080 unicode += ((string[2] & 0x3f) << 6);
2081 unicode += (string[3] & 0x3f);
2084 unicode = (string[0] & 0x0f) << 24;
2085 unicode += ((string[1] & 0x3f) << 18);
2086 unicode += ((string[2] & 0x3f) << 12);
2087 unicode += ((string[3] & 0x3f) << 6);
2088 unicode += (string[4] & 0x3f);
2091 unicode = (string[0] & 0x01) << 30;
2092 unicode += ((string[1] & 0x3f) << 24);
2093 unicode += ((string[2] & 0x3f) << 18);
2094 unicode += ((string[3] & 0x3f) << 12);
2095 unicode += ((string[4] & 0x3f) << 6);
2096 unicode += (string[5] & 0x3f);
2099 die("Invalid unicode length");
2102 /* Invalid characters could return the special 0xfffd value but NUL
2103 * should be just as good. */
2104 return unicode > 0xffff ? 0 : unicode;
2107 /* Calculates how much of string can be shown within the given maximum width
2108 * and sets trimmed parameter to non-zero value if all of string could not be
2111 * Additionally, adds to coloffset how many many columns to move to align with
2112 * the expected position. Takes into account how multi-byte and double-width
2113 * characters will effect the cursor position.
2115 * Returns the number of bytes to output from string to satisfy max_width. */
2117 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2119 const char *start = string;
2120 const char *end = strchr(string, '\0');
2126 while (string < end) {
2127 int c = *(unsigned char *) string;
2128 unsigned char bytes = utf8_bytes[c];
2130 unsigned long unicode;
2132 if (string + bytes > end)
2135 /* Change representation to figure out whether
2136 * it is a single- or double-width character. */
2138 unicode = utf8_to_unicode(string, bytes);
2139 /* FIXME: Graceful handling of invalid unicode character. */
2143 ucwidth = unicode_width(unicode);
2145 if (width > max_width) {
2150 /* The column offset collects the differences between the
2151 * number of bytes encoding a character and the number of
2152 * columns will be used for rendering said character.
2154 * So if some character A is encoded in 2 bytes, but will be
2155 * represented on the screen using only 1 byte this will and up
2156 * adding 1 to the multi-byte column offset.
2158 * Assumes that no double-width character can be encoding in
2159 * less than two bytes. */
2160 if (bytes > ucwidth)
2161 mbwidth += bytes - ucwidth;
2166 *coloffset += mbwidth;
2168 return string - start;
2176 /* Whether or not the curses interface has been initialized. */
2177 static bool cursed = FALSE;
2179 /* The status window is used for polling keystrokes. */
2180 static WINDOW *status_win;
2182 /* Update status and title window. */
2184 report(const char *msg, ...)
2186 static bool empty = TRUE;
2187 struct view *view = display[current_view];
2189 if (!empty || *msg) {
2192 va_start(args, msg);
2195 wmove(status_win, 0, 0);
2197 vwprintw(status_win, msg, args);
2202 wrefresh(status_win);
2207 update_view_title(view);
2209 /* Move the cursor to the right-most column of the cursor line.
2211 * XXX: This could turn out to be a bit expensive, but it ensures that
2212 * the cursor does not jump around. */
2214 wmove(view->win, view->lineno - view->offset, view->width - 1);
2215 wrefresh(view->win);
2219 /* Controls when nodelay should be in effect when polling user input. */
2221 set_nonblocking_input(bool loading)
2223 static unsigned int loading_views;
2225 if ((loading == FALSE && loading_views-- == 1) ||
2226 (loading == TRUE && loading_views++ == 0))
2227 nodelay(status_win, loading);
2235 /* Initialize the curses library */
2236 if (isatty(STDIN_FILENO)) {
2237 cursed = !!initscr();
2239 /* Leave stdin and stdout alone when acting as a pager. */
2240 FILE *io = fopen("/dev/tty", "r+");
2242 cursed = !!newterm(NULL, io, io);
2246 die("Failed to initialize curses");
2248 nonl(); /* Tell curses not to do NL->CR/NL on output */
2249 cbreak(); /* Take input chars one at a time, no wait for \n */
2250 noecho(); /* Don't echo input */
2251 leaveok(stdscr, TRUE);
2256 getmaxyx(stdscr, y, x);
2257 status_win = newwin(1, 0, y - 1, 0);
2259 die("Failed to create status window");
2261 /* Enable keyboard mapping */
2262 keypad(status_win, TRUE);
2263 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2268 * Repository references
2271 static struct ref *refs;
2272 static size_t refs_size;
2274 /* Id <-> ref store */
2275 static struct ref ***id_refs;
2276 static size_t id_refs_size;
2278 static struct ref **
2281 struct ref ***tmp_id_refs;
2282 struct ref **ref_list = NULL;
2283 size_t ref_list_size = 0;
2286 for (i = 0; i < id_refs_size; i++)
2287 if (!strcmp(id, id_refs[i][0]->id))
2290 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2294 id_refs = tmp_id_refs;
2296 for (i = 0; i < refs_size; i++) {
2299 if (strcmp(id, refs[i].id))
2302 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2310 if (ref_list_size > 0)
2311 ref_list[ref_list_size - 1]->next = 1;
2312 ref_list[ref_list_size] = &refs[i];
2314 /* XXX: The properties of the commit chains ensures that we can
2315 * safely modify the shared ref. The repo references will
2316 * always be similar for the same id. */
2317 ref_list[ref_list_size]->next = 0;
2322 id_refs[id_refs_size++] = ref_list;
2328 read_ref(char *id, int idlen, char *name, int namelen)
2332 bool tag_commit = FALSE;
2334 /* Commits referenced by tags has "^{}" appended. */
2335 if (name[namelen - 1] == '}') {
2336 while (namelen > 0 && name[namelen] != '^')
2343 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2346 name += STRING_SIZE("refs/tags/");
2349 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2350 name += STRING_SIZE("refs/heads/");
2352 } else if (!strcmp(name, "HEAD")) {
2356 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2360 ref = &refs[refs_size++];
2361 ref->name = strdup(name);
2366 string_copy(ref->id, id);
2374 const char *cmd_env = getenv("TIG_LS_REMOTE");
2375 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2377 return read_properties(cmd, '\t', read_ref);
2381 read_config_option(char *name, int namelen, char *value, int valuelen)
2383 if (!strcmp(name, "i18n.commitencoding")) {
2384 string_copy(opt_encoding, value);
2393 return read_properties("git repo-config --list", '=',
2394 read_config_option);
2398 read_properties(const char *cmd, int separator,
2399 int (*read_property)(char *, int, char *, int))
2401 FILE *pipe = popen(cmd, "r");
2402 char buffer[BUFSIZ];
2409 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2410 char *value = strchr(name, separator);
2415 namelen = value - name;
2417 valuelen = strlen(value);
2419 value[valuelen - 1] = 0;
2422 namelen = strlen(name);
2428 state = read_property(name, namelen, value, valuelen);
2431 if (state != ERR && ferror(pipe))
2445 #define __NORETURN __attribute__((__noreturn__))
2450 static void __NORETURN
2453 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2459 static void __NORETURN
2460 die(const char *err, ...)
2466 va_start(args, err);
2467 fputs("tig: ", stderr);
2468 vfprintf(stderr, err, args);
2469 fputs("\n", stderr);
2476 main(int argc, char *argv[])
2479 enum request request;
2482 signal(SIGINT, quit);
2484 /* Load the repo config file first so options can be overwritten from
2485 * the command line. */
2486 if (load_config() == ERR)
2487 die("Failed to load repo config.");
2489 if (!parse_options(argc, argv))
2492 if (load_refs() == ERR)
2493 die("Failed to load refs.");
2495 /* Require a git repository unless when running in pager mode. */
2496 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2497 die("Not a git repository");
2499 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2500 view->cmd_env = getenv(view->cmd_env);
2502 request = opt_request;
2506 while (view_driver(display[current_view], request)) {
2510 foreach_view (view, i)
2513 /* Refresh, accept single keystroke of input */
2514 key = wgetch(status_win);
2515 request = get_request(key);
2517 /* Some low-level request handling. This keeps access to
2518 * status_win restricted. */
2522 /* Temporarily switch to line-oriented and echoed
2527 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2528 memcpy(opt_cmd, "git ", 4);
2529 opt_request = REQ_VIEW_PAGER;
2538 case REQ_SCREEN_RESIZE:
2542 getmaxyx(stdscr, height, width);
2544 /* Resize the status view and let the view driver take
2545 * care of resizing the displayed views. */
2546 wresize(status_win, 1, width);
2547 mvwin(status_win, height - 1, 0);
2548 wrefresh(status_win);
2563 * Revision specification
2564 * ----------------------
2565 * This section describes various ways to specify what revisions to display
2566 * or otherwise limit the view to. tig(1) does not itself parse the described
2567 * revision options so refer to the relevant git man pages for futher
2568 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2571 * You can tune the interaction with git by making use of the options
2572 * explained in this section. For example, by configuring the environment
2573 * variables described in the <<view-commands, "View commands">> section.
2575 * Limit by path name
2576 * ~~~~~~~~~~~~~~~~~~
2577 * If you are interested only in those revisions that made changes to a
2578 * specific file (or even several files) list the files like this:
2580 * $ tig log Makefile README
2582 * To avoid ambiguity with repository references such as tag name, be sure
2583 * to separate file names from other git options using "\--". So if you
2584 * have a file named 'master' it will clash with the reference named
2585 * 'master', and thus you will have to use:
2587 * $ tig log -- master
2589 * NOTE: For the main view, avoiding ambiguity will in some cases require
2590 * you to specify two "\--" options. The first will make tig(1) stop
2591 * option processing and the latter will be passed to git log.
2593 * Limit by date or number
2594 * ~~~~~~~~~~~~~~~~~~~~~~~
2595 * To speed up interaction with git, you can limit the amount of commits
2596 * to show both for the log and main view. Either limit by date using
2597 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2599 * If you are only interested in changed that happened between two dates
2602 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2604 * NOTE: If you want to avoid having to quote dates containing spaces you
2605 * can use "." instead, e.g. `--after=May.5th`.
2607 * Limiting by commit ranges
2608 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2609 * Alternatively, commits can be limited to a specific range, such as
2610 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2612 * $ tig log tag-1.0..tag-2.0
2614 * This way of commit limiting makes it trivial to only browse the commits
2615 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2616 * upstream remote branch, using:
2618 * $ tig log origin..HEAD
2620 * will list what will be pushed to the remote branch. Optionally, the ending
2621 * 'HEAD' can be left out since it is implied.
2623 * Limiting by reachability
2624 * ~~~~~~~~~~~~~~~~~~~~~~~~
2625 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2626 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2627 * Where reachability refers to what commits are ancestors (or part of the
2628 * history) of the branch or tagged revision in question.
2630 * If you prefer to specify which commit to preview in this way use the
2633 * $ tig log tag-2.0 ^tag-1.0
2635 * You can think of '^' as a negation operator. Using this alternate syntax,
2636 * it is possible to further prune commits by specifying multiple branch
2639 * Combining revisions specification
2640 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2641 * Revisions options can to some degree be combined, which makes it possible
2642 * to say "show at most 20 commits from within the last month that changed
2643 * files under the Documentation/ directory."
2645 * $ tig -- --since=1.month -n20 -- Documentation/
2647 * Examining all repository references
2648 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2649 * In some cases, it can be useful to query changes across all references
2650 * in a repository. An example is to ask "did any line of development in
2651 * this repository change a particular file within the last week". This
2652 * can be accomplished using:
2654 * $ tig -- --all --since=1.week -- Makefile
2658 * Known bugs and problems:
2660 * - In it's current state tig is pretty much UTF-8 only.
2662 * - If the screen width is very small the main view can draw
2663 * outside the current view causing bad wrapping. Same goes
2664 * for title and status windows.
2666 * - The cursor can wrap-around on the last line and cause the
2671 * Features that should be explored.
2679 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2681 * This program is free software; you can redistribute it and/or modify
2682 * it under the terms of the GNU General Public License as published by
2683 * the Free Software Foundation; either version 2 of the License, or
2684 * (at your option) any later version.
2688 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2689 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2691 * Other git repository browsers: