Merge branch 'jc/binary'

* jc/binary:
  diff --binary generates full index on binary files.
  Make apply --binary a no-op.

diff --git a/Documentation/git-apply.txt b/Documentation/git-apply.txt
index c76cfffdc6cd9982aa02e34b2b09fc22897e7402..0a6f7b32192df8a8a2266b0d302271a62c612b1f 100644 (file)
--- a/Documentation/git-apply.txt
+++ b/Documentation/git-apply.txt
@@ -110,15 +110,10 @@ OPTIONS
        deletion part but not addition part.
 
 --allow-binary-replacement, --binary::
-       When applying a patch, which is a git-enhanced patch
-       that was prepared to record the pre- and post-image object
-       name in full, and the path being patched exactly matches
-       the object the patch applies to (i.e. "index" line's
-       pre-image object name is what is in the working tree),
-       and the post-image object is available in the object
-       database, use the post-image object as the patch
-       result.  This allows binary files to be patched in a
-       very limited way.
+       Historically we did not allow binary patch applied
+       without an explicit permission from the user, and this
+       flag was the way to do so.  Currently we always allow binary
+       patch application, so this is a no-op.
 
 --exclude=<path-pattern>::
        Don't apply changes to files matching the given path pattern. This can

diff --git a/builtin-apply.c b/builtin-apply.c
index 872c8005a27c0085d47680a8e638b8cf6f3d70a3..6e0864ce27619d1153575876e2a617a392906aed 100644 (file)
--- a/builtin-apply.c
+++ b/builtin-apply.c
@@ -28,7 +28,6 @@ static int prefix_length = -1;
 static int newfd = -1;
 
 static int p_value = 1;
-static int allow_binary_replacement;
 static int check_index;
 static int write_index;
 static int cached;
@@ -1228,14 +1227,12 @@ static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
                        }
                }
 
-               /* Empty patch cannot be applied if:
-                * - it is a binary patch and we do not do binary_replace, or
-                * - text patch without metadata change
+               /* Empty patch cannot be applied if it is a text patch
+                * without metadata change.  A binary patch appears
+                * empty to us here.
                 */
                if ((apply || check) &&
-                   (patch->is_binary
-                    ? !allow_binary_replacement
-                    : !metadata_changes(patch)))
+                   (!patch->is_binary && !metadata_changes(patch)))
                        die("patch with only garbage at line %d", linenr);
        }
 
@@ -1676,11 +1673,6 @@ static int apply_binary(struct buffer_desc *desc, struct patch *patch)
        unsigned char hdr[50];
        int hdrlen;
 
-       if (!allow_binary_replacement)
-               return error("cannot apply binary patch to '%s' "
-                            "without --allow-binary-replacement",
-                            name);
-
        /* For safety, we require patch index line to contain
         * full 40-byte textual SHA1 for old and new, at least for now.
         */
@@ -2497,8 +2489,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix)
                }
                if (!strcmp(arg, "--allow-binary-replacement") ||
                    !strcmp(arg, "--binary")) {
-                       allow_binary_replacement = 1;
-                       continue;
+                       continue; /* now no-op */
                }
                if (!strcmp(arg, "--numstat")) {
                        apply = 0;

diff --git a/diff.c b/diff.c
index 9dcbda3117a5b225aa5ee0f077b03cf8e859228b..6638865709888cc0ad2860ca1389a098b6f402f1 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -1588,6 +1588,12 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
        if (hashcmp(one->sha1, two->sha1)) {
                int abbrev = o->full_index ? 40 : DEFAULT_ABBREV;
 
+               if (o->binary) {
+                       mmfile_t mf;
+                       if ((!fill_mmfile(&mf, one) && mmfile_is_binary(&mf)) ||
+                           (!fill_mmfile(&mf, two) && mmfile_is_binary(&mf)))
+                               abbrev = 40;
+               }
                len += snprintf(msg + len, sizeof(msg) - len,
                                "index %.*s..%.*s",
                                abbrev, sha1_to_hex(one->sha1),
@@ -1818,7 +1824,7 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
                options->full_index = 1;
        else if (!strcmp(arg, "--binary")) {
                options->output_format |= DIFF_FORMAT_PATCH;
-               options->full_index = options->binary = 1;
+               options->binary = 1;
        }
        else if (!strcmp(arg, "-a") || !strcmp(arg, "--text")) {
                options->text = 1;

diff --git a/t/t4103-apply-binary.sh b/t/t4103-apply-binary.sh
index ff052699a28d2d96de4bdaa4702f175527f28536..e2b1124c78540ed9613877d10eed3641268c2c8f 100755 (executable)
--- a/t/t4103-apply-binary.sh
+++ b/t/t4103-apply-binary.sh
@@ -94,11 +94,11 @@ test_expect_failure 'apply binary diff (copy) -- should fail.' \
        'do_reset
         git-apply --index C.diff'
 
-test_expect_failure 'apply binary diff without replacement -- should fail.' \
+test_expect_success 'apply binary diff without replacement.' \
        'do_reset
         git-apply BF.diff'
 
-test_expect_failure 'apply binary diff without replacement (copy) -- should fail.' \
+test_expect_success 'apply binary diff without replacement (copy).' \
        'do_reset
         git-apply CF.diff'