1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License as
5 * published by the Free Software Foundation; either version 2 of
6 * the License, or (at your option) any later version.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
19 * tig - text-mode interface for git
25 * tig [options] [--] [git log options]
26 * tig [options] log [git log options]
27 * tig [options] diff [git diff options]
28 * tig [options] show [git show options]
29 * tig [options] < [git command output]
33 * Browse changes in a git repository. Additionally, tig(1) can also act
34 * as a pager for output of various git commands.
36 * When browsing repositories, tig(1) uses the underlying git commands
37 * to present the user with various views, such as summarized commit log
38 * and showing the commit with the log message, diffstat, and the diff.
40 * Using tig(1) as a pager, it will display input from stdin and try
45 #define VERSION "tig-0.3"
65 static void die(const char *err, ...);
66 static void report(const char *msg, ...);
67 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
68 static void set_nonblocking_input(bool loading);
69 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
71 #define ABS(x) ((x) >= 0 ? (x) : -(x))
72 #define MIN(x, y) ((x) < (y) ? (x) : (y))
74 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
75 #define STRING_SIZE(x) (sizeof(x) - 1)
77 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
78 #define SIZEOF_CMD 1024 /* Size of command buffer. */
80 /* This color name can be used to refer to the default term colors. */
81 #define COLOR_DEFAULT (-1)
83 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
85 /* The format and size of the date column in the main view. */
86 #define DATE_FORMAT "%Y-%m-%d %H:%M"
87 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
89 #define AUTHOR_COLS 20
91 /* The default interval between line numbers. */
92 #define NUMBER_INTERVAL 1
96 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
98 /* Some ascii-shorthands fitted into the ncurses namespace. */
100 #define KEY_RETURN '\r'
104 /* User action requests. */
106 /* Offset all requests to avoid conflicts with ncurses getch values. */
107 REQ_OFFSET = KEY_MAX + 1,
109 /* XXX: Keep the view request first and in sync with views[]. */
124 REQ_TOGGLE_LINE_NUMBERS,
138 REQ_SCROLL_LINE_DOWN,
140 REQ_SCROLL_PAGE_DOWN,
144 char *name; /* Ref name; tag or head names are shortened. */
145 char id[41]; /* Commit SHA1 ID */
146 unsigned int tag:1; /* Is it a tag? */
147 unsigned int next:1; /* For ref lists: are there more refs? */
150 static struct ref **get_refs(char *id);
158 string_ncopy(char *dst, const char *src, int dstlen)
160 strncpy(dst, src, dstlen - 1);
165 /* Shorthand for safely copying into a fixed buffer. */
166 #define string_copy(dst, src) \
167 string_ncopy(dst, src, sizeof(dst))
170 chomp_string(char *name)
174 while (isspace(*name))
177 namelen = strlen(name) - 1;
178 while (namelen > 0 && isspace(name[namelen]))
187 * NOTE: The following is a slightly modified copy of the git project's shell
188 * quoting routines found in the quote.c file.
190 * Help to copy the thing properly quoted for the shell safety. any single
191 * quote is replaced with '\'', any exclamation point is replaced with '\!',
192 * and the whole thing is enclosed in a
195 * original sq_quote result
196 * name ==> name ==> 'name'
197 * a b ==> a b ==> 'a b'
198 * a'b ==> a'\''b ==> 'a'\''b'
199 * a!b ==> a'\!'b ==> 'a'\!'b'
203 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
207 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
210 while ((c = *src++)) {
211 if (c == '\'' || c == '!') {
231 static const char usage[] =
232 VERSION " (" __DATE__ ")\n"
234 "Usage: tig [options]\n"
235 " or: tig [options] [--] [git log options]\n"
236 " or: tig [options] log [git log options]\n"
237 " or: tig [options] diff [git diff options]\n"
238 " or: tig [options] show [git show options]\n"
239 " or: tig [options] < [git command output]\n"
242 " -l Start up in log view\n"
243 " -d Start up in diff view\n"
244 " -n[I], --line-number[=I] Show line numbers with given interval\n"
245 " -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
246 " -- Mark end of tig options\n"
247 " -v, --version Show version and exit\n"
248 " -h, --help Show help message and exit\n";
250 /* Option and state variables. */
251 static bool opt_line_number = FALSE;
252 static int opt_num_interval = NUMBER_INTERVAL;
253 static int opt_tab_size = TABSIZE;
254 static enum request opt_request = REQ_VIEW_MAIN;
255 static char opt_cmd[SIZEOF_CMD] = "";
256 static char opt_encoding[20] = "";
257 static bool opt_utf8 = TRUE;
258 static FILE *opt_pipe = NULL;
260 /* Returns the index of log or diff command or -1 to exit. */
262 parse_options(int argc, char *argv[])
266 for (i = 1; i < argc; i++) {
271 * Start up in log view using the internal log command.
273 if (!strcmp(opt, "-l")) {
274 opt_request = REQ_VIEW_LOG;
280 * Start up in diff view using the internal diff command.
282 if (!strcmp(opt, "-d")) {
283 opt_request = REQ_VIEW_DIFF;
288 * -n[INTERVAL], --line-number[=INTERVAL]::
289 * Prefix line numbers in log and diff view.
290 * Optionally, with interval different than each line.
292 if (!strncmp(opt, "-n", 2) ||
293 !strncmp(opt, "--line-number", 13)) {
299 } else if (opt[STRING_SIZE("--line-number")] == '=') {
300 num = opt + STRING_SIZE("--line-number=");
304 opt_num_interval = atoi(num);
306 opt_line_number = TRUE;
311 * -b[NSPACES], --tab-size[=NSPACES]::
312 * Set the number of spaces tabs should be expanded to.
314 if (!strncmp(opt, "-b", 2) ||
315 !strncmp(opt, "--tab-size", 10)) {
321 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
322 num = opt + STRING_SIZE("--tab-size=");
326 opt_tab_size = MIN(atoi(num), TABSIZE);
332 * Show version and exit.
334 if (!strcmp(opt, "-v") ||
335 !strcmp(opt, "--version")) {
336 printf("tig version %s\n", VERSION);
342 * Show help message and exit.
344 if (!strcmp(opt, "-h") ||
345 !strcmp(opt, "--help")) {
352 * End of tig(1) options. Useful when specifying command
353 * options for the main view. Example:
355 * $ tig -- --since=1.month
357 if (!strcmp(opt, "--")) {
363 * log [git log options]::
364 * Open log view using the given git log options.
366 * diff [git diff options]::
367 * Open diff view using the given git diff options.
369 * show [git show options]::
370 * Open diff view using the given git show options.
372 if (!strcmp(opt, "log") ||
373 !strcmp(opt, "diff") ||
374 !strcmp(opt, "show")) {
375 opt_request = opt[0] == 'l'
376 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
381 * [git log options]::
382 * tig(1) will stop the option parsing when the first
383 * command line parameter not starting with "-" is
384 * encountered. All options including this one will be
385 * passed to git log when loading the main view.
386 * This makes it possible to say:
388 * $ tig tag-1.0..HEAD
390 if (opt[0] && opt[0] != '-')
393 die("unknown command '%s'", opt);
396 if (!isatty(STDIN_FILENO)) {
400 * If stdin is a pipe, any log or diff options will be ignored and the
401 * pager view will be opened loading data from stdin. The pager mode
402 * can be used for colorizing output from various git commands.
404 * Example on how to colorize the output of git-show(1):
408 opt_request = REQ_VIEW_PAGER;
411 } else if (i < argc) {
415 * Git command options
416 * ~~~~~~~~~~~~~~~~~~~
417 * All git command options specified on the command line will
418 * be passed to the given command and all will be shell quoted
419 * before they are passed to the shell.
421 * NOTE: If you specify options for the main view, you should
422 * not use the `--pretty` option as this option will be set
423 * automatically to the format expected by the main view.
425 * Example on how to open the log view and show both author and
426 * committer information:
428 * $ tig log --pretty=fuller
430 * See the <<refspec, "Specifying revisions">> section below
431 * for an introduction to revision options supported by the git
432 * commands. For details on specific git command options, refer
433 * to the man page of the command in question.
436 if (opt_request == REQ_VIEW_MAIN)
437 /* XXX: This is vulnerable to the user overriding
438 * options required for the main view parser. */
439 string_copy(opt_cmd, "git log --stat --pretty=raw");
441 string_copy(opt_cmd, "git");
442 buf_size = strlen(opt_cmd);
444 while (buf_size < sizeof(opt_cmd) && i < argc) {
445 opt_cmd[buf_size++] = ' ';
446 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
449 if (buf_size >= sizeof(opt_cmd))
450 die("command too long");
452 opt_cmd[buf_size] = 0;
456 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
464 * ENVIRONMENT VARIABLES
465 * ---------------------
466 * Several options related to the interface with git can be configured
467 * via environment options.
469 * Repository references
470 * ~~~~~~~~~~~~~~~~~~~~~
471 * Commits that are referenced by tags and branch heads will be marked
472 * by the reference name surrounded by '[' and ']':
474 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
476 * If you want to filter out certain directories under `.git/refs/`, say
477 * `tmp` you can do it by setting the following variable:
479 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
481 * Or set the variable permanently in your environment.
484 * Set command for retrieving all repository references. The command
485 * should output data in the same format as git-ls-remote(1).
488 #define TIG_LS_REMOTE \
489 "git ls-remote . 2>/dev/null"
492 * [[history-commands]]
495 * It is possible to alter which commands are used for the different views.
496 * If for example you prefer commits in the main view to be sorted by date
497 * and only show 500 commits, use:
499 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
501 * Or set the variable permanently in your environment.
503 * Notice, how `%s` is used to specify the commit reference. There can
504 * be a maximum of 5 `%s` ref specifications.
507 * The command used for the diff view. By default, git show is used
511 * The command used for the log view. If you prefer to have both
512 * author and committer shown in the log view be sure to pass
513 * `--pretty=fuller` to git log.
516 * The command used for the main view. Note, you must always specify
517 * the option: `--pretty=raw` since the main view parser expects to
521 #define TIG_DIFF_CMD \
522 "git show --patch-with-stat --find-copies-harder -B -C %s"
524 #define TIG_LOG_CMD \
525 "git log --cc --stat -n100 %s"
527 #define TIG_MAIN_CMD \
528 "git log --topo-order --stat --pretty=raw %s"
530 /* ... silently ignore that the following are also exported. */
532 #define TIG_HELP_CMD \
533 "man tig 2>/dev/null"
535 #define TIG_PAGER_CMD \
540 * Line-oriented content detection.
544 /* Line type String to match Foreground Background Attributes
545 * --------- --------------- ---------- ---------- ---------- */ \
547 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
548 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
549 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
550 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
551 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
552 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
553 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
554 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
555 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
556 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
557 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
558 /* Pretty print commit header */ \
559 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
560 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
561 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
562 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
563 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
564 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
565 /* Raw commit header */ \
566 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
567 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
568 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
569 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
570 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
572 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
573 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
575 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
576 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
577 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
578 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
579 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
580 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
581 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
582 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
583 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
584 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
585 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
588 #define LINE(type, line, fg, bg, attr) \
595 const char *line; /* The start of line to match. */
596 int linelen; /* Size of string to match. */
597 int fg, bg, attr; /* Color and text attributes for the lines. */
600 static struct line_info line_info[] = {
601 #define LINE(type, line, fg, bg, attr) \
602 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
607 static enum line_type
608 get_line_type(char *line)
610 int linelen = strlen(line);
613 for (type = 0; type < ARRAY_SIZE(line_info); type++)
614 /* Case insensitive search matches Signed-off-by lines better. */
615 if (linelen >= line_info[type].linelen &&
616 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
623 get_line_attr(enum line_type type)
625 assert(type < ARRAY_SIZE(line_info));
626 return COLOR_PAIR(type) | line_info[type].attr;
632 int default_bg = COLOR_BLACK;
633 int default_fg = COLOR_WHITE;
638 if (use_default_colors() != ERR) {
643 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
644 struct line_info *info = &line_info[type];
645 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
646 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
648 init_pair(type, fg, bg);
654 void *data; /* User data */
661 * The display consists of a status window on the last line of the screen and
662 * one or more views. The default is to only show one view at the time but it
663 * is possible to split both the main and log view to also show the commit
666 * If you are in the log view and press 'Enter' when the current line is a
667 * commit line, such as:
669 * commit 4d55caff4cc89335192f3e566004b4ceef572521
671 * You will split the view so that the log view is displayed in the top window
672 * and the diff view in the bottom window. You can switch between the two
673 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
679 /* The display array of active views and the index of the current view. */
680 static struct view *display[2];
681 static unsigned int current_view;
683 #define foreach_view(view, i) \
684 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
686 #define displayed_views() (display[1] != NULL ? 2 : 1)
689 * Current head and commit ID
690 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
691 * The viewer keeps track of both what head and commit ID you are currently
692 * viewing. The commit ID will follow the cursor line and change everytime time
693 * you highlight a different commit. Whenever you reopen the diff view it
694 * will be reloaded, if the commit ID changed.
696 * The head ID is used when opening the main and log view to indicate from
697 * what revision to show history.
700 static char ref_commit[SIZEOF_REF] = "HEAD";
701 static char ref_head[SIZEOF_REF] = "HEAD";
704 const char *name; /* View name */
705 const char *cmd_fmt; /* Default command line format */
706 const char *cmd_env; /* Command line set via environment */
707 const char *id; /* Points to either of ref_{head,commit} */
709 struct view_ops *ops; /* View operations */
711 char cmd[SIZEOF_CMD]; /* Command buffer */
712 char ref[SIZEOF_REF]; /* Hovered commit reference */
713 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
715 int height, width; /* The width and height of the main window */
716 WINDOW *win; /* The main window */
717 WINDOW *title; /* The title window living below the main window */
720 unsigned long offset; /* Offset of the window top */
721 unsigned long lineno; /* Current line number */
723 /* If non-NULL, points to the view that opened this view. If this view
724 * is closed tig will switch back to the parent view. */
728 unsigned long lines; /* Total number of lines */
729 struct line *line; /* Line index */
730 unsigned int digits; /* Number of digits in the lines member. */
738 /* What type of content being displayed. Used in the title bar. */
740 /* Draw one line; @lineno must be < view->height. */
741 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
742 /* Read one line; updates view->line. */
743 bool (*read)(struct view *view, struct line *prev, char *data);
744 /* Depending on view, change display based on current line. */
745 bool (*enter)(struct view *view, struct line *line);
748 static struct view_ops pager_ops;
749 static struct view_ops main_ops;
751 #define VIEW_STR(name, cmd, env, ref, ops) \
752 { name, cmd, #env, ref, ops }
754 #define VIEW_(id, name, ops, ref) \
755 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
760 * tig(1) presents various 'views' of a repository. Each view is based on output
761 * from an external command, most often 'git log', 'git diff', or 'git show'.
764 * Is the default view, and it shows a one line summary of each commit
765 * in the chosen list of revisions. The summary includes commit date,
766 * author, and the first line of the log message. Additionally, any
767 * repository references, such as tags, will be shown.
770 * Presents a more rich view of the revision log showing the whole log
771 * message and the diffstat.
774 * Shows either the diff of the current working tree, that is, what
775 * has changed since the last commit, or the commit diff complete
776 * with log message, diffstat and diff.
779 * Is used for displaying both input from stdin and output from git
780 * commands entered in the internal prompt.
783 * Displays the information from the tig(1) man page. For the help view
784 * to work you need to have the tig(1) man page installed.
787 static struct view views[] = {
788 VIEW_(MAIN, "main", &main_ops, ref_head),
789 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
790 VIEW_(LOG, "log", &pager_ops, ref_head),
791 VIEW_(HELP, "help", &pager_ops, "static"),
792 VIEW_(PAGER, "pager", &pager_ops, "static"),
795 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
799 draw_view_line(struct view *view, unsigned int lineno)
801 if (view->offset + lineno >= view->lines)
804 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
808 redraw_view_from(struct view *view, int lineno)
810 assert(0 <= lineno && lineno < view->height);
812 for (; lineno < view->height; lineno++) {
813 if (!draw_view_line(view, lineno))
817 redrawwin(view->win);
822 redraw_view(struct view *view)
825 redraw_view_from(view, 0);
832 * Each view has a title window which shows the name of the view, current
833 * commit ID if available, and where the view is positioned:
835 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
837 * By default, the title of the current view is highlighted using bold font.
838 * For long loading views (taking over 3 seconds) the time since loading
839 * started will be appended:
841 * [main] 77d9e40fbcea3238015aea403e06f61542df9a31 - commit 1 of 779 (0%) 5s
845 update_view_title(struct view *view)
847 if (view == display[current_view])
848 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
850 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
853 wmove(view->title, 0, 0);
856 wprintw(view->title, "[%s] %s", view->name, view->ref);
858 wprintw(view->title, "[%s]", view->name);
860 if (view->lines || view->pipe) {
861 unsigned int lines = view->lines
862 ? (view->lineno + 1) * 100 / view->lines
865 wprintw(view->title, " - %s %d of %d (%d%%)",
873 time_t secs = time(NULL) - view->start_time;
875 /* Three git seconds are a long time ... */
877 wprintw(view->title, " %lds", secs);
880 wmove(view->title, 0, view->width - 1);
881 wrefresh(view->title);
888 struct view *base = display[0];
889 struct view *view = display[1] ? display[1] : display[0];
891 /* Setup window dimensions */
893 getmaxyx(stdscr, base->height, base->width);
895 /* Make room for the status window. */
899 /* Horizontal split. */
900 view->width = base->width;
901 view->height = SCALE_SPLIT_VIEW(base->height);
902 base->height -= view->height;
904 /* Make room for the title bar. */
908 /* Make room for the title bar. */
913 foreach_view (view, i) {
915 view->win = newwin(view->height, 0, offset, 0);
917 die("Failed to create %s view", view->name);
919 scrollok(view->win, TRUE);
921 view->title = newwin(1, 0, offset + view->height, 0);
923 die("Failed to create title window");
926 wresize(view->win, view->height, view->width);
927 mvwin(view->win, offset, 0);
928 mvwin(view->title, offset + view->height, 0);
931 offset += view->height + 1;
941 foreach_view (view, i) {
943 update_view_title(view);
948 update_display_cursor(void)
950 struct view *view = display[current_view];
952 /* Move the cursor to the right-most column of the cursor line.
954 * XXX: This could turn out to be a bit expensive, but it ensures that
955 * the cursor does not jump around. */
957 wmove(view->win, view->lineno - view->offset, view->width - 1);
966 /* Scrolling backend */
968 do_scroll_view(struct view *view, int lines, bool redraw)
970 /* The rendering expects the new offset. */
971 view->offset += lines;
973 assert(0 <= view->offset && view->offset < view->lines);
976 /* Redraw the whole screen if scrolling is pointless. */
977 if (view->height < ABS(lines)) {
981 int line = lines > 0 ? view->height - lines : 0;
982 int end = line + ABS(lines);
984 wscrl(view->win, lines);
986 for (; line < end; line++) {
987 if (!draw_view_line(view, line))
992 /* Move current line into the view. */
993 if (view->lineno < view->offset) {
994 view->lineno = view->offset;
995 draw_view_line(view, 0);
997 } else if (view->lineno >= view->offset + view->height) {
998 if (view->lineno == view->offset + view->height) {
999 /* Clear the hidden line so it doesn't show if the view
1000 * is scrolled up. */
1001 wmove(view->win, view->height, 0);
1002 wclrtoeol(view->win);
1004 view->lineno = view->offset + view->height - 1;
1005 draw_view_line(view, view->lineno - view->offset);
1008 assert(view->offset <= view->lineno && view->lineno < view->lines);
1013 redrawwin(view->win);
1014 wrefresh(view->win);
1018 /* Scroll frontend */
1020 scroll_view(struct view *view, enum request request)
1025 case REQ_SCROLL_PAGE_DOWN:
1026 lines = view->height;
1027 case REQ_SCROLL_LINE_DOWN:
1028 if (view->offset + lines > view->lines)
1029 lines = view->lines - view->offset;
1031 if (lines == 0 || view->offset + view->height >= view->lines) {
1032 report("Cannot scroll beyond the last line");
1037 case REQ_SCROLL_PAGE_UP:
1038 lines = view->height;
1039 case REQ_SCROLL_LINE_UP:
1040 if (lines > view->offset)
1041 lines = view->offset;
1044 report("Cannot scroll beyond the first line");
1052 die("request %d not handled in switch", request);
1055 do_scroll_view(view, lines, TRUE);
1060 move_view(struct view *view, enum request request, bool redraw)
1065 case REQ_MOVE_FIRST_LINE:
1066 steps = -view->lineno;
1069 case REQ_MOVE_LAST_LINE:
1070 steps = view->lines - view->lineno - 1;
1073 case REQ_MOVE_PAGE_UP:
1074 steps = view->height > view->lineno
1075 ? -view->lineno : -view->height;
1078 case REQ_MOVE_PAGE_DOWN:
1079 steps = view->lineno + view->height >= view->lines
1080 ? view->lines - view->lineno - 1 : view->height;
1092 die("request %d not handled in switch", request);
1095 if (steps <= 0 && view->lineno == 0) {
1096 report("Cannot move beyond the first line");
1099 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1100 report("Cannot move beyond the last line");
1104 /* Move the current line */
1105 view->lineno += steps;
1106 assert(0 <= view->lineno && view->lineno < view->lines);
1108 /* Repaint the old "current" line if we be scrolling */
1109 if (ABS(steps) < view->height) {
1110 int prev_lineno = view->lineno - steps - view->offset;
1112 wmove(view->win, prev_lineno, 0);
1113 wclrtoeol(view->win);
1114 draw_view_line(view, prev_lineno);
1117 /* Check whether the view needs to be scrolled */
1118 if (view->lineno < view->offset ||
1119 view->lineno >= view->offset + view->height) {
1120 if (steps < 0 && -steps > view->offset) {
1121 steps = -view->offset;
1123 } else if (steps > 0) {
1124 if (view->lineno == view->lines - 1 &&
1125 view->lines > view->height) {
1126 steps = view->lines - view->offset - 1;
1127 if (steps >= view->height)
1128 steps -= view->height - 1;
1132 do_scroll_view(view, steps, redraw);
1136 /* Draw the current line */
1137 draw_view_line(view, view->lineno - view->offset);
1142 redrawwin(view->win);
1143 wrefresh(view->win);
1149 * Incremental updating
1153 end_update(struct view *view)
1157 set_nonblocking_input(FALSE);
1158 if (view->pipe == stdin)
1166 begin_update(struct view *view)
1168 const char *id = view->id;
1174 string_copy(view->cmd, opt_cmd);
1176 /* When running random commands, the view ref could have become
1177 * invalid so clear it. */
1180 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1182 if (snprintf(view->cmd, sizeof(view->cmd), format,
1183 id, id, id, id, id) >= sizeof(view->cmd))
1187 /* Special case for the pager view. */
1189 view->pipe = opt_pipe;
1192 view->pipe = popen(view->cmd, "r");
1198 set_nonblocking_input(TRUE);
1203 string_copy(view->vid, id);
1208 for (i = 0; i < view->lines; i++)
1209 if (view->line[i].data)
1210 free(view->line[i].data);
1216 view->start_time = time(NULL);
1222 update_view(struct view *view)
1224 char buffer[BUFSIZ];
1227 /* The number of lines to read. If too low it will cause too much
1228 * redrawing (and possible flickering), if too high responsiveness
1230 unsigned long lines = view->height;
1231 int redraw_from = -1;
1236 /* Only redraw if lines are visible. */
1237 if (view->offset + view->height >= view->lines)
1238 redraw_from = view->lines - view->offset;
1240 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1246 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1247 int linelen = strlen(line);
1249 struct line *prev = view->lines
1250 ? &view->line[view->lines - 1]
1254 line[linelen - 1] = 0;
1256 if (!view->ops->read(view, prev, line))
1266 lines = view->lines;
1267 for (digits = 0; lines; digits++)
1270 /* Keep the displayed view in sync with line number scaling. */
1271 if (digits != view->digits) {
1272 view->digits = digits;
1277 if (redraw_from >= 0) {
1278 /* If this is an incremental update, redraw the previous line
1279 * since for commits some members could have changed when
1280 * loading the main view. */
1281 if (redraw_from > 0)
1284 /* Incrementally draw avoids flickering. */
1285 redraw_view_from(view, redraw_from);
1288 /* Update the title _after_ the redraw so that if the redraw picks up a
1289 * commit reference in view->ref it'll be available here. */
1290 update_view_title(view);
1292 if (ferror(view->pipe)) {
1293 report("Failed to read: %s", strerror(errno));
1296 } else if (feof(view->pipe)) {
1297 if (view == VIEW(REQ_VIEW_HELP)) {
1298 const char *msg = TIG_HELP;
1300 if (view->lines == 0) {
1301 /* Slightly ugly, but abusing view->ref keeps
1302 * the error message. */
1303 string_copy(view->ref, "No help available");
1304 msg = "The tig(1) manpage is not installed";
1318 report("Allocation failure");
1326 OPEN_DEFAULT = 0, /* Use default view switching. */
1327 OPEN_SPLIT = 1, /* Split current view. */
1328 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1329 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1333 open_view(struct view *prev, enum request request, enum open_flags flags)
1335 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1336 bool split = !!(flags & OPEN_SPLIT);
1337 bool reload = !!(flags & OPEN_RELOAD);
1338 struct view *view = VIEW(request);
1339 int nviews = displayed_views();
1340 struct view *base_view = display[0];
1342 if (view == prev && nviews == 1 && !reload) {
1343 report("Already in %s view", view->name);
1347 if ((reload || strcmp(view->vid, view->id)) &&
1348 !begin_update(view)) {
1349 report("Failed to load %s view", view->name);
1354 display[current_view + 1] = view;
1358 /* Maximize the current view. */
1359 memset(display, 0, sizeof(display));
1361 display[current_view] = view;
1364 /* Resize the view when switching between split- and full-screen,
1365 * or when switching between two different full-screen views. */
1366 if (nviews != displayed_views() ||
1367 (nviews == 1 && base_view != display[0]))
1370 if (split && prev->lineno - prev->offset >= prev->height) {
1371 /* Take the title line into account. */
1372 int lines = prev->lineno - prev->offset - prev->height + 1;
1374 /* Scroll the view that was split if the current line is
1375 * outside the new limited view. */
1376 do_scroll_view(prev, lines, TRUE);
1379 if (prev && view != prev) {
1380 if (split && !backgrounded) {
1381 /* "Blur" the previous view. */
1382 update_view_title(prev);
1385 view->parent = prev;
1388 if (view->pipe && view->lines == 0) {
1389 /* Clear the old view and let the incremental updating refill
1395 if (view == VIEW(REQ_VIEW_HELP))
1396 report("%s", TIG_HELP);
1401 /* If the view is backgrounded the above calls to report()
1402 * won't redraw the view title. */
1404 update_view_title(view);
1409 * User request switch noodle
1413 view_driver(struct view *view, enum request request)
1420 case REQ_MOVE_PAGE_UP:
1421 case REQ_MOVE_PAGE_DOWN:
1422 case REQ_MOVE_FIRST_LINE:
1423 case REQ_MOVE_LAST_LINE:
1424 move_view(view, request, TRUE);
1427 case REQ_SCROLL_LINE_DOWN:
1428 case REQ_SCROLL_LINE_UP:
1429 case REQ_SCROLL_PAGE_DOWN:
1430 case REQ_SCROLL_PAGE_UP:
1431 scroll_view(view, request);
1438 case REQ_VIEW_PAGER:
1439 open_view(view, request, OPEN_DEFAULT);
1444 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1446 if (view == VIEW(REQ_VIEW_DIFF) &&
1447 view->parent == VIEW(REQ_VIEW_MAIN)) {
1448 bool redraw = display[1] == view;
1450 view = view->parent;
1451 move_view(view, request, redraw);
1453 update_view_title(view);
1455 move_view(view, request, TRUE);
1462 report("Nothing to enter");
1465 return view->ops->enter(view, &view->line[view->lineno]);
1469 int nviews = displayed_views();
1470 int next_view = (current_view + 1) % nviews;
1472 if (next_view == current_view) {
1473 report("Only one view is displayed");
1477 current_view = next_view;
1478 /* Blur out the title of the previous view. */
1479 update_view_title(view);
1483 case REQ_TOGGLE_LINE_NUMBERS:
1484 opt_line_number = !opt_line_number;
1489 /* Always reload^Wrerun commands from the prompt. */
1490 open_view(view, opt_request, OPEN_RELOAD);
1493 case REQ_STOP_LOADING:
1494 for (i = 0; i < ARRAY_SIZE(views); i++) {
1497 report("Stopped loading the %s view", view->name),
1502 case REQ_SHOW_VERSION:
1503 report("%s (built %s)", VERSION, __DATE__);
1506 case REQ_SCREEN_RESIZE:
1509 case REQ_SCREEN_REDRAW:
1513 case REQ_SCREEN_UPDATE:
1517 case REQ_VIEW_CLOSE:
1518 /* XXX: Mark closed views by letting view->parent point to the
1519 * view itself. Parents to closed view should never be
1522 view->parent->parent != view->parent) {
1523 memset(display, 0, sizeof(display));
1525 display[current_view] = view->parent;
1526 view->parent = view;
1536 /* An unknown key will show most commonly used commands. */
1537 report("Unknown key, press 'h' for help");
1550 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1552 char *text = line->data;
1553 enum line_type type = line->type;
1554 int textlen = strlen(text);
1557 wmove(view->win, lineno, 0);
1559 if (view->offset + lineno == view->lineno) {
1560 if (type == LINE_COMMIT) {
1561 string_copy(view->ref, text + 7);
1562 string_copy(ref_commit, view->ref);
1566 wchgat(view->win, -1, 0, type, NULL);
1569 attr = get_line_attr(type);
1570 wattrset(view->win, attr);
1572 if (opt_line_number || opt_tab_size < TABSIZE) {
1573 static char spaces[] = " ";
1574 int col_offset = 0, col = 0;
1576 if (opt_line_number) {
1577 unsigned long real_lineno = view->offset + lineno + 1;
1579 if (real_lineno == 1 ||
1580 (real_lineno % opt_num_interval) == 0) {
1581 wprintw(view->win, "%.*d", view->digits, real_lineno);
1584 waddnstr(view->win, spaces,
1585 MIN(view->digits, STRING_SIZE(spaces)));
1587 waddstr(view->win, ": ");
1588 col_offset = view->digits + 2;
1591 while (text && col_offset + col < view->width) {
1592 int cols_max = view->width - col_offset - col;
1596 if (*text == '\t') {
1598 assert(sizeof(spaces) > TABSIZE);
1600 cols = opt_tab_size - (col % opt_tab_size);
1603 text = strchr(text, '\t');
1604 cols = line ? text - pos : strlen(pos);
1607 waddnstr(view->win, pos, MIN(cols, cols_max));
1612 int col = 0, pos = 0;
1614 for (; pos < textlen && col < view->width; pos++, col++)
1615 if (text[pos] == '\t')
1616 col += TABSIZE - (col % TABSIZE) - 1;
1618 waddnstr(view->win, text, pos);
1625 pager_read(struct view *view, struct line *prev, char *line)
1627 /* Compress empty lines in the help view. */
1628 if (view == VIEW(REQ_VIEW_HELP) &&
1629 !*line && prev && !*((char *) prev->data))
1632 view->line[view->lines].data = strdup(line);
1633 if (!view->line[view->lines].data)
1636 view->line[view->lines].type = get_line_type(line);
1643 pager_enter(struct view *view, struct line *line)
1647 if (line->type == LINE_COMMIT &&
1648 (view == VIEW(REQ_VIEW_LOG) ||
1649 view == VIEW(REQ_VIEW_PAGER))) {
1650 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1654 /* Always scroll the view even if it was split. That way
1655 * you can use Enter to scroll through the log view and
1656 * split open each commit diff. */
1657 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1659 /* FIXME: A minor workaround. Scrolling the view will call report("")
1660 * but if we are scrolling a non-current view this won't properly
1661 * update the view title. */
1663 update_view_title(view);
1668 static struct view_ops pager_ops = {
1681 char id[41]; /* SHA1 ID. */
1682 char title[75]; /* The first line of the commit message. */
1683 char author[75]; /* The author of the commit. */
1684 struct tm time; /* Date from the author ident. */
1685 struct ref **refs; /* Repository references; tags & branch heads. */
1689 main_draw(struct view *view, struct line *line, unsigned int lineno)
1691 char buf[DATE_COLS + 1];
1692 struct commit *commit = line->data;
1693 enum line_type type;
1699 if (!*commit->author)
1702 wmove(view->win, lineno, col);
1704 if (view->offset + lineno == view->lineno) {
1705 string_copy(view->ref, commit->id);
1706 string_copy(ref_commit, view->ref);
1708 wattrset(view->win, get_line_attr(type));
1709 wchgat(view->win, -1, 0, type, NULL);
1712 type = LINE_MAIN_COMMIT;
1713 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1716 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1717 waddnstr(view->win, buf, timelen);
1718 waddstr(view->win, " ");
1721 wmove(view->win, lineno, col);
1722 if (type != LINE_CURSOR)
1723 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1726 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1728 authorlen = strlen(commit->author);
1729 if (authorlen > AUTHOR_COLS - 2) {
1730 authorlen = AUTHOR_COLS - 2;
1736 waddnstr(view->win, commit->author, authorlen);
1737 if (type != LINE_CURSOR)
1738 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1739 waddch(view->win, '~');
1741 waddstr(view->win, commit->author);
1745 if (type != LINE_CURSOR)
1746 wattrset(view->win, A_NORMAL);
1748 mvwaddch(view->win, lineno, col, ACS_LTEE);
1749 wmove(view->win, lineno, col + 2);
1756 if (type == LINE_CURSOR)
1758 else if (commit->refs[i]->tag)
1759 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1761 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1762 waddstr(view->win, "[");
1763 waddstr(view->win, commit->refs[i]->name);
1764 waddstr(view->win, "]");
1765 if (type != LINE_CURSOR)
1766 wattrset(view->win, A_NORMAL);
1767 waddstr(view->win, " ");
1768 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1769 } while (commit->refs[i++]->next);
1772 if (type != LINE_CURSOR)
1773 wattrset(view->win, get_line_attr(type));
1776 int titlelen = strlen(commit->title);
1778 if (col + titlelen > view->width)
1779 titlelen = view->width - col;
1781 waddnstr(view->win, commit->title, titlelen);
1787 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1789 main_read(struct view *view, struct line *prev, char *line)
1791 enum line_type type = get_line_type(line);
1792 struct commit *commit;
1796 commit = calloc(1, sizeof(struct commit));
1800 line += STRING_SIZE("commit ");
1802 view->line[view->lines++].data = commit;
1803 string_copy(commit->id, line);
1804 commit->refs = get_refs(commit->id);
1809 char *ident = line + STRING_SIZE("author ");
1810 char *end = strchr(ident, '<');
1815 commit = prev->data;
1818 for (; end > ident && isspace(end[-1]); end--) ;
1822 string_copy(commit->author, ident);
1824 /* Parse epoch and timezone */
1826 char *secs = strchr(end + 1, '>');
1830 if (!secs || secs[1] != ' ')
1834 time = (time_t) atol(secs);
1835 zone = strchr(secs, ' ');
1836 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1840 tz = ('0' - zone[1]) * 60 * 60 * 10;
1841 tz += ('0' - zone[2]) * 60 * 60;
1842 tz += ('0' - zone[3]) * 60;
1843 tz += ('0' - zone[4]) * 60;
1850 gmtime_r(&time, &commit->time);
1858 commit = prev->data;
1860 /* Fill in the commit title if it has not already been set. */
1861 if (commit->title[0])
1864 /* Require titles to start with a non-space character at the
1865 * offset used by git log. */
1866 /* FIXME: More gracefull handling of titles; append "..." to
1867 * shortened titles, etc. */
1868 if (strncmp(line, " ", 4) ||
1872 string_copy(commit->title, line + 4);
1879 main_enter(struct view *view, struct line *line)
1881 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1883 open_view(view, REQ_VIEW_DIFF, flags);
1887 static struct view_ops main_ops = {
1898 * Below the default key bindings are shown.
1906 static struct keymap keymap[] = {
1911 * Switch to main view.
1913 * Switch to diff view.
1915 * Switch to log view.
1917 * Switch to pager view.
1921 { 'm', REQ_VIEW_MAIN },
1922 { 'd', REQ_VIEW_DIFF },
1923 { 'l', REQ_VIEW_LOG },
1924 { 'p', REQ_VIEW_PAGER },
1925 { 'h', REQ_VIEW_HELP },
1931 * Close view, if multiple views are open it will jump back to the
1932 * previous view in the view stack. If it is the last open view it
1933 * will quit. Use 'Q' to quit all views at once.
1935 * This key is "context sensitive" depending on what view you are
1936 * currently in. When in log view on a commit line or in the main
1937 * view, split the view and show the commit diff. In the diff view
1938 * pressing Enter will simply scroll the view one line down.
1940 * Switch to next view.
1942 * This key is "context sensitive" and will move the cursor one
1943 * line up. However, uf you opened a diff view from the main view
1944 * (split- or full-screen) it will change the cursor to point to
1945 * the previous commit in the main view and update the diff view
1948 * Similar to 'Up' but will move down.
1950 { 'q', REQ_VIEW_CLOSE },
1951 { KEY_TAB, REQ_VIEW_NEXT },
1952 { KEY_RETURN, REQ_ENTER },
1953 { KEY_UP, REQ_PREVIOUS },
1954 { KEY_DOWN, REQ_NEXT },
1960 * Move cursor one line up.
1962 * Move cursor one line down.
1966 * Move cursor one page up.
1969 * Move cursor one page down.
1971 * Jump to first line.
1973 * Jump to last line.
1975 { 'k', REQ_MOVE_UP },
1976 { 'j', REQ_MOVE_DOWN },
1977 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1978 { KEY_END, REQ_MOVE_LAST_LINE },
1979 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1980 { ' ', REQ_MOVE_PAGE_DOWN },
1981 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1982 { 'b', REQ_MOVE_PAGE_UP },
1983 { '-', REQ_MOVE_PAGE_UP },
1989 * Scroll view one line up.
1991 * Scroll view one line down.
1993 * Scroll view one page up.
1995 * Scroll view one page down.
1997 { KEY_IC, REQ_SCROLL_LINE_UP },
1998 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1999 { 'w', REQ_SCROLL_PAGE_UP },
2000 { 's', REQ_SCROLL_PAGE_DOWN },
2010 * Stop all background loading. This can be useful if you use
2011 * tig(1) in a repository with a long history without limiting
2016 * Toggle line numbers on/off.
2018 * Open prompt. This allows you to specify what git command
2024 { 'z', REQ_STOP_LOADING },
2025 { 'v', REQ_SHOW_VERSION },
2026 { 'r', REQ_SCREEN_REDRAW },
2027 { 'n', REQ_TOGGLE_LINE_NUMBERS },
2028 { ':', REQ_PROMPT },
2030 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2031 { ERR, REQ_SCREEN_UPDATE },
2033 /* Use the ncurses SIGWINCH handler. */
2034 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2038 get_request(int key)
2042 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2043 if (keymap[i].alias == key)
2044 return keymap[i].request;
2046 return (enum request) key;
2051 * Unicode / UTF-8 handling
2053 * NOTE: Much of the following code for dealing with unicode is derived from
2054 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2055 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2058 /* I've (over)annotated a lot of code snippets because I am not entirely
2059 * confident that the approach taken by this small UTF-8 interface is correct.
2063 unicode_width(unsigned long c)
2066 (c <= 0x115f /* Hangul Jamo */
2069 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2071 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2072 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2073 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2074 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2075 || (c >= 0xffe0 && c <= 0xffe6)
2076 || (c >= 0x20000 && c <= 0x2fffd)
2077 || (c >= 0x30000 && c <= 0x3fffd)))
2083 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2084 * Illegal bytes are set one. */
2085 static const unsigned char utf8_bytes[256] = {
2086 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,
2087 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,
2088 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,
2089 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,
2090 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,
2091 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,
2092 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,
2093 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,
2096 /* Decode UTF-8 multi-byte representation into a unicode character. */
2097 static inline unsigned long
2098 utf8_to_unicode(const char *string, size_t length)
2100 unsigned long unicode;
2104 unicode = string[0];
2107 unicode = (string[0] & 0x1f) << 6;
2108 unicode += (string[1] & 0x3f);
2111 unicode = (string[0] & 0x0f) << 12;
2112 unicode += ((string[1] & 0x3f) << 6);
2113 unicode += (string[2] & 0x3f);
2116 unicode = (string[0] & 0x0f) << 18;
2117 unicode += ((string[1] & 0x3f) << 12);
2118 unicode += ((string[2] & 0x3f) << 6);
2119 unicode += (string[3] & 0x3f);
2122 unicode = (string[0] & 0x0f) << 24;
2123 unicode += ((string[1] & 0x3f) << 18);
2124 unicode += ((string[2] & 0x3f) << 12);
2125 unicode += ((string[3] & 0x3f) << 6);
2126 unicode += (string[4] & 0x3f);
2129 unicode = (string[0] & 0x01) << 30;
2130 unicode += ((string[1] & 0x3f) << 24);
2131 unicode += ((string[2] & 0x3f) << 18);
2132 unicode += ((string[3] & 0x3f) << 12);
2133 unicode += ((string[4] & 0x3f) << 6);
2134 unicode += (string[5] & 0x3f);
2137 die("Invalid unicode length");
2140 /* Invalid characters could return the special 0xfffd value but NUL
2141 * should be just as good. */
2142 return unicode > 0xffff ? 0 : unicode;
2145 /* Calculates how much of string can be shown within the given maximum width
2146 * and sets trimmed parameter to non-zero value if all of string could not be
2149 * Additionally, adds to coloffset how many many columns to move to align with
2150 * the expected position. Takes into account how multi-byte and double-width
2151 * characters will effect the cursor position.
2153 * Returns the number of bytes to output from string to satisfy max_width. */
2155 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2157 const char *start = string;
2158 const char *end = strchr(string, '\0');
2164 while (string < end) {
2165 int c = *(unsigned char *) string;
2166 unsigned char bytes = utf8_bytes[c];
2168 unsigned long unicode;
2170 if (string + bytes > end)
2173 /* Change representation to figure out whether
2174 * it is a single- or double-width character. */
2176 unicode = utf8_to_unicode(string, bytes);
2177 /* FIXME: Graceful handling of invalid unicode character. */
2181 ucwidth = unicode_width(unicode);
2183 if (width > max_width) {
2188 /* The column offset collects the differences between the
2189 * number of bytes encoding a character and the number of
2190 * columns will be used for rendering said character.
2192 * So if some character A is encoded in 2 bytes, but will be
2193 * represented on the screen using only 1 byte this will and up
2194 * adding 1 to the multi-byte column offset.
2196 * Assumes that no double-width character can be encoding in
2197 * less than two bytes. */
2198 if (bytes > ucwidth)
2199 mbwidth += bytes - ucwidth;
2204 *coloffset += mbwidth;
2206 return string - start;
2214 /* Whether or not the curses interface has been initialized. */
2215 static bool cursed = FALSE;
2217 /* The status window is used for polling keystrokes. */
2218 static WINDOW *status_win;
2220 /* Update status and title window. */
2222 report(const char *msg, ...)
2224 static bool empty = TRUE;
2225 struct view *view = display[current_view];
2227 if (!empty || *msg) {
2230 va_start(args, msg);
2233 wmove(status_win, 0, 0);
2235 vwprintw(status_win, msg, args);
2240 wrefresh(status_win);
2245 update_view_title(view);
2246 update_display_cursor();
2249 /* Controls when nodelay should be in effect when polling user input. */
2251 set_nonblocking_input(bool loading)
2253 static unsigned int loading_views;
2255 if ((loading == FALSE && loading_views-- == 1) ||
2256 (loading == TRUE && loading_views++ == 0))
2257 nodelay(status_win, loading);
2265 /* Initialize the curses library */
2266 if (isatty(STDIN_FILENO)) {
2267 cursed = !!initscr();
2269 /* Leave stdin and stdout alone when acting as a pager. */
2270 FILE *io = fopen("/dev/tty", "r+");
2272 cursed = !!newterm(NULL, io, io);
2276 die("Failed to initialize curses");
2278 nonl(); /* Tell curses not to do NL->CR/NL on output */
2279 cbreak(); /* Take input chars one at a time, no wait for \n */
2280 noecho(); /* Don't echo input */
2281 leaveok(stdscr, TRUE);
2286 getmaxyx(stdscr, y, x);
2287 status_win = newwin(1, 0, y - 1, 0);
2289 die("Failed to create status window");
2291 /* Enable keyboard mapping */
2292 keypad(status_win, TRUE);
2293 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2298 * Repository references
2301 static struct ref *refs;
2302 static size_t refs_size;
2304 /* Id <-> ref store */
2305 static struct ref ***id_refs;
2306 static size_t id_refs_size;
2308 static struct ref **
2311 struct ref ***tmp_id_refs;
2312 struct ref **ref_list = NULL;
2313 size_t ref_list_size = 0;
2316 for (i = 0; i < id_refs_size; i++)
2317 if (!strcmp(id, id_refs[i][0]->id))
2320 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2324 id_refs = tmp_id_refs;
2326 for (i = 0; i < refs_size; i++) {
2329 if (strcmp(id, refs[i].id))
2332 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2340 if (ref_list_size > 0)
2341 ref_list[ref_list_size - 1]->next = 1;
2342 ref_list[ref_list_size] = &refs[i];
2344 /* XXX: The properties of the commit chains ensures that we can
2345 * safely modify the shared ref. The repo references will
2346 * always be similar for the same id. */
2347 ref_list[ref_list_size]->next = 0;
2352 id_refs[id_refs_size++] = ref_list;
2358 read_ref(char *id, int idlen, char *name, int namelen)
2362 bool tag_commit = FALSE;
2364 /* Commits referenced by tags has "^{}" appended. */
2365 if (name[namelen - 1] == '}') {
2366 while (namelen > 0 && name[namelen] != '^')
2373 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2376 name += STRING_SIZE("refs/tags/");
2379 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2380 name += STRING_SIZE("refs/heads/");
2382 } else if (!strcmp(name, "HEAD")) {
2386 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2390 ref = &refs[refs_size++];
2391 ref->name = strdup(name);
2396 string_copy(ref->id, id);
2404 const char *cmd_env = getenv("TIG_LS_REMOTE");
2405 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2407 return read_properties(popen(cmd, "r"), "\t", read_ref);
2411 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2413 if (!strcmp(name, "i18n.commitencoding")) {
2414 string_copy(opt_encoding, value);
2421 load_repo_config(void)
2423 return read_properties(popen("git repo-config --list", "r"),
2424 "=", read_repo_config_option);
2428 read_properties(FILE *pipe, const char *separators,
2429 int (*read_property)(char *, int, char *, int))
2431 char buffer[BUFSIZ];
2438 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2443 name = chomp_string(name);
2444 namelen = strcspn(name, separators);
2446 if (name[namelen]) {
2448 value = chomp_string(name + namelen + 1);
2449 valuelen = strlen(value);
2457 state = read_property(name, namelen, value, valuelen);
2460 if (state != ERR && ferror(pipe))
2474 #define __NORETURN __attribute__((__noreturn__))
2479 static void __NORETURN
2482 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2488 static void __NORETURN
2489 die(const char *err, ...)
2495 va_start(args, err);
2496 fputs("tig: ", stderr);
2497 vfprintf(stderr, err, args);
2498 fputs("\n", stderr);
2505 main(int argc, char *argv[])
2508 enum request request;
2511 signal(SIGINT, quit);
2513 /* Load the repo config file first so options can be overwritten from
2514 * the command line. */
2515 if (load_repo_config() == ERR)
2516 die("Failed to load repo config.");
2518 if (!parse_options(argc, argv))
2521 if (load_refs() == ERR)
2522 die("Failed to load refs.");
2524 /* Require a git repository unless when running in pager mode. */
2525 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2526 die("Not a git repository");
2528 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2529 view->cmd_env = getenv(view->cmd_env);
2531 request = opt_request;
2535 while (view_driver(display[current_view], request)) {
2539 foreach_view (view, i)
2542 /* Refresh, accept single keystroke of input */
2543 key = wgetch(status_win);
2544 request = get_request(key);
2546 /* Some low-level request handling. This keeps access to
2547 * status_win restricted. */
2551 /* Temporarily switch to line-oriented and echoed
2556 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2557 memcpy(opt_cmd, "git ", 4);
2558 opt_request = REQ_VIEW_PAGER;
2560 report("Prompt interrupted by loading view, "
2561 "press 'z' to stop loading views");
2562 request = REQ_SCREEN_UPDATE;
2569 case REQ_SCREEN_RESIZE:
2573 getmaxyx(stdscr, height, width);
2575 /* Resize the status view and let the view driver take
2576 * care of resizing the displayed views. */
2577 wresize(status_win, 1, width);
2578 mvwin(status_win, height - 1, 0);
2579 wrefresh(status_win);
2594 * Revision specification
2595 * ----------------------
2596 * This section describes various ways to specify what revisions to display
2597 * or otherwise limit the view to. tig(1) does not itself parse the described
2598 * revision options so refer to the relevant git man pages for futher
2599 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2602 * You can tune the interaction with git by making use of the options
2603 * explained in this section. For example, by configuring the environment
2604 * variables described in the <<history-commands, "History commands">>
2607 * Limit by path name
2608 * ~~~~~~~~~~~~~~~~~~
2609 * If you are interested only in those revisions that made changes to a
2610 * specific file (or even several files) list the files like this:
2612 * $ tig log Makefile README
2614 * To avoid ambiguity with repository references such as tag name, be sure
2615 * to separate file names from other git options using "\--". So if you
2616 * have a file named 'master' it will clash with the reference named
2617 * 'master', and thus you will have to use:
2619 * $ tig log -- master
2621 * NOTE: For the main view, avoiding ambiguity will in some cases require
2622 * you to specify two "\--" options. The first will make tig(1) stop
2623 * option processing and the latter will be passed to git log.
2625 * Limit by date or number
2626 * ~~~~~~~~~~~~~~~~~~~~~~~
2627 * To speed up interaction with git, you can limit the amount of commits
2628 * to show both for the log and main view. Either limit by date using
2629 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2631 * If you are only interested in changed that happened between two dates
2634 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2636 * NOTE: If you want to avoid having to quote dates containing spaces you
2637 * can use "." instead, e.g. `--after=May.5th`.
2639 * Limiting by commit ranges
2640 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2641 * Alternatively, commits can be limited to a specific range, such as
2642 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2644 * $ tig log tag-1.0..tag-2.0
2646 * This way of commit limiting makes it trivial to only browse the commits
2647 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2648 * upstream remote branch, using:
2650 * $ tig log origin..HEAD
2652 * will list what will be pushed to the remote branch. Optionally, the ending
2653 * 'HEAD' can be left out since it is implied.
2655 * Limiting by reachability
2656 * ~~~~~~~~~~~~~~~~~~~~~~~~
2657 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2658 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2659 * Where reachability refers to what commits are ancestors (or part of the
2660 * history) of the branch or tagged revision in question.
2662 * If you prefer to specify which commit to preview in this way use the
2665 * $ tig log tag-2.0 ^tag-1.0
2667 * You can think of '^' as a negation operator. Using this alternate syntax,
2668 * it is possible to further prune commits by specifying multiple branch
2671 * Combining revisions specification
2672 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2673 * Revisions options can to some degree be combined, which makes it possible
2674 * to say "show at most 20 commits from within the last month that changed
2675 * files under the Documentation/ directory."
2677 * $ tig -- --since=1.month -n20 -- Documentation/
2679 * Examining all repository references
2680 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2681 * In some cases, it can be useful to query changes across all references
2682 * in a repository. An example is to ask "did any line of development in
2683 * this repository change a particular file within the last week". This
2684 * can be accomplished using:
2686 * $ tig -- --all --since=1.week -- Makefile
2690 * Known bugs and problems:
2692 * - In it's current state tig is pretty much UTF-8 only.
2694 * - If the screen width is very small the main view can draw
2695 * outside the current view causing bad wrapping. Same goes
2696 * for title and status windows.
2698 * - The cursor can wrap-around on the last line and cause the
2701 * - The prompt doesn't work while loading.
2705 * Features that should be explored.
2713 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2715 * This program is free software; you can redistribute it and/or modify
2716 * it under the terms of the GNU General Public License as published by
2717 * the Free Software Foundation; either version 2 of the License, or
2718 * (at your option) any later version.
2722 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2723 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2725 * Other git repository browsers: