src/main.c

   1 /* Copyright (c) 2006-2014 Jonas Fonseca <jonas.fonseca@gmail.com>
   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 #include "tig/repo.h"
  15 #include "tig/options.h"
  16 #include "tig/parse.h"
  17 #include "tig/watch.h"
  18 #include "tig/graph.h"
  19 #include "tig/display.h"
  20 #include "tig/view.h"
  21 #include "tig/draw.h"
  22 #include "tig/git.h"
  23 #include "tig/status.h"
  24 #include "tig/stage.h"
  25 #include "tig/main.h"
  26 #include "tig/diff.h"
  27
  28 /*
  29  * Main view backend
  30  */
  31
  32 DEFINE_ALLOCATOR(realloc_reflogs, char *, 32)
  33
  34 static void
  35 main_register_commit(struct view *view, struct commit *commit, const char *ids, bool is_boundary)
  36 {
  37         struct main_state *state = view->private;
  38
  39         string_copy_rev(commit->id, ids);
  40         if (state->with_graph)
  41                 graph_add_commit(state->graph, &commit->graph, commit->id, ids, is_boundary);
  42 }
  43
  44 static struct commit *
  45 main_add_commit(struct view *view, enum line_type type, struct commit *template,
  46                 const char *title, bool custom)
  47 {
  48         struct main_state *state = view->private;
  49         size_t titlelen;
  50         struct commit *commit;
  51         char buf[SIZEOF_STR / 2];
  52         struct line *line;
  53
  54         /* FIXME: More graceful handling of titles; append "..." to
  55          * shortened titles, etc. */
  56         string_expand(buf, sizeof(buf), title, 1);
  57         title = buf;
  58         titlelen = strlen(title);
  59
  60         line = add_line_alloc(view, &commit, type, titlelen, custom);
  61         if (!line)
  62                 return NULL;
  63
  64         *commit = *template;
  65         strncpy(commit->title, title, titlelen);
  66         memset(template, 0, sizeof(*template));
  67         state->reflogmsg[0] = 0;
  68
  69         view_column_info_update(view, line);
  70         return commit;
  71 }
  72
  73 static inline void
  74 main_flush_commit(struct view *view, struct commit *commit)
  75 {
  76         if (*commit->id)
  77                 main_add_commit(view, LINE_MAIN_COMMIT, commit, "", FALSE);
  78 }
  79
  80 static bool
  81 main_add_changes_commit(struct view *view, enum line_type type, const char *parent, const char *title)
  82 {
  83         char ids[SIZEOF_STR] = NULL_ID " ";
  84         struct main_state *state = view->private;
  85         struct commit commit = {};
  86         struct timeval now;
  87         struct timezone tz;
  88
  89         if (!parent)
  90                 return TRUE;
  91
  92         if (*parent)
  93                 string_copy_rev(ids + STRING_SIZE(NULL_ID " "), parent);
  94         else
  95                 ids[STRING_SIZE(NULL_ID)] = 0;
  96
  97         if (!gettimeofday(&now, &tz)) {
  98                 commit.time.tz = tz.tz_minuteswest * 60;
  99                 commit.time.sec = now.tv_sec - commit.time.tz;
 100         }
 101
 102         commit.author = &unknown_ident;
 103         main_register_commit(view, &commit, ids, FALSE);
 104         if (state->with_graph && *parent)
 105                 graph_render_parents(state->graph, &commit.graph);
 106
 107         if (!main_add_commit(view, type, &commit, title, TRUE))
 108                 return FALSE;
 109
 110         return TRUE;
 111 }
 112
 113 static bool
 114 main_check_index(struct view *view, struct main_state *state)
 115 {
 116         struct index_diff diff;
 117
 118         if (!index_diff(&diff, FALSE, FALSE))
 119                 return FALSE;
 120
 121         if (!diff.unstaged) {
 122                 watch_apply(&view->watch, WATCH_INDEX_UNSTAGED_NO);
 123         } else {
 124                 watch_apply(&view->watch, WATCH_INDEX_UNSTAGED_YES);
 125                 state->add_changes_unstaged = TRUE;
 126         }
 127
 128         if (!diff.staged) {
 129                 watch_apply(&view->watch, WATCH_INDEX_STAGED_NO);
 130         } else {
 131                 watch_apply(&view->watch, WATCH_INDEX_STAGED_YES);
 132                 state->add_changes_staged = TRUE;
 133         }
 134
 135         return TRUE;
 136 }
 137
 138 static bool
 139 main_add_changes(struct view *view, struct main_state *state, const char *parent)
 140 {
 141         const char *staged_parent = NULL_ID;
 142         const char *unstaged_parent = parent;
 143
 144         if (!state->add_changes_unstaged) {
 145                 unstaged_parent = NULL;
 146                 staged_parent = parent;
 147         }
 148
 149         if (!state->add_changes_staged) {
 150                 staged_parent = NULL;
 151         }
 152
 153         return main_add_changes_commit(view, LINE_STAT_STAGED, staged_parent, "Staged changes")
 154             && main_add_changes_commit(view, LINE_STAT_UNSTAGED, unstaged_parent, "Unstaged changes");
 155 }
 156
 157 static bool
 158 main_check_argv(struct view *view, const char *argv[])
 159 {
 160         struct main_state *state = view->private;
 161         bool with_reflog = FALSE;
 162         int i;
 163
 164         for (i = 0; argv[i]; i++) {
 165                 const char *arg = argv[i];
 166                 struct rev_flags rev_flags = {};
 167
 168                 if (!strcmp(arg, "--graph")) {
 169                         struct view_column *column = get_view_column(view, VIEW_COLUMN_COMMIT_TITLE);
 170
 171                         if (column) {
 172                                 column->opt.commit_title.graph = TRUE;
 173                                 if (opt_commit_order != COMMIT_ORDER_REVERSE)
 174                                         state->with_graph = TRUE;
 175                         }
 176                         argv[i] = "";
 177                         continue;
 178                 }
 179
 180                 if (!strcmp(arg, "--first-parent"))
 181                         state->first_parent = TRUE;
 182
 183                 if (!argv_parse_rev_flag(arg, &rev_flags))
 184                         continue;
 185
 186                 if (rev_flags.with_reflog)
 187                         with_reflog = TRUE;
 188                 if (!rev_flags.with_graph)
 189                         state->with_graph = FALSE;
 190                 arg += rev_flags.search_offset;
 191                 if (*arg && !*view->env->search)
 192                         string_ncopy(view->env->search, arg, strlen(arg));
 193         }
 194
 195         return with_reflog;
 196 }
 197
 198 static enum graph_display
 199 main_with_graph(struct view *view, enum open_flags flags)
 200 {
 201         struct view_column *column = get_view_column(view, VIEW_COLUMN_COMMIT_TITLE);
 202
 203         return column && opt_commit_order != COMMIT_ORDER_REVERSE && !open_in_pager_mode(flags)
 204                ? column->opt.commit_title.graph : GRAPH_DISPLAY_NO;
 205 }
 206
 207 static bool
 208 main_open(struct view *view, enum open_flags flags)
 209 {
 210         enum graph_display graph_display = main_with_graph(view, flags);
 211         const char *pretty_custom_argv[] = {
 212                 GIT_MAIN_LOG_CUSTOM(encoding_arg, commit_order_arg_with_graph(graph_display),
 213                         "%(cmdlineargs)", "%(revargs)", "%(fileargs)")
 214         };
 215         const char *pretty_raw_argv[] = {
 216                 GIT_MAIN_LOG_RAW(encoding_arg, commit_order_arg_with_graph(graph_display),
 217                         "%(cmdlineargs)", "%(revargs)", "%(fileargs)")
 218         };
 219         struct main_state *state = view->private;
 220         const char **main_argv = pretty_custom_argv;
 221         enum watch_trigger changes_triggers = WATCH_NONE;
 222
 223         if (opt_show_changes && repo.is_inside_work_tree)
 224                 changes_triggers |= WATCH_INDEX;
 225
 226         state->with_graph = graph_display != GRAPH_DISPLAY_NO;
 227
 228         if (opt_rev_args && main_check_argv(view, opt_rev_args))
 229                 main_argv = pretty_raw_argv;
 230
 231         if (state->with_graph) {
 232                 state->graph = init_graph();
 233                 if (!state->graph)
 234                         return FALSE;
 235         }
 236
 237         if (open_in_pager_mode(flags)) {
 238                 changes_triggers = WATCH_NONE;
 239         }
 240
 241         /* This calls reset_view() so must be before adding changes commits. */
 242         if (!begin_update(view, NULL, main_argv, flags))
 243                 return FALSE;
 244
 245         /* Register watch before changes commits are added to record the
 246          * start. */
 247         if (view_can_refresh(view))
 248                 watch_register(&view->watch, WATCH_HEAD | WATCH_REFS | changes_triggers);
 249
 250         if (changes_triggers)
 251                 main_check_index(view, state);
 252
 253         return TRUE;
 254 }
 255
 256 void
 257 main_done(struct view *view)
 258 {
 259         struct main_state *state = view->private;
 260         int i;
 261
 262         for (i = 0; i < view->lines; i++) {
 263                 struct commit *commit = view->line[i].data;
 264
 265                 free(commit->graph.symbols);
 266         }
 267
 268         for (i = 0; i < state->reflogs; i++)
 269                 free(state->reflog[i]);
 270         free(state->reflog);
 271 }
 272
 273 #define main_check_commit_refs(line)    !((line)->no_commit_refs)
 274 #define main_mark_no_commit_refs(line)  (((struct line *) (line))->no_commit_refs = 1)
 275
 276 static inline struct ref_list *
 277 main_get_commit_refs(const struct line *line, struct commit *commit)
 278 {
 279         struct ref_list *refs = NULL;
 280
 281         if (main_check_commit_refs(line) && !(refs = get_ref_list(commit->id)))
 282                 main_mark_no_commit_refs(line);
 283
 284         return refs;
 285 }
 286
 287 bool
 288 main_get_column_data(struct view *view, const struct line *line, struct view_column_data *column_data)
 289 {
 290         struct main_state *state = view->private;
 291         struct commit *commit = line->data;
 292         struct ref_list *refs = NULL;
 293
 294         column_data->author = commit->author;
 295         column_data->date = &commit->time;
 296         column_data->id = commit->id;
 297         if (state->reflogs)
 298                 column_data->reflog = state->reflog[line->lineno - 1];
 299
 300         column_data->commit_title = commit->title;
 301         if (state->with_graph)
 302                 column_data->graph = &commit->graph;
 303
 304         if ((refs = main_get_commit_refs(line, commit)))
 305                 column_data->refs = refs;
 306
 307         return TRUE;
 308 }
 309
 310 static bool
 311 main_add_reflog(struct view *view, struct main_state *state, char *reflog)
 312 {
 313         char *end = strchr(reflog, ' ');
 314         int id_width;
 315
 316         if (!end)
 317                 return FALSE;
 318         *end = 0;
 319
 320         if (!realloc_reflogs(&state->reflog, state->reflogs, 1)
 321             || !(reflog = strdup(reflog)))
 322                 return FALSE;
 323
 324         state->reflog[state->reflogs++] = reflog;
 325         id_width = strlen(reflog);
 326         if (state->reflog_width < id_width) {
 327                 struct view_column *column = get_view_column(view, VIEW_COLUMN_ID);
 328
 329                 state->reflog_width = id_width;
 330                 if (column && column->opt.id.display)
 331                         view->force_redraw = TRUE;
 332         }
 333
 334         return TRUE;
 335 }
 336
 337 /* Reads git log --pretty=raw output and parses it into the commit struct. */
 338 bool
 339 main_read(struct view *view, struct buffer *buf)
 340 {
 341         struct main_state *state = view->private;
 342         struct graph *graph = state->graph;
 343         enum line_type type;
 344         struct commit *commit = &state->current;
 345         char *line;
 346
 347         if (!buf) {
 348                 main_flush_commit(view, commit);
 349
 350                 if (failed_to_load_initial_view(view))
 351                         die("No revisions match the given arguments.");
 352                 if (view->lines > 0) {
 353                         struct commit *last = view->line[view->lines - 1].data;
 354
 355                         view->line[view->lines - 1].dirty = 1;
 356                         if (!last->author) {
 357                                 view->lines--;
 358                                 free(last);
 359                         }
 360                 }
 361
 362                 if (state->graph) {
 363                         done_graph(graph);
 364                         state->graph = NULL;
 365                 }
 366                 return TRUE;
 367         }
 368
 369         line = buf->data;
 370         type = get_line_type(line);
 371         if (type == LINE_COMMIT) {
 372                 bool is_boundary;
 373                 char *author;
 374
 375                 state->in_header = TRUE;
 376                 line += STRING_SIZE("commit ");
 377                 is_boundary = *line == '-';
 378                 while (*line && !isalnum(*line))
 379                         line++;
 380
 381                 if (state->add_changes_unstaged || state->add_changes_staged) {
 382                         main_add_changes(view, state, line);
 383                         state->add_changes_unstaged = state->add_changes_staged = FALSE;
 384                 }
 385
 386                 main_flush_commit(view, commit);
 387
 388                 author = io_memchr(buf, line, 0);
 389
 390                 if (state->first_parent) {
 391                         char *parent = strchr(line, ' ');
 392                         char *parent_end = parent ? strchr(parent + 1, ' ') : NULL;
 393
 394                         if (parent_end)
 395                                 *parent_end = 0;
 396
 397                         io_trace("[parent] %s\n", line);
 398                 }
 399
 400                 main_register_commit(view, &state->current, line, is_boundary);
 401
 402                 if (author) {
 403                         char *title = io_memchr(buf, author, 0);
 404
 405                         parse_author_line(author, &commit->author, &commit->time);
 406                         if (state->with_graph)
 407                                 graph_render_parents(graph, &commit->graph);
 408                         if (title)
 409                                 main_add_commit(view, LINE_MAIN_COMMIT, commit, title, FALSE);
 410                 }
 411
 412                 return TRUE;
 413         }
 414
 415         if (!*commit->id)
 416                 return TRUE;
 417
 418         /* Empty line separates the commit header from the log itself. */
 419         if (*line == '\0')
 420                 state->in_header = FALSE;
 421
 422         switch (type) {
 423         case LINE_PP_REFLOG:
 424                 if (!main_add_reflog(view, state, line + STRING_SIZE("Reflog: ")))
 425                         return FALSE;
 426                 break;
 427
 428         case LINE_PP_REFLOGMSG:
 429                 line += STRING_SIZE("Reflog message: ");
 430                 string_ncopy(state->reflogmsg, line, strlen(line));
 431                 break;
 432
 433         case LINE_PARENT:
 434                 if (state->with_graph && !graph->has_parents)
 435                         graph_add_parent(graph, line + STRING_SIZE("parent "));
 436                 break;
 437
 438         case LINE_AUTHOR:
 439                 parse_author_line(line + STRING_SIZE("author "),
 440                                   &commit->author, &commit->time);
 441                 if (state->with_graph)
 442                         graph_render_parents(graph, &commit->graph);
 443                 break;
 444
 445         default:
 446                 /* Fill in the commit title if it has not already been set. */
 447                 if (*commit->title)
 448                         break;
 449
 450                 /* Skip lines in the commit header. */
 451                 if (state->in_header)
 452                         break;
 453
 454                 /* Require titles to start with a non-space character at the
 455                  * offset used by git log. */
 456                 if (strncmp(line, "    ", 4))
 457                         break;
 458                 line += 4;
 459                 /* Well, if the title starts with a whitespace character,
 460                  * try to be forgiving.  Otherwise we end up with no title. */
 461                 while (isspace(*line))
 462                         line++;
 463                 if (*line == '\0')
 464                         break;
 465                 if (*state->reflogmsg)
 466                         line = state->reflogmsg;
 467                 main_add_commit(view, LINE_MAIN_COMMIT, commit, line, FALSE);
 468         }
 469
 470         return TRUE;
 471 }
 472
 473 enum request
 474 main_request(struct view *view, enum request request, struct line *line)
 475 {
 476         enum open_flags flags = (view_is_displayed(view) && request != REQ_VIEW_DIFF)
 477                                 ? OPEN_SPLIT : OPEN_DEFAULT;
 478
 479         switch (request) {
 480         case REQ_NEXT:
 481         case REQ_PREVIOUS:
 482                 if (view_is_displayed(view) && display[0] != view)
 483                         return request;
 484                 /* Do not pass navigation requests to the branch view
 485                  * when the main view is maximized. (GH #38) */
 486                 return request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
 487
 488         case REQ_VIEW_DIFF:
 489         case REQ_ENTER:
 490                 if (view_is_displayed(view) && display[0] != view)
 491                         maximize_view(view, TRUE);
 492
 493                 if (line->type == LINE_STAT_UNSTAGED
 494                     || line->type == LINE_STAT_STAGED)
 495                         open_stage_view(view, NULL, line->type, flags);
 496                 else
 497                         open_diff_view(view, flags);
 498                 break;
 499
 500         case REQ_REFRESH:
 501                 load_refs(TRUE);
 502                 refresh_view(view);
 503                 break;
 504
 505         default:
 506                 return request;
 507         }
 508
 509         return REQ_NONE;
 510 }
 511
 512 static void
 513 main_update_env(struct view *view, struct line *line, struct commit *commit)
 514 {
 515         struct ref_list *list = main_get_commit_refs(line, commit);
 516         size_t i;
 517
 518         for (i = 0; list && i < list->size; i++)
 519                 ref_update_env(view->env, list->refs[list->size - i - 1], !i);
 520 }
 521
 522 void
 523 main_select(struct view *view, struct line *line)
 524 {
 525         struct commit *commit = line->data;
 526
 527         if (line->type == LINE_STAT_STAGED || line->type == LINE_STAT_UNSTAGED) {
 528                 string_ncopy(view->ref, commit->title, strlen(commit->title));
 529                 status_stage_info(view->env->status, line->type, NULL);
 530         } else {
 531                 string_copy_rev(view->ref, commit->id);
 532                 main_update_env(view, line, commit);
 533         }
 534         string_copy_rev(view->env->commit, commit->id);
 535 }
 536
 537 static struct view_ops main_ops = {
 538         "commit",
 539         argv_env.head,
 540         VIEW_SEND_CHILD_ENTER | VIEW_FILE_FILTER | VIEW_LOG_LIKE | VIEW_REFRESH,
 541         sizeof(struct main_state),
 542         main_open,
 543         main_read,
 544         view_column_draw,
 545         main_request,
 546         view_column_grep,
 547         main_select,
 548         main_done,
 549         view_column_bit(AUTHOR) | view_column_bit(COMMIT_TITLE) |
 550                 view_column_bit(DATE) | view_column_bit(ID) |
 551                 view_column_bit(LINE_NUMBER),
 552         main_get_column_data,
 553 };
 554
 555 DEFINE_VIEW(main);
 556
 557 /* vim: set ts=8 sw=8 noexpandtab: */