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