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

   1 /**
   2  * TIG(1)
   3  * ======
   4  *
   5  * NAME
   6  * ----
   7  * tig - text-mode interface for git
   8  *
   9  * SYNOPSIS
  10  * --------
  11  * [verse]
  12  * tig [options]
  13  * tig [options] log  [git log options]
  14  * tig [options] diff [git diff options]
  15  * tig [options] <    [git log or git diff output]
  16  *
  17  * DESCRIPTION
  18  * -----------
  19  * Browse changes in a git repository.
  20  **/
  21
  22 #define DEBUG
  23 #ifndef DEBUG
  24 #define NDEBUG
  25 #endif
  26
  27 #ifndef VERSION
  28 #define VERSION "tig-0.1"
  29 #endif
  30
  31 #include <assert.h>
  32 #include <errno.h>
  33 #include <ctype.h>
  34 #include <signal.h>
  35 #include <stdarg.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <time.h>
  40
  41 #include <curses.h>
  42 #include <form.h>
  43
  44 static void die(const char *err, ...);
  45 static void report(const char *msg, ...);
  46
  47 /* Some ascii-shorthands that fit into the ncurses namespace. */
  48 #define KEY_TAB         9
  49 #define KEY_ESC         27
  50 #define KEY_DEL         127
  51
  52 /* View requests */
  53 enum request {
  54         /* REQ_* values from form.h is used as a basis for user actions.
  55          * Offset new values below relative to MAX_COMMAND from form.h. */
  56         REQ_OFFSET      = MAX_COMMAND,
  57
  58         /* Requests for switching between the different views. */
  59         REQ_DIFF,
  60         REQ_LOG,
  61         REQ_MAIN,
  62         REQ_VIEWS,
  63
  64         REQ_QUIT,
  65         REQ_VERSION,
  66         REQ_STOP,
  67         REQ_UPDATE,
  68         REQ_REDRAW,
  69         REQ_FIRST_LINE,
  70         REQ_LAST_LINE,
  71         REQ_LINE_NUMBER,
  72 };
  73
  74 /* The request are used for adressing the view array. */
  75 #define VIEW_OFFSET(r)  ((r) - REQ_OFFSET - 1)
  76
  77 #define SIZEOF_ID       1024
  78
  79 #define COLOR_TRANSP    (-1)
  80
  81 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
  82 #define DATE_COLS       (STRING_SIZE("2006-04-29 14:21") + 1)
  83
  84 #define ABS(x)          ((x) >= 0 ? (x) : -(x))
  85 #define MIN(x, y)       ((x) < (y) ? (x) : (y))
  86
  87 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
  88 #define STRING_SIZE(x)  (sizeof(x) - 1)
  89
  90 struct commit {
  91         char id[41];
  92         char title[75];
  93         char author[75];
  94         struct tm time;
  95 };
  96
  97
  98 /**
  99  * OPTIONS
 100  * -------
 101  **/
 102
 103 static int opt_line_number;
 104 static int opt_request = REQ_MAIN;
 105
 106 char head_id[SIZEOF_ID] = "HEAD";
 107 char commit_id[SIZEOF_ID] = "HEAD";
 108
 109 /* Returns the index of log or diff command or -1 to exit. */
 110 static int
 111 parse_options(int argc, char *argv[])
 112 {
 113         int i;
 114
 115         for (i = 1; i < argc; i++) {
 116                 char *opt = argv[i];
 117
 118                 /**
 119                  * log [options]::
 120                  *      git log options.
 121                  **/
 122                 if (!strcmp(opt, "log")) {
 123                         opt_request = REQ_LOG;
 124                         return i;
 125
 126                 /**
 127                  * diff [options]::
 128                  *      git diff options.
 129                  **/
 130                 } else if (!strcmp(opt, "diff")) {
 131                         opt_request = REQ_DIFF;
 132                         return i;
 133
 134                 /**
 135                  * -l::
 136                  *      Start up in log view.
 137                  **/
 138                 } else if (!strcmp(opt, "-l")) {
 139                         opt_request = REQ_LOG;
 140
 141                 /**
 142                  * -d::
 143                  *      Start up in diff view.
 144                  **/
 145                 } else if (!strcmp(opt, "-d")) {
 146                         opt_request = REQ_DIFF;
 147
 148                 /**
 149                  * -n, --line-number::
 150                  *      Prefix line numbers in log and diff view.
 151                  **/
 152                 } else if (!strcmp(opt, "-n") ||
 153                            !strcmp(opt, "--line-number")) {
 154                         opt_line_number = 1;
 155
 156                 /**
 157                  * -v, --version::
 158                  *      Show version and exit.
 159                  **/
 160                 } else if (!strcmp(opt, "-v") ||
 161                            !strcmp(opt, "--version")) {
 162                         printf("tig version %s\n", VERSION);
 163                         return -1;
 164
 165                 /**
 166                  * ref::
 167                  *      Commit reference, symbolic or raw SHA1 ID.
 168                  **/
 169                 } else if (opt[0] && opt[0] != '-') {
 170                         strncpy(head_id, opt, SIZEOF_ID);
 171                         strncpy(commit_id, opt, SIZEOF_ID);
 172
 173                 } else {
 174                         die("unknown command '%s'", opt);
 175                 }
 176         }
 177
 178         return i;
 179 }
 180
 181
 182 /*
 183  * Line-oriented content detection.
 184  */
 185
 186 enum line_type {
 187         LINE_DEFAULT,
 188         LINE_AUTHOR,
 189         LINE_AUTHOR_IDENT,
 190         LINE_COMMIT,
 191         LINE_COMMITTER,
 192         LINE_CURSOR,
 193         LINE_DATE,
 194         LINE_DIFF,
 195         LINE_DIFF_ADD,
 196         LINE_DIFF_CHUNK,
 197         LINE_DIFF_COPY,
 198         LINE_DIFF_DEL,
 199         LINE_DIFF_DISSIM,
 200         LINE_DIFF_NEWMODE,
 201         LINE_DIFF_OLDMODE,
 202         LINE_DIFF_RENAME,
 203         LINE_DIFF_SIM,
 204         LINE_DIFF_TREE,
 205         LINE_INDEX,
 206         LINE_MAIN_AUTHOR,
 207         LINE_MAIN_COMMIT,
 208         LINE_MAIN_DATE,
 209         LINE_MAIN_DELIM,
 210         LINE_MERGE,
 211         LINE_PARENT,
 212         LINE_SIGNOFF,
 213         LINE_STATUS,
 214         LINE_TITLE,
 215         LINE_TREE,
 216 };
 217
 218 struct line_info {
 219         enum line_type type;
 220         char *line;
 221         int linelen;
 222
 223         int fg;
 224         int bg;
 225         int attr;
 226 };
 227
 228 #define LINE(type, line, fg, bg, attr) \
 229         { LINE_##type, (line), STRING_SIZE(line), (fg), (bg), (attr) }
 230
 231 static struct line_info line_info[] = {
 232         /* Diff markup */
 233         LINE(DIFF,         "diff --git ",       COLOR_YELLOW,   COLOR_TRANSP,   0),
 234         LINE(INDEX,        "index ",            COLOR_BLUE,     COLOR_TRANSP,   0),
 235         LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_TRANSP,   0),
 236         LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_TRANSP,   0),
 237         LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_TRANSP,   0),
 238         LINE(DIFF_OLDMODE, "old mode ",         COLOR_YELLOW,   COLOR_TRANSP,   0),
 239         LINE(DIFF_NEWMODE, "new mode ",         COLOR_YELLOW,   COLOR_TRANSP,   0),
 240         LINE(DIFF_COPY,    "copy ",             COLOR_YELLOW,   COLOR_TRANSP,   0),
 241         LINE(DIFF_RENAME,  "rename ",           COLOR_YELLOW,   COLOR_TRANSP,   0),
 242         LINE(DIFF_SIM,     "similarity ",       COLOR_YELLOW,   COLOR_TRANSP,   0),
 243         LINE(DIFF_DISSIM,  "dissimilarity ",    COLOR_YELLOW,   COLOR_TRANSP,   0),
 244
 245         /* Pretty print commit header */
 246         LINE(AUTHOR,       "Author: ",          COLOR_CYAN,     COLOR_TRANSP,   0),
 247         LINE(MERGE,        "Merge: ",           COLOR_BLUE,     COLOR_TRANSP,   0),
 248         LINE(DATE,         "Date:   ",          COLOR_YELLOW,   COLOR_TRANSP,   0),
 249
 250         /* Raw commit header */
 251         LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_TRANSP,   0),
 252         LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_TRANSP,   0),
 253         LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_TRANSP,   0),
 254         LINE(AUTHOR_IDENT, "author ",           COLOR_CYAN,     COLOR_TRANSP,   0),
 255         LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_TRANSP,   0),
 256
 257         /* Misc */
 258         LINE(DIFF_TREE,    "diff-tree ",        COLOR_BLUE,     COLOR_TRANSP,   0),
 259         LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_TRANSP,   0),
 260
 261         /* UI colors */
 262         LINE(DEFAULT,      "",  COLOR_TRANSP,   COLOR_TRANSP,   A_NORMAL),
 263         LINE(CURSOR,       "",  COLOR_WHITE,    COLOR_GREEN,    A_BOLD),
 264         LINE(STATUS,       "",  COLOR_GREEN,    COLOR_TRANSP,   0),
 265         LINE(TITLE,        "",  COLOR_YELLOW,   COLOR_BLUE,     A_BOLD),
 266         LINE(MAIN_DATE,    "",  COLOR_BLUE,     COLOR_TRANSP,   0),
 267         LINE(MAIN_AUTHOR,  "",  COLOR_GREEN,    COLOR_TRANSP,   0),
 268         LINE(MAIN_COMMIT,  "",  COLOR_TRANSP,   COLOR_TRANSP,   0),
 269         LINE(MAIN_DELIM,   "",  COLOR_MAGENTA,  COLOR_TRANSP,   0),
 270 };
 271
 272 static struct line_info *
 273 get_line_info(char *line)
 274 {
 275         int linelen = strlen(line);
 276         int i;
 277
 278         for (i = 0; i < ARRAY_SIZE(line_info); i++) {
 279                 if (linelen < line_info[i].linelen
 280                     || strncasecmp(line_info[i].line, line, line_info[i].linelen))
 281                         continue;
 282
 283                 return &line_info[i];
 284         }
 285
 286         return NULL;
 287 }
 288
 289 static enum line_type
 290 get_line_type(char *line)
 291 {
 292         struct line_info *info = get_line_info(line);
 293
 294         return info ? info->type : LINE_DEFAULT;
 295 }
 296
 297 static int
 298 get_line_attr(enum line_type type)
 299 {
 300         int i;
 301
 302         for (i = 0; i < ARRAY_SIZE(line_info); i++)
 303                 if (line_info[i].type == type)
 304                         return COLOR_PAIR(line_info[i].type) | line_info[i].attr;
 305
 306         return A_NORMAL;
 307 }
 308
 309 static void
 310 init_colors(void)
 311 {
 312         int transparent_bg = COLOR_BLACK;
 313         int transparent_fg = COLOR_WHITE;
 314         int i;
 315
 316         start_color();
 317
 318         if (use_default_colors() != ERR) {
 319                 transparent_bg = -1;
 320                 transparent_fg = -1;
 321         }
 322
 323         for (i = 0; i < ARRAY_SIZE(line_info); i++) {
 324                 struct line_info *info = &line_info[i];
 325                 int bg = info->bg == COLOR_TRANSP ? transparent_bg : info->bg;
 326                 int fg = info->fg == COLOR_TRANSP ? transparent_fg : info->fg;
 327
 328                 init_pair(info->type, fg, bg);
 329         }
 330 }
 331
 332
 333 /**
 334  * KEYS
 335  * ----
 336  *
 337  * d::
 338  *      diff
 339  * l::
 340  *      log
 341  * q::
 342  *      quit
 343  * r::
 344  *      redraw screen
 345  * s::
 346  *      stop all background loading
 347  * j::
 348  *      down
 349  * k::
 350  *      up
 351  * h, ?::
 352  *      help
 353  * v::
 354  *      version
 355  **/
 356
 357 #define HELP "(d)iff, (l)og, (m)ain, (q)uit, (v)ersion, (h)elp"
 358
 359 struct keymap {
 360         int alias;
 361         int request;
 362 };
 363
 364 struct keymap keymap[] = {
 365         /* Cursor navigation */
 366         { KEY_UP,       REQ_PREV_LINE },
 367         { 'k',          REQ_PREV_LINE },
 368         { KEY_DOWN,     REQ_NEXT_LINE },
 369         { 'j',          REQ_NEXT_LINE },
 370         { KEY_HOME,     REQ_FIRST_LINE },
 371         { KEY_END,      REQ_LAST_LINE },
 372         { KEY_NPAGE,    REQ_NEXT_PAGE },
 373         { KEY_PPAGE,    REQ_PREV_PAGE },
 374
 375         /* Scrolling */
 376         { KEY_IC,       REQ_SCR_BLINE }, /* scroll field backward a line */
 377         { KEY_DC,       REQ_SCR_FLINE }, /* scroll field forward a line */
 378         { 's',          REQ_SCR_FPAGE }, /* scroll field forward a page */
 379         { 'w',          REQ_SCR_BPAGE }, /* scroll field backward a page */
 380
 381         { 'd',          REQ_DIFF },
 382         { 'l',          REQ_LOG },
 383         { 'm',          REQ_MAIN },
 384
 385         { 'n',          REQ_LINE_NUMBER },
 386
 387         /* No input from wgetch() with nodelay() enabled. */
 388         { ERR,          REQ_UPDATE },
 389
 390         { KEY_ESC,      REQ_QUIT },
 391         { 'q',          REQ_QUIT },
 392         { 's',          REQ_STOP },
 393         { 'v',          REQ_VERSION },
 394         { 'r',          REQ_REDRAW },
 395 };
 396
 397 static int
 398 get_request(int request)
 399 {
 400         int i;
 401
 402         for (i = 0; i < ARRAY_SIZE(keymap); i++)
 403                 if (keymap[i].alias == request)
 404                         return keymap[i].request;
 405
 406         return request;
 407 }
 408
 409
 410 /*
 411  * Viewer
 412  */
 413
 414 struct view {
 415         char *name;
 416         char *cmd;
 417         char *id;
 418
 419
 420         /* Rendering */
 421         int (*read)(struct view *, char *);
 422         int (*draw)(struct view *, unsigned int);
 423         size_t objsize;         /* Size of objects in the line index */
 424
 425         WINDOW *win;
 426         int height, width;
 427
 428         /* Navigation */
 429         unsigned long offset;   /* Offset of the window top */
 430         unsigned long lineno;   /* Current line number */
 431
 432         /* Buffering */
 433         unsigned long lines;    /* Total number of lines */
 434         void **line;            /* Line index */
 435
 436         /* Loading */
 437         FILE *pipe;
 438 };
 439
 440 static int pager_draw(struct view *view, unsigned int lineno);
 441 static int pager_read(struct view *view, char *line);
 442
 443 static int main_draw(struct view *view, unsigned int lineno);
 444 static int main_read(struct view *view, char *line);
 445
 446 #define DIFF_CMD \
 447         "git log --stat -n1 %s ; echo; " \
 448         "git diff --find-copies-harder -B -C %s^ %s"
 449
 450 #define LOG_CMD \
 451         "git log --stat -n100 %s"
 452
 453 #define MAIN_CMD \
 454         "git log --stat --pretty=raw %s"
 455
 456 /* The status window is used for polling keystrokes. */
 457 static WINDOW *status_win;
 458 static WINDOW *title_win;
 459
 460 /* The number of loading views. Controls when nodelay should be in effect when
 461  * polling user input. */
 462 static unsigned int nloading;
 463
 464 static struct view views[] = {
 465         { "diff",  DIFF_CMD,   commit_id,  pager_read,  pager_draw, sizeof(char) },
 466         { "log",   LOG_CMD,    head_id,    pager_read,  pager_draw, sizeof(char) },
 467         { "main",  MAIN_CMD,   head_id,    main_read,   main_draw,  sizeof(struct commit) },
 468 };
 469
 470 /* The display array of active views and the index of the current view. */
 471 static struct view *display[ARRAY_SIZE(views)];
 472 static unsigned int current_view;
 473
 474 #define foreach_view(view, i) \
 475         for (i = 0; i < sizeof(display) && (view = display[i]); i++)
 476
 477
 478 static void
 479 redraw_view(struct view *view)
 480 {
 481         int lineno;
 482
 483         wclear(view->win);
 484         wmove(view->win, 0, 0);
 485
 486         for (lineno = 0; lineno < view->height; lineno++) {
 487                 if (!view->draw(view, lineno))
 488                         break;
 489         }
 490
 491         redrawwin(view->win);
 492         wrefresh(view->win);
 493 }
 494
 495 static void
 496 resize_view(struct view *view)
 497 {
 498         int lines, cols;
 499
 500         getmaxyx(stdscr, lines, cols);
 501
 502         if (view->win) {
 503                 mvwin(view->win, 0, 0);
 504                 wresize(view->win, lines - 2, cols);
 505
 506         } else {
 507                 view->win = newwin(lines - 2, 0, 0, 0);
 508                 if (!view->win) {
 509                         report("failed to create %s view", view->name);
 510                         return;
 511                 }
 512                 scrollok(view->win, TRUE);
 513         }
 514
 515         getmaxyx(view->win, view->height, view->width);
 516 }
 517
 518 /* FIXME: Fix percentage. */
 519 static void
 520 report_position(struct view *view, int all)
 521 {
 522         report(all ? "line %d of %d (%d%%)"
 523                      : "line %d of %d",
 524                view->lineno + 1,
 525                view->lines,
 526                view->lines ? (view->lineno + 1) * 100 / view->lines : 0);
 527 }
 528
 529
 530 static void
 531 move_view(struct view *view, int lines)
 532 {
 533         /* The rendering expects the new offset. */
 534         view->offset += lines;
 535
 536         assert(0 <= view->offset && view->offset < view->lines);
 537         assert(lines);
 538
 539         if (view->height < ABS(lines)) {
 540                 redraw_view(view);
 541
 542         } else {
 543                 int line = lines > 0 ? view->height - lines : 0;
 544                 int end = line + (lines > 0 ? lines : -lines);
 545
 546                 wscrl(view->win, lines);
 547
 548                 for (; line < end; line++) {
 549                         if (!view->draw(view, line))
 550                                 break;
 551                 }
 552         }
 553
 554         /* Move current line into the view. */
 555         if (view->lineno < view->offset) {
 556                 view->lineno = view->offset;
 557                 view->draw(view, 0);
 558
 559         } else if (view->lineno >= view->offset + view->height) {
 560                 view->lineno = view->offset + view->height - 1;
 561                 view->draw(view, view->lineno - view->offset);
 562         }
 563
 564         assert(view->offset <= view->lineno && view->lineno < view->lines);
 565
 566         redrawwin(view->win);
 567         wrefresh(view->win);
 568
 569         report_position(view, lines);
 570 }
 571
 572 static void
 573 scroll_view(struct view *view, int request)
 574 {
 575         int lines = 1;
 576
 577         switch (request) {
 578         case REQ_SCR_FPAGE:
 579                 lines = view->height;
 580         case REQ_SCR_FLINE:
 581                 if (view->offset + lines > view->lines)
 582                         lines = view->lines - view->offset;
 583
 584                 if (lines == 0 || view->offset + view->height >= view->lines) {
 585                         report("already at last line");
 586                         return;
 587                 }
 588                 break;
 589
 590         case REQ_SCR_BPAGE:
 591                 lines = view->height;
 592         case REQ_SCR_BLINE:
 593                 if (lines > view->offset)
 594                         lines = view->offset;
 595
 596                 if (lines == 0) {
 597                         report("already at first line");
 598                         return;
 599                 }
 600
 601                 lines = -lines;
 602                 break;
 603         }
 604
 605         move_view(view, lines);
 606 }
 607
 608 static void
 609 navigate_view(struct view *view, int request)
 610 {
 611         int steps;
 612
 613         switch (request) {
 614         case REQ_FIRST_LINE:
 615                 steps = -view->lineno;
 616                 break;
 617
 618         case REQ_LAST_LINE:
 619                 steps = view->lines - view->lineno - 1;
 620                 break;
 621
 622         case REQ_PREV_PAGE:
 623                 steps = view->height > view->lineno
 624                       ? -view->lineno : -view->height;
 625                 break;
 626
 627         case REQ_NEXT_PAGE:
 628                 steps = view->lineno + view->height >= view->lines
 629                       ? view->lines - view->lineno - 1 : view->height;
 630                 break;
 631
 632         case REQ_PREV_LINE:
 633                 steps = -1;
 634                 break;
 635
 636         case REQ_NEXT_LINE:
 637                 steps = 1;
 638                 break;
 639         }
 640
 641         if (steps <= 0 && view->lineno == 0) {
 642                 report("already at first line");
 643                 return;
 644
 645         } else if (steps >= 0 && view->lineno + 1 == view->lines) {
 646                 report("already at last line");
 647                 return;
 648         }
 649
 650         /* Move the current line */
 651         view->lineno += steps;
 652         assert(0 <= view->lineno && view->lineno < view->lines);
 653
 654         /* Repaint the old "current" line if we be scrolling */
 655         if (ABS(steps) < view->height)
 656                 view->draw(view, view->lineno - steps - view->offset);
 657
 658         /* Check whether the view needs to be scrolled */
 659         if (view->lineno < view->offset ||
 660             view->lineno >= view->offset + view->height) {
 661                 if (steps < 0 && -steps > view->offset) {
 662                         steps = -view->offset;
 663
 664                 } else if (steps > 0) {
 665                         if (view->lineno == view->lines - 1 &&
 666                             view->lines > view->height) {
 667                                 steps = view->lines - view->offset - 1;
 668                                 if (steps >= view->height)
 669                                         steps -= view->height - 1;
 670                         }
 671                 }
 672
 673                 move_view(view, steps);
 674                 return;
 675         }
 676
 677         /* Draw the current line */
 678         view->draw(view, view->lineno - view->offset);
 679
 680         redrawwin(view->win);
 681         wrefresh(view->win);
 682
 683         report_position(view, view->height);
 684 }
 685
 686
 687
 688 static bool
 689 begin_update(struct view *view)
 690 {
 691         char buf[1024];
 692
 693         if (view->cmd) {
 694                 char *id = view->id;
 695
 696                 if (snprintf(buf, sizeof(buf), view->cmd, id, id, id) < sizeof(buf))
 697                         view->pipe = popen(buf, "r");
 698
 699                 if (!view->pipe)
 700                         return FALSE;
 701
 702                 if (nloading++ == 0)
 703                         nodelay(status_win, TRUE);
 704         }
 705
 706         display[current_view] = view;
 707
 708         view->offset = 0;
 709         view->lines  = 0;
 710         view->lineno = 0;
 711
 712         return TRUE;
 713 }
 714
 715 static void
 716 end_update(struct view *view)
 717 {
 718         wattrset(view->win, A_NORMAL);
 719         pclose(view->pipe);
 720         view->pipe = NULL;
 721
 722         if (nloading-- == 1)
 723                 nodelay(status_win, FALSE);
 724 }
 725
 726 static int
 727 update_view(struct view *view)
 728 {
 729         char buffer[BUFSIZ];
 730         char *line;
 731         void **tmp;
 732         int redraw;
 733         int lines = view->height;
 734
 735         if (!view->pipe)
 736                 return TRUE;
 737
 738         /* Only redraw after the first reading session. */
 739         /* FIXME: ... and possibly more. */
 740         redraw = view->height > view->lines;
 741
 742         tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
 743         if (!tmp)
 744                 goto alloc_error;
 745
 746         view->line = tmp;
 747
 748         while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
 749                 int linelen;
 750
 751                 linelen = strlen(line);
 752                 if (linelen)
 753                         line[linelen - 1] = 0;
 754
 755                 if (!view->read(view, line))
 756                         goto alloc_error;
 757
 758                 if (lines-- == 1)
 759                         break;
 760         }
 761
 762         if (redraw) {
 763                 /* FIXME: This causes flickering. Draw incrementally. */
 764                 redraw_view(view);
 765         }
 766
 767         if (ferror(view->pipe)) {
 768                 report("failed to read %s: %s", view->cmd, strerror(errno));
 769                 goto end;
 770
 771         } else if (feof(view->pipe)) {
 772                 report_position(view, 0);
 773                 goto end;
 774         }
 775
 776         return TRUE;
 777
 778 alloc_error:
 779         report("allocation failure");
 780
 781 end:
 782         end_update(view);
 783         return FALSE;
 784 }
 785
 786
 787 static struct view *
 788 switch_view(struct view *prev, int request)
 789 {
 790         struct view *view = &views[VIEW_OFFSET(request)];
 791         struct view *displayed;
 792         int i;
 793
 794         if (view == prev) {
 795                 foreach_view (displayed, i) ;
 796
 797                 if (i == 1)
 798                         report("already in %s view", view->name);
 799                 else
 800                         report("FIXME: Maximize");
 801
 802                 return view;
 803
 804         } else {
 805                 foreach_view (displayed, i) {
 806                         if (view == displayed) {
 807                                 current_view = i;
 808                                 report("new current view");
 809                                 return view;
 810                         }
 811                 }
 812         }
 813
 814         if (!view->win)
 815                 resize_view(view);
 816
 817         /* Reload */
 818
 819         if (view->line) {
 820                 for (i = 0; i < view->lines; i++)
 821                         if (view->line[i])
 822                                 free(view->line[i]);
 823
 824                 free(view->line);
 825                 view->line = NULL;
 826         }
 827
 828         if (prev && prev->pipe)
 829                 end_update(prev);
 830
 831         if (begin_update(view)) {
 832                 if (!view->cmd)
 833                         report("%s", HELP);
 834                 else
 835                         report("loading...");
 836         }
 837
 838         return view;
 839 }
 840
 841
 842 /* Process a keystroke */
 843 static int
 844 view_driver(struct view *view, int key)
 845 {
 846         int request = get_request(key);
 847         int i;
 848
 849         switch (request) {
 850         case REQ_NEXT_LINE:
 851         case REQ_PREV_LINE:
 852         case REQ_FIRST_LINE:
 853         case REQ_LAST_LINE:
 854         case REQ_NEXT_PAGE:
 855         case REQ_PREV_PAGE:
 856                 if (view)
 857                         navigate_view(view, request);
 858                 break;
 859
 860         case REQ_SCR_FLINE:
 861         case REQ_SCR_BLINE:
 862         case REQ_SCR_FPAGE:
 863         case REQ_SCR_BPAGE:
 864                 if (view)
 865                         scroll_view(view, request);
 866                 break;
 867
 868         case REQ_MAIN:
 869         case REQ_LOG:
 870         case REQ_DIFF:
 871                 view = switch_view(view, request);
 872                 break;
 873
 874         case REQ_LINE_NUMBER:
 875                 opt_line_number = !opt_line_number;
 876                 redraw_view(view);
 877                 break;
 878
 879         case REQ_REDRAW:
 880                 redraw_view(view);
 881                 break;
 882
 883         case REQ_STOP:
 884                 foreach_view (view, i) {
 885                         if (view->pipe) {
 886                                 end_update(view);
 887                                 scroll_view(view, 0);
 888                         }
 889                 }
 890                 break;
 891
 892         case REQ_VERSION:
 893                 report("version %s", VERSION);
 894                 return TRUE;
 895
 896         case REQ_UPDATE:
 897                 doupdate();
 898                 return TRUE;
 899
 900         case REQ_QUIT:
 901                 return FALSE;
 902
 903         default:
 904                 report(HELP);
 905                 return TRUE;
 906         }
 907
 908         return TRUE;
 909 }
 910
 911
 912 /*
 913  * Rendering
 914  */
 915
 916 static int
 917 pager_draw(struct view *view, unsigned int lineno)
 918 {
 919         enum line_type type;
 920         char *line;
 921         int linelen;
 922         int attr;
 923
 924         if (view->offset + lineno >= view->lines)
 925                 return FALSE;
 926
 927         line = view->line[view->offset + lineno];
 928         type = get_line_type(line);
 929
 930         if (view->offset + lineno == view->lineno) {
 931                 if (type == LINE_COMMIT)
 932                         strncpy(commit_id, line + 7, SIZEOF_ID);
 933                 type = LINE_CURSOR;
 934         }
 935
 936         attr = get_line_attr(type);
 937         wattrset(view->win, attr);
 938
 939         linelen = strlen(line);
 940         linelen = MIN(linelen, view->width);
 941
 942         if (opt_line_number) {
 943                 wmove(view->win, lineno, 0);
 944                 lineno += view->offset + 1;
 945                 if (lineno == 1 || (lineno % 10) == 0)
 946                         wprintw(view->win, "%4d: ", lineno);
 947                 else
 948                         wprintw(view->win, "    : ", lineno);
 949
 950                 while (line) {
 951                         if (*line == '\t') {
 952                                 waddstr(view->win, "        ");
 953                                 line++;
 954                         } else {
 955                                 char *tab = strchr(line, '\t');
 956
 957                                 if (tab)
 958                                         waddnstr(view->win, line, tab - line);
 959                                 else
 960                                         waddstr(view->win, line);
 961                                 line = tab;
 962                         }
 963                 }
 964                 waddstr(view->win, line);
 965
 966         } else {
 967                 /* No empty lines makes cursor drawing and clearing implicit. */
 968                 if (!*line)
 969                         line = " ", linelen = 1;
 970                 mvwaddnstr(view->win, lineno, 0, line, linelen);
 971         }
 972
 973         return TRUE;
 974 }
 975
 976 static int
 977 pager_read(struct view *view, char *line)
 978 {
 979         view->line[view->lines] = strdup(line);
 980         if (!view->line[view->lines])
 981                 return FALSE;
 982
 983         view->lines++;
 984         return TRUE;
 985 }
 986
 987 static int
 988 main_draw(struct view *view, unsigned int lineno)
 989 {
 990         char buf[21];
 991         struct commit *commit;
 992         enum line_type type;
 993         int cols = 0;
 994         size_t timelen;
 995
 996         if (view->offset + lineno >= view->lines)
 997                 return FALSE;
 998
 999         commit = view->line[view->offset + lineno];
1000         if (!*commit->author)
1001                 return FALSE;
1002
1003         if (view->offset + lineno == view->lineno) {
1004                 strncpy(commit_id, commit->id, SIZEOF_ID);
1005                 type = LINE_CURSOR;
1006         } else {
1007                 type = LINE_MAIN_COMMIT;
1008         }
1009
1010         wmove(view->win, lineno, cols);
1011         wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1012
1013         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1014         waddnstr(view->win, buf, timelen);
1015         waddstr(view->win, " ");
1016
1017         cols += DATE_COLS;
1018         wmove(view->win, lineno, cols);
1019         wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1020
1021         if (strlen(commit->author) > 19) {
1022                 waddnstr(view->win, commit->author, 18);
1023                 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1024                 waddch(view->win, '~');
1025         } else {
1026                 waddstr(view->win, commit->author);
1027         }
1028
1029         cols += 20;
1030         wattrset(view->win, A_NORMAL);
1031         mvwaddch(view->win, lineno, cols, ACS_LTEE);
1032         wattrset(view->win, get_line_attr(type));
1033         mvwaddstr(view->win, lineno, cols + 2, commit->title);
1034         wattrset(view->win, A_NORMAL);
1035
1036         return TRUE;
1037 }
1038
1039 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1040 static int
1041 main_read(struct view *view, char *line)
1042 {
1043         enum line_type type = get_line_type(line);
1044         struct commit *commit;
1045
1046         switch (type) {
1047         case LINE_COMMIT:
1048                 commit = calloc(1, sizeof(struct commit));
1049                 if (!commit)
1050                         return FALSE;
1051
1052                 line += STRING_SIZE("commit ");
1053
1054                 view->line[view->lines++] = commit;
1055                 strncpy(commit->id, line, sizeof(commit->id));
1056                 break;
1057
1058         case LINE_AUTHOR_IDENT:
1059         {
1060                 char *ident = line + STRING_SIZE("author ");
1061                 char *end = strchr(ident, '<');
1062
1063                 if (end) {
1064                         for (; end > ident && isspace(end[-1]); end--) ;
1065                         *end = 0;
1066                 }
1067
1068                 commit = view->line[view->lines - 1];
1069                 strncpy(commit->author, ident, sizeof(commit->author));
1070
1071                 /* Parse epoch and timezone */
1072                 if (end) {
1073                         char *secs = strchr(end + 1, '>');
1074                         char *zone;
1075                         time_t time;
1076
1077                         if (!secs || secs[1] != ' ')
1078                                 break;
1079
1080                         secs += 2;
1081                         time = (time_t) atol(secs);
1082                         zone = strchr(secs, ' ');
1083                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1084                                 long tz;
1085
1086                                 zone++;
1087                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
1088                                 tz += ('0' - zone[2]) * 60 * 60;
1089                                 tz += ('0' - zone[3]) * 60;
1090                                 tz += ('0' - zone[4]) * 60;
1091
1092                                 if (zone[0] == '-')
1093                                         tz = -tz;
1094
1095                                 time -= tz;
1096                         }
1097                         gmtime_r(&time, &commit->time);
1098                 }
1099                 break;
1100         }
1101         default:
1102                 /* Fill in the commit title */
1103                 commit = view->line[view->lines - 1];
1104                 if (!commit->title[0] &&
1105                     !strncmp(line, "    ", 4) &&
1106                     !isspace(line[5]))
1107                         strncpy(commit->title, line + 4, sizeof(commit->title));
1108         }
1109
1110         return TRUE;
1111 }
1112
1113
1114 /*
1115  * Main
1116  */
1117
1118 static void
1119 quit(int sig)
1120 {
1121         if (status_win)
1122                 delwin(status_win);
1123         if (title_win)
1124                 delwin(title_win);
1125         endwin();
1126
1127         /* FIXME: Shutdown gracefully. */
1128
1129         exit(0);
1130 }
1131
1132 static void die(const char *err, ...)
1133 {
1134         va_list args;
1135
1136         endwin();
1137
1138         va_start(args, err);
1139         fputs("tig: ", stderr);
1140         vfprintf(stderr, err, args);
1141         fputs("\n", stderr);
1142         va_end(args);
1143
1144         exit(1);
1145 }
1146
1147 static void
1148 report(const char *msg, ...)
1149 {
1150         va_list args;
1151
1152         werase(title_win);
1153         wmove(title_win, 0, 0);
1154         wprintw(title_win, "commit %s", commit_id);
1155         wrefresh(title_win);
1156
1157         va_start(args, msg);
1158
1159         werase(status_win);
1160         wmove(status_win, 0, 0);
1161
1162 #if 0
1163         if (display[current_view])
1164                 wprintw(status_win, "%s %4s: ", commit_id, display[current_view]->name);
1165 #endif
1166         vwprintw(status_win, msg, args);
1167         wrefresh(status_win);
1168
1169         va_end(args);
1170 }
1171
1172 int
1173 main(int argc, char *argv[])
1174 {
1175         int x, y;
1176         int request;
1177         int git_cmd;
1178
1179         signal(SIGINT, quit);
1180
1181         git_cmd = parse_options(argc, argv);
1182         if (git_cmd < 0)
1183                 return 0;
1184
1185         request = opt_request;
1186
1187         initscr();      /* initialize the curses library */
1188         nonl();         /* tell curses not to do NL->CR/NL on output */
1189         cbreak();       /* take input chars one at a time, no wait for \n */
1190         noecho();       /* don't echo input */
1191         leaveok(stdscr, TRUE);
1192         /* curs_set(0); */
1193
1194         if (has_colors())
1195                 init_colors();
1196
1197         getmaxyx(stdscr, y, x);
1198         status_win = newwin(1, 0, y - 1, 0);
1199         if (!status_win)
1200                 die("Failed to create status window");
1201
1202         title_win = newwin(1, 0, y - 2, 0);
1203         if (!title_win)
1204                 die("Failed to create title window");
1205
1206         /* Enable keyboard mapping */
1207         keypad(status_win, TRUE);
1208         wbkgdset(status_win, get_line_attr(LINE_STATUS));
1209         wbkgdset(title_win, get_line_attr(LINE_TITLE));
1210
1211         while (view_driver(display[current_view], request)) {
1212                 struct view *view;
1213                 int i;
1214
1215                 foreach_view (view, i) {
1216                         if (view->pipe) {
1217                                 update_view(view);
1218                         }
1219                 }
1220
1221                 /* Refresh, accept single keystroke of input */
1222                 request = wgetch(status_win);
1223                 if (request == KEY_RESIZE) {
1224                         int lines, cols;
1225
1226                         getmaxyx(stdscr, lines, cols);
1227
1228                         mvwin(status_win, lines - 1, 0);
1229                         wresize(status_win, 1, cols - 1);
1230
1231                         mvwin(title_win, lines - 2, 0);
1232                         wresize(title_win, 1, cols - 1);
1233                 }
1234         }
1235
1236         quit(0);
1237
1238         return 0;
1239 }
1240
1241 /**
1242  * BUGS
1243  * ----
1244  * Known bugs and problems:
1245  *
1246  * Redrawing of the main view while loading::
1247  *      If only part of a commit has been parsed not all fields will be visible
1248  *      or even redrawn when the whole commit have loaded. This can be
1249  *      triggered when continuously moving to the last line. Use 'r' to redraw
1250  *      the whole screen.
1251  *
1252  * TODO
1253  * ----
1254  * Features that should be explored.
1255  *
1256  *  - Proper command line handling; ability to take the command that should be
1257  *    shown. Example:
1258  *
1259  *      $ tig log -p
1260  *
1261  *  - Internal command line (exmode-inspired) which allows to specify what git
1262  *    log or git diff command to run. Example:
1263  *
1264  *      :log -p
1265  *
1266  * - Proper resizing support. I am yet to figure out whether catching SIGWINCH
1267  *   is preferred over using ncurses' built-in support for resizing.
1268  *
1269  * - Locale support.
1270  *
1271  * COPYRIGHT
1272  * ---------
1273  * Copyright (c) Jonas Fonseca, 2006
1274  *
1275  * This program is free software; you can redistribute it and/or modify
1276  * it under the terms of the GNU General Public License as published by
1277  * the Free Software Foundation; either version 2 of the License, or
1278  * (at your option) any later version.
1279  *
1280  * SEE ALSO
1281  * --------
1282  * [verse]
1283  * link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
1284  * link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
1285  * gitk(1): git repository browser written using tcl/tk,
1286  * gitview(1): git repository browser written using python/gtk.
1287  **/