~mdw / tig / blob
? search:


982c1cc8a0eee0ce591d10fad17838aae2d62e32
[tig] / tig.c
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 **/
43
44 #ifndef VERSION
45 #define VERSION "tig-0.3"
46 #endif
47
48 #ifndef DEBUG
49 #define NDEBUG
50 #endif
51
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>
62
63 #include <curses.h>
64
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);
70
71 #define ABS(x) ((x) >= 0 ? (x) : -(x))
72 #define MIN(x, y) ((x) < (y) ? (x) : (y))
73
74 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
75 #define STRING_SIZE(x) (sizeof(x) - 1)
76
77 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
78 #define SIZEOF_CMD 1024 /* Size of command buffer. */
79
80 /* This color name can be used to refer to the default term colors. */
81 #define COLOR_DEFAULT (-1)
82
83 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
84
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 ")
88
89 #define AUTHOR_COLS 20
90
91 /* The default interval between line numbers. */
92 #define NUMBER_INTERVAL 1
93
94 #define TABSIZE 8
95
96 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
97
98 /* Some ascii-shorthands fitted into the ncurses namespace. */
99 #define KEY_TAB '\t'
100 #define KEY_RETURN '\r'
101 #define KEY_ESC 27
102
103
104 /* User action requests. */
105 enum request {
106 /* Offset all requests to avoid conflicts with ncurses getch values. */
107 REQ_OFFSET = KEY_MAX + 1,
108
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,
115
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,
129
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,
136
137 REQ_SCROLL_LINE_UP,
138 REQ_SCROLL_LINE_DOWN,
139 REQ_SCROLL_PAGE_UP,
140 REQ_SCROLL_PAGE_DOWN,
141 };
142
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 };
149
150 static struct ref **get_refs(char *id);
151
152 struct int_map {
153 const char *name;
154 int namelen;
155 int value;
156 };
157
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 {
162
163 int i;
164
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 }
171
172 return ERR;
173 }
174
175
176 /*
177 * String helpers
178 */
179
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;
185
186 }
187
188 /* Shorthand for safely copying into a fixed buffer. */
189 #define string_copy(dst, src) \
190 string_ncopy(dst, src, sizeof(dst))
191
192 static char *
193 chomp_string(char *name)
194 {
195 int namelen;
196
197 while (isspace(*name))
198 name++;
199
200 namelen = strlen(name) - 1;
201 while (namelen > 0 && isspace(name[namelen]))
202 name[namelen--] = 0;
203
204 return name;
205 }
206
207
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 */
224
225 static size_t
226 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
227 {
228 char c;
229
230 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
231
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('\'');
244
245 return bufsize;
246 }
247
248
249 /**
250 * OPTIONS
251 * -------
252 **/
253
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";
272
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;
282
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;
288
289 for (i = 1; i < argc; i++) {
290 char *opt = argv[i];
291
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 }
300
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 }
309
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;
318
319 if (opt[1] == 'n') {
320 num = opt + 2;
321
322 } else if (opt[STRING_SIZE("--line-number")] == '=') {
323 num = opt + STRING_SIZE("--line-number=");
324 }
325
326 if (isdigit(*num))
327 opt_num_interval = atoi(num);
328
329 opt_line_number = TRUE;
330 continue;
331 }
332
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;
340
341 if (opt[1] == 'b') {
342 num = opt + 2;
343
344 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
345 num = opt + STRING_SIZE("--tab-size=");
346 }
347
348 if (isdigit(*num))
349 opt_tab_size = MIN(atoi(num), TABSIZE);
350 continue;
351 }
352
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 }
362
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 }
372
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 }
384
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 }
402
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;
415
416 die("unknown command '%s'", opt);
417 }
418
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;
433
434 } else if (i < argc) {
435 size_t buf_size;
436
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 **/
458
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);
466
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 }
471
472 if (buf_size >= sizeof(opt_cmd))
473 die("command too long");
474
475 opt_cmd[buf_size] = 0;
476
477 }
478
479 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
480 opt_utf8 = FALSE;
481
482 return TRUE;
483 }
484
485
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 **/
510
511 #define TIG_LS_REMOTE \
512 "git ls-remote . 2>/dev/null"
513
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 **/
543
544 #define TIG_DIFF_CMD \
545 "git show --patch-with-stat --find-copies-harder -B -C %s"
546
547 #define TIG_LOG_CMD \
548 "git log --cc --stat -n100 %s"
549
550 #define TIG_MAIN_CMD \
551 "git log --topo-order --stat --pretty=raw %s"
552
553 /* ... silently ignore that the following are also exported. */
554
555 #define TIG_HELP_CMD \
556 "man tig 2>/dev/null"
557
558 #define TIG_PAGER_CMD \
559 ""
560
561
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 * Some sample options:
586 *
587 * ==========================================================================
588 * # Diff colors
589 * color diff-header yellow default
590 * color diff-index blue default
591 * color diff-chunk magenta default
592 * # UI colors
593 * color title-blur white blue
594 * color title-focus white blue bold
595 * ==========================================================================
596 *
597 * [[color-options]]
598 * Color options
599 * ~~~~~~~~~~~~~
600 * Color options control highlighting and the user interface styles.
601 * If your terminal supports color, these commands can be used to assign
602 * foreground/backgound combinations to certain areas. Optionally, an
603 * attribute can be given as the last parameter. The syntax is:
604 *
605 * [verse]
606 * ..........................................................................
607 * *color* 'area' 'fgcolor' 'bgcolor' '[attributes]'
608 * ..........................................................................
609 *
610 * Valid colors include: *white*, *black*, *green*, *magenta*, *blue*, *cyan*,
611 * *yellow*, *red*, *default*. Use *default* to refer to the default terminal
612 * colors.
613 **/
614
615 static struct int_map color_map[] = {
616 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
617 COLOR_MAP(DEFAULT),
618 COLOR_MAP(BLACK),
619 COLOR_MAP(BLUE),
620 COLOR_MAP(CYAN),
621 COLOR_MAP(GREEN),
622 COLOR_MAP(MAGENTA),
623 COLOR_MAP(RED),
624 COLOR_MAP(WHITE),
625 COLOR_MAP(YELLOW),
626 };
627
628 /**
629 * Valid attributes include: *normal*, *blink*, *bold*, *dim*, *reverse*, *standout*,
630 * and *underline*. Note, not all attributes may be supported by the terminal.
631 **/
632
633 static struct int_map attr_map[] = {
634 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
635 ATTR_MAP(NORMAL),
636 ATTR_MAP(BLINK),
637 ATTR_MAP(BOLD),
638 ATTR_MAP(DIM),
639 ATTR_MAP(REVERSE),
640 ATTR_MAP(STANDOUT),
641 ATTR_MAP(UNDERLINE),
642 };
643
644 /**
645 * Valid area names are described below. Note, all names are case-insensitive,
646 * and you may use '-', '_', and '.' interchangeably. So "Diff-Header",
647 * "DIFF_HEADER", and "diff.header" are the same.
648 *
649 * --
650 **/
651 #define LINE_INFO \
652 /**
653 * Diff markup::
654 *
655 * Options concerning diff start, chunks and lines added and deleted.
656 *
657 * *diff-header*, *diff-chunk*, *diff-add*, *diff-del*
658 **/ \
659 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
660 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
661 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
662 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
663 /**
664 * Enhanced git diff markup::
665 *
666 * Extra diff information emitted by the git diff machinery, such as mode
667 * changes, rename detection, and similarity.
668 *
669 * *diff-oldmode*, *diff-newmode*, *diff-copy-from*, *diff-copy-to*,
670 * *diff-rename-from*, *diff-rename-to*, *diff-similarity* *diff-dissimilarity*
671 * *diff-tree*, *diff-index*
672 **/ \
673 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
674 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
675 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
676 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
677 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
678 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
679 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
680 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
681 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
682 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
683 /**
684 * Pretty print commit headers::
685 *
686 * Commit diffs and the revision logs are usually formatted using pretty
687 * printed headers , unless `--pretty=raw` was given. This includes lines,
688 * such as merge info, commit ID, and author and comitter date.
689 *
690 * *pp-author*, *pp-commit*, *pp-merge*, *pp-date*, *pp-adate*, *pp-cdate*
691 **/ \
692 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
693 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
694 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
695 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
696 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
697 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
698 /**
699 * Raw commit header::
700 *
701 * Usually shown when `--pretty=raw` is given, however 'commit' is pretty
702 * much omnipresent.
703 *
704 * *commit*, *parent*, *tree*, *author*, *committer*
705 **/ \
706 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
707 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
708 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
709 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
710 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
711 /**
712 * Commit message::
713 *
714 * For now only `Signed-off-by lines` are colorized.
715 *
716 * *signoff*
717 **/ \
718 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
719 /**
720 * UI colors::
721 *
722 * Colors for text not matching any of the above: *default*
723 *
724 * Status window colors: *status*
725 *
726 * Title window colors: *title-blur*, *title-focus*
727 *
728 * Cursor line colors: *cursor*
729 *
730 * Main view specific: *main-date*, *main-author*, *main-commit*, *main-delim*,
731 * *main-tag*, *main-ref*
732 **/ \
733 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
734 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
735 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
736 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
737 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
738 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
739 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
740 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
741 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
742 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
743 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
744 /**
745 * --
746 **/
747
748
749 /*
750 * Line-oriented content detection.
751 */
752
753 enum line_type {
754 #define LINE(type, line, fg, bg, attr) \
755 LINE_##type
756 LINE_INFO
757 #undef LINE
758 };
759
760 struct line_info {
761 const char *name; /* Option name. */
762 int namelen; /* Size of option name. */
763 const char *line; /* The start of line to match. */
764 int linelen; /* Size of string to match. */
765 int fg, bg, attr; /* Color and text attributes for the lines. */
766 };
767
768 static struct line_info line_info[] = {
769 #define LINE(type, line, fg, bg, attr) \
770 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
771 LINE_INFO
772 #undef LINE
773 };
774
775 static enum line_type
776 get_line_type(char *line)
777 {
778 int linelen = strlen(line);
779 enum line_type type;
780
781 for (type = 0; type < ARRAY_SIZE(line_info); type++)
782 /* Case insensitive search matches Signed-off-by lines better. */
783 if (linelen >= line_info[type].linelen &&
784 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
785 return type;
786
787 return LINE_DEFAULT;
788 }
789
790 static inline int
791 get_line_attr(enum line_type type)
792 {
793 assert(type < ARRAY_SIZE(line_info));
794 return COLOR_PAIR(type) | line_info[type].attr;
795 }
796
797 static struct line_info *
798 get_line_info(char *name, int namelen)
799 {
800 enum line_type type;
801 int i;
802
803 /* Diff-Header -> DIFF_HEADER */
804 for (i = 0; i < namelen; i++) {
805 if (name[i] == '-')
806 name[i] = '_';
807 else if (name[i] == '.')
808 name[i] = '_';
809 }
810
811 for (type = 0; type < ARRAY_SIZE(line_info); type++)
812 if (namelen == line_info[type].namelen &&
813 !strncasecmp(line_info[type].name, name, namelen))
814 return &line_info[type];
815
816 return NULL;
817 }
818
819 static void
820 init_colors(void)
821 {
822 int default_bg = COLOR_BLACK;
823 int default_fg = COLOR_WHITE;
824 enum line_type type;
825
826 start_color();
827
828 if (use_default_colors() != ERR) {
829 default_bg = -1;
830 default_fg = -1;
831 }
832
833 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
834 struct line_info *info = &line_info[type];
835 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
836 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
837
838 init_pair(type, fg, bg);
839 }
840 }
841
842 struct line {
843 enum line_type type;
844 void *data; /* User data */
845 };
846
847
848 /*
849 * User config file handling.
850 */
851
852 #define set_color(color, name, namelen) \
853 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, namelen)
854
855 #define set_attribute(attr, name, namelen) \
856 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, namelen)
857
858 static int
859 read_option(char *opt, int optlen, char *value, int valuelen)
860 {
861 optlen = strcspn(opt, "#;");
862 if (optlen == 0) {
863 /* The whole line is a comment. */
864 return OK;
865
866 } else if (opt[optlen] != 0) {
867 /* Part of the option name is a comment, so the value part
868 * should be ignored. */
869 valuelen = 0;
870 opt[optlen] = value[valuelen] = 0;
871 } else {
872 /* Else look for comment endings in the value. */
873 valuelen = strcspn(value, "#;");
874 value[valuelen] = 0;
875 }
876
877 /* Reads: "color" object fgcolor bgcolor [attr] */
878 if (!strcmp(opt, "color")) {
879 struct line_info *info;
880
881 value = chomp_string(value);
882 valuelen = strcspn(value, " \t");
883 info = get_line_info(value, valuelen);
884 if (!info)
885 return ERR;
886
887 value = chomp_string(value + valuelen);
888 valuelen = strcspn(value, " \t");
889 if (set_color(&info->fg, value, valuelen) == ERR)
890 return ERR;
891
892 value = chomp_string(value + valuelen);
893 valuelen = strcspn(value, " \t");
894 if (set_color(&info->bg, value, valuelen) == ERR)
895 return ERR;
896
897 value = chomp_string(value + valuelen);
898 if (*value &&
899 set_attribute(&info->attr, value, strlen(value)) == ERR)
900 return ERR;
901
902 return OK;
903 }
904
905 return ERR;
906 }
907
908 static int
909 load_options(void)
910 {
911 char *home = getenv("HOME");
912 char buf[1024];
913 FILE *file;
914
915 if (!home ||
916 snprintf(buf, sizeof(buf), "%s/.tig", home) >= sizeof(buf))
917 return ERR;
918
919 /* It's ok that the file doesn't exist. */
920 file = fopen(buf, "r");
921 if (!file)
922 return OK;
923
924 return read_properties(file, " \t", read_option);
925 }
926
927
928 /**
929 * The viewer
930 * ----------
931 * The display consists of a status window on the last line of the screen and
932 * one or more views. The default is to only show one view at the time but it
933 * is possible to split both the main and log view to also show the commit
934 * diff.
935 *
936 * If you are in the log view and press 'Enter' when the current line is a
937 * commit line, such as:
938 *
939 * commit 4d55caff4cc89335192f3e566004b4ceef572521
940 *
941 * You will split the view so that the log view is displayed in the top window
942 * and the diff view in the bottom window. You can switch between the two
943 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
944 **/
945
946 struct view;
947 struct view_ops;
948
949 /* The display array of active views and the index of the current view. */
950 static struct view *display[2];
951 static unsigned int current_view;
952
953 #define foreach_view(view, i) \
954 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
955
956 #define displayed_views() (display[1] != NULL ? 2 : 1)
957
958 /**
959 * Current head and commit ID
960 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
961 * The viewer keeps track of both what head and commit ID you are currently
962 * viewing. The commit ID will follow the cursor line and change everytime time
963 * you highlight a different commit. Whenever you reopen the diff view it
964 * will be reloaded, if the commit ID changed.
965 *
966 * The head ID is used when opening the main and log view to indicate from
967 * what revision to show history.
968 **/
969
970 static char ref_commit[SIZEOF_REF] = "HEAD";
971 static char ref_head[SIZEOF_REF] = "HEAD";
972
973 struct view {
974 const char *name; /* View name */
975 const char *cmd_fmt; /* Default command line format */
976 const char *cmd_env; /* Command line set via environment */
977 const char *id; /* Points to either of ref_{head,commit} */
978
979 struct view_ops *ops; /* View operations */
980
981 char cmd[SIZEOF_CMD]; /* Command buffer */
982 char ref[SIZEOF_REF]; /* Hovered commit reference */
983 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
984
985 int height, width; /* The width and height of the main window */
986 WINDOW *win; /* The main window */
987 WINDOW *title; /* The title window living below the main window */
988
989 /* Navigation */
990 unsigned long offset; /* Offset of the window top */
991 unsigned long lineno; /* Current line number */
992
993 /* If non-NULL, points to the view that opened this view. If this view
994 * is closed tig will switch back to the parent view. */
995 struct view *parent;
996
997 /* Buffering */
998 unsigned long lines; /* Total number of lines */
999 struct line *line; /* Line index */
1000 unsigned int digits; /* Number of digits in the lines member. */
1001
1002 /* Loading */
1003 FILE *pipe;
1004 time_t start_time;
1005 };
1006
1007 struct view_ops {
1008 /* What type of content being displayed. Used in the title bar. */
1009 const char *type;
1010 /* Draw one line; @lineno must be < view->height. */
1011 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1012 /* Read one line; updates view->line. */
1013 bool (*read)(struct view *view, struct line *prev, char *data);
1014 /* Depending on view, change display based on current line. */
1015 bool (*enter)(struct view *view, struct line *line);
1016 };
1017
1018 static struct view_ops pager_ops;
1019 static struct view_ops main_ops;
1020
1021 #define VIEW_STR(name, cmd, env, ref, ops) \
1022 { name, cmd, #env, ref, ops }
1023
1024 #define VIEW_(id, name, ops, ref) \
1025 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
1026
1027 /**
1028 * Views
1029 * ~~~~~
1030 * tig(1) presents various 'views' of a repository. Each view is based on output
1031 * from an external command, most often 'git log', 'git diff', or 'git show'.
1032 *
1033 * The main view::
1034 * Is the default view, and it shows a one line summary of each commit
1035 * in the chosen list of revisions. The summary includes commit date,
1036 * author, and the first line of the log message. Additionally, any
1037 * repository references, such as tags, will be shown.
1038 *
1039 * The log view::
1040 * Presents a more rich view of the revision log showing the whole log
1041 * message and the diffstat.
1042 *
1043 * The diff view::
1044 * Shows either the diff of the current working tree, that is, what
1045 * has changed since the last commit, or the commit diff complete
1046 * with log message, diffstat and diff.
1047 *
1048 * The pager view::
1049 * Is used for displaying both input from stdin and output from git
1050 * commands entered in the internal prompt.
1051 *
1052 * The help view::
1053 * Displays the information from the tig(1) man page. For the help view
1054 * to work you need to have the tig(1) man page installed.
1055 **/
1056
1057 static struct view views[] = {
1058 VIEW_(MAIN, "main", &main_ops, ref_head),
1059 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1060 VIEW_(LOG, "log", &pager_ops, ref_head),
1061 VIEW_(HELP, "help", &pager_ops, "static"),
1062 VIEW_(PAGER, "pager", &pager_ops, "static"),
1063 };
1064
1065 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1066
1067
1068 static bool
1069 draw_view_line(struct view *view, unsigned int lineno)
1070 {
1071 if (view->offset + lineno >= view->lines)
1072 return FALSE;
1073
1074 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
1075 }
1076
1077 static void
1078 redraw_view_from(struct view *view, int lineno)
1079 {
1080 assert(0 <= lineno && lineno < view->height);
1081
1082 for (; lineno < view->height; lineno++) {
1083 if (!draw_view_line(view, lineno))
1084 break;
1085 }
1086
1087 redrawwin(view->win);
1088 wrefresh(view->win);
1089 }
1090
1091 static void
1092 redraw_view(struct view *view)
1093 {
1094 wclear(view->win);
1095 redraw_view_from(view, 0);
1096 }
1097
1098
1099 /**
1100 * Title windows
1101 * ~~~~~~~~~~~~~
1102 * Each view has a title window which shows the name of the view, current
1103 * commit ID if available, and where the view is positioned:
1104 *
1105 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
1106 *
1107 * By default, the title of the current view is highlighted using bold font.
1108 * For long loading views (taking over 3 seconds) the time since loading
1109 * started will be appended:
1110 *
1111 * [main] 77d9e40fbcea3238015aea403e06f61542df9a31 - commit 1 of 779 (0%) 5s
1112 **/
1113
1114 static void
1115 update_view_title(struct view *view)
1116 {
1117 if (view == display[current_view])
1118 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1119 else
1120 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1121
1122 werase(view->title);
1123 wmove(view->title, 0, 0);
1124
1125 if (*view->ref)
1126 wprintw(view->title, "[%s] %s", view->name, view->ref);
1127 else
1128 wprintw(view->title, "[%s]", view->name);
1129
1130 if (view->lines || view->pipe) {
1131 unsigned int lines = view->lines
1132 ? (view->lineno + 1) * 100 / view->lines
1133 : 0;
1134
1135 wprintw(view->title, " - %s %d of %d (%d%%)",
1136 view->ops->type,
1137 view->lineno + 1,
1138 view->lines,
1139 lines);
1140 }
1141
1142 if (view->pipe) {
1143 time_t secs = time(NULL) - view->start_time;
1144
1145 /* Three git seconds are a long time ... */
1146 if (secs > 2)
1147 wprintw(view->title, " %lds", secs);
1148 }
1149
1150 wmove(view->title, 0, view->width - 1);
1151 wrefresh(view->title);
1152 }
1153
1154 static void
1155 resize_display(void)
1156 {
1157 int offset, i;
1158 struct view *base = display[0];
1159 struct view *view = display[1] ? display[1] : display[0];
1160
1161 /* Setup window dimensions */
1162
1163 getmaxyx(stdscr, base->height, base->width);
1164
1165 /* Make room for the status window. */
1166 base->height -= 1;
1167
1168 if (view != base) {
1169 /* Horizontal split. */
1170 view->width = base->width;
1171 view->height = SCALE_SPLIT_VIEW(base->height);
1172 base->height -= view->height;
1173
1174 /* Make room for the title bar. */
1175 view->height -= 1;
1176 }
1177
1178 /* Make room for the title bar. */
1179 base->height -= 1;
1180
1181 offset = 0;
1182
1183 foreach_view (view, i) {
1184 if (!view->win) {
1185 view->win = newwin(view->height, 0, offset, 0);
1186 if (!view->win)
1187 die("Failed to create %s view", view->name);
1188
1189 scrollok(view->win, TRUE);
1190
1191 view->title = newwin(1, 0, offset + view->height, 0);
1192 if (!view->title)
1193 die("Failed to create title window");
1194
1195 } else {
1196 wresize(view->win, view->height, view->width);
1197 mvwin(view->win, offset, 0);
1198 mvwin(view->title, offset + view->height, 0);
1199 }
1200
1201 offset += view->height + 1;
1202 }
1203 }
1204
1205 static void
1206 redraw_display(void)
1207 {
1208 struct view *view;
1209 int i;
1210
1211 foreach_view (view, i) {
1212 redraw_view(view);
1213 update_view_title(view);
1214 }
1215 }
1216
1217 static void
1218 update_display_cursor(void)
1219 {
1220 struct view *view = display[current_view];
1221
1222 /* Move the cursor to the right-most column of the cursor line.
1223 *
1224 * XXX: This could turn out to be a bit expensive, but it ensures that
1225 * the cursor does not jump around. */
1226 if (view->lines) {
1227 wmove(view->win, view->lineno - view->offset, view->width - 1);
1228 wrefresh(view->win);
1229 }
1230 }
1231
1232 /*
1233 * Navigation
1234 */
1235
1236 /* Scrolling backend */
1237 static void
1238 do_scroll_view(struct view *view, int lines, bool redraw)
1239 {
1240 /* The rendering expects the new offset. */
1241 view->offset += lines;
1242
1243 assert(0 <= view->offset && view->offset < view->lines);
1244 assert(lines);
1245
1246 /* Redraw the whole screen if scrolling is pointless. */
1247 if (view->height < ABS(lines)) {
1248 redraw_view(view);
1249
1250 } else {
1251 int line = lines > 0 ? view->height - lines : 0;
1252 int end = line + ABS(lines);
1253
1254 wscrl(view->win, lines);
1255
1256 for (; line < end; line++) {
1257 if (!draw_view_line(view, line))
1258 break;
1259 }
1260 }
1261
1262 /* Move current line into the view. */
1263 if (view->lineno < view->offset) {
1264 view->lineno = view->offset;
1265 draw_view_line(view, 0);
1266
1267 } else if (view->lineno >= view->offset + view->height) {
1268 if (view->lineno == view->offset + view->height) {
1269 /* Clear the hidden line so it doesn't show if the view
1270 * is scrolled up. */
1271 wmove(view->win, view->height, 0);
1272 wclrtoeol(view->win);
1273 }
1274 view->lineno = view->offset + view->height - 1;
1275 draw_view_line(view, view->lineno - view->offset);
1276 }
1277
1278 assert(view->offset <= view->lineno && view->lineno < view->lines);
1279
1280 if (!redraw)
1281 return;
1282
1283 redrawwin(view->win);
1284 wrefresh(view->win);
1285 report("");
1286 }
1287
1288 /* Scroll frontend */
1289 static void
1290 scroll_view(struct view *view, enum request request)
1291 {
1292 int lines = 1;
1293
1294 switch (request) {
1295 case REQ_SCROLL_PAGE_DOWN:
1296 lines = view->height;
1297 case REQ_SCROLL_LINE_DOWN:
1298 if (view->offset + lines > view->lines)
1299 lines = view->lines - view->offset;
1300
1301 if (lines == 0 || view->offset + view->height >= view->lines) {
1302 report("Cannot scroll beyond the last line");
1303 return;
1304 }
1305 break;
1306
1307 case REQ_SCROLL_PAGE_UP:
1308 lines = view->height;
1309 case REQ_SCROLL_LINE_UP:
1310 if (lines > view->offset)
1311 lines = view->offset;
1312
1313 if (lines == 0) {
1314 report("Cannot scroll beyond the first line");
1315 return;
1316 }
1317
1318 lines = -lines;
1319 break;
1320
1321 default:
1322 die("request %d not handled in switch", request);
1323 }
1324
1325 do_scroll_view(view, lines, TRUE);
1326 }
1327
1328 /* Cursor moving */
1329 static void
1330 move_view(struct view *view, enum request request, bool redraw)
1331 {
1332 int steps;
1333
1334 switch (request) {
1335 case REQ_MOVE_FIRST_LINE:
1336 steps = -view->lineno;
1337 break;
1338
1339 case REQ_MOVE_LAST_LINE:
1340 steps = view->lines - view->lineno - 1;
1341 break;
1342
1343 case REQ_MOVE_PAGE_UP:
1344 steps = view->height > view->lineno
1345 ? -view->lineno : -view->height;
1346 break;
1347
1348 case REQ_MOVE_PAGE_DOWN:
1349 steps = view->lineno + view->height >= view->lines
1350 ? view->lines - view->lineno - 1 : view->height;
1351 break;
1352
1353 case REQ_MOVE_UP:
1354 steps = -1;
1355 break;
1356
1357 case REQ_MOVE_DOWN:
1358 steps = 1;
1359 break;
1360
1361 default:
1362 die("request %d not handled in switch", request);
1363 }
1364
1365 if (steps <= 0 && view->lineno == 0) {
1366 report("Cannot move beyond the first line");
1367 return;
1368
1369 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1370 report("Cannot move beyond the last line");
1371 return;
1372 }
1373
1374 /* Move the current line */
1375 view->lineno += steps;
1376 assert(0 <= view->lineno && view->lineno < view->lines);
1377
1378 /* Repaint the old "current" line if we be scrolling */
1379 if (ABS(steps) < view->height) {
1380 int prev_lineno = view->lineno - steps - view->offset;
1381
1382 wmove(view->win, prev_lineno, 0);
1383 wclrtoeol(view->win);
1384 draw_view_line(view, prev_lineno);
1385 }
1386
1387 /* Check whether the view needs to be scrolled */
1388 if (view->lineno < view->offset ||
1389 view->lineno >= view->offset + view->height) {
1390 if (steps < 0 && -steps > view->offset) {
1391 steps = -view->offset;
1392
1393 } else if (steps > 0) {
1394 if (view->lineno == view->lines - 1 &&
1395 view->lines > view->height) {
1396 steps = view->lines - view->offset - 1;
1397 if (steps >= view->height)
1398 steps -= view->height - 1;
1399 }
1400 }
1401
1402 do_scroll_view(view, steps, redraw);
1403 return;
1404 }
1405
1406 /* Draw the current line */
1407 draw_view_line(view, view->lineno - view->offset);
1408
1409 if (!redraw)
1410 return;
1411
1412 redrawwin(view->win);
1413 wrefresh(view->win);
1414 report("");
1415 }
1416
1417
1418 /*
1419 * Incremental updating
1420 */
1421
1422 static void
1423 end_update(struct view *view)
1424 {
1425 if (!view->pipe)
1426 return;
1427 set_nonblocking_input(FALSE);
1428 if (view->pipe == stdin)
1429 fclose(view->pipe);
1430 else
1431 pclose(view->pipe);
1432 view->pipe = NULL;
1433 }
1434
1435 static bool
1436 begin_update(struct view *view)
1437 {
1438 const char *id = view->id;
1439
1440 if (view->pipe)
1441 end_update(view);
1442
1443 if (opt_cmd[0]) {
1444 string_copy(view->cmd, opt_cmd);
1445 opt_cmd[0] = 0;
1446 /* When running random commands, the view ref could have become
1447 * invalid so clear it. */
1448 view->ref[0] = 0;
1449 } else {
1450 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1451
1452 if (snprintf(view->cmd, sizeof(view->cmd), format,
1453 id, id, id, id, id) >= sizeof(view->cmd))
1454 return FALSE;
1455 }
1456
1457 /* Special case for the pager view. */
1458 if (opt_pipe) {
1459 view->pipe = opt_pipe;
1460 opt_pipe = NULL;
1461 } else {
1462 view->pipe = popen(view->cmd, "r");
1463 }
1464
1465 if (!view->pipe)
1466 return FALSE;
1467
1468 set_nonblocking_input(TRUE);
1469
1470 view->offset = 0;
1471 view->lines = 0;
1472 view->lineno = 0;
1473 string_copy(view->vid, id);
1474
1475 if (view->line) {
1476 int i;
1477
1478 for (i = 0; i < view->lines; i++)
1479 if (view->line[i].data)
1480 free(view->line[i].data);
1481
1482 free(view->line);
1483 view->line = NULL;
1484 }
1485
1486 view->start_time = time(NULL);
1487
1488 return TRUE;
1489 }
1490
1491 static bool
1492 update_view(struct view *view)
1493 {
1494 char buffer[BUFSIZ];
1495 char *line;
1496 struct line *tmp;
1497 /* The number of lines to read. If too low it will cause too much
1498 * redrawing (and possible flickering), if too high responsiveness
1499 * will suffer. */
1500 unsigned long lines = view->height;
1501 int redraw_from = -1;
1502
1503 if (!view->pipe)
1504 return TRUE;
1505
1506 /* Only redraw if lines are visible. */
1507 if (view->offset + view->height >= view->lines)
1508 redraw_from = view->lines - view->offset;
1509
1510 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1511 if (!tmp)
1512 goto alloc_error;
1513
1514 view->line = tmp;
1515
1516 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1517 int linelen = strlen(line);
1518
1519 struct line *prev = view->lines
1520 ? &view->line[view->lines - 1]
1521 : NULL;
1522
1523 if (linelen)
1524 line[linelen - 1] = 0;
1525
1526 if (!view->ops->read(view, prev, line))
1527 goto alloc_error;
1528
1529 if (lines-- == 1)
1530 break;
1531 }
1532
1533 {
1534 int digits;
1535
1536 lines = view->lines;
1537 for (digits = 0; lines; digits++)
1538 lines /= 10;
1539
1540 /* Keep the displayed view in sync with line number scaling. */
1541 if (digits != view->digits) {
1542 view->digits = digits;
1543 redraw_from = 0;
1544 }
1545 }
1546
1547 if (redraw_from >= 0) {
1548 /* If this is an incremental update, redraw the previous line
1549 * since for commits some members could have changed when
1550 * loading the main view. */
1551 if (redraw_from > 0)
1552 redraw_from--;
1553
1554 /* Incrementally draw avoids flickering. */
1555 redraw_view_from(view, redraw_from);
1556 }
1557
1558 /* Update the title _after_ the redraw so that if the redraw picks up a
1559 * commit reference in view->ref it'll be available here. */
1560 update_view_title(view);
1561
1562 if (ferror(view->pipe)) {
1563 report("Failed to read: %s", strerror(errno));
1564 goto end;
1565
1566 } else if (feof(view->pipe)) {
1567 if (view == VIEW(REQ_VIEW_HELP)) {
1568 const char *msg = TIG_HELP;
1569
1570 if (view->lines == 0) {
1571 /* Slightly ugly, but abusing view->ref keeps
1572 * the error message. */
1573 string_copy(view->ref, "No help available");
1574 msg = "The tig(1) manpage is not installed";
1575 }
1576
1577 report("%s", msg);
1578 goto end;
1579 }
1580
1581 report("");
1582 goto end;
1583 }
1584
1585 return TRUE;
1586
1587 alloc_error:
1588 report("Allocation failure");
1589
1590 end:
1591 end_update(view);
1592 return FALSE;
1593 }
1594
1595 enum open_flags {
1596 OPEN_DEFAULT = 0, /* Use default view switching. */
1597 OPEN_SPLIT = 1, /* Split current view. */
1598 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1599 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1600 };
1601
1602 static void
1603 open_view(struct view *prev, enum request request, enum open_flags flags)
1604 {
1605 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1606 bool split = !!(flags & OPEN_SPLIT);
1607 bool reload = !!(flags & OPEN_RELOAD);
1608 struct view *view = VIEW(request);
1609 int nviews = displayed_views();
1610 struct view *base_view = display[0];
1611
1612 if (view == prev && nviews == 1 && !reload) {
1613 report("Already in %s view", view->name);
1614 return;
1615 }
1616
1617 if ((reload || strcmp(view->vid, view->id)) &&
1618 !begin_update(view)) {
1619 report("Failed to load %s view", view->name);
1620 return;
1621 }
1622
1623 if (split) {
1624 display[current_view + 1] = view;
1625 if (!backgrounded)
1626 current_view++;
1627 } else {
1628 /* Maximize the current view. */
1629 memset(display, 0, sizeof(display));
1630 current_view = 0;
1631 display[current_view] = view;
1632 }
1633
1634 /* Resize the view when switching between split- and full-screen,
1635 * or when switching between two different full-screen views. */
1636 if (nviews != displayed_views() ||
1637 (nviews == 1 && base_view != display[0]))
1638 resize_display();
1639
1640 if (split && prev->lineno - prev->offset >= prev->height) {
1641 /* Take the title line into account. */
1642 int lines = prev->lineno - prev->offset - prev->height + 1;
1643
1644 /* Scroll the view that was split if the current line is
1645 * outside the new limited view. */
1646 do_scroll_view(prev, lines, TRUE);
1647 }
1648
1649 if (prev && view != prev) {
1650 if (split && !backgrounded) {
1651 /* "Blur" the previous view. */
1652 update_view_title(prev);
1653 }
1654
1655 view->parent = prev;
1656 }
1657
1658 if (view->pipe && view->lines == 0) {
1659 /* Clear the old view and let the incremental updating refill
1660 * the screen. */
1661 wclear(view->win);
1662 report("");
1663 } else {
1664 redraw_view(view);
1665 if (view == VIEW(REQ_VIEW_HELP))
1666 report("%s", TIG_HELP);
1667 else
1668 report("");
1669 }
1670
1671 /* If the view is backgrounded the above calls to report()
1672 * won't redraw the view title. */
1673 if (backgrounded)
1674 update_view_title(view);
1675 }
1676
1677
1678 /*
1679 * User request switch noodle
1680 */
1681
1682 static int
1683 view_driver(struct view *view, enum request request)
1684 {
1685 int i;
1686
1687 switch (request) {
1688 case REQ_MOVE_UP:
1689 case REQ_MOVE_DOWN:
1690 case REQ_MOVE_PAGE_UP:
1691 case REQ_MOVE_PAGE_DOWN:
1692 case REQ_MOVE_FIRST_LINE:
1693 case REQ_MOVE_LAST_LINE:
1694 move_view(view, request, TRUE);
1695 break;
1696
1697 case REQ_SCROLL_LINE_DOWN:
1698 case REQ_SCROLL_LINE_UP:
1699 case REQ_SCROLL_PAGE_DOWN:
1700 case REQ_SCROLL_PAGE_UP:
1701 scroll_view(view, request);
1702 break;
1703
1704 case REQ_VIEW_MAIN:
1705 case REQ_VIEW_DIFF:
1706 case REQ_VIEW_LOG:
1707 case REQ_VIEW_HELP:
1708 case REQ_VIEW_PAGER:
1709 open_view(view, request, OPEN_DEFAULT);
1710 break;
1711
1712 case REQ_NEXT:
1713 case REQ_PREVIOUS:
1714 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1715
1716 if (view == VIEW(REQ_VIEW_DIFF) &&
1717 view->parent == VIEW(REQ_VIEW_MAIN)) {
1718 bool redraw = display[1] == view;
1719
1720 view = view->parent;
1721 move_view(view, request, redraw);
1722 if (redraw)
1723 update_view_title(view);
1724 } else {
1725 move_view(view, request, TRUE);
1726 break;
1727 }
1728 /* Fall-through */
1729
1730 case REQ_ENTER:
1731 if (!view->lines) {
1732 report("Nothing to enter");
1733 break;
1734 }
1735 return view->ops->enter(view, &view->line[view->lineno]);
1736
1737 case REQ_VIEW_NEXT:
1738 {
1739 int nviews = displayed_views();
1740 int next_view = (current_view + 1) % nviews;
1741
1742 if (next_view == current_view) {
1743 report("Only one view is displayed");
1744 break;
1745 }
1746
1747 current_view = next_view;
1748 /* Blur out the title of the previous view. */
1749 update_view_title(view);
1750 report("");
1751 break;
1752 }
1753 case REQ_TOGGLE_LINE_NUMBERS:
1754 opt_line_number = !opt_line_number;
1755 redraw_display();
1756 break;
1757
1758 case REQ_PROMPT:
1759 /* Always reload^Wrerun commands from the prompt. */
1760 open_view(view, opt_request, OPEN_RELOAD);
1761 break;
1762
1763 case REQ_STOP_LOADING:
1764 for (i = 0; i < ARRAY_SIZE(views); i++) {
1765 view = &views[i];
1766 if (view->pipe)
1767 report("Stopped loading the %s view", view->name),
1768 end_update(view);
1769 }
1770 break;
1771
1772 case REQ_SHOW_VERSION:
1773 report("%s (built %s)", VERSION, __DATE__);
1774 return TRUE;
1775
1776 case REQ_SCREEN_RESIZE:
1777 resize_display();
1778 /* Fall-through */
1779 case REQ_SCREEN_REDRAW:
1780 redraw_display();
1781 break;
1782
1783 case REQ_SCREEN_UPDATE:
1784 doupdate();
1785 return TRUE;
1786
1787 case REQ_VIEW_CLOSE:
1788 /* XXX: Mark closed views by letting view->parent point to the
1789 * view itself. Parents to closed view should never be
1790 * followed. */
1791 if (view->parent &&
1792 view->parent->parent != view->parent) {
1793 memset(display, 0, sizeof(display));
1794 current_view = 0;
1795 display[current_view] = view->parent;
1796 view->parent = view;
1797 resize_display();
1798 redraw_display();
1799 break;
1800 }
1801 /* Fall-through */
1802 case REQ_QUIT:
1803 return FALSE;
1804
1805 default:
1806 /* An unknown key will show most commonly used commands. */
1807 report("Unknown key, press 'h' for help");
1808 return TRUE;
1809 }
1810
1811 return TRUE;
1812 }
1813
1814
1815 /*
1816 * Pager backend
1817 */
1818
1819 static bool
1820 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1821 {
1822 char *text = line->data;
1823 enum line_type type = line->type;
1824 int textlen = strlen(text);
1825 int attr;
1826
1827 wmove(view->win, lineno, 0);
1828
1829 if (view->offset + lineno == view->lineno) {
1830 if (type == LINE_COMMIT) {
1831 string_copy(view->ref, text + 7);
1832 string_copy(ref_commit, view->ref);
1833 }
1834
1835 type = LINE_CURSOR;
1836 wchgat(view->win, -1, 0, type, NULL);
1837 }
1838
1839 attr = get_line_attr(type);
1840 wattrset(view->win, attr);
1841
1842 if (opt_line_number || opt_tab_size < TABSIZE) {
1843 static char spaces[] = " ";
1844 int col_offset = 0, col = 0;
1845
1846 if (opt_line_number) {
1847 unsigned long real_lineno = view->offset + lineno + 1;
1848
1849 if (real_lineno == 1 ||
1850 (real_lineno % opt_num_interval) == 0) {
1851 wprintw(view->win, "%.*d", view->digits, real_lineno);
1852
1853 } else {
1854 waddnstr(view->win, spaces,
1855 MIN(view->digits, STRING_SIZE(spaces)));
1856 }
1857 waddstr(view->win, ": ");
1858 col_offset = view->digits + 2;
1859 }
1860
1861 while (text && col_offset + col < view->width) {
1862 int cols_max = view->width - col_offset - col;
1863 char *pos = text;
1864 int cols;
1865
1866 if (*text == '\t') {
1867 text++;
1868 assert(sizeof(spaces) > TABSIZE);
1869 pos = spaces;
1870 cols = opt_tab_size - (col % opt_tab_size);
1871
1872 } else {
1873 text = strchr(text, '\t');
1874 cols = line ? text - pos : strlen(pos);
1875 }
1876
1877 waddnstr(view->win, pos, MIN(cols, cols_max));
1878 col += cols;
1879 }
1880
1881 } else {
1882 int col = 0, pos = 0;
1883
1884 for (; pos < textlen && col < view->width; pos++, col++)
1885 if (text[pos] == '\t')
1886 col += TABSIZE - (col % TABSIZE) - 1;
1887
1888 waddnstr(view->win, text, pos);
1889 }
1890
1891 return TRUE;
1892 }
1893
1894 static bool
1895 pager_read(struct view *view, struct line *prev, char *line)
1896 {
1897 /* Compress empty lines in the help view. */
1898 if (view == VIEW(REQ_VIEW_HELP) &&
1899 !*line && prev && !*((char *) prev->data))
1900 return TRUE;
1901
1902 view->line[view->lines].data = strdup(line);
1903 if (!view->line[view->lines].data)
1904 return FALSE;
1905
1906 view->line[view->lines].type = get_line_type(line);
1907
1908 view->lines++;
1909 return TRUE;
1910 }
1911
1912 static bool
1913 pager_enter(struct view *view, struct line *line)
1914 {
1915 int split = 0;
1916
1917 if (line->type == LINE_COMMIT &&
1918 (view == VIEW(REQ_VIEW_LOG) ||
1919 view == VIEW(REQ_VIEW_PAGER))) {
1920 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1921 split = 1;
1922 }
1923
1924 /* Always scroll the view even if it was split. That way
1925 * you can use Enter to scroll through the log view and
1926 * split open each commit diff. */
1927 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1928
1929 /* FIXME: A minor workaround. Scrolling the view will call report("")
1930 * but if we are scrolling a non-current view this won't properly
1931 * update the view title. */
1932 if (split)
1933 update_view_title(view);
1934
1935 return TRUE;
1936 }
1937
1938 static struct view_ops pager_ops = {
1939 "line",
1940 pager_draw,
1941 pager_read,
1942 pager_enter,
1943 };
1944
1945
1946 /*
1947 * Main view backend
1948 */
1949
1950 struct commit {
1951 char id[41]; /* SHA1 ID. */
1952 char title[75]; /* The first line of the commit message. */
1953 char author[75]; /* The author of the commit. */
1954 struct tm time; /* Date from the author ident. */
1955 struct ref **refs; /* Repository references; tags & branch heads. */
1956 };
1957
1958 static bool
1959 main_draw(struct view *view, struct line *line, unsigned int lineno)
1960 {
1961 char buf[DATE_COLS + 1];
1962 struct commit *commit = line->data;
1963 enum line_type type;
1964 int col = 0;
1965 size_t timelen;
1966 size_t authorlen;
1967 int trimmed = 1;
1968
1969 if (!*commit->author)
1970 return FALSE;
1971
1972 wmove(view->win, lineno, col);
1973
1974 if (view->offset + lineno == view->lineno) {
1975 string_copy(view->ref, commit->id);
1976 string_copy(ref_commit, view->ref);
1977 type = LINE_CURSOR;
1978 wattrset(view->win, get_line_attr(type));
1979 wchgat(view->win, -1, 0, type, NULL);
1980
1981 } else {
1982 type = LINE_MAIN_COMMIT;
1983 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1984 }
1985
1986 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1987 waddnstr(view->win, buf, timelen);
1988 waddstr(view->win, " ");
1989
1990 col += DATE_COLS;
1991 wmove(view->win, lineno, col);
1992 if (type != LINE_CURSOR)
1993 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1994
1995 if (opt_utf8) {
1996 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1997 } else {
1998 authorlen = strlen(commit->author);
1999 if (authorlen > AUTHOR_COLS - 2) {
2000 authorlen = AUTHOR_COLS - 2;
2001 trimmed = 1;
2002 }
2003 }
2004
2005 if (trimmed) {
2006 waddnstr(view->win, commit->author, authorlen);
2007 if (type != LINE_CURSOR)
2008 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2009 waddch(view->win, '~');
2010 } else {
2011 waddstr(view->win, commit->author);
2012 }
2013
2014 col += AUTHOR_COLS;
2015 if (type != LINE_CURSOR)
2016 wattrset(view->win, A_NORMAL);
2017
2018 mvwaddch(view->win, lineno, col, ACS_LTEE);
2019 wmove(view->win, lineno, col + 2);
2020 col += 2;
2021
2022 if (commit->refs) {
2023 size_t i = 0;
2024
2025 do {
2026 if (type == LINE_CURSOR)
2027 ;
2028 else if (commit->refs[i]->tag)
2029 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2030 else
2031 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2032 waddstr(view->win, "[");
2033 waddstr(view->win, commit->refs[i]->name);
2034 waddstr(view->win, "]");
2035 if (type != LINE_CURSOR)
2036 wattrset(view->win, A_NORMAL);
2037 waddstr(view->win, " ");
2038 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2039 } while (commit->refs[i++]->next);
2040 }
2041
2042 if (type != LINE_CURSOR)
2043 wattrset(view->win, get_line_attr(type));
2044
2045 {
2046 int titlelen = strlen(commit->title);
2047
2048 if (col + titlelen > view->width)
2049 titlelen = view->width - col;
2050
2051 waddnstr(view->win, commit->title, titlelen);
2052 }
2053
2054 return TRUE;
2055 }
2056
2057 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2058 static bool
2059 main_read(struct view *view, struct line *prev, char *line)
2060 {
2061 enum line_type type = get_line_type(line);
2062 struct commit *commit;
2063
2064 switch (type) {
2065 case LINE_COMMIT:
2066 commit = calloc(1, sizeof(struct commit));
2067 if (!commit)
2068 return FALSE;
2069
2070 line += STRING_SIZE("commit ");
2071
2072 view->line[view->lines++].data = commit;
2073 string_copy(commit->id, line);
2074 commit->refs = get_refs(commit->id);
2075 break;
2076
2077 case LINE_AUTHOR:
2078 {
2079 char *ident = line + STRING_SIZE("author ");
2080 char *end = strchr(ident, '<');
2081
2082 if (!prev)
2083 break;
2084
2085 commit = prev->data;
2086
2087 if (end) {
2088 for (; end > ident && isspace(end[-1]); end--) ;
2089 *end = 0;
2090 }
2091
2092 string_copy(commit->author, ident);
2093
2094 /* Parse epoch and timezone */
2095 if (end) {
2096 char *secs = strchr(end + 1, '>');
2097 char *zone;
2098 time_t time;
2099
2100 if (!secs || secs[1] != ' ')
2101 break;
2102
2103 secs += 2;
2104 time = (time_t) atol(secs);
2105 zone = strchr(secs, ' ');
2106 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2107 long tz;
2108
2109 zone++;
2110 tz = ('0' - zone[1]) * 60 * 60 * 10;
2111 tz += ('0' - zone[2]) * 60 * 60;
2112 tz += ('0' - zone[3]) * 60;
2113 tz += ('0' - zone[4]) * 60;
2114
2115 if (zone[0] == '-')
2116 tz = -tz;
2117
2118 time -= tz;
2119 }
2120 gmtime_r(&time, &commit->time);
2121 }
2122 break;
2123 }
2124 default:
2125 if (!prev)
2126 break;
2127
2128 commit = prev->data;
2129
2130 /* Fill in the commit title if it has not already been set. */
2131 if (commit->title[0])
2132 break;
2133
2134 /* Require titles to start with a non-space character at the
2135 * offset used by git log. */
2136 /* FIXME: More gracefull handling of titles; append "..." to
2137 * shortened titles, etc. */
2138 if (strncmp(line, " ", 4) ||
2139 isspace(line[4]))
2140 break;
2141
2142 string_copy(commit->title, line + 4);
2143 }
2144
2145 return TRUE;
2146 }
2147
2148 static bool
2149 main_enter(struct view *view, struct line *line)
2150 {
2151 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2152
2153 open_view(view, REQ_VIEW_DIFF, flags);
2154 return TRUE;
2155 }
2156
2157 static struct view_ops main_ops = {
2158 "commit",
2159 main_draw,
2160 main_read,
2161 main_enter,
2162 };
2163
2164
2165 /**
2166 * KEYS
2167 * ----
2168 * Below the default key bindings are shown.
2169 **/
2170
2171 struct keymap {
2172 int alias;
2173 int request;
2174 };
2175
2176 static struct keymap keymap[] = {
2177 /**
2178 * View switching
2179 * ~~~~~~~~~~~~~~
2180 * m::
2181 * Switch to main view.
2182 * d::
2183 * Switch to diff view.
2184 * l::
2185 * Switch to log view.
2186 * p::
2187 * Switch to pager view.
2188 * h::
2189 * Show man page.
2190 **/
2191 { 'm', REQ_VIEW_MAIN },
2192 { 'd', REQ_VIEW_DIFF },
2193 { 'l', REQ_VIEW_LOG },
2194 { 'p', REQ_VIEW_PAGER },
2195 { 'h', REQ_VIEW_HELP },
2196
2197 /**
2198 * View manipulation
2199 * ~~~~~~~~~~~~~~~~~
2200 * q::
2201 * Close view, if multiple views are open it will jump back to the
2202 * previous view in the view stack. If it is the last open view it
2203 * will quit. Use 'Q' to quit all views at once.
2204 * Enter::
2205 * This key is "context sensitive" depending on what view you are
2206 * currently in. When in log view on a commit line or in the main
2207 * view, split the view and show the commit diff. In the diff view
2208 * pressing Enter will simply scroll the view one line down.
2209 * Tab::
2210 * Switch to next view.
2211 * Up::
2212 * This key is "context sensitive" and will move the cursor one
2213 * line up. However, uf you opened a diff view from the main view
2214 * (split- or full-screen) it will change the cursor to point to
2215 * the previous commit in the main view and update the diff view
2216 * to display it.
2217 * Down::
2218 * Similar to 'Up' but will move down.
2219 **/
2220 { 'q', REQ_VIEW_CLOSE },
2221 { KEY_TAB, REQ_VIEW_NEXT },
2222 { KEY_RETURN, REQ_ENTER },
2223 { KEY_UP, REQ_PREVIOUS },
2224 { KEY_DOWN, REQ_NEXT },
2225
2226 /**
2227 * Cursor navigation
2228 * ~~~~~~~~~~~~~~~~~
2229 * j::
2230 * Move cursor one line up.
2231 * k::
2232 * Move cursor one line down.
2233 * PgUp::
2234 * b::
2235 * -::
2236 * Move cursor one page up.
2237 * PgDown::
2238 * Space::
2239 * Move cursor one page down.
2240 * Home::
2241 * Jump to first line.
2242 * End::
2243 * Jump to last line.
2244 **/
2245 { 'k', REQ_MOVE_UP },
2246 { 'j', REQ_MOVE_DOWN },
2247 { KEY_HOME, REQ_MOVE_FIRST_LINE },
2248 { KEY_END, REQ_MOVE_LAST_LINE },
2249 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
2250 { ' ', REQ_MOVE_PAGE_DOWN },
2251 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
2252 { 'b', REQ_MOVE_PAGE_UP },
2253 { '-', REQ_MOVE_PAGE_UP },
2254
2255 /**
2256 * Scrolling
2257 * ~~~~~~~~~
2258 * Insert::
2259 * Scroll view one line up.
2260 * Delete::
2261 * Scroll view one line down.
2262 * w::
2263 * Scroll view one page up.
2264 * s::
2265 * Scroll view one page down.
2266 **/
2267 { KEY_IC, REQ_SCROLL_LINE_UP },
2268 { KEY_DC, REQ_SCROLL_LINE_DOWN },
2269 { 'w', REQ_SCROLL_PAGE_UP },
2270 { 's', REQ_SCROLL_PAGE_DOWN },
2271
2272 /**
2273 * Misc
2274 * ~~~~
2275 * Q::
2276 * Quit.
2277 * r::
2278 * Redraw screen.
2279 * z::
2280 * Stop all background loading. This can be useful if you use
2281 * tig(1) in a repository with a long history without limiting
2282 * the revision log.
2283 * v::
2284 * Show version.
2285 * n::
2286 * Toggle line numbers on/off.
2287 * ':'::
2288 * Open prompt. This allows you to specify what git command
2289 * to run. Example:
2290 *
2291 * :log -p
2292 **/
2293 { 'Q', REQ_QUIT },
2294 { 'z', REQ_STOP_LOADING },
2295 { 'v', REQ_SHOW_VERSION },
2296 { 'r', REQ_SCREEN_REDRAW },
2297 { 'n', REQ_TOGGLE_LINE_NUMBERS },
2298 { ':', REQ_PROMPT },
2299
2300 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2301 { ERR, REQ_SCREEN_UPDATE },
2302
2303 /* Use the ncurses SIGWINCH handler. */
2304 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2305 };
2306
2307 static enum request
2308 get_request(int key)
2309 {
2310 int i;
2311
2312 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2313 if (keymap[i].alias == key)
2314 return keymap[i].request;
2315
2316 return (enum request) key;
2317 }
2318
2319
2320 /*
2321 * Unicode / UTF-8 handling
2322 *
2323 * NOTE: Much of the following code for dealing with unicode is derived from
2324 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2325 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2326 */
2327
2328 /* I've (over)annotated a lot of code snippets because I am not entirely
2329 * confident that the approach taken by this small UTF-8 interface is correct.
2330 * --jonas */
2331
2332 static inline int
2333 unicode_width(unsigned long c)
2334 {
2335 if (c >= 0x1100 &&
2336 (c <= 0x115f /* Hangul Jamo */
2337 || c == 0x2329
2338 || c == 0x232a
2339 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2340 /* CJK ... Yi */
2341 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2342 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2343 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2344 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2345 || (c >= 0xffe0 && c <= 0xffe6)
2346 || (c >= 0x20000 && c <= 0x2fffd)
2347 || (c >= 0x30000 && c <= 0x3fffd)))
2348 return 2;
2349
2350 return 1;
2351 }
2352
2353 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2354 * Illegal bytes are set one. */
2355 static const unsigned char utf8_bytes[256] = {
2356 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,
2357 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,
2358 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,
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 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,
2363 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,
2364 };
2365
2366 /* Decode UTF-8 multi-byte representation into a unicode character. */
2367 static inline unsigned long
2368 utf8_to_unicode(const char *string, size_t length)
2369 {
2370 unsigned long unicode;
2371
2372 switch (length) {
2373 case 1:
2374 unicode = string[0];
2375 break;
2376 case 2:
2377 unicode = (string[0] & 0x1f) << 6;
2378 unicode += (string[1] & 0x3f);
2379 break;
2380 case 3:
2381 unicode = (string[0] & 0x0f) << 12;
2382 unicode += ((string[1] & 0x3f) << 6);
2383 unicode += (string[2] & 0x3f);
2384 break;
2385 case 4:
2386 unicode = (string[0] & 0x0f) << 18;
2387 unicode += ((string[1] & 0x3f) << 12);
2388 unicode += ((string[2] & 0x3f) << 6);
2389 unicode += (string[3] & 0x3f);
2390 break;
2391 case 5:
2392 unicode = (string[0] & 0x0f) << 24;
2393 unicode += ((string[1] & 0x3f) << 18);
2394 unicode += ((string[2] & 0x3f) << 12);
2395 unicode += ((string[3] & 0x3f) << 6);
2396 unicode += (string[4] & 0x3f);
2397 break;
2398 case 6:
2399 unicode = (string[0] & 0x01) << 30;
2400 unicode += ((string[1] & 0x3f) << 24);
2401 unicode += ((string[2] & 0x3f) << 18);
2402 unicode += ((string[3] & 0x3f) << 12);
2403 unicode += ((string[4] & 0x3f) << 6);
2404 unicode += (string[5] & 0x3f);
2405 break;
2406 default:
2407 die("Invalid unicode length");
2408 }
2409
2410 /* Invalid characters could return the special 0xfffd value but NUL
2411 * should be just as good. */
2412 return unicode > 0xffff ? 0 : unicode;
2413 }
2414
2415 /* Calculates how much of string can be shown within the given maximum width
2416 * and sets trimmed parameter to non-zero value if all of string could not be
2417 * shown.
2418 *
2419 * Additionally, adds to coloffset how many many columns to move to align with
2420 * the expected position. Takes into account how multi-byte and double-width
2421 * characters will effect the cursor position.
2422 *
2423 * Returns the number of bytes to output from string to satisfy max_width. */
2424 static size_t
2425 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2426 {
2427 const char *start = string;
2428 const char *end = strchr(string, '\0');
2429 size_t mbwidth = 0;
2430 size_t width = 0;
2431
2432 *trimmed = 0;
2433
2434 while (string < end) {
2435 int c = *(unsigned char *) string;
2436 unsigned char bytes = utf8_bytes[c];
2437 size_t ucwidth;
2438 unsigned long unicode;
2439
2440 if (string + bytes > end)
2441 break;
2442
2443 /* Change representation to figure out whether
2444 * it is a single- or double-width character. */
2445
2446 unicode = utf8_to_unicode(string, bytes);
2447 /* FIXME: Graceful handling of invalid unicode character. */
2448 if (!unicode)
2449 break;
2450
2451 ucwidth = unicode_width(unicode);
2452 width += ucwidth;
2453 if (width > max_width) {
2454 *trimmed = 1;
2455 break;
2456 }
2457
2458 /* The column offset collects the differences between the
2459 * number of bytes encoding a character and the number of
2460 * columns will be used for rendering said character.
2461 *
2462 * So if some character A is encoded in 2 bytes, but will be
2463 * represented on the screen using only 1 byte this will and up
2464 * adding 1 to the multi-byte column offset.
2465 *
2466 * Assumes that no double-width character can be encoding in
2467 * less than two bytes. */
2468 if (bytes > ucwidth)
2469 mbwidth += bytes - ucwidth;
2470
2471 string += bytes;
2472 }
2473
2474 *coloffset += mbwidth;
2475
2476 return string - start;
2477 }
2478
2479
2480 /*
2481 * Status management
2482 */
2483
2484 /* Whether or not the curses interface has been initialized. */
2485 static bool cursed = FALSE;
2486
2487 /* The status window is used for polling keystrokes. */
2488 static WINDOW *status_win;
2489
2490 /* Update status and title window. */
2491 static void
2492 report(const char *msg, ...)
2493 {
2494 static bool empty = TRUE;
2495 struct view *view = display[current_view];
2496
2497 if (!empty || *msg) {
2498 va_list args;
2499
2500 va_start(args, msg);
2501
2502 werase(status_win);
2503 wmove(status_win, 0, 0);
2504 if (*msg) {
2505 vwprintw(status_win, msg, args);
2506 empty = FALSE;
2507 } else {
2508 empty = TRUE;
2509 }
2510 wrefresh(status_win);
2511
2512 va_end(args);
2513 }
2514
2515 update_view_title(view);
2516 update_display_cursor();
2517 }
2518
2519 /* Controls when nodelay should be in effect when polling user input. */
2520 static void
2521 set_nonblocking_input(bool loading)
2522 {
2523 static unsigned int loading_views;
2524
2525 if ((loading == FALSE && loading_views-- == 1) ||
2526 (loading == TRUE && loading_views++ == 0))
2527 nodelay(status_win, loading);
2528 }
2529
2530 static void
2531 init_display(void)
2532 {
2533 int x, y;
2534
2535 /* Initialize the curses library */
2536 if (isatty(STDIN_FILENO)) {
2537 cursed = !!initscr();
2538 } else {
2539 /* Leave stdin and stdout alone when acting as a pager. */
2540 FILE *io = fopen("/dev/tty", "r+");
2541
2542 cursed = !!newterm(NULL, io, io);
2543 }
2544
2545 if (!cursed)
2546 die("Failed to initialize curses");
2547
2548 nonl(); /* Tell curses not to do NL->CR/NL on output */
2549 cbreak(); /* Take input chars one at a time, no wait for \n */
2550 noecho(); /* Don't echo input */
2551 leaveok(stdscr, TRUE);
2552
2553 if (has_colors())
2554 init_colors();
2555
2556 getmaxyx(stdscr, y, x);
2557 status_win = newwin(1, 0, y - 1, 0);
2558 if (!status_win)
2559 die("Failed to create status window");
2560
2561 /* Enable keyboard mapping */
2562 keypad(status_win, TRUE);
2563 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2564 }
2565
2566
2567 /*
2568 * Repository references
2569 */
2570
2571 static struct ref *refs;
2572 static size_t refs_size;
2573
2574 /* Id <-> ref store */
2575 static struct ref ***id_refs;
2576 static size_t id_refs_size;
2577
2578 static struct ref **
2579 get_refs(char *id)
2580 {
2581 struct ref ***tmp_id_refs;
2582 struct ref **ref_list = NULL;
2583 size_t ref_list_size = 0;
2584 size_t i;
2585
2586 for (i = 0; i < id_refs_size; i++)
2587 if (!strcmp(id, id_refs[i][0]->id))
2588 return id_refs[i];
2589
2590 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2591 if (!tmp_id_refs)
2592 return NULL;
2593
2594 id_refs = tmp_id_refs;
2595
2596 for (i = 0; i < refs_size; i++) {
2597 struct ref **tmp;
2598
2599 if (strcmp(id, refs[i].id))
2600 continue;
2601
2602 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2603 if (!tmp) {
2604 if (ref_list)
2605 free(ref_list);
2606 return NULL;
2607 }
2608
2609 ref_list = tmp;
2610 if (ref_list_size > 0)
2611 ref_list[ref_list_size - 1]->next = 1;
2612 ref_list[ref_list_size] = &refs[i];
2613
2614 /* XXX: The properties of the commit chains ensures that we can
2615 * safely modify the shared ref. The repo references will
2616 * always be similar for the same id. */
2617 ref_list[ref_list_size]->next = 0;
2618 ref_list_size++;
2619 }
2620
2621 if (ref_list)
2622 id_refs[id_refs_size++] = ref_list;
2623
2624 return ref_list;
2625 }
2626
2627 static int
2628 read_ref(char *id, int idlen, char *name, int namelen)
2629 {
2630 struct ref *ref;
2631 bool tag = FALSE;
2632 bool tag_commit = FALSE;
2633
2634 /* Commits referenced by tags has "^{}" appended. */
2635 if (name[namelen - 1] == '}') {
2636 while (namelen > 0 && name[namelen] != '^')
2637 namelen--;
2638 if (namelen > 0)
2639 tag_commit = TRUE;
2640 name[namelen] = 0;
2641 }
2642
2643 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2644 if (!tag_commit)
2645 return OK;
2646 name += STRING_SIZE("refs/tags/");
2647 tag = TRUE;
2648
2649 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2650 name += STRING_SIZE("refs/heads/");
2651
2652 } else if (!strcmp(name, "HEAD")) {
2653 return OK;
2654 }
2655
2656 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2657 if (!refs)
2658 return ERR;
2659
2660 ref = &refs[refs_size++];
2661 ref->name = strdup(name);
2662 if (!ref->name)
2663 return ERR;
2664
2665 ref->tag = tag;
2666 string_copy(ref->id, id);
2667
2668 return OK;
2669 }
2670
2671 static int
2672 load_refs(void)
2673 {
2674 const char *cmd_env = getenv("TIG_LS_REMOTE");
2675 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2676
2677 return read_properties(popen(cmd, "r"), "\t", read_ref);
2678 }
2679
2680 static int
2681 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2682 {
2683 if (!strcmp(name, "i18n.commitencoding")) {
2684 string_copy(opt_encoding, value);
2685 }
2686
2687 return OK;
2688 }
2689
2690 static int
2691 load_repo_config(void)
2692 {
2693 return read_properties(popen("git repo-config --list", "r"),
2694 "=", read_repo_config_option);
2695 }
2696
2697 static int
2698 read_properties(FILE *pipe, const char *separators,
2699 int (*read_property)(char *, int, char *, int))
2700 {
2701 char buffer[BUFSIZ];
2702 char *name;
2703 int state = OK;
2704
2705 if (!pipe)
2706 return ERR;
2707
2708 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2709 char *value;
2710 size_t namelen;
2711 size_t valuelen;
2712
2713 name = chomp_string(name);
2714 namelen = strcspn(name, separators);
2715
2716 if (name[namelen]) {
2717 name[namelen] = 0;
2718 value = chomp_string(name + namelen + 1);
2719 valuelen = strlen(value);
2720
2721 } else {
2722 value = "";
2723 valuelen = 0;
2724 }
2725
2726 if (namelen)
2727 state = read_property(name, namelen, value, valuelen);
2728 }
2729
2730 if (state != ERR && ferror(pipe))
2731 state = ERR;
2732
2733 pclose(pipe);
2734
2735 return state;
2736 }
2737
2738
2739 /*
2740 * Main
2741 */
2742
2743 #if __GNUC__ >= 3
2744 #define __NORETURN __attribute__((__noreturn__))
2745 #else
2746 #define __NORETURN
2747 #endif
2748
2749 static void __NORETURN
2750 quit(int sig)
2751 {
2752 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2753 if (cursed)
2754 endwin();
2755 exit(0);
2756 }
2757
2758 static void __NORETURN
2759 die(const char *err, ...)
2760 {
2761 va_list args;
2762
2763 endwin();
2764
2765 va_start(args, err);
2766 fputs("tig: ", stderr);
2767 vfprintf(stderr, err, args);
2768 fputs("\n", stderr);
2769 va_end(args);
2770
2771 exit(1);
2772 }
2773
2774 int
2775 main(int argc, char *argv[])
2776 {
2777 struct view *view;
2778 enum request request;
2779 size_t i;
2780
2781 signal(SIGINT, quit);
2782
2783 if (load_options() == ERR)
2784 die("Failed to load user config.");
2785
2786 /* Load the repo config file so options can be overwritten from
2787 * the command line. */
2788 if (load_repo_config() == ERR)
2789 die("Failed to load repo config.");
2790
2791 if (!parse_options(argc, argv))
2792 return 0;
2793
2794 if (load_refs() == ERR)
2795 die("Failed to load refs.");
2796
2797 /* Require a git repository unless when running in pager mode. */
2798 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2799 die("Not a git repository");
2800
2801 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2802 view->cmd_env = getenv(view->cmd_env);
2803
2804 request = opt_request;
2805
2806 init_display();
2807
2808 while (view_driver(display[current_view], request)) {
2809 int key;
2810 int i;
2811
2812 foreach_view (view, i)
2813 update_view(view);
2814
2815 /* Refresh, accept single keystroke of input */
2816 key = wgetch(status_win);
2817 request = get_request(key);
2818
2819 /* Some low-level request handling. This keeps access to
2820 * status_win restricted. */
2821 switch (request) {
2822 case REQ_PROMPT:
2823 report(":");
2824 /* Temporarily switch to line-oriented and echoed
2825 * input. */
2826 nocbreak();
2827 echo();
2828
2829 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2830 memcpy(opt_cmd, "git ", 4);
2831 opt_request = REQ_VIEW_PAGER;
2832 } else {
2833 report("Prompt interrupted by loading view, "
2834 "press 'z' to stop loading views");
2835 request = REQ_SCREEN_UPDATE;
2836 }
2837
2838 noecho();
2839 cbreak();
2840 break;
2841
2842 case REQ_SCREEN_RESIZE:
2843 {
2844 int height, width;
2845
2846 getmaxyx(stdscr, height, width);
2847
2848 /* Resize the status view and let the view driver take
2849 * care of resizing the displayed views. */
2850 wresize(status_win, 1, width);
2851 mvwin(status_win, height - 1, 0);
2852 wrefresh(status_win);
2853 break;
2854 }
2855 default:
2856 break;
2857 }
2858 }
2859
2860 quit(0);
2861
2862 return 0;
2863 }
2864
2865 /**
2866 * [[refspec]]
2867 * Revision specification
2868 * ----------------------
2869 * This section describes various ways to specify what revisions to display
2870 * or otherwise limit the view to. tig(1) does not itself parse the described
2871 * revision options so refer to the relevant git man pages for futher
2872 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2873 * git-rev-list(1).
2874 *
2875 * You can tune the interaction with git by making use of the options
2876 * explained in this section. For example, by configuring the environment
2877 * variables described in the <<history-commands, "History commands">>
2878 * section.
2879 *
2880 * Limit by path name
2881 * ~~~~~~~~~~~~~~~~~~
2882 * If you are interested only in those revisions that made changes to a
2883 * specific file (or even several files) list the files like this:
2884 *
2885 * $ tig log Makefile README
2886 *
2887 * To avoid ambiguity with repository references such as tag name, be sure
2888 * to separate file names from other git options using "\--". So if you
2889 * have a file named 'master' it will clash with the reference named
2890 * 'master', and thus you will have to use:
2891 *
2892 * $ tig log -- master
2893 *
2894 * NOTE: For the main view, avoiding ambiguity will in some cases require
2895 * you to specify two "\--" options. The first will make tig(1) stop
2896 * option processing and the latter will be passed to git log.
2897 *
2898 * Limit by date or number
2899 * ~~~~~~~~~~~~~~~~~~~~~~~
2900 * To speed up interaction with git, you can limit the amount of commits
2901 * to show both for the log and main view. Either limit by date using
2902 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2903 *
2904 * If you are only interested in changed that happened between two dates
2905 * you can use:
2906 *
2907 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2908 *
2909 * NOTE: If you want to avoid having to quote dates containing spaces you
2910 * can use "." instead, e.g. `--after=May.5th`.
2911 *
2912 * Limiting by commit ranges
2913 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2914 * Alternatively, commits can be limited to a specific range, such as
2915 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2916 *
2917 * $ tig log tag-1.0..tag-2.0
2918 *
2919 * This way of commit limiting makes it trivial to only browse the commits
2920 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2921 * upstream remote branch, using:
2922 *
2923 * $ tig log origin..HEAD
2924 *
2925 * will list what will be pushed to the remote branch. Optionally, the ending
2926 * 'HEAD' can be left out since it is implied.
2927 *
2928 * Limiting by reachability
2929 * ~~~~~~~~~~~~~~~~~~~~~~~~
2930 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2931 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2932 * Where reachability refers to what commits are ancestors (or part of the
2933 * history) of the branch or tagged revision in question.
2934 *
2935 * If you prefer to specify which commit to preview in this way use the
2936 * following:
2937 *
2938 * $ tig log tag-2.0 ^tag-1.0
2939 *
2940 * You can think of '^' as a negation operator. Using this alternate syntax,
2941 * it is possible to further prune commits by specifying multiple branch
2942 * cut offs.
2943 *
2944 * Combining revisions specification
2945 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2946 * Revisions options can to some degree be combined, which makes it possible
2947 * to say "show at most 20 commits from within the last month that changed
2948 * files under the Documentation/ directory."
2949 *
2950 * $ tig -- --since=1.month -n20 -- Documentation/
2951 *
2952 * Examining all repository references
2953 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2954 * In some cases, it can be useful to query changes across all references
2955 * in a repository. An example is to ask "did any line of development in
2956 * this repository change a particular file within the last week". This
2957 * can be accomplished using:
2958 *
2959 * $ tig -- --all --since=1.week -- Makefile
2960 *
2961 * BUGS
2962 * ----
2963 * Known bugs and problems:
2964 *
2965 * - In it's current state tig is pretty much UTF-8 only.
2966 *
2967 * - If the screen width is very small the main view can draw
2968 * outside the current view causing bad wrapping. Same goes
2969 * for title and status windows.
2970 *
2971 * - The cursor can wrap-around on the last line and cause the
2972 * window to scroll.
2973 *
2974 * - The prompt doesn't work while loading.
2975 *
2976 * TODO
2977 * ----
2978 * Features that should be explored.
2979 *
2980 * - Searching.
2981 *
2982 * - Locale support.
2983 *
2984 * COPYRIGHT
2985 * ---------
2986 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2987 *
2988 * This program is free software; you can redistribute it and/or modify
2989 * it under the terms of the GNU General Public License as published by
2990 * the Free Software Foundation; either version 2 of the License, or
2991 * (at your option) any later version.
2992 *
2993 * SEE ALSO
2994 * --------
2995 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2996 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2997 *
2998 * Other git repository browsers:
2999 *
3000 * - gitk(1)
3001 * - qgit(1)
3002 * - gitview(1)
3003 **/
Full-screen terminal Git browser.