Merge branch 'cc/revert-strategy'
authorJunio C Hamano <gitster@pobox.com>
Sun, 9 May 2010 05:34:47 +0000 (22:34 -0700)
committerJunio C Hamano <gitster@pobox.com>
Sun, 9 May 2010 05:34:47 +0000 (22:34 -0700)
* cc/revert-strategy:
  revert: add "--strategy" option to choose merge strategy
  merge: make function try_merge_command non static
  merge: refactor code that calls "git merge-STRATEGY"
  revert: refactor merge recursive code into its own function
  revert: use strbuf to refactor the code that writes the merge message

Conflicts:
builtin/revert.c

1  2 
builtin/merge.c
builtin/revert.c

diff --cc builtin/merge.c
Simple merge
@@@ -62,20 -62,10 +63,21 @@@ static void parse_args(int argc, const 
                OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
                OPT_INTEGER('m', "mainline", &mainline, "parent number"),
                OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),
+               OPT_STRING(0, "strategy", &strategy, "strategy", "merge strategy"),
                OPT_END(),
 +              OPT_END(),
 +              OPT_END(),
        };
  
 +      if (action == CHERRY_PICK) {
 +              struct option cp_extra[] = {
 +                      OPT_BOOLEAN(0, "ff", &allow_ff, "allow fast-forward"),
 +                      OPT_END(),
 +              };
 +              if (parse_options_concat(options, ARRAY_SIZE(options), cp_extra))
 +                      die("program error");
 +      }
 +
        if (parse_options(argc, argv, NULL, options, usage_str, 0) != 1)
                usage_with_options(usage_str, options);
  
@@@ -294,28 -281,70 +298,81 @@@ static NORETURN void die_dirty_index(co
        }
  }
  
 +static int fast_forward_to(const unsigned char *to, const unsigned char *from)
 +{
 +      struct ref_lock *ref_lock;
 +
 +      read_cache();
 +      if (checkout_fast_forward(from, to))
 +              exit(1); /* the callee should have complained already */
 +      ref_lock = lock_any_ref_for_update("HEAD", from, 0);
 +      return write_ref_sha1(ref_lock, to, "cherry-pick");
 +}
 +
+ static void do_recursive_merge(struct commit *base, struct commit *next,
+                              const char *base_label, const char *next_label,
+                              unsigned char *head, struct strbuf *msgbuf,
+                              char *defmsg)
+ {
+       struct merge_options o;
+       struct tree *result, *next_tree, *base_tree, *head_tree;
+       int clean, index_fd;
+       static struct lock_file index_lock;
+       index_fd = hold_locked_index(&index_lock, 1);
+       read_cache();
+       init_merge_options(&o);
+       o.ancestor = base ? base_label : "(empty tree)";
+       o.branch1 = "HEAD";
+       o.branch2 = next ? next_label : "(empty tree)";
+       head_tree = parse_tree_indirect(head);
+       next_tree = next ? next->tree : empty_tree();
+       base_tree = base ? base->tree : empty_tree();
+       clean = merge_trees(&o,
+                           head_tree,
+                           next_tree, base_tree, &result);
+       if (active_cache_changed &&
+           (write_cache(index_fd, active_cache, active_nr) ||
+            commit_locked_index(&index_lock)))
+               die("%s: Unable to write new index file", me);
+       rollback_lock_file(&index_lock);
+       if (!clean) {
+               int i;
+               strbuf_addstr(msgbuf, "\nConflicts:\n\n");
+               for (i = 0; i < active_nr;) {
+                       struct cache_entry *ce = active_cache[i++];
+                       if (ce_stage(ce)) {
+                               strbuf_addch(msgbuf, '\t');
+                               strbuf_addstr(msgbuf, ce->name);
+                               strbuf_addch(msgbuf, '\n');
+                               while (i < active_nr && !strcmp(ce->name,
+                                               active_cache[i]->name))
+                                       i++;
+                       }
+               }
+               write_message(msgbuf, defmsg);
+               fprintf(stderr, "Automatic %s failed.%s\n",
+                       me, help_msg(commit_name));
+               rerere(allow_rerere_auto);
+               exit(1);
+       }
+       write_message(msgbuf, defmsg);
+       fprintf(stderr, "Finished one %s.\n", me);
+ }
  static int revert_or_cherry_pick(int argc, const char **argv)
  {
        unsigned char head[20];
        struct commit *base, *next, *parent;
        const char *base_label, *next_label;
-       int i, index_fd, clean;
        struct commit_message msg = { NULL, NULL, NULL, NULL, NULL };
 -      char *defmsg = git_pathdup("MERGE_MSG");
 +      char *defmsg = NULL;
-       struct merge_options o;
-       struct tree *result, *next_tree, *base_tree, *head_tree;
-       static struct lock_file index_lock;
+       struct strbuf msgbuf = STRBUF_INIT;
  
        git_config(git_default_config, NULL);
        me = action == REVERT ? "revert" : "cherry-pick";
         * reverse of it if we are revert.
         */
  
-       msg_fd = hold_lock_file_for_update(&msg_file, defmsg,
-                                          LOCK_DIE_ON_ERROR);
-       index_fd = hold_locked_index(&index_lock, 1);
 +      defmsg = git_pathdup("MERGE_MSG");
 +
        if (action == REVERT) {
                base = commit;
                base_label = msg.label;