1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 */
12 /**
13 * TIG(1)
14 * ======
15 *
16 * NAME
17 * ----
18 * tig - text-mode interface for git
19 *
20 * SYNOPSIS
21 * --------
22 * [verse]
23 * tig [options]
24 * tig [options] [--] [git log options]
25 * tig [options] log [git log options]
26 * tig [options] diff [git diff options]
27 * tig [options] show [git show options]
28 * tig [options] < [git command output]
29 *
30 * DESCRIPTION
31 * -----------
32 * Browse changes in a git repository. Additionally, tig(1) can also act
33 * as a pager for output of various git commands.
34 *
35 * When browsing repositories, tig(1) uses the underlying git commands
36 * to present the user with various views, such as summarized commit log
37 * and showing the commit with the log message, diffstat, and the diff.
38 *
39 * Using tig(1) as a pager, it will display input from stdin and try
40 * to colorize it.
41 **/
43 #ifndef VERSION
44 #define VERSION "tig-0.3"
45 #endif
47 #ifndef DEBUG
48 #define NDEBUG
49 #endif
51 #include <assert.h>
52 #include <errno.h>
53 #include <ctype.h>
54 #include <signal.h>
55 #include <stdarg.h>
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <unistd.h>
60 #include <time.h>
62 #include <curses.h>
64 static void die(const char *err, ...);
65 static void report(const char *msg, ...);
66 static void set_nonblocking_input(bool loading);
67 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
69 #define ABS(x) ((x) >= 0 ? (x) : -(x))
70 #define MIN(x, y) ((x) < (y) ? (x) : (y))
72 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
73 #define STRING_SIZE(x) (sizeof(x) - 1)
75 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
76 #define SIZEOF_CMD 1024 /* Size of command buffer. */
78 /* This color name can be used to refer to the default term colors. */
79 #define COLOR_DEFAULT (-1)
81 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
83 /* The format and size of the date column in the main view. */
84 #define DATE_FORMAT "%Y-%m-%d %H:%M"
85 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
87 #define AUTHOR_COLS 20
89 /* The default interval between line numbers. */
90 #define NUMBER_INTERVAL 1
92 #define TABSIZE 8
94 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
96 /* Some ascii-shorthands fitted into the ncurses namespace. */
97 #define KEY_TAB '\t'
98 #define KEY_RETURN '\r'
99 #define KEY_ESC 27
102 /* User action requests. */
103 enum request {
104 /* Offset all requests to avoid conflicts with ncurses getch values. */
105 REQ_OFFSET = KEY_MAX + 1,
107 /* XXX: Keep the view request first and in sync with views[]. */
108 REQ_VIEW_MAIN,
109 REQ_VIEW_DIFF,
110 REQ_VIEW_LOG,
111 REQ_VIEW_HELP,
112 REQ_VIEW_PAGER,
114 REQ_ENTER,
115 REQ_QUIT,
116 REQ_PROMPT,
117 REQ_SCREEN_REDRAW,
118 REQ_SCREEN_RESIZE,
119 REQ_SCREEN_UPDATE,
120 REQ_SHOW_VERSION,
121 REQ_STOP_LOADING,
122 REQ_TOGGLE_LINE_NUMBERS,
123 REQ_VIEW_NEXT,
124 REQ_VIEW_CLOSE,
125 REQ_NEXT,
126 REQ_PREVIOUS,
128 REQ_MOVE_UP,
129 REQ_MOVE_DOWN,
130 REQ_MOVE_PAGE_UP,
131 REQ_MOVE_PAGE_DOWN,
132 REQ_MOVE_FIRST_LINE,
133 REQ_MOVE_LAST_LINE,
135 REQ_SCROLL_LINE_UP,
136 REQ_SCROLL_LINE_DOWN,
137 REQ_SCROLL_PAGE_UP,
138 REQ_SCROLL_PAGE_DOWN,
139 };
141 struct ref {
142 char *name; /* Ref name; tag or head names are shortened. */
143 char id[41]; /* Commit SHA1 ID */
144 unsigned int tag:1; /* Is it a tag? */
145 unsigned int next:1; /* For ref lists: are there more refs? */
146 };
148 static struct ref **get_refs(char *id);
151 /*
152 * String helpers
153 */
155 static inline void
156 string_ncopy(char *dst, const char *src, int dstlen)
157 {
158 strncpy(dst, src, dstlen - 1);
159 dst[dstlen - 1] = 0;
161 }
163 /* Shorthand for safely copying into a fixed buffer. */
164 #define string_copy(dst, src) \
165 string_ncopy(dst, src, sizeof(dst))
168 /* Shell quoting
169 *
170 * NOTE: The following is a slightly modified copy of the git project's shell
171 * quoting routines found in the quote.c file.
172 *
173 * Help to copy the thing properly quoted for the shell safety. any single
174 * quote is replaced with '\'', any exclamation point is replaced with '\!',
175 * and the whole thing is enclosed in a
176 *
177 * E.g.
178 * original sq_quote result
179 * name ==> name ==> 'name'
180 * a b ==> a b ==> 'a b'
181 * a'b ==> a'\''b ==> 'a'\''b'
182 * a!b ==> a'\!'b ==> 'a'\!'b'
183 */
185 static size_t
186 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
187 {
188 char c;
190 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
192 BUFPUT('\'');
193 while ((c = *src++)) {
194 if (c == '\'' || c == '!') {
195 BUFPUT('\'');
196 BUFPUT('\\');
197 BUFPUT(c);
198 BUFPUT('\'');
199 } else {
200 BUFPUT(c);
201 }
202 }
203 BUFPUT('\'');
205 return bufsize;
206 }
209 /**
210 * OPTIONS
211 * -------
212 **/
214 static const char usage[] =
215 VERSION " (" __DATE__ ")\n"
216 "\n"
217 "Usage: tig [options]\n"
218 " or: tig [options] [--] [git log options]\n"
219 " or: tig [options] log [git log options]\n"
220 " or: tig [options] diff [git diff options]\n"
221 " or: tig [options] show [git show options]\n"
222 " or: tig [options] < [git command output]\n"
223 "\n"
224 "Options:\n"
225 " -l Start up in log view\n"
226 " -d Start up in diff view\n"
227 " -n[I], --line-number[=I] Show line numbers with given interval\n"
228 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
229 " -- Mark end of tig options\n"
230 " -v, --version Show version and exit\n"
231 " -h, --help Show help message and exit\n";
233 /* Option and state variables. */
234 static bool opt_line_number = FALSE;
235 static int opt_num_interval = NUMBER_INTERVAL;
236 static int opt_tab_size = TABSIZE;
237 static enum request opt_request = REQ_VIEW_MAIN;
238 static char opt_cmd[SIZEOF_CMD] = "";
239 static char opt_encoding[20] = "";
240 static bool opt_utf8 = TRUE;
241 static FILE *opt_pipe = NULL;
243 /* Returns the index of log or diff command or -1 to exit. */
244 static bool
245 parse_options(int argc, char *argv[])
246 {
247 int i;
249 for (i = 1; i < argc; i++) {
250 char *opt = argv[i];
252 /**
253 * -l::
254 * Start up in log view using the internal log command.
255 **/
256 if (!strcmp(opt, "-l")) {
257 opt_request = REQ_VIEW_LOG;
258 continue;
259 }
261 /**
262 * -d::
263 * Start up in diff view using the internal diff command.
264 **/
265 if (!strcmp(opt, "-d")) {
266 opt_request = REQ_VIEW_DIFF;
267 continue;
268 }
270 /**
271 * -n[INTERVAL], --line-number[=INTERVAL]::
272 * Prefix line numbers in log and diff view.
273 * Optionally, with interval different than each line.
274 **/
275 if (!strncmp(opt, "-n", 2) ||
276 !strncmp(opt, "--line-number", 13)) {
277 char *num = opt;
279 if (opt[1] == 'n') {
280 num = opt + 2;
282 } else if (opt[STRING_SIZE("--line-number")] == '=') {
283 num = opt + STRING_SIZE("--line-number=");
284 }
286 if (isdigit(*num))
287 opt_num_interval = atoi(num);
289 opt_line_number = TRUE;
290 continue;
291 }
293 /**
294 * -t[NSPACES], --tab-size[=NSPACES]::
295 * Set the number of spaces tabs should be expanded to.
296 **/
297 if (!strncmp(opt, "-t", 2) ||
298 !strncmp(opt, "--tab-size", 10)) {
299 char *num = opt;
301 if (opt[1] == 't') {
302 num = opt + 2;
304 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
305 num = opt + STRING_SIZE("--tab-size=");
306 }
308 if (isdigit(*num))
309 opt_tab_size = MIN(atoi(num), TABSIZE);
310 continue;
311 }
313 /**
314 * -v, --version::
315 * Show version and exit.
316 **/
317 if (!strcmp(opt, "-v") ||
318 !strcmp(opt, "--version")) {
319 printf("tig version %s\n", VERSION);
320 return FALSE;
321 }
323 /**
324 * -h, --help::
325 * Show help message and exit.
326 **/
327 if (!strcmp(opt, "-h") ||
328 !strcmp(opt, "--help")) {
329 printf(usage);
330 return FALSE;
331 }
333 /**
334 * \--::
335 * End of tig(1) options. Useful when specifying command
336 * options for the main view. Example:
337 *
338 * $ tig -- --since=1.month
339 **/
340 if (!strcmp(opt, "--")) {
341 i++;
342 break;
343 }
345 /**
346 * log [git log options]::
347 * Open log view using the given git log options.
348 *
349 * diff [git diff options]::
350 * Open diff view using the given git diff options.
351 *
352 * show [git show options]::
353 * Open diff view using the given git show options.
354 **/
355 if (!strcmp(opt, "log") ||
356 !strcmp(opt, "diff") ||
357 !strcmp(opt, "show")) {
358 opt_request = opt[0] == 'l'
359 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
360 break;
361 }
363 /**
364 * [git log options]::
365 * tig(1) will stop the option parsing when the first
366 * command line parameter not starting with "-" is
367 * encountered. All options including this one will be
368 * passed to git log when loading the main view.
369 * This makes it possible to say:
370 *
371 * $ tig tag-1.0..HEAD
372 **/
373 if (opt[0] && opt[0] != '-')
374 break;
376 die("unknown command '%s'", opt);
377 }
379 if (!isatty(STDIN_FILENO)) {
380 /**
381 * Pager mode
382 * ~~~~~~~~~~
383 * If stdin is a pipe, any log or diff options will be ignored and the
384 * pager view will be opened loading data from stdin. The pager mode
385 * can be used for colorizing output from various git commands.
386 *
387 * Example on how to colorize the output of git-show(1):
388 *
389 * $ git show | tig
390 **/
391 opt_request = REQ_VIEW_PAGER;
392 opt_pipe = stdin;
394 } else if (i < argc) {
395 size_t buf_size;
397 /**
398 * Git command options
399 * ~~~~~~~~~~~~~~~~~~~
400 * All git command options specified on the command line will
401 * be passed to the given command and all will be shell quoted
402 * before they are passed to the shell.
403 *
404 * NOTE: If you specify options for the main view, you should
405 * not use the `--pretty` option as this option will be set
406 * automatically to the format expected by the main view.
407 *
408 * Example on how to open the log view and show both author and
409 * committer information:
410 *
411 * $ tig log --pretty=fuller
412 *
413 * See the <<refspec, "Specifying revisions">> section below
414 * for an introduction to revision options supported by the git
415 * commands. For details on specific git command options, refer
416 * to the man page of the command in question.
417 **/
419 if (opt_request == REQ_VIEW_MAIN)
420 /* XXX: This is vulnerable to the user overriding
421 * options required for the main view parser. */
422 string_copy(opt_cmd, "git log --stat --pretty=raw");
423 else
424 string_copy(opt_cmd, "git");
425 buf_size = strlen(opt_cmd);
427 while (buf_size < sizeof(opt_cmd) && i < argc) {
428 opt_cmd[buf_size++] = ' ';
429 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
430 }
432 if (buf_size >= sizeof(opt_cmd))
433 die("command too long");
435 opt_cmd[buf_size] = 0;
437 }
439 return TRUE;
440 }
443 /**
444 * ENVIRONMENT VARIABLES
445 * ---------------------
446 * Several options related to the interface with git can be configured
447 * via environment options.
448 *
449 * Repository references
450 * ~~~~~~~~~~~~~~~~~~~~~
451 * Commits that are referenced by tags and branch heads will be marked
452 * by the reference name surrounded by '[' and ']':
453 *
454 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
455 *
456 * If you want to filter out certain directories under `.git/refs/`, say
457 * `tmp` you can do it by setting the following variable:
458 *
459 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
460 *
461 * Or set the variable permanently in your environment.
462 *
463 * TIG_LS_REMOTE::
464 * Set command for retrieving all repository references. The command
465 * should output data in the same format as git-ls-remote(1).
466 **/
468 #define TIG_LS_REMOTE \
469 "git ls-remote . 2>/dev/null"
471 /**
472 * [[view-commands]]
473 * View commands
474 * ~~~~~~~~~~~~~
475 * It is possible to alter which commands are used for the different views.
476 * If for example you prefer commits in the main view to be sorted by date
477 * and only show 500 commits, use:
478 *
479 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
480 *
481 * Or set the variable permanently in your environment.
482 *
483 * Notice, how `%s` is used to specify the commit reference. There can
484 * be a maximum of 5 `%s` ref specifications.
485 *
486 * TIG_DIFF_CMD::
487 * The command used for the diff view. By default, git show is used
488 * as a backend.
489 *
490 * TIG_LOG_CMD::
491 * The command used for the log view. If you prefer to have both
492 * author and committer shown in the log view be sure to pass
493 * `--pretty=fuller` to git log.
494 *
495 * TIG_MAIN_CMD::
496 * The command used for the main view. Note, you must always specify
497 * the option: `--pretty=raw` since the main view parser expects to
498 * read that format.
499 **/
501 #define TIG_DIFF_CMD \
502 "git show --patch-with-stat --find-copies-harder -B -C %s"
504 #define TIG_LOG_CMD \
505 "git log --cc --stat -n100 %s"
507 #define TIG_MAIN_CMD \
508 "git log --topo-order --stat --pretty=raw %s"
510 /* ... silently ignore that the following are also exported. */
512 #define TIG_HELP_CMD \
513 "man tig 2>/dev/null"
515 #define TIG_PAGER_CMD \
516 ""
519 /*
520 * Line-oriented content detection.
521 */
523 #define LINE_INFO \
524 /* Line type String to match Foreground Background Attributes
525 * --------- --------------- ---------- ---------- ---------- */ \
526 /* Diff markup */ \
527 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
528 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
529 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
530 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
531 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
532 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
533 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
534 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
535 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
536 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
537 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
538 /* Pretty print commit header */ \
539 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
540 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
541 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
542 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
543 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
544 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
545 /* Raw commit header */ \
546 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
547 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
548 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
549 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
550 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
551 /* Misc */ \
552 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
553 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
554 /* UI colors */ \
555 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
556 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
557 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
558 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
559 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
560 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
561 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
562 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
563 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
564 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
565 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
567 enum line_type {
568 #define LINE(type, line, fg, bg, attr) \
569 LINE_##type
570 LINE_INFO
571 #undef LINE
572 };
574 struct line_info {
575 const char *line; /* The start of line to match. */
576 int linelen; /* Size of string to match. */
577 int fg, bg, attr; /* Color and text attributes for the lines. */
578 };
580 static struct line_info line_info[] = {
581 #define LINE(type, line, fg, bg, attr) \
582 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
583 LINE_INFO
584 #undef LINE
585 };
587 static enum line_type
588 get_line_type(char *line)
589 {
590 int linelen = strlen(line);
591 enum line_type type;
593 for (type = 0; type < ARRAY_SIZE(line_info); type++)
594 /* Case insensitive search matches Signed-off-by lines better. */
595 if (linelen >= line_info[type].linelen &&
596 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
597 return type;
599 return LINE_DEFAULT;
600 }
602 static inline int
603 get_line_attr(enum line_type type)
604 {
605 assert(type < ARRAY_SIZE(line_info));
606 return COLOR_PAIR(type) | line_info[type].attr;
607 }
609 static void
610 init_colors(void)
611 {
612 int default_bg = COLOR_BLACK;
613 int default_fg = COLOR_WHITE;
614 enum line_type type;
616 start_color();
618 if (use_default_colors() != ERR) {
619 default_bg = -1;
620 default_fg = -1;
621 }
623 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
624 struct line_info *info = &line_info[type];
625 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
626 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
628 init_pair(type, fg, bg);
629 }
630 }
632 struct line {
633 enum line_type type;
634 void *data; /* User data */
635 };
638 /**
639 * The viewer
640 * ----------
641 * The display consists of a status window on the last line of the screen and
642 * one or more views. The default is to only show one view at the time but it
643 * is possible to split both the main and log view to also show the commit
644 * diff.
645 *
646 * If you are in the log view and press 'Enter' when the current line is a
647 * commit line, such as:
648 *
649 * commit 4d55caff4cc89335192f3e566004b4ceef572521
650 *
651 * You will split the view so that the log view is displayed in the top window
652 * and the diff view in the bottom window. You can switch between the two
653 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
654 **/
656 struct view;
657 struct view_ops;
659 /* The display array of active views and the index of the current view. */
660 static struct view *display[2];
661 static unsigned int current_view;
663 #define foreach_view(view, i) \
664 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
666 #define displayed_views() (display[1] != NULL ? 2 : 1)
668 /**
669 * Current head and commit ID
670 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
671 * The viewer keeps track of both what head and commit ID you are currently
672 * viewing. The commit ID will follow the cursor line and change everytime time
673 * you highlight a different commit. Whenever you reopen the diff view it
674 * will be reloaded, if the commit ID changed.
675 *
676 * The head ID is used when opening the main and log view to indicate from
677 * what revision to show history.
678 **/
680 static char ref_commit[SIZEOF_REF] = "HEAD";
681 static char ref_head[SIZEOF_REF] = "HEAD";
683 struct view {
684 const char *name; /* View name */
685 const char *cmd_fmt; /* Default command line format */
686 const char *cmd_env; /* Command line set via environment */
687 const char *id; /* Points to either of ref_{head,commit} */
689 struct view_ops *ops; /* View operations */
691 char cmd[SIZEOF_CMD]; /* Command buffer */
692 char ref[SIZEOF_REF]; /* Hovered commit reference */
693 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
695 int height, width; /* The width and height of the main window */
696 WINDOW *win; /* The main window */
697 WINDOW *title; /* The title window living below the main window */
699 /* Navigation */
700 unsigned long offset; /* Offset of the window top */
701 unsigned long lineno; /* Current line number */
703 /* If non-NULL, points to the view that opened this view. If this view
704 * is closed tig will switch back to the parent view. */
705 struct view *parent;
707 /* Buffering */
708 unsigned long lines; /* Total number of lines */
709 struct line *line; /* Line index */
710 unsigned int digits; /* Number of digits in the lines member. */
712 /* Loading */
713 FILE *pipe;
714 time_t start_time;
715 };
717 struct view_ops {
718 /* What type of content being displayed. Used in the title bar. */
719 const char *type;
720 /* Draw one line; @lineno must be < view->height. */
721 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
722 /* Read one line; updates view->line. */
723 bool (*read)(struct view *view, struct line *prev, char *data);
724 /* Depending on view, change display based on current line. */
725 bool (*enter)(struct view *view, struct line *line);
726 };
728 static struct view_ops pager_ops;
729 static struct view_ops main_ops;
731 #define VIEW_STR(name, cmd, env, ref, ops) \
732 { name, cmd, #env, ref, ops }
734 #define VIEW_(id, name, ops, ref) \
735 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
737 /**
738 * Views
739 * ~~~~~
740 * tig(1) presents various 'views' of a repository. Each view is based on output
741 * from an external command, most often 'git log', 'git diff', or 'git show'.
742 *
743 * The main view::
744 * Is the default view, and it shows a one line summary of each commit
745 * in the chosen list of revisions. The summary includes commit date,
746 * author, and the first line of the log message. Additionally, any
747 * repository references, such as tags, will be shown.
748 *
749 * The log view::
750 * Presents a more rich view of the revision log showing the whole log
751 * message and the diffstat.
752 *
753 * The diff view::
754 * Shows either the diff of the current working tree, that is, what
755 * has changed since the last commit, or the commit diff complete
756 * with log message, diffstat and diff.
757 *
758 * The pager view::
759 * Is used for displaying both input from stdin and output from git
760 * commands entered in the internal prompt.
761 *
762 * The help view::
763 * Displays the information from the tig(1) man page. For the help view
764 * to work you need to have the tig(1) man page installed.
765 **/
767 static struct view views[] = {
768 VIEW_(MAIN, "main", &main_ops, ref_head),
769 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
770 VIEW_(LOG, "log", &pager_ops, ref_head),
771 VIEW_(HELP, "help", &pager_ops, "static"),
772 VIEW_(PAGER, "pager", &pager_ops, "static"),
773 };
775 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
778 static bool
779 draw_view_line(struct view *view, unsigned int lineno)
780 {
781 if (view->offset + lineno >= view->lines)
782 return FALSE;
784 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
785 }
787 static void
788 redraw_view_from(struct view *view, int lineno)
789 {
790 assert(0 <= lineno && lineno < view->height);
792 for (; lineno < view->height; lineno++) {
793 if (!draw_view_line(view, lineno))
794 break;
795 }
797 redrawwin(view->win);
798 wrefresh(view->win);
799 }
801 static void
802 redraw_view(struct view *view)
803 {
804 wclear(view->win);
805 redraw_view_from(view, 0);
806 }
809 /**
810 * Title windows
811 * ~~~~~~~~~~~~~
812 * Each view has a title window which shows the name of the view, current
813 * commit ID if available, and where the view is positioned:
814 *
815 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
816 *
817 * By default, the title of the current view is highlighted using bold font.
818 **/
820 static void
821 update_view_title(struct view *view)
822 {
823 if (view == display[current_view])
824 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
825 else
826 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
828 werase(view->title);
829 wmove(view->title, 0, 0);
831 if (*view->ref)
832 wprintw(view->title, "[%s] %s", view->name, view->ref);
833 else
834 wprintw(view->title, "[%s]", view->name);
836 if (view->lines || view->pipe) {
837 unsigned int lines = view->lines
838 ? (view->lineno + 1) * 100 / view->lines
839 : 0;
841 wprintw(view->title, " - %s %d of %d (%d%%)",
842 view->ops->type,
843 view->lineno + 1,
844 view->lines,
845 lines);
846 }
848 if (view->pipe) {
849 time_t secs = time(NULL) - view->start_time;
851 /* Three git seconds are a long time ... */
852 if (secs > 2)
853 wprintw(view->title, " %lds", secs);
854 }
857 wrefresh(view->title);
858 }
860 static void
861 resize_display(void)
862 {
863 int offset, i;
864 struct view *base = display[0];
865 struct view *view = display[1] ? display[1] : display[0];
867 /* Setup window dimensions */
869 getmaxyx(stdscr, base->height, base->width);
871 /* Make room for the status window. */
872 base->height -= 1;
874 if (view != base) {
875 /* Horizontal split. */
876 view->width = base->width;
877 view->height = SCALE_SPLIT_VIEW(base->height);
878 base->height -= view->height;
880 /* Make room for the title bar. */
881 view->height -= 1;
882 }
884 /* Make room for the title bar. */
885 base->height -= 1;
887 offset = 0;
889 foreach_view (view, i) {
890 if (!view->win) {
891 view->win = newwin(view->height, 0, offset, 0);
892 if (!view->win)
893 die("Failed to create %s view", view->name);
895 scrollok(view->win, TRUE);
897 view->title = newwin(1, 0, offset + view->height, 0);
898 if (!view->title)
899 die("Failed to create title window");
901 } else {
902 wresize(view->win, view->height, view->width);
903 mvwin(view->win, offset, 0);
904 mvwin(view->title, offset + view->height, 0);
905 wrefresh(view->win);
906 }
908 offset += view->height + 1;
909 }
910 }
912 static void
913 redraw_display(void)
914 {
915 struct view *view;
916 int i;
918 foreach_view (view, i) {
919 redraw_view(view);
920 update_view_title(view);
921 }
922 }
925 /*
926 * Navigation
927 */
929 /* Scrolling backend */
930 static void
931 do_scroll_view(struct view *view, int lines, bool redraw)
932 {
933 /* The rendering expects the new offset. */
934 view->offset += lines;
936 assert(0 <= view->offset && view->offset < view->lines);
937 assert(lines);
939 /* Redraw the whole screen if scrolling is pointless. */
940 if (view->height < ABS(lines)) {
941 redraw_view(view);
943 } else {
944 int line = lines > 0 ? view->height - lines : 0;
945 int end = line + ABS(lines);
947 wscrl(view->win, lines);
949 for (; line < end; line++) {
950 if (!draw_view_line(view, line))
951 break;
952 }
953 }
955 /* Move current line into the view. */
956 if (view->lineno < view->offset) {
957 view->lineno = view->offset;
958 draw_view_line(view, 0);
960 } else if (view->lineno >= view->offset + view->height) {
961 if (view->lineno == view->offset + view->height) {
962 /* Clear the hidden line so it doesn't show if the view
963 * is scrolled up. */
964 wmove(view->win, view->height, 0);
965 wclrtoeol(view->win);
966 }
967 view->lineno = view->offset + view->height - 1;
968 draw_view_line(view, view->lineno - view->offset);
969 }
971 assert(view->offset <= view->lineno && view->lineno < view->lines);
973 if (!redraw)
974 return;
976 redrawwin(view->win);
977 wrefresh(view->win);
978 report("");
979 }
981 /* Scroll frontend */
982 static void
983 scroll_view(struct view *view, enum request request)
984 {
985 int lines = 1;
987 switch (request) {
988 case REQ_SCROLL_PAGE_DOWN:
989 lines = view->height;
990 case REQ_SCROLL_LINE_DOWN:
991 if (view->offset + lines > view->lines)
992 lines = view->lines - view->offset;
994 if (lines == 0 || view->offset + view->height >= view->lines) {
995 report("Cannot scroll beyond the last line");
996 return;
997 }
998 break;
1000 case REQ_SCROLL_PAGE_UP:
1001 lines = view->height;
1002 case REQ_SCROLL_LINE_UP:
1003 if (lines > view->offset)
1004 lines = view->offset;
1006 if (lines == 0) {
1007 report("Cannot scroll beyond the first line");
1008 return;
1009 }
1011 lines = -lines;
1012 break;
1014 default:
1015 die("request %d not handled in switch", request);
1016 }
1018 do_scroll_view(view, lines, TRUE);
1019 }
1021 /* Cursor moving */
1022 static void
1023 move_view(struct view *view, enum request request, bool redraw)
1024 {
1025 int steps;
1027 switch (request) {
1028 case REQ_MOVE_FIRST_LINE:
1029 steps = -view->lineno;
1030 break;
1032 case REQ_MOVE_LAST_LINE:
1033 steps = view->lines - view->lineno - 1;
1034 break;
1036 case REQ_MOVE_PAGE_UP:
1037 steps = view->height > view->lineno
1038 ? -view->lineno : -view->height;
1039 break;
1041 case REQ_MOVE_PAGE_DOWN:
1042 steps = view->lineno + view->height >= view->lines
1043 ? view->lines - view->lineno - 1 : view->height;
1044 break;
1046 case REQ_MOVE_UP:
1047 steps = -1;
1048 break;
1050 case REQ_MOVE_DOWN:
1051 steps = 1;
1052 break;
1054 default:
1055 die("request %d not handled in switch", request);
1056 }
1058 if (steps <= 0 && view->lineno == 0) {
1059 report("Cannot move beyond the first line");
1060 return;
1062 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1063 report("Cannot move beyond the last line");
1064 return;
1065 }
1067 /* Move the current line */
1068 view->lineno += steps;
1069 assert(0 <= view->lineno && view->lineno < view->lines);
1071 /* Repaint the old "current" line if we be scrolling */
1072 if (ABS(steps) < view->height) {
1073 int prev_lineno = view->lineno - steps - view->offset;
1075 wmove(view->win, prev_lineno, 0);
1076 wclrtoeol(view->win);
1077 draw_view_line(view, prev_lineno);
1078 }
1080 /* Check whether the view needs to be scrolled */
1081 if (view->lineno < view->offset ||
1082 view->lineno >= view->offset + view->height) {
1083 if (steps < 0 && -steps > view->offset) {
1084 steps = -view->offset;
1086 } else if (steps > 0) {
1087 if (view->lineno == view->lines - 1 &&
1088 view->lines > view->height) {
1089 steps = view->lines - view->offset - 1;
1090 if (steps >= view->height)
1091 steps -= view->height - 1;
1092 }
1093 }
1095 do_scroll_view(view, steps, redraw);
1096 return;
1097 }
1099 /* Draw the current line */
1100 draw_view_line(view, view->lineno - view->offset);
1102 if (!redraw)
1103 return;
1105 redrawwin(view->win);
1106 wrefresh(view->win);
1107 report("");
1108 }
1111 /*
1112 * Incremental updating
1113 */
1115 static void
1116 end_update(struct view *view)
1117 {
1118 if (!view->pipe)
1119 return;
1120 set_nonblocking_input(FALSE);
1121 if (view->pipe == stdin)
1122 fclose(view->pipe);
1123 else
1124 pclose(view->pipe);
1125 view->pipe = NULL;
1126 }
1128 static bool
1129 begin_update(struct view *view)
1130 {
1131 const char *id = view->id;
1133 if (view->pipe)
1134 end_update(view);
1136 if (opt_cmd[0]) {
1137 string_copy(view->cmd, opt_cmd);
1138 opt_cmd[0] = 0;
1139 /* When running random commands, the view ref could have become
1140 * invalid so clear it. */
1141 view->ref[0] = 0;
1142 } else {
1143 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1145 if (snprintf(view->cmd, sizeof(view->cmd), format,
1146 id, id, id, id, id) >= sizeof(view->cmd))
1147 return FALSE;
1148 }
1150 /* Special case for the pager view. */
1151 if (opt_pipe) {
1152 view->pipe = opt_pipe;
1153 opt_pipe = NULL;
1154 } else {
1155 view->pipe = popen(view->cmd, "r");
1156 }
1158 if (!view->pipe)
1159 return FALSE;
1161 set_nonblocking_input(TRUE);
1163 view->offset = 0;
1164 view->lines = 0;
1165 view->lineno = 0;
1166 string_copy(view->vid, id);
1168 if (view->line) {
1169 int i;
1171 for (i = 0; i < view->lines; i++)
1172 if (view->line[i].data)
1173 free(view->line[i].data);
1175 free(view->line);
1176 view->line = NULL;
1177 }
1179 view->start_time = time(NULL);
1181 return TRUE;
1182 }
1184 static bool
1185 update_view(struct view *view)
1186 {
1187 char buffer[BUFSIZ];
1188 char *line;
1189 struct line *tmp;
1190 /* The number of lines to read. If too low it will cause too much
1191 * redrawing (and possible flickering), if too high responsiveness
1192 * will suffer. */
1193 unsigned long lines = view->height;
1194 int redraw_from = -1;
1196 if (!view->pipe)
1197 return TRUE;
1199 /* Only redraw if lines are visible. */
1200 if (view->offset + view->height >= view->lines)
1201 redraw_from = view->lines - view->offset;
1203 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1204 if (!tmp)
1205 goto alloc_error;
1207 view->line = tmp;
1209 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1210 int linelen = strlen(line);
1212 struct line *prev = view->lines
1213 ? &view->line[view->lines - 1]
1214 : NULL;
1216 if (linelen)
1217 line[linelen - 1] = 0;
1219 if (!view->ops->read(view, prev, line))
1220 goto alloc_error;
1222 if (lines-- == 1)
1223 break;
1224 }
1226 {
1227 int digits;
1229 lines = view->lines;
1230 for (digits = 0; lines; digits++)
1231 lines /= 10;
1233 /* Keep the displayed view in sync with line number scaling. */
1234 if (digits != view->digits) {
1235 view->digits = digits;
1236 redraw_from = 0;
1237 }
1238 }
1240 if (redraw_from >= 0) {
1241 /* If this is an incremental update, redraw the previous line
1242 * since for commits some members could have changed when
1243 * loading the main view. */
1244 if (redraw_from > 0)
1245 redraw_from--;
1247 /* Incrementally draw avoids flickering. */
1248 redraw_view_from(view, redraw_from);
1249 }
1251 /* Update the title _after_ the redraw so that if the redraw picks up a
1252 * commit reference in view->ref it'll be available here. */
1253 update_view_title(view);
1255 if (ferror(view->pipe)) {
1256 report("Failed to read: %s", strerror(errno));
1257 goto end;
1259 } else if (feof(view->pipe)) {
1260 if (view == VIEW(REQ_VIEW_HELP)) {
1261 const char *msg = TIG_HELP;
1263 if (view->lines == 0) {
1264 /* Slightly ugly, but abusing view->ref keeps
1265 * the error message. */
1266 string_copy(view->ref, "No help available");
1267 msg = "The tig(1) manpage is not installed";
1268 }
1270 report("%s", msg);
1271 goto end;
1272 }
1274 report("");
1275 goto end;
1276 }
1278 return TRUE;
1280 alloc_error:
1281 report("Allocation failure");
1283 end:
1284 end_update(view);
1285 return FALSE;
1286 }
1288 enum open_flags {
1289 OPEN_DEFAULT = 0, /* Use default view switching. */
1290 OPEN_SPLIT = 1, /* Split current view. */
1291 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1292 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1293 };
1295 static void
1296 open_view(struct view *prev, enum request request, enum open_flags flags)
1297 {
1298 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1299 bool split = !!(flags & OPEN_SPLIT);
1300 bool reload = !!(flags & OPEN_RELOAD);
1301 struct view *view = VIEW(request);
1302 int nviews = displayed_views();
1303 struct view *base_view = display[0];
1305 if (view == prev && nviews == 1 && !reload) {
1306 report("Already in %s view", view->name);
1307 return;
1308 }
1310 if ((reload || strcmp(view->vid, view->id)) &&
1311 !begin_update(view)) {
1312 report("Failed to load %s view", view->name);
1313 return;
1314 }
1316 if (split) {
1317 display[current_view + 1] = view;
1318 if (!backgrounded)
1319 current_view++;
1320 } else {
1321 /* Maximize the current view. */
1322 memset(display, 0, sizeof(display));
1323 current_view = 0;
1324 display[current_view] = view;
1325 }
1327 /* Resize the view when switching between split- and full-screen,
1328 * or when switching between two different full-screen views. */
1329 if (nviews != displayed_views() ||
1330 (nviews == 1 && base_view != display[0]))
1331 resize_display();
1333 if (split && prev->lineno - prev->offset >= prev->height) {
1334 /* Take the title line into account. */
1335 int lines = prev->lineno - prev->offset - prev->height + 1;
1337 /* Scroll the view that was split if the current line is
1338 * outside the new limited view. */
1339 do_scroll_view(prev, lines, TRUE);
1340 }
1342 if (prev && view != prev) {
1343 /* Continue loading split views in the background. */
1344 if (!split)
1345 end_update(prev);
1346 else if (!backgrounded)
1347 /* "Blur" the previous view. */
1348 update_view_title(prev);
1350 view->parent = prev;
1351 }
1353 if (view->pipe) {
1354 /* Clear the old view and let the incremental updating refill
1355 * the screen. */
1356 wclear(view->win);
1357 report("");
1358 } else {
1359 redraw_view(view);
1360 if (view == VIEW(REQ_VIEW_HELP))
1361 report("%s", TIG_HELP);
1362 else
1363 report("");
1364 }
1366 /* If the view is backgrounded the above calls to report()
1367 * won't redraw the view title. */
1368 if (backgrounded)
1369 update_view_title(view);
1370 }
1373 /*
1374 * User request switch noodle
1375 */
1377 static int
1378 view_driver(struct view *view, enum request request)
1379 {
1380 int i;
1382 switch (request) {
1383 case REQ_MOVE_UP:
1384 case REQ_MOVE_DOWN:
1385 case REQ_MOVE_PAGE_UP:
1386 case REQ_MOVE_PAGE_DOWN:
1387 case REQ_MOVE_FIRST_LINE:
1388 case REQ_MOVE_LAST_LINE:
1389 move_view(view, request, TRUE);
1390 break;
1392 case REQ_SCROLL_LINE_DOWN:
1393 case REQ_SCROLL_LINE_UP:
1394 case REQ_SCROLL_PAGE_DOWN:
1395 case REQ_SCROLL_PAGE_UP:
1396 scroll_view(view, request);
1397 break;
1399 case REQ_VIEW_MAIN:
1400 case REQ_VIEW_DIFF:
1401 case REQ_VIEW_LOG:
1402 case REQ_VIEW_HELP:
1403 case REQ_VIEW_PAGER:
1404 open_view(view, request, OPEN_DEFAULT);
1405 break;
1407 case REQ_NEXT:
1408 case REQ_PREVIOUS:
1409 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1411 if (view == VIEW(REQ_VIEW_DIFF) &&
1412 view->parent == VIEW(REQ_VIEW_MAIN)) {
1413 bool redraw = display[1] == view;
1415 view = view->parent;
1416 move_view(view, request, redraw);
1417 if (redraw)
1418 update_view_title(view);
1419 } else {
1420 move_view(view, request, TRUE);
1421 break;
1422 }
1423 /* Fall-through */
1425 case REQ_ENTER:
1426 if (!view->lines) {
1427 report("Nothing to enter");
1428 break;
1429 }
1430 return view->ops->enter(view, &view->line[view->lineno]);
1432 case REQ_VIEW_NEXT:
1433 {
1434 int nviews = displayed_views();
1435 int next_view = (current_view + 1) % nviews;
1437 if (next_view == current_view) {
1438 report("Only one view is displayed");
1439 break;
1440 }
1442 current_view = next_view;
1443 /* Blur out the title of the previous view. */
1444 update_view_title(view);
1445 report("");
1446 break;
1447 }
1448 case REQ_TOGGLE_LINE_NUMBERS:
1449 opt_line_number = !opt_line_number;
1450 redraw_display();
1451 break;
1453 case REQ_PROMPT:
1454 /* Always reload^Wrerun commands from the prompt. */
1455 open_view(view, opt_request, OPEN_RELOAD);
1456 break;
1458 case REQ_STOP_LOADING:
1459 foreach_view (view, i) {
1460 if (view->pipe)
1461 report("Stopped loaded the %s view", view->name),
1462 end_update(view);
1463 }
1464 break;
1466 case REQ_SHOW_VERSION:
1467 report("%s (built %s)", VERSION, __DATE__);
1468 return TRUE;
1470 case REQ_SCREEN_RESIZE:
1471 resize_display();
1472 /* Fall-through */
1473 case REQ_SCREEN_REDRAW:
1474 redraw_display();
1475 break;
1477 case REQ_SCREEN_UPDATE:
1478 doupdate();
1479 return TRUE;
1481 case REQ_VIEW_CLOSE:
1482 if (view->parent) {
1483 memset(display, 0, sizeof(display));
1484 current_view = 0;
1485 display[current_view] = view->parent;
1486 view->parent = NULL;
1487 resize_display();
1488 redraw_display();
1489 break;
1490 }
1491 /* Fall-through */
1492 case REQ_QUIT:
1493 return FALSE;
1495 default:
1496 /* An unknown key will show most commonly used commands. */
1497 report("Unknown key, press 'h' for help");
1498 return TRUE;
1499 }
1501 return TRUE;
1502 }
1505 /*
1506 * Pager backend
1507 */
1509 static bool
1510 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1511 {
1512 char *text = line->data;
1513 enum line_type type = line->type;
1514 int textlen = strlen(text);
1515 int attr;
1517 wmove(view->win, lineno, 0);
1519 if (view->offset + lineno == view->lineno) {
1520 if (type == LINE_COMMIT) {
1521 string_copy(view->ref, text + 7);
1522 string_copy(ref_commit, view->ref);
1523 }
1525 type = LINE_CURSOR;
1526 wchgat(view->win, -1, 0, type, NULL);
1527 }
1529 attr = get_line_attr(type);
1530 wattrset(view->win, attr);
1532 if (opt_line_number || opt_tab_size < TABSIZE) {
1533 static char spaces[] = " ";
1534 int col_offset = 0, col = 0;
1536 if (opt_line_number) {
1537 unsigned long real_lineno = view->offset + lineno + 1;
1539 if (real_lineno == 1 ||
1540 (real_lineno % opt_num_interval) == 0) {
1541 wprintw(view->win, "%.*d", view->digits, real_lineno);
1543 } else {
1544 waddnstr(view->win, spaces,
1545 MIN(view->digits, STRING_SIZE(spaces)));
1546 }
1547 waddstr(view->win, ": ");
1548 col_offset = view->digits + 2;
1549 }
1551 while (text && col_offset + col < view->width) {
1552 int cols_max = view->width - col_offset - col;
1553 char *pos = text;
1554 int cols;
1556 if (*text == '\t') {
1557 text++;
1558 assert(sizeof(spaces) > TABSIZE);
1559 pos = spaces;
1560 cols = opt_tab_size - (col % opt_tab_size);
1562 } else {
1563 text = strchr(text, '\t');
1564 cols = line ? text - pos : strlen(pos);
1565 }
1567 waddnstr(view->win, pos, MIN(cols, cols_max));
1568 col += cols;
1569 }
1571 } else {
1572 int col = 0, pos = 0;
1574 for (; pos < textlen && col < view->width; pos++, col++)
1575 if (text[pos] == '\t')
1576 col += TABSIZE - (col % TABSIZE) - 1;
1578 waddnstr(view->win, text, pos);
1579 }
1581 return TRUE;
1582 }
1584 static bool
1585 pager_read(struct view *view, struct line *prev, char *line)
1586 {
1587 /* Compress empty lines in the help view. */
1588 if (view == VIEW(REQ_VIEW_HELP) &&
1589 !*line && prev && !*((char *) prev->data))
1590 return TRUE;
1592 view->line[view->lines].data = strdup(line);
1593 if (!view->line[view->lines].data)
1594 return FALSE;
1596 view->line[view->lines].type = get_line_type(line);
1598 view->lines++;
1599 return TRUE;
1600 }
1602 static bool
1603 pager_enter(struct view *view, struct line *line)
1604 {
1605 int split = 0;
1607 if (line->type == LINE_COMMIT &&
1608 (view == VIEW(REQ_VIEW_LOG) ||
1609 view == VIEW(REQ_VIEW_PAGER))) {
1610 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1611 split = 1;
1612 }
1614 /* Always scroll the view even if it was split. That way
1615 * you can use Enter to scroll through the log view and
1616 * split open each commit diff. */
1617 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1619 /* FIXME: A minor workaround. Scrolling the view will call report("")
1620 * but if we are scolling a non-current view this won't properly update
1621 * the view title. */
1622 if (split)
1623 update_view_title(view);
1625 return TRUE;
1626 }
1628 static struct view_ops pager_ops = {
1629 "line",
1630 pager_draw,
1631 pager_read,
1632 pager_enter,
1633 };
1636 /*
1637 * Main view backend
1638 */
1640 struct commit {
1641 char id[41]; /* SHA1 ID. */
1642 char title[75]; /* The first line of the commit message. */
1643 char author[75]; /* The author of the commit. */
1644 struct tm time; /* Date from the author ident. */
1645 struct ref **refs; /* Repository references; tags & branch heads. */
1646 };
1648 static bool
1649 main_draw(struct view *view, struct line *line, unsigned int lineno)
1650 {
1651 char buf[DATE_COLS + 1];
1652 struct commit *commit = line->data;
1653 enum line_type type;
1654 int col = 0;
1655 size_t timelen;
1656 size_t authorlen;
1657 int trimmed = 1;
1659 if (!*commit->author)
1660 return FALSE;
1662 wmove(view->win, lineno, col);
1664 if (view->offset + lineno == view->lineno) {
1665 string_copy(view->ref, commit->id);
1666 string_copy(ref_commit, view->ref);
1667 type = LINE_CURSOR;
1668 wattrset(view->win, get_line_attr(type));
1669 wchgat(view->win, -1, 0, type, NULL);
1671 } else {
1672 type = LINE_MAIN_COMMIT;
1673 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1674 }
1676 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1677 waddnstr(view->win, buf, timelen);
1678 waddstr(view->win, " ");
1680 col += DATE_COLS;
1681 wmove(view->win, lineno, col);
1682 if (type != LINE_CURSOR)
1683 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1685 if (opt_utf8) {
1686 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1687 } else {
1688 authorlen = strlen(commit->author);
1689 if (authorlen > AUTHOR_COLS - 2) {
1690 authorlen = AUTHOR_COLS - 2;
1691 trimmed = 1;
1692 }
1693 }
1695 if (trimmed) {
1696 waddnstr(view->win, commit->author, authorlen);
1697 if (type != LINE_CURSOR)
1698 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1699 waddch(view->win, '~');
1700 } else {
1701 waddstr(view->win, commit->author);
1702 }
1704 col += AUTHOR_COLS;
1705 if (type != LINE_CURSOR)
1706 wattrset(view->win, A_NORMAL);
1708 mvwaddch(view->win, lineno, col, ACS_LTEE);
1709 wmove(view->win, lineno, col + 2);
1710 col += 2;
1712 if (commit->refs) {
1713 size_t i = 0;
1715 do {
1716 if (type == LINE_CURSOR)
1717 ;
1718 else if (commit->refs[i]->tag)
1719 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1720 else
1721 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1722 waddstr(view->win, "[");
1723 waddstr(view->win, commit->refs[i]->name);
1724 waddstr(view->win, "]");
1725 if (type != LINE_CURSOR)
1726 wattrset(view->win, A_NORMAL);
1727 waddstr(view->win, " ");
1728 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1729 } while (commit->refs[i++]->next);
1730 }
1732 if (type != LINE_CURSOR)
1733 wattrset(view->win, get_line_attr(type));
1735 {
1736 int titlelen = strlen(commit->title);
1738 if (col + titlelen > view->width)
1739 titlelen = view->width - col;
1741 waddnstr(view->win, commit->title, titlelen);
1742 }
1744 return TRUE;
1745 }
1747 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1748 static bool
1749 main_read(struct view *view, struct line *prev, char *line)
1750 {
1751 enum line_type type = get_line_type(line);
1752 struct commit *commit;
1754 switch (type) {
1755 case LINE_COMMIT:
1756 commit = calloc(1, sizeof(struct commit));
1757 if (!commit)
1758 return FALSE;
1760 line += STRING_SIZE("commit ");
1762 view->line[view->lines++].data = commit;
1763 string_copy(commit->id, line);
1764 commit->refs = get_refs(commit->id);
1765 break;
1767 case LINE_AUTHOR:
1768 {
1769 char *ident = line + STRING_SIZE("author ");
1770 char *end = strchr(ident, '<');
1772 if (!prev)
1773 break;
1775 commit = prev->data;
1777 if (end) {
1778 for (; end > ident && isspace(end[-1]); end--) ;
1779 *end = 0;
1780 }
1782 string_copy(commit->author, ident);
1784 /* Parse epoch and timezone */
1785 if (end) {
1786 char *secs = strchr(end + 1, '>');
1787 char *zone;
1788 time_t time;
1790 if (!secs || secs[1] != ' ')
1791 break;
1793 secs += 2;
1794 time = (time_t) atol(secs);
1795 zone = strchr(secs, ' ');
1796 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1797 long tz;
1799 zone++;
1800 tz = ('0' - zone[1]) * 60 * 60 * 10;
1801 tz += ('0' - zone[2]) * 60 * 60;
1802 tz += ('0' - zone[3]) * 60;
1803 tz += ('0' - zone[4]) * 60;
1805 if (zone[0] == '-')
1806 tz = -tz;
1808 time -= tz;
1809 }
1810 gmtime_r(&time, &commit->time);
1811 }
1812 break;
1813 }
1814 default:
1815 if (!prev)
1816 break;
1818 commit = prev->data;
1820 /* Fill in the commit title if it has not already been set. */
1821 if (commit->title[0])
1822 break;
1824 /* Require titles to start with a non-space character at the
1825 * offset used by git log. */
1826 /* FIXME: More gracefull handling of titles; append "..." to
1827 * shortened titles, etc. */
1828 if (strncmp(line, " ", 4) ||
1829 isspace(line[4]))
1830 break;
1832 string_copy(commit->title, line + 4);
1833 }
1835 return TRUE;
1836 }
1838 static bool
1839 main_enter(struct view *view, struct line *line)
1840 {
1841 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1843 open_view(view, REQ_VIEW_DIFF, flags);
1844 return TRUE;
1845 }
1847 static struct view_ops main_ops = {
1848 "commit",
1849 main_draw,
1850 main_read,
1851 main_enter,
1852 };
1855 /**
1856 * KEYS
1857 * ----
1858 * Below the default key bindings are shown.
1859 **/
1861 struct keymap {
1862 int alias;
1863 int request;
1864 };
1866 static struct keymap keymap[] = {
1867 /**
1868 * View switching
1869 * ~~~~~~~~~~~~~~
1870 * m::
1871 * Switch to main view.
1872 * d::
1873 * Switch to diff view.
1874 * l::
1875 * Switch to log view.
1876 * p::
1877 * Switch to pager view.
1878 * h::
1879 * Show man page.
1880 **/
1881 { 'm', REQ_VIEW_MAIN },
1882 { 'd', REQ_VIEW_DIFF },
1883 { 'l', REQ_VIEW_LOG },
1884 { 'p', REQ_VIEW_PAGER },
1885 { 'h', REQ_VIEW_HELP },
1887 /**
1888 * View manipulation
1889 * ~~~~~~~~~~~~~~~~~
1890 * q::
1891 * Close view, if multiple views are open it will jump back to the
1892 * previous view in the view stack. If it is the last open view it
1893 * will quit. Use 'Q' to quit all views at once.
1894 * Enter::
1895 * This key is "context sensitive" depending on what view you are
1896 * currently in. When in log view on a commit line or in the main
1897 * view, split the view and show the commit diff. In the diff view
1898 * pressing Enter will simply scroll the view one line down.
1899 * Tab::
1900 * Switch to next view.
1901 * Up::
1902 * This key is "context sensitive" and will move the cursor one
1903 * line up. However, uf you opened a diff view from the main view
1904 * (split- or full-screen) it will change the cursor to point to
1905 * the previous commit in the main view and update the diff view
1906 * to display it.
1907 * Down::
1908 * Similar to 'Up' but will move down.
1909 **/
1910 { 'q', REQ_VIEW_CLOSE },
1911 { KEY_TAB, REQ_VIEW_NEXT },
1912 { KEY_RETURN, REQ_ENTER },
1913 { KEY_UP, REQ_PREVIOUS },
1914 { KEY_DOWN, REQ_NEXT },
1916 /**
1917 * Cursor navigation
1918 * ~~~~~~~~~~~~~~~~~
1919 * j::
1920 * Move cursor one line up.
1921 * k::
1922 * Move cursor one line down.
1923 * PgUp::
1924 * b::
1925 * -::
1926 * Move cursor one page up.
1927 * PgDown::
1928 * Space::
1929 * Move cursor one page down.
1930 * Home::
1931 * Jump to first line.
1932 * End::
1933 * Jump to last line.
1934 **/
1935 { 'k', REQ_MOVE_UP },
1936 { 'j', REQ_MOVE_DOWN },
1937 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1938 { KEY_END, REQ_MOVE_LAST_LINE },
1939 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1940 { ' ', REQ_MOVE_PAGE_DOWN },
1941 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1942 { 'b', REQ_MOVE_PAGE_UP },
1943 { '-', REQ_MOVE_PAGE_UP },
1945 /**
1946 * Scrolling
1947 * ~~~~~~~~~
1948 * Insert::
1949 * Scroll view one line up.
1950 * Delete::
1951 * Scroll view one line down.
1952 * w::
1953 * Scroll view one page up.
1954 * s::
1955 * Scroll view one page down.
1956 **/
1957 { KEY_IC, REQ_SCROLL_LINE_UP },
1958 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1959 { 'w', REQ_SCROLL_PAGE_UP },
1960 { 's', REQ_SCROLL_PAGE_DOWN },
1962 /**
1963 * Misc
1964 * ~~~~
1965 * Q::
1966 * Quit.
1967 * r::
1968 * Redraw screen.
1969 * z::
1970 * Stop all background loading. This can be useful if you use
1971 * tig(1) in a repository with a long history without limiting
1972 * the revision log.
1973 * v::
1974 * Show version.
1975 * n::
1976 * Toggle line numbers on/off.
1977 * ':'::
1978 * Open prompt. This allows you to specify what git command
1979 * to run. Example:
1980 *
1981 * :log -p
1982 **/
1983 { 'Q', REQ_QUIT },
1984 { 'z', REQ_STOP_LOADING },
1985 { 'v', REQ_SHOW_VERSION },
1986 { 'r', REQ_SCREEN_REDRAW },
1987 { 'n', REQ_TOGGLE_LINE_NUMBERS },
1988 { ':', REQ_PROMPT },
1990 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1991 { ERR, REQ_SCREEN_UPDATE },
1993 /* Use the ncurses SIGWINCH handler. */
1994 { KEY_RESIZE, REQ_SCREEN_RESIZE },
1995 };
1997 static enum request
1998 get_request(int key)
1999 {
2000 int i;
2002 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2003 if (keymap[i].alias == key)
2004 return keymap[i].request;
2006 return (enum request) key;
2007 }
2010 /*
2011 * Unicode / UTF-8 handling
2012 *
2013 * NOTE: Much of the following code for dealing with unicode is derived from
2014 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2015 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2016 */
2018 /* I've (over)annotated a lot of code snippets because I am not entirely
2019 * confident that the approach taken by this small UTF-8 interface is correct.
2020 * --jonas */
2022 static inline int
2023 unicode_width(unsigned long c)
2024 {
2025 if (c >= 0x1100 &&
2026 (c <= 0x115f /* Hangul Jamo */
2027 || c == 0x2329
2028 || c == 0x232a
2029 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2030 /* CJK ... Yi */
2031 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2032 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2033 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2034 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2035 || (c >= 0xffe0 && c <= 0xffe6)
2036 || (c >= 0x20000 && c <= 0x2fffd)
2037 || (c >= 0x30000 && c <= 0x3fffd)))
2038 return 2;
2040 return 1;
2041 }
2043 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2044 * Illegal bytes are set one. */
2045 static const unsigned char utf8_bytes[256] = {
2046 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,
2047 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,
2048 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2049 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2050 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2051 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2052 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,
2053 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,
2054 };
2056 /* Decode UTF-8 multi-byte representation into a unicode character. */
2057 static inline unsigned long
2058 utf8_to_unicode(const char *string, size_t length)
2059 {
2060 unsigned long unicode;
2062 switch (length) {
2063 case 1:
2064 unicode = string[0];
2065 break;
2066 case 2:
2067 unicode = (string[0] & 0x1f) << 6;
2068 unicode += (string[1] & 0x3f);
2069 break;
2070 case 3:
2071 unicode = (string[0] & 0x0f) << 12;
2072 unicode += ((string[1] & 0x3f) << 6);
2073 unicode += (string[2] & 0x3f);
2074 break;
2075 case 4:
2076 unicode = (string[0] & 0x0f) << 18;
2077 unicode += ((string[1] & 0x3f) << 12);
2078 unicode += ((string[2] & 0x3f) << 6);
2079 unicode += (string[3] & 0x3f);
2080 break;
2081 case 5:
2082 unicode = (string[0] & 0x0f) << 24;
2083 unicode += ((string[1] & 0x3f) << 18);
2084 unicode += ((string[2] & 0x3f) << 12);
2085 unicode += ((string[3] & 0x3f) << 6);
2086 unicode += (string[4] & 0x3f);
2087 break;
2088 case 6:
2089 unicode = (string[0] & 0x01) << 30;
2090 unicode += ((string[1] & 0x3f) << 24);
2091 unicode += ((string[2] & 0x3f) << 18);
2092 unicode += ((string[3] & 0x3f) << 12);
2093 unicode += ((string[4] & 0x3f) << 6);
2094 unicode += (string[5] & 0x3f);
2095 break;
2096 default:
2097 die("Invalid unicode length");
2098 }
2100 /* Invalid characters could return the special 0xfffd value but NUL
2101 * should be just as good. */
2102 return unicode > 0xffff ? 0 : unicode;
2103 }
2105 /* Calculates how much of string can be shown within the given maximum width
2106 * and sets trimmed parameter to non-zero value if all of string could not be
2107 * shown.
2108 *
2109 * Additionally, adds to coloffset how many many columns to move to align with
2110 * the expected position. Takes into account how multi-byte and double-width
2111 * characters will effect the cursor position.
2112 *
2113 * Returns the number of bytes to output from string to satisfy max_width. */
2114 static size_t
2115 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2116 {
2117 const char *start = string;
2118 const char *end = strchr(string, '\0');
2119 size_t mbwidth = 0;
2120 size_t width = 0;
2122 *trimmed = 0;
2124 while (string < end) {
2125 int c = *(unsigned char *) string;
2126 unsigned char bytes = utf8_bytes[c];
2127 size_t ucwidth;
2128 unsigned long unicode;
2130 if (string + bytes > end)
2131 break;
2133 /* Change representation to figure out whether
2134 * it is a single- or double-width character. */
2136 unicode = utf8_to_unicode(string, bytes);
2137 /* FIXME: Graceful handling of invalid unicode character. */
2138 if (!unicode)
2139 break;
2141 ucwidth = unicode_width(unicode);
2142 width += ucwidth;
2143 if (width > max_width) {
2144 *trimmed = 1;
2145 break;
2146 }
2148 /* The column offset collects the differences between the
2149 * number of bytes encoding a character and the number of
2150 * columns will be used for rendering said character.
2151 *
2152 * So if some character A is encoded in 2 bytes, but will be
2153 * represented on the screen using only 1 byte this will and up
2154 * adding 1 to the multi-byte column offset.
2155 *
2156 * Assumes that no double-width character can be encoding in
2157 * less than two bytes. */
2158 if (bytes > ucwidth)
2159 mbwidth += bytes - ucwidth;
2161 string += bytes;
2162 }
2164 *coloffset += mbwidth;
2166 return string - start;
2167 }
2170 /*
2171 * Status management
2172 */
2174 /* Whether or not the curses interface has been initialized. */
2175 static bool cursed = FALSE;
2177 /* The status window is used for polling keystrokes. */
2178 static WINDOW *status_win;
2180 /* Update status and title window. */
2181 static void
2182 report(const char *msg, ...)
2183 {
2184 static bool empty = TRUE;
2185 struct view *view = display[current_view];
2187 if (!empty || *msg) {
2188 va_list args;
2190 va_start(args, msg);
2192 werase(status_win);
2193 wmove(status_win, 0, 0);
2194 if (*msg) {
2195 vwprintw(status_win, msg, args);
2196 empty = FALSE;
2197 } else {
2198 empty = TRUE;
2199 }
2200 wrefresh(status_win);
2202 va_end(args);
2203 }
2205 update_view_title(view);
2207 /* Move the cursor to the right-most column of the cursor line.
2208 *
2209 * XXX: This could turn out to be a bit expensive, but it ensures that
2210 * the cursor does not jump around. */
2211 if (view->lines) {
2212 wmove(view->win, view->lineno - view->offset, view->width - 1);
2213 wrefresh(view->win);
2214 }
2215 }
2217 /* Controls when nodelay should be in effect when polling user input. */
2218 static void
2219 set_nonblocking_input(bool loading)
2220 {
2221 static unsigned int loading_views;
2223 if ((loading == FALSE && loading_views-- == 1) ||
2224 (loading == TRUE && loading_views++ == 0))
2225 nodelay(status_win, loading);
2226 }
2228 static void
2229 init_display(void)
2230 {
2231 int x, y;
2233 /* Initialize the curses library */
2234 if (isatty(STDIN_FILENO)) {
2235 cursed = !!initscr();
2236 } else {
2237 /* Leave stdin and stdout alone when acting as a pager. */
2238 FILE *io = fopen("/dev/tty", "r+");
2240 cursed = !!newterm(NULL, io, io);
2241 }
2243 if (!cursed)
2244 die("Failed to initialize curses");
2246 nonl(); /* Tell curses not to do NL->CR/NL on output */
2247 cbreak(); /* Take input chars one at a time, no wait for \n */
2248 noecho(); /* Don't echo input */
2249 leaveok(stdscr, TRUE);
2251 if (has_colors())
2252 init_colors();
2254 getmaxyx(stdscr, y, x);
2255 status_win = newwin(1, 0, y - 1, 0);
2256 if (!status_win)
2257 die("Failed to create status window");
2259 /* Enable keyboard mapping */
2260 keypad(status_win, TRUE);
2261 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2262 }
2265 /*
2266 * Repository references
2267 */
2269 static struct ref *refs;
2270 static size_t refs_size;
2272 /* Id <-> ref store */
2273 static struct ref ***id_refs;
2274 static size_t id_refs_size;
2276 static struct ref **
2277 get_refs(char *id)
2278 {
2279 struct ref ***tmp_id_refs;
2280 struct ref **ref_list = NULL;
2281 size_t ref_list_size = 0;
2282 size_t i;
2284 for (i = 0; i < id_refs_size; i++)
2285 if (!strcmp(id, id_refs[i][0]->id))
2286 return id_refs[i];
2288 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2289 if (!tmp_id_refs)
2290 return NULL;
2292 id_refs = tmp_id_refs;
2294 for (i = 0; i < refs_size; i++) {
2295 struct ref **tmp;
2297 if (strcmp(id, refs[i].id))
2298 continue;
2300 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2301 if (!tmp) {
2302 if (ref_list)
2303 free(ref_list);
2304 return NULL;
2305 }
2307 ref_list = tmp;
2308 if (ref_list_size > 0)
2309 ref_list[ref_list_size - 1]->next = 1;
2310 ref_list[ref_list_size] = &refs[i];
2312 /* XXX: The properties of the commit chains ensures that we can
2313 * safely modify the shared ref. The repo references will
2314 * always be similar for the same id. */
2315 ref_list[ref_list_size]->next = 0;
2316 ref_list_size++;
2317 }
2319 if (ref_list)
2320 id_refs[id_refs_size++] = ref_list;
2322 return ref_list;
2323 }
2325 static int
2326 load_refs(void)
2327 {
2328 const char *cmd_env = getenv("TIG_LS_REMOTE");
2329 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2330 FILE *pipe = popen(cmd, "r");
2331 char buffer[BUFSIZ];
2332 char *line;
2334 if (!pipe)
2335 return ERR;
2337 while ((line = fgets(buffer, sizeof(buffer), pipe))) {
2338 char *name = strchr(line, '\t');
2339 struct ref *ref;
2340 int namelen;
2341 bool tag = FALSE;
2342 bool tag_commit = FALSE;
2344 if (!name)
2345 continue;
2347 *name++ = 0;
2348 namelen = strlen(name) - 1;
2350 /* Commits referenced by tags has "^{}" appended. */
2351 if (name[namelen - 1] == '}') {
2352 while (namelen > 0 && name[namelen] != '^')
2353 namelen--;
2354 if (namelen > 0)
2355 tag_commit = TRUE;
2356 }
2357 name[namelen] = 0;
2359 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2360 if (!tag_commit)
2361 continue;
2362 name += STRING_SIZE("refs/tags/");
2363 tag = TRUE;
2365 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2366 name += STRING_SIZE("refs/heads/");
2368 } else if (!strcmp(name, "HEAD")) {
2369 continue;
2370 }
2372 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2373 if (!refs)
2374 return ERR;
2376 ref = &refs[refs_size++];
2377 ref->tag = tag;
2378 ref->name = strdup(name);
2379 if (!ref->name)
2380 return ERR;
2382 string_copy(ref->id, line);
2383 }
2385 if (ferror(pipe))
2386 return ERR;
2388 pclose(pipe);
2390 return OK;
2391 }
2393 static int
2394 load_config(void)
2395 {
2396 FILE *pipe = popen("git repo-config --list", "r");
2397 char buffer[BUFSIZ];
2398 char *name;
2400 if (!pipe)
2401 return ERR;
2403 while ((name = fgets(buffer, sizeof(buffer), pipe))) {
2404 char *value = strchr(name, '=');
2405 int valuelen, namelen;
2407 /* No boolean options, yet */
2408 if (!value)
2409 continue;
2411 namelen = value - name;
2413 *value++ = 0;
2414 valuelen = strlen(value);
2415 if (valuelen > 0)
2416 value[valuelen - 1] = 0;
2418 if (!strcmp(name, "i18n.commitencoding")) {
2419 string_copy(opt_encoding, value);
2420 }
2421 }
2423 if (ferror(pipe))
2424 return ERR;
2426 pclose(pipe);
2428 return OK;
2429 }
2431 /*
2432 * Main
2433 */
2435 #if __GNUC__ >= 3
2436 #define __NORETURN __attribute__((__noreturn__))
2437 #else
2438 #define __NORETURN
2439 #endif
2441 static void __NORETURN
2442 quit(int sig)
2443 {
2444 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2445 if (cursed)
2446 endwin();
2447 exit(0);
2448 }
2450 static void __NORETURN
2451 die(const char *err, ...)
2452 {
2453 va_list args;
2455 endwin();
2457 va_start(args, err);
2458 fputs("tig: ", stderr);
2459 vfprintf(stderr, err, args);
2460 fputs("\n", stderr);
2461 va_end(args);
2463 exit(1);
2464 }
2466 int
2467 main(int argc, char *argv[])
2468 {
2469 struct view *view;
2470 enum request request;
2471 size_t i;
2473 signal(SIGINT, quit);
2475 if (!parse_options(argc, argv))
2476 return 0;
2478 if (load_refs() == ERR)
2479 die("Failed to load refs.");
2481 /* Require a git repository unless when running in pager mode. */
2482 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2483 die("Not a git repository");
2485 if (load_config() == ERR)
2486 die("Failed to load repo config.");
2488 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2489 view->cmd_env = getenv(view->cmd_env);
2491 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
2492 opt_utf8 = FALSE;
2494 request = opt_request;
2496 init_display();
2498 while (view_driver(display[current_view], request)) {
2499 int key;
2500 int i;
2502 foreach_view (view, i)
2503 update_view(view);
2505 /* Refresh, accept single keystroke of input */
2506 key = wgetch(status_win);
2507 request = get_request(key);
2509 /* Some low-level request handling. This keeps access to
2510 * status_win restricted. */
2511 switch (request) {
2512 case REQ_PROMPT:
2513 report(":");
2514 /* Temporarily switch to line-oriented and echoed
2515 * input. */
2516 nocbreak();
2517 echo();
2519 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2520 memcpy(opt_cmd, "git ", 4);
2521 opt_request = REQ_VIEW_PAGER;
2522 } else {
2523 request = ERR;
2524 }
2526 noecho();
2527 cbreak();
2528 break;
2530 case REQ_SCREEN_RESIZE:
2531 {
2532 int height, width;
2534 getmaxyx(stdscr, height, width);
2536 /* Resize the status view and let the view driver take
2537 * care of resizing the displayed views. */
2538 wresize(status_win, 1, width);
2539 mvwin(status_win, height - 1, 0);
2540 wrefresh(status_win);
2541 break;
2542 }
2543 default:
2544 break;
2545 }
2546 }
2548 quit(0);
2550 return 0;
2551 }
2553 /**
2554 * [[refspec]]
2555 * Revision specification
2556 * ----------------------
2557 * This section describes various ways to specify what revisions to display
2558 * or otherwise limit the view to. tig(1) does not itself parse the described
2559 * revision options so refer to the relevant git man pages for futher
2560 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2561 * git-rev-list(1).
2562 *
2563 * You can tune the interaction with git by making use of the options
2564 * explained in this section. For example, by configuring the environment
2565 * variables described in the <<view-commands, "View commands">> section.
2566 *
2567 * Limit by path name
2568 * ~~~~~~~~~~~~~~~~~~
2569 * If you are interested only in those revisions that made changes to a
2570 * specific file (or even several files) list the files like this:
2571 *
2572 * $ tig log Makefile README
2573 *
2574 * To avoid ambiguity with repository references such as tag name, be sure
2575 * to separate file names from other git options using "\--". So if you
2576 * have a file named 'master' it will clash with the reference named
2577 * 'master', and thus you will have to use:
2578 *
2579 * $ tig log -- master
2580 *
2581 * NOTE: For the main view, avoiding ambiguity will in some cases require
2582 * you to specify two "\--" options. The first will make tig(1) stop
2583 * option processing and the latter will be passed to git log.
2584 *
2585 * Limit by date or number
2586 * ~~~~~~~~~~~~~~~~~~~~~~~
2587 * To speed up interaction with git, you can limit the amount of commits
2588 * to show both for the log and main view. Either limit by date using
2589 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2590 *
2591 * If you are only interested in changed that happened between two dates
2592 * you can use:
2593 *
2594 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2595 *
2596 * NOTE: If you want to avoid having to quote dates containing spaces you
2597 * can use "." instead, e.g. `--after=May.5th`.
2598 *
2599 * Limiting by commit ranges
2600 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2601 * Alternatively, commits can be limited to a specific range, such as
2602 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2603 *
2604 * $ tig log tag-1.0..tag-2.0
2605 *
2606 * This way of commit limiting makes it trivial to only browse the commits
2607 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2608 * upstream remote branch, using:
2609 *
2610 * $ tig log origin..HEAD
2611 *
2612 * will list what will be pushed to the remote branch. Optionally, the ending
2613 * 'HEAD' can be left out since it is implied.
2614 *
2615 * Limiting by reachability
2616 * ~~~~~~~~~~~~~~~~~~~~~~~~
2617 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2618 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2619 * Where reachability refers to what commits are ancestors (or part of the
2620 * history) of the branch or tagged revision in question.
2621 *
2622 * If you prefer to specify which commit to preview in this way use the
2623 * following:
2624 *
2625 * $ tig log tag-2.0 ^tag-1.0
2626 *
2627 * You can think of '^' as a negation operator. Using this alternate syntax,
2628 * it is possible to further prune commits by specifying multiple branch
2629 * cut offs.
2630 *
2631 * Combining revisions specification
2632 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2633 * Revisions options can to some degree be combined, which makes it possible
2634 * to say "show at most 20 commits from within the last month that changed
2635 * files under the Documentation/ directory."
2636 *
2637 * $ tig -- --since=1.month -n20 -- Documentation/
2638 *
2639 * Examining all repository references
2640 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2641 * In some cases, it can be useful to query changes across all references
2642 * in a repository. An example is to ask "did any line of development in
2643 * this repository change a particular file within the last week". This
2644 * can be accomplished using:
2645 *
2646 * $ tig -- --all --since=1.week -- Makefile
2647 *
2648 * BUGS
2649 * ----
2650 * Known bugs and problems:
2651 *
2652 * - In it's current state tig is pretty much UTF-8 only.
2653 *
2654 * - If the screen width is very small the main view can draw
2655 * outside the current view causing bad wrapping. Same goes
2656 * for title and status windows.
2657 *
2658 * - The cursor can wrap-around on the last line and cause the
2659 * window to scroll.
2660 *
2661 * TODO
2662 * ----
2663 * Features that should be explored.
2664 *
2665 * - Searching.
2666 *
2667 * - Locale support.
2668 *
2669 * COPYRIGHT
2670 * ---------
2671 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2672 *
2673 * This program is free software; you can redistribute it and/or modify
2674 * it under the terms of the GNU General Public License as published by
2675 * the Free Software Foundation; either version 2 of the License, or
2676 * (at your option) any later version.
2677 *
2678 * SEE ALSO
2679 * --------
2680 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2681 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2682 *
2683 * Other git repository browsers:
2684 *
2685 * - gitk(1)
2686 * - qgit(1)
2687 * - gitview(1)
2688 **/