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