aboutsummaryrefslogtreecommitdiff
path: root/diffcore-rename.c
diff options
context:
space:
mode:
authorJunio C Hamano <junkio@cox.net>2005-05-21 02:39:09 -0700
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-05-21 09:58:03 -0700
commit427dcb4bca49117664d9428fd4e86483f516d703 (patch)
treeb97246a87e8852b9b3cdf3c9956c895d92fbab6f /diffcore-rename.c
parentc8265ac096afe8a0eb460a41c0620f6ae13394fe (diff)
downloadgit-427dcb4bca49117664d9428fd4e86483f516d703.tar.gz
git-427dcb4bca49117664d9428fd4e86483f516d703.tar.xz
[PATCH] Diff overhaul, adding half of copy detection.
This introduces the diff-core, the layer between the diff-tree family and the external diff interface engine. The calls to the interface diff-tree family uses (diff_change and diff_addremove) have not changed and will not change. The purpose of the diff-core layer is to provide an infrastructure to transform the set of differences sent from the applications, before sending them to the external diff interface. The recently introduced rename detection code has been rewritten to use the diff-core facility. When applications send in separate creates and deletes, matching ones are transformed into a single rename-and-edit diff, and sent out to the external diff interface as such. This patch also enhances the rename detection code further to be able to detect copies. Currently this happens only as long as copy sources appear as part of the modified files, but there already is enough provision for callers to report unmodified files to diff-core, so that they can be also used as copy source candidates. Extending the callers this way will be done in a separate patch. Please see and marvel at how well this works by trying out the newly added t/t4003-diff-rename-1.sh test script. Signed-off-by: Junio C Hamano <junkio@cox.net> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Diffstat (limited to 'diffcore-rename.c')
-rw-r--r--diffcore-rename.c443
1 files changed, 443 insertions, 0 deletions
diff --git a/diffcore-rename.c b/diffcore-rename.c
new file mode 100644
index 000000000..8aa8f841c
--- /dev/null
+++ b/diffcore-rename.c
@@ -0,0 +1,443 @@
+/*
+ * Copyright (C) 2005 Junio C Hamano
+ */
+#include "cache.h"
+#include "diff.h"
+#include "diffcore.h"
+#include "delta.h"
+
+struct diff_rename_pool {
+ struct diff_filespec **s;
+ int nr, alloc;
+};
+
+static void diff_rename_pool_clear(struct diff_rename_pool *pool)
+{
+ pool->s = NULL; pool->nr = pool->alloc = 0;
+}
+
+static void diff_rename_pool_add(struct diff_rename_pool *pool,
+ struct diff_filespec *s)
+{
+ if (S_ISDIR(s->mode))
+ return; /* rename/copy patch for tree does not make sense. */
+
+ if (pool->alloc <= pool->nr) {
+ pool->alloc = alloc_nr(pool->alloc);
+ pool->s = xrealloc(pool->s,
+ sizeof(*(pool->s)) * pool->alloc);
+ }
+ pool->s[pool->nr] = s;
+ pool->nr++;
+}
+
+static int is_exact_match(struct diff_filespec *src, struct diff_filespec *dst)
+{
+ if (src->sha1_valid && dst->sha1_valid &&
+ !memcmp(src->sha1, dst->sha1, 20))
+ return 1;
+ if (diff_populate_filespec(src) || diff_populate_filespec(dst))
+ /* this is an error but will be caught downstream */
+ return 0;
+ if (src->size == dst->size &&
+ !memcmp(src->data, dst->data, src->size))
+ return 1;
+ return 0;
+}
+
+struct diff_score {
+ struct diff_filespec *src;
+ struct diff_filespec *dst;
+ int score;
+ int rank;
+};
+
+static int estimate_similarity(struct diff_filespec *src,
+ struct diff_filespec *dst,
+ int minimum_score)
+{
+ /* src points at a file that existed in the original tree (or
+ * optionally a file in the destination tree) and dst points
+ * at a newly created file. They may be quite similar, in which
+ * case we want to say src is renamed to dst or src is copied into
+ * dst, and then some edit has been applied to dst.
+ *
+ * Compare them and return how similar they are, representing
+ * the score as an integer between 0 and 10000, except
+ * where they match exactly it is considered better than anything
+ * else.
+ */
+ void *delta;
+ unsigned long delta_size;
+ int score;
+
+ delta_size = ((src->size < dst->size) ?
+ (dst->size - src->size) : (src->size - dst->size));
+
+ /* We would not consider rename followed by more than
+ * minimum_score/MAX_SCORE edits; that is, delta_size must be smaller
+ * than (src->size + dst->size)/2 * minimum_score/MAX_SCORE,
+ * which means...
+ */
+
+ if ((src->size+dst->size)*minimum_score < delta_size*MAX_SCORE*2)
+ return 0;
+
+ delta = diff_delta(src->data, src->size,
+ dst->data, dst->size,
+ &delta_size);
+ free(delta);
+
+ /* This "delta" is really xdiff with adler32 and all the
+ * overheads but it is a quick and dirty approximation.
+ *
+ * Now we will give some score to it. 100% edit gets
+ * 0 points and 0% edit gets MAX_SCORE points. That is, every
+ * 1/MAX_SCORE edit gets 1 point penalty. The amount of penalty is:
+ *
+ * (delta_size * 2 / (src->size + dst->size)) * MAX_SCORE
+ *
+ */
+ score = MAX_SCORE-(MAX_SCORE*2*delta_size/(src->size+dst->size));
+ if (score < 0) return 0;
+ if (MAX_SCORE < score) return MAX_SCORE;
+ return score;
+}
+
+static void record_rename_pair(struct diff_queue_struct *outq,
+ struct diff_filespec *src,
+ struct diff_filespec *dst,
+ int rank,
+ int score)
+{
+ /* The rank is used to sort the final output, because there
+ * are certain dependencies.
+ *
+ * - rank #0 depends on deleted ones.
+ * - rank #1 depends on kept files before they are modified.
+ * - rank #2 depends on kept files after they are modified;
+ * currently not used.
+ *
+ * Therefore, the final output order should be:
+ *
+ * 1. rank #0 rename/copy diffs.
+ * 2. deletions in the original.
+ * 3. rank #1 rename/copy diffs.
+ * 4. additions and modifications in the original.
+ * 5. rank #2 rename/copy diffs; currently not used.
+ *
+ * To achieve this sort order, we give xform_work the number
+ * above.
+ */
+ struct diff_file_pair *dp = diff_queue(outq, src, dst);
+ dp->xfrm_work = (rank * 2 + 1) | (score<<RENAME_SCORE_SHIFT);
+ dst->xfrm_flags |= RENAME_DST_MATCHED;
+}
+
+#if 0
+static void debug_filespec(struct diff_filespec *s, int x, const char *one)
+{
+ fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",
+ x, one,
+ s->path,
+ s->file_valid ? "valid" : "invalid",
+ s->mode,
+ s->sha1_valid ? sha1_to_hex(s->sha1) : "");
+ fprintf(stderr, "queue[%d] %s size %lu flags %d\n",
+ x, one,
+ s->size, s->xfrm_flags);
+}
+
+static void debug_filepair(const struct diff_file_pair *p, int i)
+{
+ debug_filespec(p->one, i, "one");
+ debug_filespec(p->two, i, "two");
+ fprintf(stderr, "pair flags %d, orig order %d, score %d\n",
+ (p->xfrm_work & ((1<<RENAME_SCORE_SHIFT) - 1)),
+ p->orig_order,
+ (p->xfrm_work >> RENAME_SCORE_SHIFT));
+}
+
+static void debug_queue(const char *msg, struct diff_queue_struct *q)
+{
+ int i;
+ if (msg)
+ fprintf(stderr, "%s\n", msg);
+ fprintf(stderr, "q->nr = %d\n", q->nr);
+ for (i = 0; i < q->nr; i++) {
+ struct diff_file_pair *p = q->queue[i];
+ debug_filepair(p, i);
+ }
+}
+#else
+#define debug_queue(a,b) do { ; /*nothing*/ } while(0)
+#endif
+
+/*
+ * We sort the outstanding diff entries according to the rank (see
+ * comment at the beginning of record_rename_pair) and tiebreak with
+ * the order in the original input.
+ */
+static int rank_compare(const void *a_, const void *b_)
+{
+ const struct diff_file_pair *a = *(const struct diff_file_pair **)a_;
+ const struct diff_file_pair *b = *(const struct diff_file_pair **)b_;
+ int a_rank = a->xfrm_work & ((1<<RENAME_SCORE_SHIFT) - 1);
+ int b_rank = b->xfrm_work & ((1<<RENAME_SCORE_SHIFT) - 1);
+
+ if (a_rank != b_rank)
+ return a_rank - b_rank;
+ return a->orig_order - b->orig_order;
+}
+
+/*
+ * We sort the rename similarity matrix with the score, in descending
+ * order (more similar first).
+ */
+static int score_compare(const void *a_, const void *b_)
+{
+ const struct diff_score *a = a_, *b = b_;
+ return b->score - a->score;
+}
+
+static int needs_to_stay(struct diff_queue_struct *q, int i,
+ struct diff_filespec *it)
+{
+ /* If it will be used in later entry (either stay or used
+ * as the source of rename/copy), we need to copy, not rename.
+ */
+ while (i < q->nr) {
+ struct diff_file_pair *p = q->queue[i++];
+ if (!p->two->file_valid)
+ continue; /* removed is fine */
+ if (strcmp(p->one->path, it->path))
+ continue; /* not relevant */
+
+ /* p has its src set to *it and it is not a delete;
+ * it will be used for in-place change or rename/copy,
+ * so we cannot rename it out.
+ */
+ return 1;
+ }
+ return 0;
+}
+
+void diff_detect_rename(struct diff_queue_struct *q,
+ int detect_rename,
+ int minimum_score)
+{
+ struct diff_queue_struct outq;
+ struct diff_rename_pool created, deleted, stay;
+ struct diff_rename_pool *(srcs[2]);
+ struct diff_score *mx;
+ int h, i, j;
+ int num_create, num_src, dst_cnt, src_cnt;
+
+ outq.queue = NULL;
+ outq.nr = outq.alloc = 0;
+
+ diff_rename_pool_clear(&created);
+ diff_rename_pool_clear(&deleted);
+ diff_rename_pool_clear(&stay);
+
+ srcs[0] = &deleted;
+ srcs[1] = &stay;
+
+ /* NEEDSWORK:
+ * (1) make sure we properly ignore but pass trees.
+ *
+ * (2) make sure we do right thing on the same path deleted
+ * and created in the same patch.
+ */
+
+ for (i = 0; i < q->nr; i++) {
+ struct diff_file_pair *p = q->queue[i];
+ if (!p->one->file_valid)
+ if (!p->two->file_valid)
+ continue; /* ignore nonsense */
+ else
+ diff_rename_pool_add(&created, p->two);
+ else if (!p->two->file_valid)
+ diff_rename_pool_add(&deleted, p->one);
+ else if (1 < detect_rename) /* find copy, too */
+ diff_rename_pool_add(&stay, p->one);
+ }
+ if (created.nr == 0)
+ goto cleanup; /* nothing to do */
+
+ /* We really want to cull the candidates list early
+ * with cheap tests in order to avoid doing deltas.
+ *
+ * With the current callers, we should not have already
+ * matched entries at this point, but it is nonetheless
+ * checked for sanity.
+ */
+ for (i = 0; i < created.nr; i++) {
+ if (created.s[i]->xfrm_flags & RENAME_DST_MATCHED)
+ continue; /* we have matched exactly already */
+ for (h = 0; h < sizeof(srcs)/sizeof(srcs[0]); h++) {
+ struct diff_rename_pool *p = srcs[h];
+ for (j = 0; j < p->nr; j++) {
+ if (!is_exact_match(p->s[j], created.s[i]))
+ continue;
+ record_rename_pair(&outq,
+ p->s[j], created.s[i], h,
+ MAX_SCORE);
+ break; /* we are done with this entry */
+ }
+ }
+ }
+ debug_queue("done detecting exact", &outq);
+
+ /* Have we run out the created file pool? If so we can avoid
+ * doing the delta matrix altogether.
+ */
+ if (outq.nr == created.nr)
+ goto flush_rest;
+
+ num_create = (created.nr - outq.nr);
+ num_src = deleted.nr + stay.nr;
+ mx = xmalloc(sizeof(*mx) * num_create * num_src);
+ for (dst_cnt = i = 0; i < created.nr; i++) {
+ int base = dst_cnt * num_src;
+ if (created.s[i]->xfrm_flags & RENAME_DST_MATCHED)
+ continue; /* dealt with exact match already. */
+ for (src_cnt = h = 0; h < sizeof(srcs)/sizeof(srcs[0]); h++) {
+ struct diff_rename_pool *p = srcs[h];
+ for (j = 0; j < p->nr; j++, src_cnt++) {
+ struct diff_score *m = &mx[base + src_cnt];
+ m->src = p->s[j];
+ m->dst = created.s[i];
+ m->score = estimate_similarity(m->src, m->dst,
+ minimum_score);
+ m->rank = h;
+ }
+ }
+ dst_cnt++;
+ }
+ /* cost matrix sorted by most to least similar pair */
+ qsort(mx, num_create * num_src, sizeof(*mx), score_compare);
+ for (i = 0; i < num_create * num_src; i++) {
+ if (mx[i].dst->xfrm_flags & RENAME_DST_MATCHED)
+ continue; /* alreayd done, either exact or fuzzy. */
+ if (mx[i].score < minimum_score)
+ continue;
+ record_rename_pair(&outq,
+ mx[i].src, mx[i].dst, mx[i].rank,
+ mx[i].score);
+ }
+ free(mx);
+ debug_queue("done detecting fuzzy", &outq);
+
+ flush_rest:
+ /* At this point, we have found some renames and copies and they
+ * are kept in outq. The original list is still in *q.
+ *
+ * Scan the original list and move them into the outq; we will sort
+ * outq and swap it into the queue supplied to pass that to
+ * downstream, so we assign the sort keys in this loop.
+ *
+ * See comments at the top of record_rename_pair for numbers used
+ * to assign xfrm_work.
+ *
+ * Note that we have not annotated the diff_file_pair with any comment
+ * so there is nothing other than p to free.
+ */
+ for (i = 0; i < q->nr; i++) {
+ struct diff_file_pair *dp, *p = q->queue[i];
+ if (!p->one->file_valid) {
+ if (p->two->file_valid) {
+ /* creation */
+ dp = diff_queue(&outq, p->one, p->two);
+ dp->xfrm_work = 4;
+ }
+ /* otherwise it is a nonsense; just ignore it */
+ }
+ else if (!p->two->file_valid) {
+ /* deletion */
+ dp = diff_queue(&outq, p->one, p->two);
+ dp->xfrm_work = 2;
+ }
+ else {
+ /* modification, or stay as is */
+ dp = diff_queue(&outq, p->one, p->two);
+ dp->xfrm_work = 4;
+ }
+ free(p);
+ }
+ debug_queue("done copying original", &outq);
+
+ /* Sort outq */
+ qsort(outq.queue, outq.nr, sizeof(outq.queue[0]), rank_compare);
+
+ debug_queue("done sorting", &outq);
+
+ free(q->queue);
+ q->nr = q->alloc = 0;
+ q->queue = NULL;
+
+ /* Copy it out to q, removing duplicates. */
+ for (i = 0; i < outq.nr; i++) {
+ struct diff_file_pair *p = outq.queue[i];
+ if (!p->one->file_valid) {
+ /* created */
+ if (p->two->xfrm_flags & RENAME_DST_MATCHED)
+ ; /* rename/copy created it already */
+ else
+ diff_queue(q, p->one, p->two);
+ }
+ else if (!p->two->file_valid) {
+ /* deleted */
+ if (p->one->xfrm_flags & RENAME_SRC_GONE)
+ ; /* rename/copy deleted it already */
+ else
+ diff_queue(q, p->one, p->two);
+ }
+ else if (strcmp(p->one->path, p->two->path)) {
+ /* rename or copy */
+ struct diff_file_pair *dp =
+ diff_queue(q, p->one, p->two);
+ int msglen = (strlen(p->one->path) +
+ strlen(p->two->path) + 100);
+ int score = (p->xfrm_work >> RENAME_SCORE_SHIFT);
+ dp->xfrm_msg = xmalloc(msglen);
+
+ /* if we have a later entry that is a rename/copy
+ * that depends on p->one, then we copy here.
+ * otherwise we rename it.
+ */
+ if (needs_to_stay(&outq, i+1, p->one)) {
+ /* copy it */
+ sprintf(dp->xfrm_msg,
+ "similarity index %d%%\n"
+ "copy from %s\n"
+ "copy to %s\n",
+ (int)(0.5 + score * 100 / MAX_SCORE),
+ p->one->path, p->two->path);
+ }
+ else {
+ /* rename it, and mark it as gone. */
+ p->one->xfrm_flags |= RENAME_SRC_GONE;
+ sprintf(dp->xfrm_msg,
+ "similarity index %d%%\n"
+ "rename old %s\n"
+ "rename new %s\n",
+ (int)(0.5 + score * 100 / MAX_SCORE),
+ p->one->path, p->two->path);
+ }
+ }
+ else
+ /* otherwise it is a modified (or stayed) entry */
+ diff_queue(q, p->one, p->two);
+ free(p);
+ }
+
+ free(outq.queue);
+ debug_queue("done collapsing", q);
+
+ cleanup:
+ free(created.s);
+ free(deleted.s);
+ free(stay.s);
+ return;
+}