match-trees.c

   1 #include "git-compat-util.h"
   2 #include "hex.h"
   3 #include "match-trees.h"
   4 #include "tree.h"
   5 #include "tree-walk.h"
   6 #include "object-store.h"
   7
   8 static int score_missing(unsigned mode)
   9 {
  10         int score;
  11
  12         if (S_ISDIR(mode))
  13                 score = -1000;
  14         else if (S_ISLNK(mode))
  15                 score = -500;
  16         else
  17                 score = -50;
  18         return score;
  19 }
  20
  21 static int score_differs(unsigned mode1, unsigned mode2)
  22 {
  23         int score;
  24
  25         if (S_ISDIR(mode1) != S_ISDIR(mode2))
  26                 score = -100;
  27         else if (S_ISLNK(mode1) != S_ISLNK(mode2))
  28                 score = -50;
  29         else
  30                 score = -5;
  31         return score;
  32 }
  33
  34 static int score_matches(unsigned mode1, unsigned mode2)
  35 {
  36         int score;
  37
  38         /* Heh, we found SHA-1 collisions between different kind of objects */
  39         if (S_ISDIR(mode1) != S_ISDIR(mode2))
  40                 score = -100;
  41         else if (S_ISLNK(mode1) != S_ISLNK(mode2))
  42                 score = -50;
  43
  44         else if (S_ISDIR(mode1))
  45                 score = 1000;
  46         else if (S_ISLNK(mode1))
  47                 score = 500;
  48         else
  49                 score = 250;
  50         return score;
  51 }
  52
  53 static void *fill_tree_desc_strict(struct tree_desc *desc,
  54                                    const struct object_id *hash)
  55 {
  56         void *buffer;
  57         enum object_type type;
  58         unsigned long size;
  59
  60         buffer = repo_read_object_file(the_repository, hash, &type, &size);
  61         if (!buffer)
  62                 die("unable to read tree (%s)", oid_to_hex(hash));
  63         if (type != OBJ_TREE)
  64                 die("%s is not a tree", oid_to_hex(hash));
  65         init_tree_desc(desc, buffer, size);
  66         return buffer;
  67 }
  68
  69 static int base_name_entries_compare(const struct name_entry *a,
  70                                      const struct name_entry *b)
  71 {
  72         return base_name_compare(a->path, tree_entry_len(a), a->mode,
  73                                  b->path, tree_entry_len(b), b->mode);
  74 }
  75
  76 /*
  77  * Inspect two trees, and give a score that tells how similar they are.
  78  */
  79 static int score_trees(const struct object_id *hash1, const struct object_id *hash2)
  80 {
  81         struct tree_desc one;
  82         struct tree_desc two;
  83         void *one_buf = fill_tree_desc_strict(&one, hash1);
  84         void *two_buf = fill_tree_desc_strict(&two, hash2);
  85         int score = 0;
  86
  87         for (;;) {
  88                 int cmp;
  89
  90                 if (one.size && two.size)
  91                         cmp = base_name_entries_compare(&one.entry, &two.entry);
  92                 else if (one.size)
  93                         /* two lacks this entry */
  94                         cmp = -1;
  95                 else if (two.size)
  96                         /* two has more entries */
  97                         cmp = 1;
  98                 else
  99                         break;
 100
 101                 if (cmp < 0) {
 102                         /* path1 does not appear in two */
 103                         score += score_missing(one.entry.mode);
 104                         update_tree_entry(&one);
 105                 } else if (cmp > 0) {
 106                         /* path2 does not appear in one */
 107                         score += score_missing(two.entry.mode);
 108                         update_tree_entry(&two);
 109                 } else {
 110                         /* path appears in both */
 111                         if (!oideq(&one.entry.oid, &two.entry.oid)) {
 112                                 /* they are different */
 113                                 score += score_differs(one.entry.mode,
 114                                                        two.entry.mode);
 115                         } else {
 116                                 /* same subtree or blob */
 117                                 score += score_matches(one.entry.mode,
 118                                                        two.entry.mode);
 119                         }
 120                         update_tree_entry(&one);
 121                         update_tree_entry(&two);
 122                 }
 123         }
 124         free(one_buf);
 125         free(two_buf);
 126         return score;
 127 }
 128
 129 /*
 130  * Match one itself and its subtrees with two and pick the best match.
 131  */
 132 static void match_trees(const struct object_id *hash1,
 133                         const struct object_id *hash2,
 134                         int *best_score,
 135                         char **best_match,
 136                         const char *base,
 137                         int recurse_limit)
 138 {
 139         struct tree_desc one;
 140         void *one_buf = fill_tree_desc_strict(&one, hash1);
 141
 142         while (one.size) {
 143                 const char *path;
 144                 const struct object_id *elem;
 145                 unsigned short mode;
 146                 int score;
 147
 148                 elem = tree_entry_extract(&one, &path, &mode);
 149                 if (!S_ISDIR(mode))
 150                         goto next;
 151                 score = score_trees(elem, hash2);
 152                 if (*best_score < score) {
 153                         free(*best_match);
 154                         *best_match = xstrfmt("%s%s", base, path);
 155                         *best_score = score;
 156                 }
 157                 if (recurse_limit) {
 158                         char *newbase = xstrfmt("%s%s/", base, path);
 159                         match_trees(elem, hash2, best_score, best_match,
 160                                     newbase, recurse_limit - 1);
 161                         free(newbase);
 162                 }
 163
 164         next:
 165                 update_tree_entry(&one);
 166         }
 167         free(one_buf);
 168 }
 169
 170 /*
 171  * A tree "oid1" has a subdirectory at "prefix".  Come up with a tree object by
 172  * replacing it with another tree "oid2".
 173  */
 174 static int splice_tree(const struct object_id *oid1, const char *prefix,
 175                        const struct object_id *oid2, struct object_id *result)
 176 {
 177         char *subpath;
 178         int toplen;
 179         char *buf;
 180         unsigned long sz;
 181         struct tree_desc desc;
 182         unsigned char *rewrite_here;
 183         const struct object_id *rewrite_with;
 184         struct object_id subtree;
 185         enum object_type type;
 186         int status;
 187
 188         subpath = strchrnul(prefix, '/');
 189         toplen = subpath - prefix;
 190         if (*subpath)
 191                 subpath++;
 192
 193         buf = repo_read_object_file(the_repository, oid1, &type, &sz);
 194         if (!buf)
 195                 die("cannot read tree %s", oid_to_hex(oid1));
 196         init_tree_desc(&desc, buf, sz);
 197
 198         rewrite_here = NULL;
 199         while (desc.size) {
 200                 const char *name;
 201                 unsigned short mode;
 202
 203                 tree_entry_extract(&desc, &name, &mode);
 204                 if (strlen(name) == toplen &&
 205                     !memcmp(name, prefix, toplen)) {
 206                         if (!S_ISDIR(mode))
 207                                 die("entry %s in tree %s is not a tree", name,
 208                                     oid_to_hex(oid1));
 209
 210                         /*
 211                          * We cast here for two reasons:
 212                          *
 213                          *   - to flip the "char *" (for the path) to "unsigned
 214                          *     char *" (for the hash stored after it)
 215                          *
 216                          *   - to discard the "const"; this is OK because we
 217                          *     know it points into our non-const "buf"
 218                          */
 219                         rewrite_here = (unsigned char *)(desc.entry.path +
 220                                                          strlen(desc.entry.path) +
 221                                                          1);
 222                         break;
 223                 }
 224                 update_tree_entry(&desc);
 225         }
 226         if (!rewrite_here)
 227                 die("entry %.*s not found in tree %s", toplen, prefix,
 228                     oid_to_hex(oid1));
 229         if (*subpath) {
 230                 struct object_id tree_oid;
 231                 oidread(&tree_oid, rewrite_here);
 232                 status = splice_tree(&tree_oid, subpath, oid2, &subtree);
 233                 if (status)
 234                         return status;
 235                 rewrite_with = &subtree;
 236         } else {
 237                 rewrite_with = oid2;
 238         }
 239         hashcpy(rewrite_here, rewrite_with->hash);
 240         status = write_object_file(buf, sz, OBJ_TREE, result);
 241         free(buf);
 242         return status;
 243 }
 244
 245 /*
 246  * We are trying to come up with a merge between one and two that
 247  * results in a tree shape similar to one.  The tree two might
 248  * correspond to a subtree of one, in which case it needs to be
 249  * shifted down by prefixing otherwise empty directories.  On the
 250  * other hand, it could cover tree one and we might need to pick a
 251  * subtree of it.
 252  */
 253 void shift_tree(struct repository *r,
 254                 const struct object_id *hash1,
 255                 const struct object_id *hash2,
 256                 struct object_id *shifted,
 257                 int depth_limit)
 258 {
 259         char *add_prefix;
 260         char *del_prefix;
 261         int add_score, del_score;
 262
 263         /*
 264          * NEEDSWORK: this limits the recursion depth to hardcoded
 265          * value '2' to avoid excessive overhead.
 266          */
 267         if (!depth_limit)
 268                 depth_limit = 2;
 269
 270         add_score = del_score = score_trees(hash1, hash2);
 271         add_prefix = xcalloc(1, 1);
 272         del_prefix = xcalloc(1, 1);
 273
 274         /*
 275          * See if one's subtree resembles two; if so we need to prefix
 276          * two with a few fake trees to match the prefix.
 277          */
 278         match_trees(hash1, hash2, &add_score, &add_prefix, "", depth_limit);
 279
 280         /*
 281          * See if two's subtree resembles one; if so we need to
 282          * pick only subtree of two.
 283          */
 284         match_trees(hash2, hash1, &del_score, &del_prefix, "", depth_limit);
 285
 286         /* Assume we do not have to do any shifting */
 287         oidcpy(shifted, hash2);
 288
 289         if (add_score < del_score) {
 290                 /* We need to pick a subtree of two */
 291                 unsigned short mode;
 292
 293                 if (!*del_prefix)
 294                         return;
 295
 296                 if (get_tree_entry(r, hash2, del_prefix, shifted, &mode))
 297                         die("cannot find path %s in tree %s",
 298                             del_prefix, oid_to_hex(hash2));
 299                 return;
 300         }
 301
 302         if (!*add_prefix)
 303                 return;
 304
 305         splice_tree(hash1, add_prefix, hash2, shifted);
 306 }
 307
 308 /*
 309  * The user says the trees will be shifted by this much.
 310  * Unfortunately we cannot fundamentally tell which one to
 311  * be prefixed, as recursive merge can work in either direction.
 312  */
 313 void shift_tree_by(struct repository *r,
 314                    const struct object_id *hash1,
 315                    const struct object_id *hash2,
 316                    struct object_id *shifted,
 317                    const char *shift_prefix)
 318 {
 319         struct object_id sub1, sub2;
 320         unsigned short mode1, mode2;
 321         unsigned candidate = 0;
 322
 323         /* Can hash2 be a tree at shift_prefix in tree hash1? */
 324         if (!get_tree_entry(r, hash1, shift_prefix, &sub1, &mode1) &&
 325             S_ISDIR(mode1))
 326                 candidate |= 1;
 327
 328         /* Can hash1 be a tree at shift_prefix in tree hash2? */
 329         if (!get_tree_entry(r, hash2, shift_prefix, &sub2, &mode2) &&
 330             S_ISDIR(mode2))
 331                 candidate |= 2;
 332
 333         if (candidate == 3) {
 334                 /* Both are plausible -- we need to evaluate the score */
 335                 int best_score = score_trees(hash1, hash2);
 336                 int score;
 337
 338                 candidate = 0;
 339                 score = score_trees(&sub1, hash2);
 340                 if (score > best_score) {
 341                         candidate = 1;
 342                         best_score = score;
 343                 }
 344                 score = score_trees(&sub2, hash1);
 345                 if (score > best_score)
 346                         candidate = 2;
 347         }
 348
 349         if (!candidate) {
 350                 /* Neither is plausible -- do not shift */
 351                 oidcpy(shifted, hash2);
 352                 return;
 353         }
 354
 355         if (candidate == 1)
 356                 /*
 357                  * shift tree2 down by adding shift_prefix above it
 358                  * to match tree1.
 359                  */
 360                 splice_tree(hash1, shift_prefix, hash2, shifted);
 361         else
 362                 /*
 363                  * shift tree2 up by removing shift_prefix from it
 364                  * to match tree1.
 365                  */
 366                 oidcpy(shifted, &sub2);
 367 }