merge-ort: implement apply_directory_rename_modifications()

This function roughly follows the same outline as the function of the
same name from merge-recursive.c, but the code diverges in multiple
ways due to some special considerations:
  * merge-ort's version needs to update opt->priv->paths with any new
    paths (and opt->priv->paths points to struct conflict_infos which
    track quite a bit of metadata for each path); merge-recursive's
    version would directly update the index
  * merge-ort requires that opt->priv->paths has any leading directories
    of any relevant files also be included in the set of paths.  And
    due to pointer equality requirements on merged_info.directory_name,
    we have to be careful how we compute and insert these.
  * due to the above requirements on opt->priv->paths, merge-ort's
    version starts with a long comment to explain all the special
    considerations that need to be handled
  * merge-ort can use the full data stored in opt->priv->paths to avoid
    making expensive get_tree_entry() calls to regather the necessary
    data.
  * due to messages being deferred automatically in merge-ort, this is
    the best place to handle conflict messages whereas in
    merge-recursive.c they are deferred manually so that processing of
    entries does all the printing

Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/merge-ort.c b/merge-ort.c
index 5b3b56dc1cdf82e2119d3606624758b869b29e38..1152d0ae21ec6c65c81b892a8153f51042dcd187 100644 (file)
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -1223,7 +1223,173 @@ static void apply_directory_rename_modifications(struct merge_options *opt,
                                                 struct diff_filepair *pair,
                                                 char *new_path)
 {
-       die("Not yet implemented.");
+       /*
+        * The basic idea is to get the conflict_info from opt->priv->paths
+        * at old path, and insert it into new_path; basically just this:
+        *     ci = strmap_get(&opt->priv->paths, old_path);
+        *     strmap_remove(&opt->priv->paths, old_path, 0);
+        *     strmap_put(&opt->priv->paths, new_path, ci);
+        * However, there are some factors complicating this:
+        *     - opt->priv->paths may already have an entry at new_path
+        *     - Each ci tracks its containing directory, so we need to
+        *       update that
+        *     - If another ci has the same containing directory, then
+        *       the two char*'s MUST point to the same location.  See the
+        *       comment in struct merged_info.  strcmp equality is not
+        *       enough; we need pointer equality.
+        *     - opt->priv->paths must hold the parent directories of any
+        *       entries that are added.  So, if this directory rename
+        *       causes entirely new directories, we must recursively add
+        *       parent directories.
+        *     - For each parent directory added to opt->priv->paths, we
+        *       also need to get its parent directory stored in its
+        *       conflict_info->merged.directory_name with all the same
+        *       requirements about pointer equality.
+        */
+       struct string_list dirs_to_insert = STRING_LIST_INIT_NODUP;
+       struct conflict_info *ci, *new_ci;
+       struct strmap_entry *entry;
+       const char *branch_with_new_path, *branch_with_dir_rename;
+       const char *old_path = pair->two->path;
+       const char *parent_name;
+       const char *cur_path;
+       int i, len;
+
+       entry = strmap_get_entry(&opt->priv->paths, old_path);
+       old_path = entry->key;
+       ci = entry->value;
+       VERIFY_CI(ci);
+
+       /* Find parent directories missing from opt->priv->paths */
+       cur_path = new_path;
+       while (1) {
+               /* Find the parent directory of cur_path */
+               char *last_slash = strrchr(cur_path, '/');
+               if (last_slash) {
+                       parent_name = xstrndup(cur_path, last_slash - cur_path);
+               } else {
+                       parent_name = opt->priv->toplevel_dir;
+                       break;
+               }
+
+               /* Look it up in opt->priv->paths */
+               entry = strmap_get_entry(&opt->priv->paths, parent_name);
+               if (entry) {
+                       free((char*)parent_name);
+                       parent_name = entry->key; /* reuse known pointer */
+                       break;
+               }
+
+               /* Record this is one of the directories we need to insert */
+               string_list_append(&dirs_to_insert, parent_name);
+               cur_path = parent_name;
+       }
+
+       /* Traverse dirs_to_insert and insert them into opt->priv->paths */
+       for (i = dirs_to_insert.nr-1; i >= 0; --i) {
+               struct conflict_info *dir_ci;
+               char *cur_dir = dirs_to_insert.items[i].string;
+
+               dir_ci = xcalloc(1, sizeof(*dir_ci));
+
+               dir_ci->merged.directory_name = parent_name;
+               len = strlen(parent_name);
+               /* len+1 because of trailing '/' character */
+               dir_ci->merged.basename_offset = (len > 0 ? len+1 : len);
+               dir_ci->dirmask = ci->filemask;
+               strmap_put(&opt->priv->paths, cur_dir, dir_ci);
+
+               parent_name = cur_dir;
+       }
+
+       /*
+        * We are removing old_path from opt->priv->paths.  old_path also will
+        * eventually need to be freed, but it may still be used by e.g.
+        * ci->pathnames.  So, store it in another string-list for now.
+        */
+       string_list_append(&opt->priv->paths_to_free, old_path);
+
+       assert(ci->filemask == 2 || ci->filemask == 4);
+       assert(ci->dirmask == 0);
+       strmap_remove(&opt->priv->paths, old_path, 0);
+
+       branch_with_new_path   = (ci->filemask == 2) ? opt->branch1 : opt->branch2;
+       branch_with_dir_rename = (ci->filemask == 2) ? opt->branch2 : opt->branch1;
+
+       /* Now, finally update ci and stick it into opt->priv->paths */
+       ci->merged.directory_name = parent_name;
+       len = strlen(parent_name);
+       ci->merged.basename_offset = (len > 0 ? len+1 : len);
+       new_ci = strmap_get(&opt->priv->paths, new_path);
+       if (!new_ci) {
+               /* Place ci back into opt->priv->paths, but at new_path */
+               strmap_put(&opt->priv->paths, new_path, ci);
+       } else {
+               int index;
+
+               /* A few sanity checks */
+               VERIFY_CI(new_ci);
+               assert(ci->filemask == 2 || ci->filemask == 4);
+               assert((new_ci->filemask & ci->filemask) == 0);
+               assert(!new_ci->merged.clean);
+
+               /* Copy stuff from ci into new_ci */
+               new_ci->filemask |= ci->filemask;
+               if (new_ci->dirmask)
+                       new_ci->df_conflict = 1;
+               index = (ci->filemask >> 1);
+               new_ci->pathnames[index] = ci->pathnames[index];
+               new_ci->stages[index].mode = ci->stages[index].mode;
+               oidcpy(&new_ci->stages[index].oid, &ci->stages[index].oid);
+
+               free(ci);
+               ci = new_ci;
+       }
+
+       if (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE) {
+               /* Notify user of updated path */
+               if (pair->status == 'A')
+                       path_msg(opt, new_path, 1,
+                                _("Path updated: %s added in %s inside a "
+                                  "directory that was renamed in %s; moving "
+                                  "it to %s."),
+                                old_path, branch_with_new_path,
+                                branch_with_dir_rename, new_path);
+               else
+                       path_msg(opt, new_path, 1,
+                                _("Path updated: %s renamed to %s in %s, "
+                                  "inside a directory that was renamed in %s; "
+                                  "moving it to %s."),
+                                pair->one->path, old_path, branch_with_new_path,
+                                branch_with_dir_rename, new_path);
+       } else {
+               /*
+                * opt->detect_directory_renames has the value
+                * MERGE_DIRECTORY_RENAMES_CONFLICT, so mark these as conflicts.
+                */
+               ci->path_conflict = 1;
+               if (pair->status == 'A')
+                       path_msg(opt, new_path, 0,
+                                _("CONFLICT (file location): %s added in %s "
+                                  "inside a directory that was renamed in %s, "
+                                  "suggesting it should perhaps be moved to "
+                                  "%s."),
+                                old_path, branch_with_new_path,
+                                branch_with_dir_rename, new_path);
+               else
+                       path_msg(opt, new_path, 0,
+                                _("CONFLICT (file location): %s renamed to %s "
+                                  "in %s, inside a directory that was renamed "
+                                  "in %s, suggesting it should perhaps be "
+                                  "moved to %s."),
+                                pair->one->path, old_path, branch_with_new_path,
+                                branch_with_dir_rename, new_path);
+       }
+
+       /*
+        * Finally, record the new location.
+        */
+       pair->two->path = new_path;
 }
 
 /*** Function Grouping: functions related to regular rename detection ***/