![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
06dd14baf9539016065c9fed0b70055249088f56
1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2 *
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.
7 *
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.
12 */
13 /**
14 * TIG(1)
15 * ======
16 *
17 * NAME
18 * ----
19 * tig - text-mode interface for git
20 *
21 * SYNOPSIS
22 * --------
23 * [verse]
24 * tig [options]
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]
30 *
31 * DESCRIPTION
32 * -----------
33 * Browse changes in a git repository. Additionally, tig(1) can also act
34 * as a pager for output of various git commands.
35 *
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.
39 *
40 * Using tig(1) as a pager, it will display input from stdin and try
41 * to colorize it.
42 **/
44 #ifndef VERSION
45 #define VERSION "tig-0.3"
46 #endif
48 #ifndef DEBUG
49 #define NDEBUG
50 #endif
52 #include <assert.h>
53 #include <errno.h>
54 #include <ctype.h>
55 #include <signal.h>
56 #include <stdarg.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <string.h>
60 #include <unistd.h>
61 #include <time.h>
63 #include <curses.h>
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
94 #define TABSIZE 8
96 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
98 /* Some ascii-shorthands fitted into the ncurses namespace. */
99 #define KEY_TAB '\t'
100 #define KEY_RETURN '\r'
101 #define KEY_ESC 27
104 /* User action requests. */
105 enum request {
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[]. */
110 REQ_VIEW_MAIN,
111 REQ_VIEW_DIFF,
112 REQ_VIEW_LOG,
113 REQ_VIEW_HELP,
114 REQ_VIEW_PAGER,
116 REQ_ENTER,
117 REQ_QUIT,
118 REQ_PROMPT,
119 REQ_SCREEN_REDRAW,
120 REQ_SCREEN_RESIZE,
121 REQ_SCREEN_UPDATE,
122 REQ_SHOW_VERSION,
123 REQ_STOP_LOADING,
124 REQ_TOGGLE_LINE_NUMBERS,
125 REQ_VIEW_NEXT,
126 REQ_VIEW_CLOSE,
127 REQ_NEXT,
128 REQ_PREVIOUS,
130 REQ_MOVE_UP,
131 REQ_MOVE_DOWN,
132 REQ_MOVE_PAGE_UP,
133 REQ_MOVE_PAGE_DOWN,
134 REQ_MOVE_FIRST_LINE,
135 REQ_MOVE_LAST_LINE,
137 REQ_SCROLL_LINE_UP,
138 REQ_SCROLL_LINE_DOWN,
139 REQ_SCROLL_PAGE_UP,
140 REQ_SCROLL_PAGE_DOWN,
141 };
143 struct ref {
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? */
148 };
150 static struct ref **get_refs(char *id);
152 struct int_map {
153 const char *name;
154 int namelen;
155 int value;
156 };
158 static int
159 set_from_int_map(struct int_map *map, size_t map_size,
160 int *value, const char *name, int namelen)
161 {
163 int i;
165 for (i = 0; i < map_size; i++)
166 if (namelen == map[i].namelen &&
167 !strncasecmp(name, map[i].name, namelen)) {
168 *value = map[i].value;
169 return OK;
170 }
172 return ERR;
173 }
176 /*
177 * String helpers
178 */
180 static inline void
181 string_ncopy(char *dst, const char *src, int dstlen)
182 {
183 strncpy(dst, src, dstlen - 1);
184 dst[dstlen - 1] = 0;
186 }
188 /* Shorthand for safely copying into a fixed buffer. */
189 #define string_copy(dst, src) \
190 string_ncopy(dst, src, sizeof(dst))
192 static char *
193 chomp_string(char *name)
194 {
195 int namelen;
197 while (isspace(*name))
198 name++;
200 namelen = strlen(name) - 1;
201 while (namelen > 0 && isspace(name[namelen]))
202 name[namelen--] = 0;
204 return name;
205 }
208 /* Shell quoting
209 *
210 * NOTE: The following is a slightly modified copy of the git project's shell
211 * quoting routines found in the quote.c file.
212 *
213 * Help to copy the thing properly quoted for the shell safety. any single
214 * quote is replaced with '\'', any exclamation point is replaced with '\!',
215 * and the whole thing is enclosed in a
216 *
217 * E.g.
218 * original sq_quote result
219 * name ==> name ==> 'name'
220 * a b ==> a b ==> 'a b'
221 * a'b ==> a'\''b ==> 'a'\''b'
222 * a!b ==> a'\!'b ==> 'a'\!'b'
223 */
225 static size_t
226 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
227 {
228 char c;
230 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
232 BUFPUT('\'');
233 while ((c = *src++)) {
234 if (c == '\'' || c == '!') {
235 BUFPUT('\'');
236 BUFPUT('\\');
237 BUFPUT(c);
238 BUFPUT('\'');
239 } else {
240 BUFPUT(c);
241 }
242 }
243 BUFPUT('\'');
245 return bufsize;
246 }
249 /**
250 * OPTIONS
251 * -------
252 **/
254 static const char usage[] =
255 VERSION " (" __DATE__ ")\n"
256 "\n"
257 "Usage: tig [options]\n"
258 " or: tig [options] [--] [git log options]\n"
259 " or: tig [options] log [git log options]\n"
260 " or: tig [options] diff [git diff options]\n"
261 " or: tig [options] show [git show options]\n"
262 " or: tig [options] < [git command output]\n"
263 "\n"
264 "Options:\n"
265 " -l Start up in log view\n"
266 " -d Start up in diff view\n"
267 " -n[I], --line-number[=I] Show line numbers with given interval\n"
268 " -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
269 " -- Mark end of tig options\n"
270 " -v, --version Show version and exit\n"
271 " -h, --help Show help message and exit\n";
273 /* Option and state variables. */
274 static bool opt_line_number = FALSE;
275 static int opt_num_interval = NUMBER_INTERVAL;
276 static int opt_tab_size = TABSIZE;
277 static enum request opt_request = REQ_VIEW_MAIN;
278 static char opt_cmd[SIZEOF_CMD] = "";
279 static char opt_encoding[20] = "";
280 static bool opt_utf8 = TRUE;
281 static FILE *opt_pipe = NULL;
283 /* Returns the index of log or diff command or -1 to exit. */
284 static bool
285 parse_options(int argc, char *argv[])
286 {
287 int i;
289 for (i = 1; i < argc; i++) {
290 char *opt = argv[i];
292 /**
293 * -l::
294 * Start up in log view using the internal log command.
295 **/
296 if (!strcmp(opt, "-l")) {
297 opt_request = REQ_VIEW_LOG;
298 continue;
299 }
301 /**
302 * -d::
303 * Start up in diff view using the internal diff command.
304 **/
305 if (!strcmp(opt, "-d")) {
306 opt_request = REQ_VIEW_DIFF;
307 continue;
308 }
310 /**
311 * -n[INTERVAL], --line-number[=INTERVAL]::
312 * Prefix line numbers in log and diff view.
313 * Optionally, with interval different than each line.
314 **/
315 if (!strncmp(opt, "-n", 2) ||
316 !strncmp(opt, "--line-number", 13)) {
317 char *num = opt;
319 if (opt[1] == 'n') {
320 num = opt + 2;
322 } else if (opt[STRING_SIZE("--line-number")] == '=') {
323 num = opt + STRING_SIZE("--line-number=");
324 }
326 if (isdigit(*num))
327 opt_num_interval = atoi(num);
329 opt_line_number = TRUE;
330 continue;
331 }
333 /**
334 * -b[NSPACES], --tab-size[=NSPACES]::
335 * Set the number of spaces tabs should be expanded to.
336 **/
337 if (!strncmp(opt, "-b", 2) ||
338 !strncmp(opt, "--tab-size", 10)) {
339 char *num = opt;
341 if (opt[1] == 'b') {
342 num = opt + 2;
344 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
345 num = opt + STRING_SIZE("--tab-size=");
346 }
348 if (isdigit(*num))
349 opt_tab_size = MIN(atoi(num), TABSIZE);
350 continue;
351 }
353 /**
354 * -v, --version::
355 * Show version and exit.
356 **/
357 if (!strcmp(opt, "-v") ||
358 !strcmp(opt, "--version")) {
359 printf("tig version %s\n", VERSION);
360 return FALSE;
361 }
363 /**
364 * -h, --help::
365 * Show help message and exit.
366 **/
367 if (!strcmp(opt, "-h") ||
368 !strcmp(opt, "--help")) {
369 printf(usage);
370 return FALSE;
371 }
373 /**
374 * \--::
375 * End of tig(1) options. Useful when specifying command
376 * options for the main view. Example:
377 *
378 * $ tig -- --since=1.month
379 **/
380 if (!strcmp(opt, "--")) {
381 i++;
382 break;
383 }
385 /**
386 * log [git log options]::
387 * Open log view using the given git log options.
388 *
389 * diff [git diff options]::
390 * Open diff view using the given git diff options.
391 *
392 * show [git show options]::
393 * Open diff view using the given git show options.
394 **/
395 if (!strcmp(opt, "log") ||
396 !strcmp(opt, "diff") ||
397 !strcmp(opt, "show")) {
398 opt_request = opt[0] == 'l'
399 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
400 break;
401 }
403 /**
404 * [git log options]::
405 * tig(1) will stop the option parsing when the first
406 * command line parameter not starting with "-" is
407 * encountered. All options including this one will be
408 * passed to git log when loading the main view.
409 * This makes it possible to say:
410 *
411 * $ tig tag-1.0..HEAD
412 **/
413 if (opt[0] && opt[0] != '-')
414 break;
416 die("unknown command '%s'", opt);
417 }
419 if (!isatty(STDIN_FILENO)) {
420 /**
421 * Pager mode
422 * ~~~~~~~~~~
423 * If stdin is a pipe, any log or diff options will be ignored and the
424 * pager view will be opened loading data from stdin. The pager mode
425 * can be used for colorizing output from various git commands.
426 *
427 * Example on how to colorize the output of git-show(1):
428 *
429 * $ git show | tig
430 **/
431 opt_request = REQ_VIEW_PAGER;
432 opt_pipe = stdin;
434 } else if (i < argc) {
435 size_t buf_size;
437 /**
438 * Git command options
439 * ~~~~~~~~~~~~~~~~~~~
440 * All git command options specified on the command line will
441 * be passed to the given command and all will be shell quoted
442 * before they are passed to the shell.
443 *
444 * NOTE: If you specify options for the main view, you should
445 * not use the `--pretty` option as this option will be set
446 * automatically to the format expected by the main view.
447 *
448 * Example on how to open the log view and show both author and
449 * committer information:
450 *
451 * $ tig log --pretty=fuller
452 *
453 * See the <<refspec, "Specifying revisions">> section below
454 * for an introduction to revision options supported by the git
455 * commands. For details on specific git command options, refer
456 * to the man page of the command in question.
457 **/
459 if (opt_request == REQ_VIEW_MAIN)
460 /* XXX: This is vulnerable to the user overriding
461 * options required for the main view parser. */
462 string_copy(opt_cmd, "git log --stat --pretty=raw");
463 else
464 string_copy(opt_cmd, "git");
465 buf_size = strlen(opt_cmd);
467 while (buf_size < sizeof(opt_cmd) && i < argc) {
468 opt_cmd[buf_size++] = ' ';
469 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
470 }
472 if (buf_size >= sizeof(opt_cmd))
473 die("command too long");
475 opt_cmd[buf_size] = 0;
477 }
479 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
480 opt_utf8 = FALSE;
482 return TRUE;
483 }
486 /**
487 * ENVIRONMENT VARIABLES
488 * ---------------------
489 * Several options related to the interface with git can be configured
490 * via environment options.
491 *
492 * Repository references
493 * ~~~~~~~~~~~~~~~~~~~~~
494 * Commits that are referenced by tags and branch heads will be marked
495 * by the reference name surrounded by '[' and ']':
496 *
497 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
498 *
499 * If you want to filter out certain directories under `.git/refs/`, say
500 * `tmp` you can do it by setting the following variable:
501 *
502 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
503 *
504 * Or set the variable permanently in your environment.
505 *
506 * TIG_LS_REMOTE::
507 * Set command for retrieving all repository references. The command
508 * should output data in the same format as git-ls-remote(1).
509 **/
511 #define TIG_LS_REMOTE \
512 "git ls-remote . 2>/dev/null"
514 /**
515 * [[history-commands]]
516 * History commands
517 * ~~~~~~~~~~~~~~~~
518 * It is possible to alter which commands are used for the different views.
519 * If for example you prefer commits in the main view to be sorted by date
520 * and only show 500 commits, use:
521 *
522 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
523 *
524 * Or set the variable permanently in your environment.
525 *
526 * Notice, how `%s` is used to specify the commit reference. There can
527 * be a maximum of 5 `%s` ref specifications.
528 *
529 * TIG_DIFF_CMD::
530 * The command used for the diff view. By default, git show is used
531 * as a backend.
532 *
533 * TIG_LOG_CMD::
534 * The command used for the log view. If you prefer to have both
535 * author and committer shown in the log view be sure to pass
536 * `--pretty=fuller` to git log.
537 *
538 * TIG_MAIN_CMD::
539 * The command used for the main view. Note, you must always specify
540 * the option: `--pretty=raw` since the main view parser expects to
541 * read that format.
542 **/
544 #define TIG_DIFF_CMD \
545 "git show --patch-with-stat --find-copies-harder -B -C %s"
547 #define TIG_LOG_CMD \
548 "git log --cc --stat -n100 %s"
550 #define TIG_MAIN_CMD \
551 "git log --topo-order --stat --pretty=raw %s"
553 /* ... silently ignore that the following are also exported. */
555 #define TIG_HELP_CMD \
556 "man tig 2>/dev/null"
558 #define TIG_PAGER_CMD \
559 ""
562 /**
563 * FILES
564 * -----
565 * '~/.tig'::
566 * User configuration file. See "<<config-options, Configuration options>>"
567 * section for examples.
568 *
569 * '.git/config'::
570 * Repository config file. Read on startup with the help of
571 * git-repo-config(1).
572 **/
573 /**
574 * [[config-options]]
575 * User Configuration file
576 * -----------------------
577 * You can permanently set an option by putting it in the `~/.tig` file.
578 * The file consists of a series of 'commands'. Each
579 * line of the file may contain only one command.
580 *
581 * The hash mark ('#'), or semi-colon (';') is used as a 'comment' character.
582 * All text after the comment character to the end of the line is ignored.
583 * You can use comments to annotate your initialization file.
584 *
585 * Configuration Commands
586 * ~~~~~~~~~~~~~~~~~~~~~~
587 *
588 * --
589 *
590 * *color* object fgcolor bgcolor [attributes]::
591 *
592 * If your terminal supports color, these commands can be used to assign
593 * foreground/backgound combinations to certain objects. Optionally, an
594 * attribute can be given as the last parameter.
595 *
596 * Valid objects are described in the "<<color-objs, Color objects>>" section
597 * below. Note, object names are case-insensitive, and you may use '-', '_',
598 * and '.' interchangeably. So "Diff-Header", "DIFF_HEADER", and "diff.header"
599 * are the same.
600 *
601 * Valid colors include: 'white', 'black', 'green', 'magenta', 'blue', 'cyan',
602 * 'yellow', 'red', 'default'. Use 'default' to refer to the default terminal
603 * colors.
604 **/
606 static struct int_map color_map[] = {
607 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
608 COLOR_MAP(DEFAULT),
609 COLOR_MAP(BLACK),
610 COLOR_MAP(BLUE),
611 COLOR_MAP(CYAN),
612 COLOR_MAP(GREEN),
613 COLOR_MAP(MAGENTA),
614 COLOR_MAP(RED),
615 COLOR_MAP(WHITE),
616 COLOR_MAP(YELLOW),
617 };
619 /**
620 * Valid attributes include: 'normal', 'blink', 'bold', 'dim', 'reverse', 'standout',
621 * and 'underline'. Note, not all attributes may be supported by the terminal.
622 **/
624 static struct int_map attr_map[] = {
625 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
626 ATTR_MAP(NORMAL),
627 ATTR_MAP(BLINK),
628 ATTR_MAP(BOLD),
629 ATTR_MAP(DIM),
630 ATTR_MAP(REVERSE),
631 ATTR_MAP(STANDOUT),
632 ATTR_MAP(UNDERLINE),
633 };
635 /**
636 * Some example color options:
637 *
638 * --------------------------------------------------------------------------
639 * # Diff colors
640 * color diff-header yellow default
641 * color diff-index blue default
642 * color diff-chunk magenta default
643 * # UI colors
644 * color title-blur white blue
645 * color title-focus white blue bold
646 * --------------------------------------------------------------------------
647 *
648 * --
649 **/
651 /**
652 * [[color-objs]]
653 * Color objects
654 * ~~~~~~~~~~~~~
655 *
656 * --
657 **/
659 #define LINE_INFO \
660 /**
661 * Diff markup::
662 *
663 * Objects concerning diff start, chunks and lines added and deleted.
664 *
665 * 'diff-header', 'diff-chunk', 'diff-add', 'diff-del'
666 **/ \
667 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
668 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
669 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
670 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
671 /**
672 * Enhanced git diff markup::
673 *
674 * Extra diff information emitted by the git diff machinery, such as mode
675 * changes, rename detection, and similarity.
676 *
677 * 'diff-oldmode', 'diff-newmode', 'diff-copy-from', 'diff-copy-to',
678 * 'diff-rename-from', 'diff-rename-to', 'diff-similarity' 'diff-dissimilarity'
679 * 'diff-tree', 'diff-index'
680 **/ \
681 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
682 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
683 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
684 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
685 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
686 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
687 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
688 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
689 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
690 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
691 /**
692 * Pretty print commit headers::
693 *
694 * Commit diffs and the revision logs are usually formatted using pretty
695 * printed headers , unless `--pretty=raw` was given. This includes lines,
696 * such as merge info, commit ID, and author and comitter date.
697 *
698 * 'pp-author' 'pp-commit' 'pp-merge' 'pp-date' 'pp-adate' 'pp-cdate'
699 **/ \
700 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
701 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
702 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
703 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
704 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
705 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
706 /**
707 * Raw commit header::
708 *
709 * Usually shown when `--pretty=raw` is given, however 'commit' is pretty
710 * much omnipresent.
711 *
712 * 'commit' 'parent' 'tree' 'author' 'committer'
713 **/ \
714 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
715 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
716 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
717 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
718 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
719 /**
720 * Commit message::
721 *
722 * For now only `Signed-off-by lines` are colorized.
723 *
724 * 'signoff'
725 **/ \
726 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
727 /**
728 * UI colors::
729 *
730 * Colors for text not matching any of the above: 'default'
731 *
732 * Status window colors: 'status'
733 *
734 * Title window colors: 'title-blur' 'title-focus'
735 *
736 * Cursor line colors: 'cursor'
737 *
738 * Main view specific: 'main-date' 'main-author' 'main-commit' 'main-delim'
739 * 'main-tag' 'main-ref'
740 **/ \
741 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
742 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
743 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
744 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
745 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
746 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
747 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
748 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
749 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
750 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
751 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
752 /**
753 * --
754 **/
757 /*
758 * Line-oriented content detection.
759 */
761 enum line_type {
762 #define LINE(type, line, fg, bg, attr) \
763 LINE_##type
764 LINE_INFO
765 #undef LINE
766 };
768 struct line_info {
769 const char *name; /* Option name. */
770 int namelen; /* Size of option name. */
771 const char *line; /* The start of line to match. */
772 int linelen; /* Size of string to match. */
773 int fg, bg, attr; /* Color and text attributes for the lines. */
774 };
776 static struct line_info line_info[] = {
777 #define LINE(type, line, fg, bg, attr) \
778 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
779 LINE_INFO
780 #undef LINE
781 };
783 static enum line_type
784 get_line_type(char *line)
785 {
786 int linelen = strlen(line);
787 enum line_type type;
789 for (type = 0; type < ARRAY_SIZE(line_info); type++)
790 /* Case insensitive search matches Signed-off-by lines better. */
791 if (linelen >= line_info[type].linelen &&
792 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
793 return type;
795 return LINE_DEFAULT;
796 }
798 static inline int
799 get_line_attr(enum line_type type)
800 {
801 assert(type < ARRAY_SIZE(line_info));
802 return COLOR_PAIR(type) | line_info[type].attr;
803 }
805 static struct line_info *
806 get_line_info(char *name, int namelen)
807 {
808 enum line_type type;
809 int i;
811 /* Diff-Header -> DIFF_HEADER */
812 for (i = 0; i < namelen; i++) {
813 if (name[i] == '-')
814 name[i] = '_';
815 else if (name[i] == '.')
816 name[i] = '_';
817 }
819 for (type = 0; type < ARRAY_SIZE(line_info); type++)
820 if (namelen == line_info[type].namelen &&
821 !strncasecmp(line_info[type].name, name, namelen))
822 return &line_info[type];
824 return NULL;
825 }
827 static void
828 init_colors(void)
829 {
830 int default_bg = COLOR_BLACK;
831 int default_fg = COLOR_WHITE;
832 enum line_type type;
834 start_color();
836 if (use_default_colors() != ERR) {
837 default_bg = -1;
838 default_fg = -1;
839 }
841 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
842 struct line_info *info = &line_info[type];
843 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
844 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
846 init_pair(type, fg, bg);
847 }
848 }
850 struct line {
851 enum line_type type;
852 void *data; /* User data */
853 };
856 #define set_color(color, name, namelen) \
857 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, namelen)
859 #define set_attribute(attr, name, namelen) \
860 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, namelen)
862 static int
863 read_option(char *opt, int optlen, char *value, int valuelen)
864 {
865 optlen = strcspn(opt, "#;");
866 if (optlen == 0)
867 /* The whole line is a comment. */
868 return OK;
870 else if (opt[optlen] != 0)
871 /* Part of the option name is a comment, so the value part
872 * should be ignored. */
873 valuelen = 0;
874 else
875 /* Else look for comment endings in the value. */
876 valuelen = strcspn(value, "#;");
878 opt[optlen] = value[valuelen] = 0;
880 /* Reads: "color" object fgcolor bgcolor [attr] */
881 if (!strcmp(opt, "color")) {
882 struct line_info *info;
884 value = chomp_string(value);
885 valuelen = strcspn(value, " \t");
886 info = get_line_info(value, valuelen);
887 if (!info)
888 return ERR;
890 value = chomp_string(value + valuelen);
891 valuelen = strcspn(value, " \t");
892 if (set_color(&info->fg, value, valuelen) == ERR)
893 return ERR;
895 value = chomp_string(value + valuelen);
896 valuelen = strcspn(value, " \t");
897 if (set_color(&info->bg, value, valuelen) == ERR)
898 return ERR;
900 value = chomp_string(value + valuelen);
901 if (*value &&
902 set_attribute(&info->attr, value, strlen(value)) == ERR)
903 return ERR;
905 return OK;
906 }
908 return ERR;
909 }
911 static int
912 load_options(void)
913 {
914 char *home = getenv("HOME");
915 char buf[1024];
916 FILE *file;
918 if (!home ||
919 snprintf(buf, sizeof(buf), "%s/.tig", home) >= sizeof(buf))
920 return ERR;
922 /* It's ok that the file doesn't exist. */
923 file = fopen(buf, "r");
924 if (!file)
925 return OK;
927 return read_properties(file, " \t", read_option);
928 }
931 /**
932 * The viewer
933 * ----------
934 * The display consists of a status window on the last line of the screen and
935 * one or more views. The default is to only show one view at the time but it
936 * is possible to split both the main and log view to also show the commit
937 * diff.
938 *
939 * If you are in the log view and press 'Enter' when the current line is a
940 * commit line, such as:
941 *
942 * commit 4d55caff4cc89335192f3e566004b4ceef572521
943 *
944 * You will split the view so that the log view is displayed in the top window
945 * and the diff view in the bottom window. You can switch between the two
946 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
947 **/
949 struct view;
950 struct view_ops;
952 /* The display array of active views and the index of the current view. */
953 static struct view *display[2];
954 static unsigned int current_view;
956 #define foreach_view(view, i) \
957 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
959 #define displayed_views() (display[1] != NULL ? 2 : 1)
961 /**
962 * Current head and commit ID
963 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
964 * The viewer keeps track of both what head and commit ID you are currently
965 * viewing. The commit ID will follow the cursor line and change everytime time
966 * you highlight a different commit. Whenever you reopen the diff view it
967 * will be reloaded, if the commit ID changed.
968 *
969 * The head ID is used when opening the main and log view to indicate from
970 * what revision to show history.
971 **/
973 static char ref_commit[SIZEOF_REF] = "HEAD";
974 static char ref_head[SIZEOF_REF] = "HEAD";
976 struct view {
977 const char *name; /* View name */
978 const char *cmd_fmt; /* Default command line format */
979 const char *cmd_env; /* Command line set via environment */
980 const char *id; /* Points to either of ref_{head,commit} */
982 struct view_ops *ops; /* View operations */
984 char cmd[SIZEOF_CMD]; /* Command buffer */
985 char ref[SIZEOF_REF]; /* Hovered commit reference */
986 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
988 int height, width; /* The width and height of the main window */
989 WINDOW *win; /* The main window */
990 WINDOW *title; /* The title window living below the main window */
992 /* Navigation */
993 unsigned long offset; /* Offset of the window top */
994 unsigned long lineno; /* Current line number */
996 /* If non-NULL, points to the view that opened this view. If this view
997 * is closed tig will switch back to the parent view. */
998 struct view *parent;
1000 /* Buffering */
1001 unsigned long lines; /* Total number of lines */
1002 struct line *line; /* Line index */
1003 unsigned int digits; /* Number of digits in the lines member. */
1005 /* Loading */
1006 FILE *pipe;
1007 time_t start_time;
1008 };
1010 struct view_ops {
1011 /* What type of content being displayed. Used in the title bar. */
1012 const char *type;
1013 /* Draw one line; @lineno must be < view->height. */
1014 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1015 /* Read one line; updates view->line. */
1016 bool (*read)(struct view *view, struct line *prev, char *data);
1017 /* Depending on view, change display based on current line. */
1018 bool (*enter)(struct view *view, struct line *line);
1019 };
1021 static struct view_ops pager_ops;
1022 static struct view_ops main_ops;
1024 #define VIEW_STR(name, cmd, env, ref, ops) \
1025 { name, cmd, #env, ref, ops }
1027 #define VIEW_(id, name, ops, ref) \
1028 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
1030 /**
1031 * Views
1032 * ~~~~~
1033 * tig(1) presents various 'views' of a repository. Each view is based on output
1034 * from an external command, most often 'git log', 'git diff', or 'git show'.
1035 *
1036 * The main view::
1037 * Is the default view, and it shows a one line summary of each commit
1038 * in the chosen list of revisions. The summary includes commit date,
1039 * author, and the first line of the log message. Additionally, any
1040 * repository references, such as tags, will be shown.
1041 *
1042 * The log view::
1043 * Presents a more rich view of the revision log showing the whole log
1044 * message and the diffstat.
1045 *
1046 * The diff view::
1047 * Shows either the diff of the current working tree, that is, what
1048 * has changed since the last commit, or the commit diff complete
1049 * with log message, diffstat and diff.
1050 *
1051 * The pager view::
1052 * Is used for displaying both input from stdin and output from git
1053 * commands entered in the internal prompt.
1054 *
1055 * The help view::
1056 * Displays the information from the tig(1) man page. For the help view
1057 * to work you need to have the tig(1) man page installed.
1058 **/
1060 static struct view views[] = {
1061 VIEW_(MAIN, "main", &main_ops, ref_head),
1062 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1063 VIEW_(LOG, "log", &pager_ops, ref_head),
1064 VIEW_(HELP, "help", &pager_ops, "static"),
1065 VIEW_(PAGER, "pager", &pager_ops, "static"),
1066 };
1068 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1071 static bool
1072 draw_view_line(struct view *view, unsigned int lineno)
1073 {
1074 if (view->offset + lineno >= view->lines)
1075 return FALSE;
1077 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
1078 }
1080 static void
1081 redraw_view_from(struct view *view, int lineno)
1082 {
1083 assert(0 <= lineno && lineno < view->height);
1085 for (; lineno < view->height; lineno++) {
1086 if (!draw_view_line(view, lineno))
1087 break;
1088 }
1090 redrawwin(view->win);
1091 wrefresh(view->win);
1092 }
1094 static void
1095 redraw_view(struct view *view)
1096 {
1097 wclear(view->win);
1098 redraw_view_from(view, 0);
1099 }
1102 /**
1103 * Title windows
1104 * ~~~~~~~~~~~~~
1105 * Each view has a title window which shows the name of the view, current
1106 * commit ID if available, and where the view is positioned:
1107 *
1108 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
1109 *
1110 * By default, the title of the current view is highlighted using bold font.
1111 * For long loading views (taking over 3 seconds) the time since loading
1112 * started will be appended:
1113 *
1114 * [main] 77d9e40fbcea3238015aea403e06f61542df9a31 - commit 1 of 779 (0%) 5s
1115 **/
1117 static void
1118 update_view_title(struct view *view)
1119 {
1120 if (view == display[current_view])
1121 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1122 else
1123 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1125 werase(view->title);
1126 wmove(view->title, 0, 0);
1128 if (*view->ref)
1129 wprintw(view->title, "[%s] %s", view->name, view->ref);
1130 else
1131 wprintw(view->title, "[%s]", view->name);
1133 if (view->lines || view->pipe) {
1134 unsigned int lines = view->lines
1135 ? (view->lineno + 1) * 100 / view->lines
1136 : 0;
1138 wprintw(view->title, " - %s %d of %d (%d%%)",
1139 view->ops->type,
1140 view->lineno + 1,
1141 view->lines,
1142 lines);
1143 }
1145 if (view->pipe) {
1146 time_t secs = time(NULL) - view->start_time;
1148 /* Three git seconds are a long time ... */
1149 if (secs > 2)
1150 wprintw(view->title, " %lds", secs);
1151 }
1153 wmove(view->title, 0, view->width - 1);
1154 wrefresh(view->title);
1155 }
1157 static void
1158 resize_display(void)
1159 {
1160 int offset, i;
1161 struct view *base = display[0];
1162 struct view *view = display[1] ? display[1] : display[0];
1164 /* Setup window dimensions */
1166 getmaxyx(stdscr, base->height, base->width);
1168 /* Make room for the status window. */
1169 base->height -= 1;
1171 if (view != base) {
1172 /* Horizontal split. */
1173 view->width = base->width;
1174 view->height = SCALE_SPLIT_VIEW(base->height);
1175 base->height -= view->height;
1177 /* Make room for the title bar. */
1178 view->height -= 1;
1179 }
1181 /* Make room for the title bar. */
1182 base->height -= 1;
1184 offset = 0;
1186 foreach_view (view, i) {
1187 if (!view->win) {
1188 view->win = newwin(view->height, 0, offset, 0);
1189 if (!view->win)
1190 die("Failed to create %s view", view->name);
1192 scrollok(view->win, TRUE);
1194 view->title = newwin(1, 0, offset + view->height, 0);
1195 if (!view->title)
1196 die("Failed to create title window");
1198 } else {
1199 wresize(view->win, view->height, view->width);
1200 mvwin(view->win, offset, 0);
1201 mvwin(view->title, offset + view->height, 0);
1202 }
1204 offset += view->height + 1;
1205 }
1206 }
1208 static void
1209 redraw_display(void)
1210 {
1211 struct view *view;
1212 int i;
1214 foreach_view (view, i) {
1215 redraw_view(view);
1216 update_view_title(view);
1217 }
1218 }
1220 static void
1221 update_display_cursor(void)
1222 {
1223 struct view *view = display[current_view];
1225 /* Move the cursor to the right-most column of the cursor line.
1226 *
1227 * XXX: This could turn out to be a bit expensive, but it ensures that
1228 * the cursor does not jump around. */
1229 if (view->lines) {
1230 wmove(view->win, view->lineno - view->offset, view->width - 1);
1231 wrefresh(view->win);
1232 }
1233 }
1235 /*
1236 * Navigation
1237 */
1239 /* Scrolling backend */
1240 static void
1241 do_scroll_view(struct view *view, int lines, bool redraw)
1242 {
1243 /* The rendering expects the new offset. */
1244 view->offset += lines;
1246 assert(0 <= view->offset && view->offset < view->lines);
1247 assert(lines);
1249 /* Redraw the whole screen if scrolling is pointless. */
1250 if (view->height < ABS(lines)) {
1251 redraw_view(view);
1253 } else {
1254 int line = lines > 0 ? view->height - lines : 0;
1255 int end = line + ABS(lines);
1257 wscrl(view->win, lines);
1259 for (; line < end; line++) {
1260 if (!draw_view_line(view, line))
1261 break;
1262 }
1263 }
1265 /* Move current line into the view. */
1266 if (view->lineno < view->offset) {
1267 view->lineno = view->offset;
1268 draw_view_line(view, 0);
1270 } else if (view->lineno >= view->offset + view->height) {
1271 if (view->lineno == view->offset + view->height) {
1272 /* Clear the hidden line so it doesn't show if the view
1273 * is scrolled up. */
1274 wmove(view->win, view->height, 0);
1275 wclrtoeol(view->win);
1276 }
1277 view->lineno = view->offset + view->height - 1;
1278 draw_view_line(view, view->lineno - view->offset);
1279 }
1281 assert(view->offset <= view->lineno && view->lineno < view->lines);
1283 if (!redraw)
1284 return;
1286 redrawwin(view->win);
1287 wrefresh(view->win);
1288 report("");
1289 }
1291 /* Scroll frontend */
1292 static void
1293 scroll_view(struct view *view, enum request request)
1294 {
1295 int lines = 1;
1297 switch (request) {
1298 case REQ_SCROLL_PAGE_DOWN:
1299 lines = view->height;
1300 case REQ_SCROLL_LINE_DOWN:
1301 if (view->offset + lines > view->lines)
1302 lines = view->lines - view->offset;
1304 if (lines == 0 || view->offset + view->height >= view->lines) {
1305 report("Cannot scroll beyond the last line");
1306 return;
1307 }
1308 break;
1310 case REQ_SCROLL_PAGE_UP:
1311 lines = view->height;
1312 case REQ_SCROLL_LINE_UP:
1313 if (lines > view->offset)
1314 lines = view->offset;
1316 if (lines == 0) {
1317 report("Cannot scroll beyond the first line");
1318 return;
1319 }
1321 lines = -lines;
1322 break;
1324 default:
1325 die("request %d not handled in switch", request);
1326 }
1328 do_scroll_view(view, lines, TRUE);
1329 }
1331 /* Cursor moving */
1332 static void
1333 move_view(struct view *view, enum request request, bool redraw)
1334 {
1335 int steps;
1337 switch (request) {
1338 case REQ_MOVE_FIRST_LINE:
1339 steps = -view->lineno;
1340 break;
1342 case REQ_MOVE_LAST_LINE:
1343 steps = view->lines - view->lineno - 1;
1344 break;
1346 case REQ_MOVE_PAGE_UP:
1347 steps = view->height > view->lineno
1348 ? -view->lineno : -view->height;
1349 break;
1351 case REQ_MOVE_PAGE_DOWN:
1352 steps = view->lineno + view->height >= view->lines
1353 ? view->lines - view->lineno - 1 : view->height;
1354 break;
1356 case REQ_MOVE_UP:
1357 steps = -1;
1358 break;
1360 case REQ_MOVE_DOWN:
1361 steps = 1;
1362 break;
1364 default:
1365 die("request %d not handled in switch", request);
1366 }
1368 if (steps <= 0 && view->lineno == 0) {
1369 report("Cannot move beyond the first line");
1370 return;
1372 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1373 report("Cannot move beyond the last line");
1374 return;
1375 }
1377 /* Move the current line */
1378 view->lineno += steps;
1379 assert(0 <= view->lineno && view->lineno < view->lines);
1381 /* Repaint the old "current" line if we be scrolling */
1382 if (ABS(steps) < view->height) {
1383 int prev_lineno = view->lineno - steps - view->offset;
1385 wmove(view->win, prev_lineno, 0);
1386 wclrtoeol(view->win);
1387 draw_view_line(view, prev_lineno);
1388 }
1390 /* Check whether the view needs to be scrolled */
1391 if (view->lineno < view->offset ||
1392 view->lineno >= view->offset + view->height) {
1393 if (steps < 0 && -steps > view->offset) {
1394 steps = -view->offset;
1396 } else if (steps > 0) {
1397 if (view->lineno == view->lines - 1 &&
1398 view->lines > view->height) {
1399 steps = view->lines - view->offset - 1;
1400 if (steps >= view->height)
1401 steps -= view->height - 1;
1402 }
1403 }
1405 do_scroll_view(view, steps, redraw);
1406 return;
1407 }
1409 /* Draw the current line */
1410 draw_view_line(view, view->lineno - view->offset);
1412 if (!redraw)
1413 return;
1415 redrawwin(view->win);
1416 wrefresh(view->win);
1417 report("");
1418 }
1421 /*
1422 * Incremental updating
1423 */
1425 static void
1426 end_update(struct view *view)
1427 {
1428 if (!view->pipe)
1429 return;
1430 set_nonblocking_input(FALSE);
1431 if (view->pipe == stdin)
1432 fclose(view->pipe);
1433 else
1434 pclose(view->pipe);
1435 view->pipe = NULL;
1436 }
1438 static bool
1439 begin_update(struct view *view)
1440 {
1441 const char *id = view->id;
1443 if (view->pipe)
1444 end_update(view);
1446 if (opt_cmd[0]) {
1447 string_copy(view->cmd, opt_cmd);
1448 opt_cmd[0] = 0;
1449 /* When running random commands, the view ref could have become
1450 * invalid so clear it. */
1451 view->ref[0] = 0;
1452 } else {
1453 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1455 if (snprintf(view->cmd, sizeof(view->cmd), format,
1456 id, id, id, id, id) >= sizeof(view->cmd))
1457 return FALSE;
1458 }
1460 /* Special case for the pager view. */
1461 if (opt_pipe) {
1462 view->pipe = opt_pipe;
1463 opt_pipe = NULL;
1464 } else {
1465 view->pipe = popen(view->cmd, "r");
1466 }
1468 if (!view->pipe)
1469 return FALSE;
1471 set_nonblocking_input(TRUE);
1473 view->offset = 0;
1474 view->lines = 0;
1475 view->lineno = 0;
1476 string_copy(view->vid, id);
1478 if (view->line) {
1479 int i;
1481 for (i = 0; i < view->lines; i++)
1482 if (view->line[i].data)
1483 free(view->line[i].data);
1485 free(view->line);
1486 view->line = NULL;
1487 }
1489 view->start_time = time(NULL);
1491 return TRUE;
1492 }
1494 static bool
1495 update_view(struct view *view)
1496 {
1497 char buffer[BUFSIZ];
1498 char *line;
1499 struct line *tmp;
1500 /* The number of lines to read. If too low it will cause too much
1501 * redrawing (and possible flickering), if too high responsiveness
1502 * will suffer. */
1503 unsigned long lines = view->height;
1504 int redraw_from = -1;
1506 if (!view->pipe)
1507 return TRUE;
1509 /* Only redraw if lines are visible. */
1510 if (view->offset + view->height >= view->lines)
1511 redraw_from = view->lines - view->offset;
1513 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1514 if (!tmp)
1515 goto alloc_error;
1517 view->line = tmp;
1519 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1520 int linelen = strlen(line);
1522 struct line *prev = view->lines
1523 ? &view->line[view->lines - 1]
1524 : NULL;
1526 if (linelen)
1527 line[linelen - 1] = 0;
1529 if (!view->ops->read(view, prev, line))
1530 goto alloc_error;
1532 if (lines-- == 1)
1533 break;
1534 }
1536 {
1537 int digits;
1539 lines = view->lines;
1540 for (digits = 0; lines; digits++)
1541 lines /= 10;
1543 /* Keep the displayed view in sync with line number scaling. */
1544 if (digits != view->digits) {
1545 view->digits = digits;
1546 redraw_from = 0;
1547 }
1548 }
1550 if (redraw_from >= 0) {
1551 /* If this is an incremental update, redraw the previous line
1552 * since for commits some members could have changed when
1553 * loading the main view. */
1554 if (redraw_from > 0)
1555 redraw_from--;
1557 /* Incrementally draw avoids flickering. */
1558 redraw_view_from(view, redraw_from);
1559 }
1561 /* Update the title _after_ the redraw so that if the redraw picks up a
1562 * commit reference in view->ref it'll be available here. */
1563 update_view_title(view);
1565 if (ferror(view->pipe)) {
1566 report("Failed to read: %s", strerror(errno));
1567 goto end;
1569 } else if (feof(view->pipe)) {
1570 if (view == VIEW(REQ_VIEW_HELP)) {
1571 const char *msg = TIG_HELP;
1573 if (view->lines == 0) {
1574 /* Slightly ugly, but abusing view->ref keeps
1575 * the error message. */
1576 string_copy(view->ref, "No help available");
1577 msg = "The tig(1) manpage is not installed";
1578 }
1580 report("%s", msg);
1581 goto end;
1582 }
1584 report("");
1585 goto end;
1586 }
1588 return TRUE;
1590 alloc_error:
1591 report("Allocation failure");
1593 end:
1594 end_update(view);
1595 return FALSE;
1596 }
1598 enum open_flags {
1599 OPEN_DEFAULT = 0, /* Use default view switching. */
1600 OPEN_SPLIT = 1, /* Split current view. */
1601 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1602 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1603 };
1605 static void
1606 open_view(struct view *prev, enum request request, enum open_flags flags)
1607 {
1608 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1609 bool split = !!(flags & OPEN_SPLIT);
1610 bool reload = !!(flags & OPEN_RELOAD);
1611 struct view *view = VIEW(request);
1612 int nviews = displayed_views();
1613 struct view *base_view = display[0];
1615 if (view == prev && nviews == 1 && !reload) {
1616 report("Already in %s view", view->name);
1617 return;
1618 }
1620 if ((reload || strcmp(view->vid, view->id)) &&
1621 !begin_update(view)) {
1622 report("Failed to load %s view", view->name);
1623 return;
1624 }
1626 if (split) {
1627 display[current_view + 1] = view;
1628 if (!backgrounded)
1629 current_view++;
1630 } else {
1631 /* Maximize the current view. */
1632 memset(display, 0, sizeof(display));
1633 current_view = 0;
1634 display[current_view] = view;
1635 }
1637 /* Resize the view when switching between split- and full-screen,
1638 * or when switching between two different full-screen views. */
1639 if (nviews != displayed_views() ||
1640 (nviews == 1 && base_view != display[0]))
1641 resize_display();
1643 if (split && prev->lineno - prev->offset >= prev->height) {
1644 /* Take the title line into account. */
1645 int lines = prev->lineno - prev->offset - prev->height + 1;
1647 /* Scroll the view that was split if the current line is
1648 * outside the new limited view. */
1649 do_scroll_view(prev, lines, TRUE);
1650 }
1652 if (prev && view != prev) {
1653 if (split && !backgrounded) {
1654 /* "Blur" the previous view. */
1655 update_view_title(prev);
1656 }
1658 view->parent = prev;
1659 }
1661 if (view->pipe && view->lines == 0) {
1662 /* Clear the old view and let the incremental updating refill
1663 * the screen. */
1664 wclear(view->win);
1665 report("");
1666 } else {
1667 redraw_view(view);
1668 if (view == VIEW(REQ_VIEW_HELP))
1669 report("%s", TIG_HELP);
1670 else
1671 report("");
1672 }
1674 /* If the view is backgrounded the above calls to report()
1675 * won't redraw the view title. */
1676 if (backgrounded)
1677 update_view_title(view);
1678 }
1681 /*
1682 * User request switch noodle
1683 */
1685 static int
1686 view_driver(struct view *view, enum request request)
1687 {
1688 int i;
1690 switch (request) {
1691 case REQ_MOVE_UP:
1692 case REQ_MOVE_DOWN:
1693 case REQ_MOVE_PAGE_UP:
1694 case REQ_MOVE_PAGE_DOWN:
1695 case REQ_MOVE_FIRST_LINE:
1696 case REQ_MOVE_LAST_LINE:
1697 move_view(view, request, TRUE);
1698 break;
1700 case REQ_SCROLL_LINE_DOWN:
1701 case REQ_SCROLL_LINE_UP:
1702 case REQ_SCROLL_PAGE_DOWN:
1703 case REQ_SCROLL_PAGE_UP:
1704 scroll_view(view, request);
1705 break;
1707 case REQ_VIEW_MAIN:
1708 case REQ_VIEW_DIFF:
1709 case REQ_VIEW_LOG:
1710 case REQ_VIEW_HELP:
1711 case REQ_VIEW_PAGER:
1712 open_view(view, request, OPEN_DEFAULT);
1713 break;
1715 case REQ_NEXT:
1716 case REQ_PREVIOUS:
1717 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1719 if (view == VIEW(REQ_VIEW_DIFF) &&
1720 view->parent == VIEW(REQ_VIEW_MAIN)) {
1721 bool redraw = display[1] == view;
1723 view = view->parent;
1724 move_view(view, request, redraw);
1725 if (redraw)
1726 update_view_title(view);
1727 } else {
1728 move_view(view, request, TRUE);
1729 break;
1730 }
1731 /* Fall-through */
1733 case REQ_ENTER:
1734 if (!view->lines) {
1735 report("Nothing to enter");
1736 break;
1737 }
1738 return view->ops->enter(view, &view->line[view->lineno]);
1740 case REQ_VIEW_NEXT:
1741 {
1742 int nviews = displayed_views();
1743 int next_view = (current_view + 1) % nviews;
1745 if (next_view == current_view) {
1746 report("Only one view is displayed");
1747 break;
1748 }
1750 current_view = next_view;
1751 /* Blur out the title of the previous view. */
1752 update_view_title(view);
1753 report("");
1754 break;
1755 }
1756 case REQ_TOGGLE_LINE_NUMBERS:
1757 opt_line_number = !opt_line_number;
1758 redraw_display();
1759 break;
1761 case REQ_PROMPT:
1762 /* Always reload^Wrerun commands from the prompt. */
1763 open_view(view, opt_request, OPEN_RELOAD);
1764 break;
1766 case REQ_STOP_LOADING:
1767 for (i = 0; i < ARRAY_SIZE(views); i++) {
1768 view = &views[i];
1769 if (view->pipe)
1770 report("Stopped loading the %s view", view->name),
1771 end_update(view);
1772 }
1773 break;
1775 case REQ_SHOW_VERSION:
1776 report("%s (built %s)", VERSION, __DATE__);
1777 return TRUE;
1779 case REQ_SCREEN_RESIZE:
1780 resize_display();
1781 /* Fall-through */
1782 case REQ_SCREEN_REDRAW:
1783 redraw_display();
1784 break;
1786 case REQ_SCREEN_UPDATE:
1787 doupdate();
1788 return TRUE;
1790 case REQ_VIEW_CLOSE:
1791 /* XXX: Mark closed views by letting view->parent point to the
1792 * view itself. Parents to closed view should never be
1793 * followed. */
1794 if (view->parent &&
1795 view->parent->parent != view->parent) {
1796 memset(display, 0, sizeof(display));
1797 current_view = 0;
1798 display[current_view] = view->parent;
1799 view->parent = view;
1800 resize_display();
1801 redraw_display();
1802 break;
1803 }
1804 /* Fall-through */
1805 case REQ_QUIT:
1806 return FALSE;
1808 default:
1809 /* An unknown key will show most commonly used commands. */
1810 report("Unknown key, press 'h' for help");
1811 return TRUE;
1812 }
1814 return TRUE;
1815 }
1818 /*
1819 * Pager backend
1820 */
1822 static bool
1823 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1824 {
1825 char *text = line->data;
1826 enum line_type type = line->type;
1827 int textlen = strlen(text);
1828 int attr;
1830 wmove(view->win, lineno, 0);
1832 if (view->offset + lineno == view->lineno) {
1833 if (type == LINE_COMMIT) {
1834 string_copy(view->ref, text + 7);
1835 string_copy(ref_commit, view->ref);
1836 }
1838 type = LINE_CURSOR;
1839 wchgat(view->win, -1, 0, type, NULL);
1840 }
1842 attr = get_line_attr(type);
1843 wattrset(view->win, attr);
1845 if (opt_line_number || opt_tab_size < TABSIZE) {
1846 static char spaces[] = " ";
1847 int col_offset = 0, col = 0;
1849 if (opt_line_number) {
1850 unsigned long real_lineno = view->offset + lineno + 1;
1852 if (real_lineno == 1 ||
1853 (real_lineno % opt_num_interval) == 0) {
1854 wprintw(view->win, "%.*d", view->digits, real_lineno);
1856 } else {
1857 waddnstr(view->win, spaces,
1858 MIN(view->digits, STRING_SIZE(spaces)));
1859 }
1860 waddstr(view->win, ": ");
1861 col_offset = view->digits + 2;
1862 }
1864 while (text && col_offset + col < view->width) {
1865 int cols_max = view->width - col_offset - col;
1866 char *pos = text;
1867 int cols;
1869 if (*text == '\t') {
1870 text++;
1871 assert(sizeof(spaces) > TABSIZE);
1872 pos = spaces;
1873 cols = opt_tab_size - (col % opt_tab_size);
1875 } else {
1876 text = strchr(text, '\t');
1877 cols = line ? text - pos : strlen(pos);
1878 }
1880 waddnstr(view->win, pos, MIN(cols, cols_max));
1881 col += cols;
1882 }
1884 } else {
1885 int col = 0, pos = 0;
1887 for (; pos < textlen && col < view->width; pos++, col++)
1888 if (text[pos] == '\t')
1889 col += TABSIZE - (col % TABSIZE) - 1;
1891 waddnstr(view->win, text, pos);
1892 }
1894 return TRUE;
1895 }
1897 static bool
1898 pager_read(struct view *view, struct line *prev, char *line)
1899 {
1900 /* Compress empty lines in the help view. */
1901 if (view == VIEW(REQ_VIEW_HELP) &&
1902 !*line && prev && !*((char *) prev->data))
1903 return TRUE;
1905 view->line[view->lines].data = strdup(line);
1906 if (!view->line[view->lines].data)
1907 return FALSE;
1909 view->line[view->lines].type = get_line_type(line);
1911 view->lines++;
1912 return TRUE;
1913 }
1915 static bool
1916 pager_enter(struct view *view, struct line *line)
1917 {
1918 int split = 0;
1920 if (line->type == LINE_COMMIT &&
1921 (view == VIEW(REQ_VIEW_LOG) ||
1922 view == VIEW(REQ_VIEW_PAGER))) {
1923 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1924 split = 1;
1925 }
1927 /* Always scroll the view even if it was split. That way
1928 * you can use Enter to scroll through the log view and
1929 * split open each commit diff. */
1930 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1932 /* FIXME: A minor workaround. Scrolling the view will call report("")
1933 * but if we are scrolling a non-current view this won't properly
1934 * update the view title. */
1935 if (split)
1936 update_view_title(view);
1938 return TRUE;
1939 }
1941 static struct view_ops pager_ops = {
1942 "line",
1943 pager_draw,
1944 pager_read,
1945 pager_enter,
1946 };
1949 /*
1950 * Main view backend
1951 */
1953 struct commit {
1954 char id[41]; /* SHA1 ID. */
1955 char title[75]; /* The first line of the commit message. */
1956 char author[75]; /* The author of the commit. */
1957 struct tm time; /* Date from the author ident. */
1958 struct ref **refs; /* Repository references; tags & branch heads. */
1959 };
1961 static bool
1962 main_draw(struct view *view, struct line *line, unsigned int lineno)
1963 {
1964 char buf[DATE_COLS + 1];
1965 struct commit *commit = line->data;
1966 enum line_type type;
1967 int col = 0;
1968 size_t timelen;
1969 size_t authorlen;
1970 int trimmed = 1;
1972 if (!*commit->author)
1973 return FALSE;
1975 wmove(view->win, lineno, col);
1977 if (view->offset + lineno == view->lineno) {
1978 string_copy(view->ref, commit->id);
1979 string_copy(ref_commit, view->ref);
1980 type = LINE_CURSOR;
1981 wattrset(view->win, get_line_attr(type));
1982 wchgat(view->win, -1, 0, type, NULL);
1984 } else {
1985 type = LINE_MAIN_COMMIT;
1986 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1987 }
1989 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1990 waddnstr(view->win, buf, timelen);
1991 waddstr(view->win, " ");
1993 col += DATE_COLS;
1994 wmove(view->win, lineno, col);
1995 if (type != LINE_CURSOR)
1996 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1998 if (opt_utf8) {
1999 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2000 } else {
2001 authorlen = strlen(commit->author);
2002 if (authorlen > AUTHOR_COLS - 2) {
2003 authorlen = AUTHOR_COLS - 2;
2004 trimmed = 1;
2005 }
2006 }
2008 if (trimmed) {
2009 waddnstr(view->win, commit->author, authorlen);
2010 if (type != LINE_CURSOR)
2011 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2012 waddch(view->win, '~');
2013 } else {
2014 waddstr(view->win, commit->author);
2015 }
2017 col += AUTHOR_COLS;
2018 if (type != LINE_CURSOR)
2019 wattrset(view->win, A_NORMAL);
2021 mvwaddch(view->win, lineno, col, ACS_LTEE);
2022 wmove(view->win, lineno, col + 2);
2023 col += 2;
2025 if (commit->refs) {
2026 size_t i = 0;
2028 do {
2029 if (type == LINE_CURSOR)
2030 ;
2031 else if (commit->refs[i]->tag)
2032 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2033 else
2034 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2035 waddstr(view->win, "[");
2036 waddstr(view->win, commit->refs[i]->name);
2037 waddstr(view->win, "]");
2038 if (type != LINE_CURSOR)
2039 wattrset(view->win, A_NORMAL);
2040 waddstr(view->win, " ");
2041 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2042 } while (commit->refs[i++]->next);
2043 }
2045 if (type != LINE_CURSOR)
2046 wattrset(view->win, get_line_attr(type));
2048 {
2049 int titlelen = strlen(commit->title);
2051 if (col + titlelen > view->width)
2052 titlelen = view->width - col;
2054 waddnstr(view->win, commit->title, titlelen);
2055 }
2057 return TRUE;
2058 }
2060 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2061 static bool
2062 main_read(struct view *view, struct line *prev, char *line)
2063 {
2064 enum line_type type = get_line_type(line);
2065 struct commit *commit;
2067 switch (type) {
2068 case LINE_COMMIT:
2069 commit = calloc(1, sizeof(struct commit));
2070 if (!commit)
2071 return FALSE;
2073 line += STRING_SIZE("commit ");
2075 view->line[view->lines++].data = commit;
2076 string_copy(commit->id, line);
2077 commit->refs = get_refs(commit->id);
2078 break;
2080 case LINE_AUTHOR:
2081 {
2082 char *ident = line + STRING_SIZE("author ");
2083 char *end = strchr(ident, '<');
2085 if (!prev)
2086 break;
2088 commit = prev->data;
2090 if (end) {
2091 for (; end > ident && isspace(end[-1]); end--) ;
2092 *end = 0;
2093 }
2095 string_copy(commit->author, ident);
2097 /* Parse epoch and timezone */
2098 if (end) {
2099 char *secs = strchr(end + 1, '>');
2100 char *zone;
2101 time_t time;
2103 if (!secs || secs[1] != ' ')
2104 break;
2106 secs += 2;
2107 time = (time_t) atol(secs);
2108 zone = strchr(secs, ' ');
2109 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2110 long tz;
2112 zone++;
2113 tz = ('0' - zone[1]) * 60 * 60 * 10;
2114 tz += ('0' - zone[2]) * 60 * 60;
2115 tz += ('0' - zone[3]) * 60;
2116 tz += ('0' - zone[4]) * 60;
2118 if (zone[0] == '-')
2119 tz = -tz;
2121 time -= tz;
2122 }
2123 gmtime_r(&time, &commit->time);
2124 }
2125 break;
2126 }
2127 default:
2128 if (!prev)
2129 break;
2131 commit = prev->data;
2133 /* Fill in the commit title if it has not already been set. */
2134 if (commit->title[0])
2135 break;
2137 /* Require titles to start with a non-space character at the
2138 * offset used by git log. */
2139 /* FIXME: More gracefull handling of titles; append "..." to
2140 * shortened titles, etc. */
2141 if (strncmp(line, " ", 4) ||
2142 isspace(line[4]))
2143 break;
2145 string_copy(commit->title, line + 4);
2146 }
2148 return TRUE;
2149 }
2151 static bool
2152 main_enter(struct view *view, struct line *line)
2153 {
2154 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2156 open_view(view, REQ_VIEW_DIFF, flags);
2157 return TRUE;
2158 }
2160 static struct view_ops main_ops = {
2161 "commit",
2162 main_draw,
2163 main_read,
2164 main_enter,
2165 };
2168 /**
2169 * KEYS
2170 * ----
2171 * Below the default key bindings are shown.
2172 **/
2174 struct keymap {
2175 int alias;
2176 int request;
2177 };
2179 static struct keymap keymap[] = {
2180 /**
2181 * View switching
2182 * ~~~~~~~~~~~~~~
2183 * m::
2184 * Switch to main view.
2185 * d::
2186 * Switch to diff view.
2187 * l::
2188 * Switch to log view.
2189 * p::
2190 * Switch to pager view.
2191 * h::
2192 * Show man page.
2193 **/
2194 { 'm', REQ_VIEW_MAIN },
2195 { 'd', REQ_VIEW_DIFF },
2196 { 'l', REQ_VIEW_LOG },
2197 { 'p', REQ_VIEW_PAGER },
2198 { 'h', REQ_VIEW_HELP },
2200 /**
2201 * View manipulation
2202 * ~~~~~~~~~~~~~~~~~
2203 * q::
2204 * Close view, if multiple views are open it will jump back to the
2205 * previous view in the view stack. If it is the last open view it
2206 * will quit. Use 'Q' to quit all views at once.
2207 * Enter::
2208 * This key is "context sensitive" depending on what view you are
2209 * currently in. When in log view on a commit line or in the main
2210 * view, split the view and show the commit diff. In the diff view
2211 * pressing Enter will simply scroll the view one line down.
2212 * Tab::
2213 * Switch to next view.
2214 * Up::
2215 * This key is "context sensitive" and will move the cursor one
2216 * line up. However, uf you opened a diff view from the main view
2217 * (split- or full-screen) it will change the cursor to point to
2218 * the previous commit in the main view and update the diff view
2219 * to display it.
2220 * Down::
2221 * Similar to 'Up' but will move down.
2222 **/
2223 { 'q', REQ_VIEW_CLOSE },
2224 { KEY_TAB, REQ_VIEW_NEXT },
2225 { KEY_RETURN, REQ_ENTER },
2226 { KEY_UP, REQ_PREVIOUS },
2227 { KEY_DOWN, REQ_NEXT },
2229 /**
2230 * Cursor navigation
2231 * ~~~~~~~~~~~~~~~~~
2232 * j::
2233 * Move cursor one line up.
2234 * k::
2235 * Move cursor one line down.
2236 * PgUp::
2237 * b::
2238 * -::
2239 * Move cursor one page up.
2240 * PgDown::
2241 * Space::
2242 * Move cursor one page down.
2243 * Home::
2244 * Jump to first line.
2245 * End::
2246 * Jump to last line.
2247 **/
2248 { 'k', REQ_MOVE_UP },
2249 { 'j', REQ_MOVE_DOWN },
2250 { KEY_HOME, REQ_MOVE_FIRST_LINE },
2251 { KEY_END, REQ_MOVE_LAST_LINE },
2252 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
2253 { ' ', REQ_MOVE_PAGE_DOWN },
2254 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
2255 { 'b', REQ_MOVE_PAGE_UP },
2256 { '-', REQ_MOVE_PAGE_UP },
2258 /**
2259 * Scrolling
2260 * ~~~~~~~~~
2261 * Insert::
2262 * Scroll view one line up.
2263 * Delete::
2264 * Scroll view one line down.
2265 * w::
2266 * Scroll view one page up.
2267 * s::
2268 * Scroll view one page down.
2269 **/
2270 { KEY_IC, REQ_SCROLL_LINE_UP },
2271 { KEY_DC, REQ_SCROLL_LINE_DOWN },
2272 { 'w', REQ_SCROLL_PAGE_UP },
2273 { 's', REQ_SCROLL_PAGE_DOWN },
2275 /**
2276 * Misc
2277 * ~~~~
2278 * Q::
2279 * Quit.
2280 * r::
2281 * Redraw screen.
2282 * z::
2283 * Stop all background loading. This can be useful if you use
2284 * tig(1) in a repository with a long history without limiting
2285 * the revision log.
2286 * v::
2287 * Show version.
2288 * n::
2289 * Toggle line numbers on/off.
2290 * ':'::
2291 * Open prompt. This allows you to specify what git command
2292 * to run. Example:
2293 *
2294 * :log -p
2295 **/
2296 { 'Q', REQ_QUIT },
2297 { 'z', REQ_STOP_LOADING },
2298 { 'v', REQ_SHOW_VERSION },
2299 { 'r', REQ_SCREEN_REDRAW },
2300 { 'n', REQ_TOGGLE_LINE_NUMBERS },
2301 { ':', REQ_PROMPT },
2303 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2304 { ERR, REQ_SCREEN_UPDATE },
2306 /* Use the ncurses SIGWINCH handler. */
2307 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2308 };
2310 static enum request
2311 get_request(int key)
2312 {
2313 int i;
2315 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2316 if (keymap[i].alias == key)
2317 return keymap[i].request;
2319 return (enum request) key;
2320 }
2323 /*
2324 * Unicode / UTF-8 handling
2325 *
2326 * NOTE: Much of the following code for dealing with unicode is derived from
2327 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2328 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2329 */
2331 /* I've (over)annotated a lot of code snippets because I am not entirely
2332 * confident that the approach taken by this small UTF-8 interface is correct.
2333 * --jonas */
2335 static inline int
2336 unicode_width(unsigned long c)
2337 {
2338 if (c >= 0x1100 &&
2339 (c <= 0x115f /* Hangul Jamo */
2340 || c == 0x2329
2341 || c == 0x232a
2342 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2343 /* CJK ... Yi */
2344 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2345 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2346 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2347 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2348 || (c >= 0xffe0 && c <= 0xffe6)
2349 || (c >= 0x20000 && c <= 0x2fffd)
2350 || (c >= 0x30000 && c <= 0x3fffd)))
2351 return 2;
2353 return 1;
2354 }
2356 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2357 * Illegal bytes are set one. */
2358 static const unsigned char utf8_bytes[256] = {
2359 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,
2360 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,
2361 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,
2362 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,
2363 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,
2364 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,
2365 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,
2366 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,
2367 };
2369 /* Decode UTF-8 multi-byte representation into a unicode character. */
2370 static inline unsigned long
2371 utf8_to_unicode(const char *string, size_t length)
2372 {
2373 unsigned long unicode;
2375 switch (length) {
2376 case 1:
2377 unicode = string[0];
2378 break;
2379 case 2:
2380 unicode = (string[0] & 0x1f) << 6;
2381 unicode += (string[1] & 0x3f);
2382 break;
2383 case 3:
2384 unicode = (string[0] & 0x0f) << 12;
2385 unicode += ((string[1] & 0x3f) << 6);
2386 unicode += (string[2] & 0x3f);
2387 break;
2388 case 4:
2389 unicode = (string[0] & 0x0f) << 18;
2390 unicode += ((string[1] & 0x3f) << 12);
2391 unicode += ((string[2] & 0x3f) << 6);
2392 unicode += (string[3] & 0x3f);
2393 break;
2394 case 5:
2395 unicode = (string[0] & 0x0f) << 24;
2396 unicode += ((string[1] & 0x3f) << 18);
2397 unicode += ((string[2] & 0x3f) << 12);
2398 unicode += ((string[3] & 0x3f) << 6);
2399 unicode += (string[4] & 0x3f);
2400 break;
2401 case 6:
2402 unicode = (string[0] & 0x01) << 30;
2403 unicode += ((string[1] & 0x3f) << 24);
2404 unicode += ((string[2] & 0x3f) << 18);
2405 unicode += ((string[3] & 0x3f) << 12);
2406 unicode += ((string[4] & 0x3f) << 6);
2407 unicode += (string[5] & 0x3f);
2408 break;
2409 default:
2410 die("Invalid unicode length");
2411 }
2413 /* Invalid characters could return the special 0xfffd value but NUL
2414 * should be just as good. */
2415 return unicode > 0xffff ? 0 : unicode;
2416 }
2418 /* Calculates how much of string can be shown within the given maximum width
2419 * and sets trimmed parameter to non-zero value if all of string could not be
2420 * shown.
2421 *
2422 * Additionally, adds to coloffset how many many columns to move to align with
2423 * the expected position. Takes into account how multi-byte and double-width
2424 * characters will effect the cursor position.
2425 *
2426 * Returns the number of bytes to output from string to satisfy max_width. */
2427 static size_t
2428 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2429 {
2430 const char *start = string;
2431 const char *end = strchr(string, '\0');
2432 size_t mbwidth = 0;
2433 size_t width = 0;
2435 *trimmed = 0;
2437 while (string < end) {
2438 int c = *(unsigned char *) string;
2439 unsigned char bytes = utf8_bytes[c];
2440 size_t ucwidth;
2441 unsigned long unicode;
2443 if (string + bytes > end)
2444 break;
2446 /* Change representation to figure out whether
2447 * it is a single- or double-width character. */
2449 unicode = utf8_to_unicode(string, bytes);
2450 /* FIXME: Graceful handling of invalid unicode character. */
2451 if (!unicode)
2452 break;
2454 ucwidth = unicode_width(unicode);
2455 width += ucwidth;
2456 if (width > max_width) {
2457 *trimmed = 1;
2458 break;
2459 }
2461 /* The column offset collects the differences between the
2462 * number of bytes encoding a character and the number of
2463 * columns will be used for rendering said character.
2464 *
2465 * So if some character A is encoded in 2 bytes, but will be
2466 * represented on the screen using only 1 byte this will and up
2467 * adding 1 to the multi-byte column offset.
2468 *
2469 * Assumes that no double-width character can be encoding in
2470 * less than two bytes. */
2471 if (bytes > ucwidth)
2472 mbwidth += bytes - ucwidth;
2474 string += bytes;
2475 }
2477 *coloffset += mbwidth;
2479 return string - start;
2480 }
2483 /*
2484 * Status management
2485 */
2487 /* Whether or not the curses interface has been initialized. */
2488 static bool cursed = FALSE;
2490 /* The status window is used for polling keystrokes. */
2491 static WINDOW *status_win;
2493 /* Update status and title window. */
2494 static void
2495 report(const char *msg, ...)
2496 {
2497 static bool empty = TRUE;
2498 struct view *view = display[current_view];
2500 if (!empty || *msg) {
2501 va_list args;
2503 va_start(args, msg);
2505 werase(status_win);
2506 wmove(status_win, 0, 0);
2507 if (*msg) {
2508 vwprintw(status_win, msg, args);
2509 empty = FALSE;
2510 } else {
2511 empty = TRUE;
2512 }
2513 wrefresh(status_win);
2515 va_end(args);
2516 }
2518 update_view_title(view);
2519 update_display_cursor();
2520 }
2522 /* Controls when nodelay should be in effect when polling user input. */
2523 static void
2524 set_nonblocking_input(bool loading)
2525 {
2526 static unsigned int loading_views;
2528 if ((loading == FALSE && loading_views-- == 1) ||
2529 (loading == TRUE && loading_views++ == 0))
2530 nodelay(status_win, loading);
2531 }
2533 static void
2534 init_display(void)
2535 {
2536 int x, y;
2538 /* Initialize the curses library */
2539 if (isatty(STDIN_FILENO)) {
2540 cursed = !!initscr();
2541 } else {
2542 /* Leave stdin and stdout alone when acting as a pager. */
2543 FILE *io = fopen("/dev/tty", "r+");
2545 cursed = !!newterm(NULL, io, io);
2546 }
2548 if (!cursed)
2549 die("Failed to initialize curses");
2551 nonl(); /* Tell curses not to do NL->CR/NL on output */
2552 cbreak(); /* Take input chars one at a time, no wait for \n */
2553 noecho(); /* Don't echo input */
2554 leaveok(stdscr, TRUE);
2556 if (has_colors())
2557 init_colors();
2559 getmaxyx(stdscr, y, x);
2560 status_win = newwin(1, 0, y - 1, 0);
2561 if (!status_win)
2562 die("Failed to create status window");
2564 /* Enable keyboard mapping */
2565 keypad(status_win, TRUE);
2566 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2567 }
2570 /*
2571 * Repository references
2572 */
2574 static struct ref *refs;
2575 static size_t refs_size;
2577 /* Id <-> ref store */
2578 static struct ref ***id_refs;
2579 static size_t id_refs_size;
2581 static struct ref **
2582 get_refs(char *id)
2583 {
2584 struct ref ***tmp_id_refs;
2585 struct ref **ref_list = NULL;
2586 size_t ref_list_size = 0;
2587 size_t i;
2589 for (i = 0; i < id_refs_size; i++)
2590 if (!strcmp(id, id_refs[i][0]->id))
2591 return id_refs[i];
2593 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2594 if (!tmp_id_refs)
2595 return NULL;
2597 id_refs = tmp_id_refs;
2599 for (i = 0; i < refs_size; i++) {
2600 struct ref **tmp;
2602 if (strcmp(id, refs[i].id))
2603 continue;
2605 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2606 if (!tmp) {
2607 if (ref_list)
2608 free(ref_list);
2609 return NULL;
2610 }
2612 ref_list = tmp;
2613 if (ref_list_size > 0)
2614 ref_list[ref_list_size - 1]->next = 1;
2615 ref_list[ref_list_size] = &refs[i];
2617 /* XXX: The properties of the commit chains ensures that we can
2618 * safely modify the shared ref. The repo references will
2619 * always be similar for the same id. */
2620 ref_list[ref_list_size]->next = 0;
2621 ref_list_size++;
2622 }
2624 if (ref_list)
2625 id_refs[id_refs_size++] = ref_list;
2627 return ref_list;
2628 }
2630 static int
2631 read_ref(char *id, int idlen, char *name, int namelen)
2632 {
2633 struct ref *ref;
2634 bool tag = FALSE;
2635 bool tag_commit = FALSE;
2637 /* Commits referenced by tags has "^{}" appended. */
2638 if (name[namelen - 1] == '}') {
2639 while (namelen > 0 && name[namelen] != '^')
2640 namelen--;
2641 if (namelen > 0)
2642 tag_commit = TRUE;
2643 name[namelen] = 0;
2644 }
2646 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2647 if (!tag_commit)
2648 return OK;
2649 name += STRING_SIZE("refs/tags/");
2650 tag = TRUE;
2652 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2653 name += STRING_SIZE("refs/heads/");
2655 } else if (!strcmp(name, "HEAD")) {
2656 return OK;
2657 }
2659 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2660 if (!refs)
2661 return ERR;
2663 ref = &refs[refs_size++];
2664 ref->name = strdup(name);
2665 if (!ref->name)
2666 return ERR;
2668 ref->tag = tag;
2669 string_copy(ref->id, id);
2671 return OK;
2672 }
2674 static int
2675 load_refs(void)
2676 {
2677 const char *cmd_env = getenv("TIG_LS_REMOTE");
2678 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2680 return read_properties(popen(cmd, "r"), "\t", read_ref);
2681 }
2683 static int
2684 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2685 {
2686 if (!strcmp(name, "i18n.commitencoding")) {
2687 string_copy(opt_encoding, value);
2688 }
2690 return OK;
2691 }
2693 static int
2694 load_repo_config(void)
2695 {
2696 return read_properties(popen("git repo-config --list", "r"),
2697 "=", read_repo_config_option);
2698 }
2700 static int
2701 read_properties(FILE *pipe, const char *separators,
2702 int (*read_property)(char *, int, char *, int))
2703 {
2704 char buffer[BUFSIZ];
2705 char *name;
2706 int state = OK;
2708 if (!pipe)
2709 return ERR;
2711 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2712 char *value;
2713 size_t namelen;
2714 size_t valuelen;
2716 name = chomp_string(name);
2717 namelen = strcspn(name, separators);
2719 if (name[namelen]) {
2720 name[namelen] = 0;
2721 value = chomp_string(name + namelen + 1);
2722 valuelen = strlen(value);
2724 } else {
2725 value = "";
2726 valuelen = 0;
2727 }
2729 if (namelen)
2730 state = read_property(name, namelen, value, valuelen);
2731 }
2733 if (state != ERR && ferror(pipe))
2734 state = ERR;
2736 pclose(pipe);
2738 return state;
2739 }
2742 /*
2743 * Main
2744 */
2746 #if __GNUC__ >= 3
2747 #define __NORETURN __attribute__((__noreturn__))
2748 #else
2749 #define __NORETURN
2750 #endif
2752 static void __NORETURN
2753 quit(int sig)
2754 {
2755 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2756 if (cursed)
2757 endwin();
2758 exit(0);
2759 }
2761 static void __NORETURN
2762 die(const char *err, ...)
2763 {
2764 va_list args;
2766 endwin();
2768 va_start(args, err);
2769 fputs("tig: ", stderr);
2770 vfprintf(stderr, err, args);
2771 fputs("\n", stderr);
2772 va_end(args);
2774 exit(1);
2775 }
2777 int
2778 main(int argc, char *argv[])
2779 {
2780 struct view *view;
2781 enum request request;
2782 size_t i;
2784 signal(SIGINT, quit);
2786 if (load_options() == ERR)
2787 die("Failed to load user config.");
2789 /* Load the repo config file so options can be overwritten from
2790 * the command line. */
2791 if (load_repo_config() == ERR)
2792 die("Failed to load repo config.");
2794 if (!parse_options(argc, argv))
2795 return 0;
2797 if (load_refs() == ERR)
2798 die("Failed to load refs.");
2800 /* Require a git repository unless when running in pager mode. */
2801 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2802 die("Not a git repository");
2804 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2805 view->cmd_env = getenv(view->cmd_env);
2807 request = opt_request;
2809 init_display();
2811 while (view_driver(display[current_view], request)) {
2812 int key;
2813 int i;
2815 foreach_view (view, i)
2816 update_view(view);
2818 /* Refresh, accept single keystroke of input */
2819 key = wgetch(status_win);
2820 request = get_request(key);
2822 /* Some low-level request handling. This keeps access to
2823 * status_win restricted. */
2824 switch (request) {
2825 case REQ_PROMPT:
2826 report(":");
2827 /* Temporarily switch to line-oriented and echoed
2828 * input. */
2829 nocbreak();
2830 echo();
2832 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2833 memcpy(opt_cmd, "git ", 4);
2834 opt_request = REQ_VIEW_PAGER;
2835 } else {
2836 report("Prompt interrupted by loading view, "
2837 "press 'z' to stop loading views");
2838 request = REQ_SCREEN_UPDATE;
2839 }
2841 noecho();
2842 cbreak();
2843 break;
2845 case REQ_SCREEN_RESIZE:
2846 {
2847 int height, width;
2849 getmaxyx(stdscr, height, width);
2851 /* Resize the status view and let the view driver take
2852 * care of resizing the displayed views. */
2853 wresize(status_win, 1, width);
2854 mvwin(status_win, height - 1, 0);
2855 wrefresh(status_win);
2856 break;
2857 }
2858 default:
2859 break;
2860 }
2861 }
2863 quit(0);
2865 return 0;
2866 }
2868 /**
2869 * [[refspec]]
2870 * Revision specification
2871 * ----------------------
2872 * This section describes various ways to specify what revisions to display
2873 * or otherwise limit the view to. tig(1) does not itself parse the described
2874 * revision options so refer to the relevant git man pages for futher
2875 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2876 * git-rev-list(1).
2877 *
2878 * You can tune the interaction with git by making use of the options
2879 * explained in this section. For example, by configuring the environment
2880 * variables described in the <<history-commands, "History commands">>
2881 * section.
2882 *
2883 * Limit by path name
2884 * ~~~~~~~~~~~~~~~~~~
2885 * If you are interested only in those revisions that made changes to a
2886 * specific file (or even several files) list the files like this:
2887 *
2888 * $ tig log Makefile README
2889 *
2890 * To avoid ambiguity with repository references such as tag name, be sure
2891 * to separate file names from other git options using "\--". So if you
2892 * have a file named 'master' it will clash with the reference named
2893 * 'master', and thus you will have to use:
2894 *
2895 * $ tig log -- master
2896 *
2897 * NOTE: For the main view, avoiding ambiguity will in some cases require
2898 * you to specify two "\--" options. The first will make tig(1) stop
2899 * option processing and the latter will be passed to git log.
2900 *
2901 * Limit by date or number
2902 * ~~~~~~~~~~~~~~~~~~~~~~~
2903 * To speed up interaction with git, you can limit the amount of commits
2904 * to show both for the log and main view. Either limit by date using
2905 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2906 *
2907 * If you are only interested in changed that happened between two dates
2908 * you can use:
2909 *
2910 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2911 *
2912 * NOTE: If you want to avoid having to quote dates containing spaces you
2913 * can use "." instead, e.g. `--after=May.5th`.
2914 *
2915 * Limiting by commit ranges
2916 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2917 * Alternatively, commits can be limited to a specific range, such as
2918 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2919 *
2920 * $ tig log tag-1.0..tag-2.0
2921 *
2922 * This way of commit limiting makes it trivial to only browse the commits
2923 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2924 * upstream remote branch, using:
2925 *
2926 * $ tig log origin..HEAD
2927 *
2928 * will list what will be pushed to the remote branch. Optionally, the ending
2929 * 'HEAD' can be left out since it is implied.
2930 *
2931 * Limiting by reachability
2932 * ~~~~~~~~~~~~~~~~~~~~~~~~
2933 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2934 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2935 * Where reachability refers to what commits are ancestors (or part of the
2936 * history) of the branch or tagged revision in question.
2937 *
2938 * If you prefer to specify which commit to preview in this way use the
2939 * following:
2940 *
2941 * $ tig log tag-2.0 ^tag-1.0
2942 *
2943 * You can think of '^' as a negation operator. Using this alternate syntax,
2944 * it is possible to further prune commits by specifying multiple branch
2945 * cut offs.
2946 *
2947 * Combining revisions specification
2948 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2949 * Revisions options can to some degree be combined, which makes it possible
2950 * to say "show at most 20 commits from within the last month that changed
2951 * files under the Documentation/ directory."
2952 *
2953 * $ tig -- --since=1.month -n20 -- Documentation/
2954 *
2955 * Examining all repository references
2956 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2957 * In some cases, it can be useful to query changes across all references
2958 * in a repository. An example is to ask "did any line of development in
2959 * this repository change a particular file within the last week". This
2960 * can be accomplished using:
2961 *
2962 * $ tig -- --all --since=1.week -- Makefile
2963 *
2964 * BUGS
2965 * ----
2966 * Known bugs and problems:
2967 *
2968 * - In it's current state tig is pretty much UTF-8 only.
2969 *
2970 * - If the screen width is very small the main view can draw
2971 * outside the current view causing bad wrapping. Same goes
2972 * for title and status windows.
2973 *
2974 * - The cursor can wrap-around on the last line and cause the
2975 * window to scroll.
2976 *
2977 * - The prompt doesn't work while loading.
2978 *
2979 * TODO
2980 * ----
2981 * Features that should be explored.
2982 *
2983 * - Searching.
2984 *
2985 * - Locale support.
2986 *
2987 * COPYRIGHT
2988 * ---------
2989 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2990 *
2991 * This program is free software; you can redistribute it and/or modify
2992 * it under the terms of the GNU General Public License as published by
2993 * the Free Software Foundation; either version 2 of the License, or
2994 * (at your option) any later version.
2995 *
2996 * SEE ALSO
2997 * --------
2998 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2999 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
3000 *
3001 * Other git repository browsers:
3002 *
3003 * - gitk(1)
3004 * - qgit(1)
3005 * - gitview(1)
3006 **/