git.oblomov.eu Git - tig/blob - tig.c

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