[PATCH] ssh-push.c: Fix handling of ssh://host/path URLs

[git.git] / diff.c

diff --git a/diff.c b/diff.c
index ab77b4b..e993601 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -555,6 +555,7 @@ static void run_diff(const char *name,
 {
        const char *pgm = external_diff();
        if (!pgm &&
+           one && two &&
            DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
            (S_IFMT & one->mode) != (S_IFMT & two->mode)) {
                /* a filepair that changes between file and symlink
@@ -661,6 +662,7 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
        dp->one = one;
        dp->two = two;
        dp->score = 0;
+       dp->status = 0;
        dp->source_stays = 0;
        dp->broken_pair = 0;
        diff_q(queue, dp);
@@ -786,8 +788,8 @@ static void diff_flush_patch(struct diff_filepair *p)
        case 'R':
                sprintf(msg_,
                        "similarity index %d%%\n"
-                       "rename old %s\n"
-                       "rename new %s",
+                       "rename from %s\n"
+                       "rename to %s",
                        (int)(0.5 + p->score * 100.0/MAX_SCORE),
                        p->one->path, p->two->path);
                msg = msg_;
@@ -919,7 +921,7 @@ static void diff_resolve_rename_copy(void)
        diff_debug_queue("resolve-rename-copy done", q);
 }
 
-void diff_flush(int diff_output_style, int resolve_rename_copy)
+void diff_flush(int diff_output_style)
 {
        struct diff_queue_struct *q = &diff_queued_diff;
        int i;
@@ -928,8 +930,6 @@ void diff_flush(int diff_output_style, int resolve_rename_copy)
 
        if (diff_output_style == DIFF_FORMAT_MACHINE)
                line_termination = inter_name_termination = 0;
-       if (resolve_rename_copy)
-               diff_resolve_rename_copy();
 
        for (i = 0; i < q->nr; i++) {
                struct diff_filepair *p = q->queue[i];
@@ -956,24 +956,88 @@ void diff_flush(int diff_output_style, int resolve_rename_copy)
        q->nr = q->alloc = 0;
 }
 
+static void diffcore_apply_filter(const char *filter)
+{
+       int i;
+       struct diff_queue_struct *q = &diff_queued_diff;
+       struct diff_queue_struct outq;
+       outq.queue = NULL;
+       outq.nr = outq.alloc = 0;
+
+       if (!filter)
+               return;
+
+       if (strchr(filter, 'A')) {
+               /* All-or-none */
+               int found;
+               for (i = found = 0; !found && i < q->nr; i++) {
+                       struct diff_filepair *p = q->queue[i];
+                       if ((p->broken_pair && strchr(filter, 'B')) ||
+                           (!p->broken_pair && strchr(filter, p->status)))
+                               found++;
+               }
+               if (found)
+                       return;
+
+               /* otherwise we will clear the whole queue
+                * by copying the empty outq at the end of this
+                * function, but first clear the current entries
+                * in the queue.
+                */
+               for (i = 0; i < q->nr; i++)
+                       diff_free_filepair(q->queue[i]);
+       }
+       else {
+               /* Only the matching ones */
+               for (i = 0; i < q->nr; i++) {
+                       struct diff_filepair *p = q->queue[i];
+                       if ((p->broken_pair && strchr(filter, 'B')) ||
+                           (!p->broken_pair && strchr(filter, p->status)))
+                               diff_q(&outq, p);
+                       else
+                               diff_free_filepair(p);
+               }
+       }
+       free(q->queue);
+       *q = outq;
+}
+
 void diffcore_std(const char **paths,
                  int detect_rename, int rename_score,
                  const char *pickaxe, int pickaxe_opts,
                  int break_opt,
-                 const char *orderfile)
+                 const char *orderfile,
+                 const char *filter)
 {
        if (paths && paths[0])
                diffcore_pathspec(paths);
-       if (0 <= break_opt)
+       if (break_opt != -1)
                diffcore_break(break_opt);
        if (detect_rename)
                diffcore_rename(detect_rename, rename_score);
-       if (0 <= break_opt)
+       if (break_opt != -1)
                diffcore_merge_broken();
        if (pickaxe)
                diffcore_pickaxe(pickaxe, pickaxe_opts);
        if (orderfile)
                diffcore_order(orderfile);
+       diff_resolve_rename_copy();
+       diffcore_apply_filter(filter);
+}
+
+
+void diffcore_std_no_resolve(const char **paths,
+                            const char *pickaxe, int pickaxe_opts,
+                            const char *orderfile,
+                            const char *filter)
+{
+       if (paths && paths[0])
+               diffcore_pathspec(paths);
+       if (pickaxe)
+               diffcore_pickaxe(pickaxe, pickaxe_opts);
+       if (orderfile)
+               diffcore_order(orderfile);
+       diffcore_apply_filter(filter);
 }
 
 void diff_addremove(int addremove, unsigned mode,