From 88f6dbaf99f43053f86474b28beedd91e77c64d9 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <gitster@pobox.com>
Date: Sat, 17 May 2008 01:46:47 -0700
Subject: [PATCH 1/3] builtin-apply: typofix
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
builtin-apply.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/builtin-apply.c b/builtin-apply.c
index 1103625a4a9..776e5963b72 100644
--- a/builtin-apply.c
+++ b/builtin-apply.c
@@ -418,7 +418,7 @@ static int guess_p_value(const char *nameline)
}
/*
- * Get the name etc info from the --/+++ lines of a traditional patch header
+ * Get the name etc info from the ---/+++ lines of a traditional patch header
*
* FIXME! The end-of-filename heuristics are kind of screwy. For existing
* files, we can happily check the index for a match, but for creating a
From 5c47f4c6e71e6de08348f837f38a446a2f2b0ed7 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <gitster@pobox.com>
Date: Sat, 17 May 2008 01:51:31 -0700
Subject: [PATCH 2/3] builtin-apply: accept patch to an empty file
A patch from a foreign SCM (or plain "diff" output) often have both
preimage and postimage filename on ---/+++ lines even for a patch that
creates a new file. However, when there is a filename for preimage, we
used to insist the file to exist (either in the work tree and/or in the
index). When we cannot be sure by parsing the patch that it is not a
creation patch, we shouldn't complain when if there is no such a file.
This commit fixes the logic.
Refactor the code that validates the preimage file into a separate
function while we are at it, as it is getting rather big.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
builtin-apply.c | 135 ++++++++++++++++++++++++++++--------------------
1 file changed, 78 insertions(+), 57 deletions(-)
diff --git a/builtin-apply.c b/builtin-apply.c
index 776e5963b72..10b1f88a3c0 100644
--- a/builtin-apply.c
+++ b/builtin-apply.c
@@ -2267,6 +2267,79 @@ static int verify_index_match(struct cache_entry *ce, struct stat *st)
return ce_match_stat(ce, st, CE_MATCH_IGNORE_VALID);
}
+static int check_preimage(struct patch *patch, struct cache_entry **ce, struct stat *st)
+{
+ const char *old_name = patch->old_name;
+ int stat_ret = 0;
+ unsigned st_mode = 0;
+
+ /*
+ * Make sure that we do not have local modifications from the
+ * index when we are looking at the index. Also make sure
+ * we have the preimage file to be patched in the work tree,
+ * unless --cached, which tells git to apply only in the index.
+ */
+ if (!old_name)
+ return 0;
+
+ assert(patch->is_new <= 0);
+ if (!cached) {
+ stat_ret = lstat(old_name, st);
+ if (stat_ret && errno != ENOENT)
+ return error("%s: %s", old_name, strerror(errno));
+ }
+ if (check_index) {
+ int pos = cache_name_pos(old_name, strlen(old_name));
+ if (pos < 0) {
+ if (patch->is_new < 0)
+ goto is_new;
+ return error("%s: does not exist in index", old_name);
+ }
+ *ce = active_cache[pos];
+ if (stat_ret < 0) {
+ struct checkout costate;
+ /* checkout */
+ costate.base_dir = "";
+ costate.base_dir_len = 0;
+ costate.force = 0;
+ costate.quiet = 0;
+ costate.not_new = 0;
+ costate.refresh_cache = 1;
+ if (checkout_entry(*ce, &costate, NULL) ||
+ lstat(old_name, st))
+ return -1;
+ }
+ if (!cached && verify_index_match(*ce, st))
+ return error("%s: does not match index", old_name);
+ if (cached)
+ st_mode = (*ce)->ce_mode;
+ } else if (stat_ret < 0) {
+ if (patch->is_new < 0)
+ goto is_new;
+ return error("%s: %s", old_name, strerror(errno));
+ }
+
+ if (!cached)
+ st_mode = ce_mode_from_stat(*ce, st->st_mode);
+
+ if (patch->is_new < 0)
+ patch->is_new = 0;
+ if (!patch->old_mode)
+ patch->old_mode = st_mode;
+ if ((st_mode ^ patch->old_mode) & S_IFMT)
+ return error("%s: wrong type", old_name);
+ if (st_mode != patch->old_mode)
+ fprintf(stderr, "warning: %s has type %o, expected %o\n",
+ old_name, st_mode, patch->old_mode);
+ return 0;
+
+ is_new:
+ patch->is_new = 1;
+ patch->is_delete = 0;
+ patch->old_name = NULL;
+ return 0;
+}
+
static int check_patch(struct patch *patch, struct patch *prev_patch)
{
struct stat st;
@@ -2275,66 +2348,14 @@ static int check_patch(struct patch *patch, struct patch *prev_patch)
const char *name = old_name ? old_name : new_name;
struct cache_entry *ce = NULL;
int ok_if_exists;
+ int status;
patch->rejected = 1; /* we will drop this after we succeed */
- /*
- * Make sure that we do not have local modifications from the
- * index when we are looking at the index. Also make sure
- * we have the preimage file to be patched in the work tree,
- * unless --cached, which tells git to apply only in the index.
- */
- if (old_name) {
- int stat_ret = 0;
- unsigned st_mode = 0;
-
- if (!cached)
- stat_ret = lstat(old_name, &st);
- if (check_index) {
- int pos = cache_name_pos(old_name, strlen(old_name));
- if (pos < 0)
- return error("%s: does not exist in index",
- old_name);
- ce = active_cache[pos];
- if (stat_ret < 0) {
- struct checkout costate;
- if (errno != ENOENT)
- return error("%s: %s", old_name,
- strerror(errno));
- /* checkout */
- costate.base_dir = "";
- costate.base_dir_len = 0;
- costate.force = 0;
- costate.quiet = 0;
- costate.not_new = 0;
- costate.refresh_cache = 1;
- if (checkout_entry(ce,
- &costate,
- NULL) ||
- lstat(old_name, &st))
- return -1;
- }
- if (!cached && verify_index_match(ce, &st))
- return error("%s: does not match index",
- old_name);
- if (cached)
- st_mode = ce->ce_mode;
- } else if (stat_ret < 0)
- return error("%s: %s", old_name, strerror(errno));
-
- if (!cached)
- st_mode = ce_mode_from_stat(ce, st.st_mode);
-
- if (patch->is_new < 0)
- patch->is_new = 0;
- if (!patch->old_mode)
- patch->old_mode = st_mode;
- if ((st_mode ^ patch->old_mode) & S_IFMT)
- return error("%s: wrong type", old_name);
- if (st_mode != patch->old_mode)
- fprintf(stderr, "warning: %s has type %o, expected %o\n",
- old_name, st_mode, patch->old_mode);
- }
+ status = check_preimage(patch, &ce, &st);
+ if (status)
+ return status;
+ old_name = patch->old_name;
if (new_name && prev_patch && 0 < prev_patch->is_delete &&
!strcmp(prev_patch->old_name, new_name))
From 032bea55a3fda805382398020657f738b8176729 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <gitster@pobox.com>
Date: Sat, 17 May 2008 02:02:44 -0700
Subject: [PATCH 3/3] builtin-apply: do not declare patch is creation when we
do not know it
When we see no context nor deleted line in the patch, we used to declare
that the patch creates a new file. But some people create an empty file
and then apply a patch to it. Similarly, a patch that delete everything
is not a deletion patch either.
This commit corrects these two issues. Together with the previous commit,
it allows a diff between an empty file and a line-ful file to be treated
as both creation patch and "add stuff to an existing empty file",
depending on the context. A new test t4126 demonstrates the fix.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
builtin-apply.c | 15 -----------
t/t4126-apply-empty.sh | 61 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 61 insertions(+), 15 deletions(-)
create mode 100755 t/t4126-apply-empty.sh
diff --git a/builtin-apply.c b/builtin-apply.c
index 10b1f88a3c0..1540f28ab4a 100644
--- a/builtin-apply.c
+++ b/builtin-apply.c
@@ -1143,21 +1143,6 @@ static int parse_single_patch(char *line, unsigned long size, struct patch *patc
if (patch->is_delete < 0 &&
(newlines || (patch->fragments && patch->fragments->next)))
patch->is_delete = 0;
- if (!unidiff_zero || context) {
- /* If the user says the patch is not generated with
- * --unified=0, or if we have seen context lines,
- * then not having oldlines means the patch is creation,
- * and not having newlines means the patch is deletion.
- */
- if (patch->is_new < 0 && !oldlines) {
- patch->is_new = 1;
- patch->old_name = NULL;
- }
- if (patch->is_delete < 0 && !newlines) {
- patch->is_delete = 1;
- patch->new_name = NULL;
- }
- }
if (0 < patch->is_new && oldlines)
die("new file %s depends on old contents", patch->new_name);
diff --git a/t/t4126-apply-empty.sh b/t/t4126-apply-empty.sh
new file mode 100755
index 00000000000..0cfd47cfcff
--- /dev/null
+++ b/t/t4126-apply-empty.sh
@@ -0,0 +1,61 @@
+#!/bin/sh
+
+test_description='apply empty'
+
+. ./test-lib.sh
+
+test_expect_success setup '
+ >empty &&
+ git add empty &&
+ test_tick &&
+ git commit -m initial &&
+ for i in a b c d e
+ do
+ echo $i
+ done >empty &&
+ cat empty >expect &&
+ git diff |
+ sed -e "/^diff --git/d" \
+ -e "/^index /d" \
+ -e "s|a/empty|empty.orig|" \
+ -e "s|b/empty|empty|" >patch0 &&
+ sed -e "s|empty|missing|" patch0 >patch1 &&
+ >empty &&
+ git update-index --refresh
+'
+
+test_expect_success 'apply empty' '
+ git reset --hard &&
+ >empty &&
+ rm -f missing &&
+ git apply patch0 &&
+ test_cmp expect empty
+'
+
+test_expect_success 'apply --index empty' '
+ git reset --hard &&
+ >empty &&
+ rm -f missing &&
+ git apply --index patch0 &&
+ test_cmp expect empty &&
+ git diff --exit-code
+'
+
+test_expect_success 'apply create' '
+ git reset --hard &&
+ >empty &&
+ rm -f missing &&
+ git apply patch1 &&
+ test_cmp expect missing
+'
+
+test_expect_success 'apply --index create' '
+ git reset --hard &&
+ >empty &&
+ rm -f missing &&
+ git apply --index patch1 &&
+ test_cmp expect missing &&
+ git diff --exit-code
+'
+
+test_done