X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=apply.c;h=f8862722fdba204d6e15e4d012f8891bcc36475c;hb=df8baa42fe4eeb5a021ac262caf601f44d2a5746;hp=20c41c51433d18b21b914f0e700501c5244de6e0;hpb=af3f929f9546268ede788b4217ff0b6a655ab62a;p=git.git

diff --git a/apply.c b/apply.c
index 20c41c51..f8862722 100644
--- a/apply.c
+++ b/apply.c
@@ -13,7 +13,7 @@
  * uses the working tree as a "branch" for a 3-way merge.
  */
 #include <ctype.h>
-
+#include <fnmatch.h>
 #include "cache.h"
 
 // We default to the merge behaviour, since that's what most people would
@@ -28,10 +28,12 @@ static int merge_patch = 1;
 static int check_index = 0;
 static int write_index = 0;
 static int diffstat = 0;
+static int summary = 0;
 static int check = 0;
 static int apply = 1;
 static int show_files = 0;
-static const char apply_usage[] = "git-apply [--stat] [--check] [--show-files] <patch>";
+static const char apply_usage[] =
+"git-apply [--no-merge] [--stat] [--summary] [--check] [--index] [--apply] [--show-files] <patch>...";
 
 /*
  * For "diff-stat" like behaviour, we keep track of the biggest change
@@ -60,6 +62,7 @@ struct patch {
 	unsigned int old_mode, new_mode;
 	int is_rename, is_copy, is_new, is_delete;
 	int lines_added, lines_deleted;
+	int score;
 	struct fragment *fragments;
 	char *result;
 	unsigned long resultsize;
@@ -329,11 +332,15 @@ static int gitdiff_renamedst(const char *line, struct patch *patch)
 
 static int gitdiff_similarity(const char *line, struct patch *patch)
 {
+	if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
+		patch->score = 0;
 	return 0;
 }
 
 static int gitdiff_dissimilarity(const char *line, struct patch *patch)
 {
+	if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
+		patch->score = 0;
 	return 0;
 }
 
@@ -380,7 +387,7 @@ static char *git_header_name(char *line)
 		default:
 			continue;
 		case '\n':
-			break;
+			return NULL;
 		case '\t': case ' ':
 			second = name+len;
 			for (;;) {
@@ -556,7 +563,7 @@ static int find_header(char *line, unsigned long size, int *hdrsize, struct patc
 			struct fragment dummy;
 			if (parse_fragment_header(line, len, &dummy) < 0)
 				continue;
-			error("patch fragment without header at line %d: %.*s", linenr, len-1, line);
+			error("patch fragment without header at line %d: %.*s", linenr, (int)len-1, line);
 		}
 
 		if (size < len + 6)
@@ -568,10 +575,13 @@ static int find_header(char *line, unsigned long size, int *hdrsize, struct patc
 		 */
 		if (!memcmp("diff --git ", line, 11)) {
 			int git_hdr_len = parse_git_header(line, len, size, patch);
-			if (git_hdr_len < 0)
+			if (git_hdr_len <= len)
 				continue;
-			if (!patch->old_name && !patch->new_name)
-				die("git diff header lacks filename information (line %d)", linenr);
+			if (!patch->old_name && !patch->new_name) {
+				if (!patch->def_name)
+					die("git diff header lacks filename information (line %d)", linenr);
+				patch->old_name = patch->new_name = patch->def_name;
+			}
 			*hdrsize = git_hdr_len;
 			return offset;
 		}
@@ -662,13 +672,24 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
 			added++;
 			newlines--;
 			break;
-		/* We allow "\ No newline at end of file" */
+
+                /* We allow "\ No newline at end of file". Depending
+                 * on locale settings when the patch was produced we
+                 * don't know what this line looks like. The only
+                 * thing we do know is that it begins with "\ ". */
 		case '\\':
-			if (len < 12 || memcmp(line, "\\ No newline", 12))
+			if (len < 12 || memcmp(line, "\\ ", 2))
 				return -1;
 			break;
 		}
 	}
+	/* If a fragment ends with an incomplete line, we failed to include
+	 * it in the above loop because we hit oldlines == newlines == 0
+	 * before seeing it.
+	 */
+	if (12 < size && !memcmp(line, "\\ ", 2))
+		offset += linelen(line, size);
+
 	patch->lines_added += added;
 	patch->lines_deleted += deleted;
 	return offset;
@@ -702,6 +723,16 @@ static int parse_single_patch(char *line, unsigned long size, struct patch *patc
 	return offset;
 }
 
+static inline int metadata_changes(struct patch *patch)
+{
+	return	patch->is_rename > 0 ||
+		patch->is_copy > 0 ||
+		patch->is_new > 0 ||
+		patch->is_delete ||
+		(patch->old_mode && patch->new_mode &&
+		 patch->old_mode != patch->new_mode);
+}
+
 static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
 {
 	int hdrsize, patchsize;
@@ -712,19 +743,23 @@ static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
 
 	patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
 
+	if (!patchsize && !metadata_changes(patch))
+		die("patch with only garbage at line %d", linenr);
+
 	return offset + hdrsize + patchsize;
 }
 
-const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
-const char minuses[]= "----------------------------------------------------------------------";
+static const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
+static const char minuses[]= "----------------------------------------------------------------------";
 
 static void show_stats(struct patch *patch)
 {
-	char *name = patch->old_name;
+	const char *prefix = "";
+	char *name = patch->new_name;
 	int len, max, add, del, total;
 
 	if (!name)
-		name = patch->new_name;
+		name = patch->old_name;
 
 	/*
 	 * "scale" the filename
@@ -733,8 +768,15 @@ static void show_stats(struct patch *patch)
 	max = max_len;
 	if (max > 50)
 		max = 50;
-	if (len > max)
+	if (len > max) {
+		char *slash;
+		prefix = "...";
+		max -= 3;
 		name += len - max;
+		slash = strchr(name, '/');
+		if (slash)
+			name = slash;
+	}
 	len = max;
 
 	/*
@@ -748,10 +790,12 @@ static void show_stats(struct patch *patch)
 	del = patch->lines_deleted;
 	total = add + del;
 
-	total = (total * max + max_change / 2) / max_change;
-	add = (add * max + max_change / 2) / max_change;
-	del = total - add;
-	printf(" %-*s |%5d %.*s%.*s\n",
+	if (max_change > 0) {
+		total = (total * max + max_change / 2) / max_change;
+		add = (add * max + max_change / 2) / max_change;
+		del = total - add;
+	}
+	printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
 		len, name, patch->lines_added + patch->lines_deleted,
 		add, pluses, del, minuses);
 }
@@ -849,7 +893,6 @@ static int find_offset(const char *buf, unsigned long size, const char *fragment
 		n = (i >> 1)+1;
 		if (i & 1)
 			n = -n;
-		fprintf(stderr, "Fragment applied at offset %d\n", n);
 		return try;
 	}
 
@@ -889,7 +932,7 @@ static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
 		 * last one (which is the newline, of course).
 		 */
 		plen = len-1;
-		if (len > size && patch[len] == '\\')
+		if (len < size && patch[len] == '\\')
 			plen--;
 		switch (*patch) {
 		case ' ':
@@ -942,7 +985,7 @@ static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
 
 	while (frag) {
 		if (apply_one_fragment(desc, frag) < 0)
-			return error("patch failed: %s:%d", patch->old_name, frag->oldpos);
+			return error("patch failed: %s:%ld", patch->old_name, frag->oldpos);
 		frag = frag->next;
 	}
 	return 0;
@@ -989,7 +1032,7 @@ static int check_patch(struct patch *patch)
 		int changed;
 
 		if (lstat(old_name, &st) < 0)
-			return error("%s: %s\n", strerror(errno));
+			return error("%s: %s", old_name, strerror(errno));
 		if (check_index) {
 			int pos = cache_name_pos(old_name, strlen(old_name));
 			if (pos < 0)
@@ -1000,6 +1043,7 @@ static int check_patch(struct patch *patch)
 		}
 		if (patch->is_new < 0)
 			patch->is_new = 0;
+		st.st_mode = ntohl(create_ce_mode(st.st_mode));
 		if (!patch->old_mode)
 			patch->old_mode = st.st_mode;
 		if ((st.st_mode ^ patch->old_mode) & S_IFMT)
@@ -1016,8 +1060,12 @@ static int check_patch(struct patch *patch)
 			return error("%s: already exists in working directory", new_name);
 		if (errno != ENOENT)
 			return error("%s: %s", new_name, strerror(errno));
-		if (!patch->new_mode)
-			patch->new_mode = S_IFREG | 0644;
+		if (!patch->new_mode) {
+			if (patch->is_new)
+				patch->new_mode = S_IFREG | 0644;
+			else
+				patch->new_mode = patch->old_mode;
+		}
 	}
 
 	if (new_name && old_name) {
@@ -1087,6 +1135,84 @@ static void stat_patch_list(struct patch *patch)
 	printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
 }
 
+static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
+{
+	if (mode)
+		printf(" %s mode %06o %s\n", newdelete, mode, name);
+	else
+		printf(" %s %s\n", newdelete, name);
+}
+
+static void show_mode_change(struct patch *p, int show_name)
+{
+	if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
+		if (show_name)
+			printf(" mode change %06o => %06o %s\n",
+			       p->old_mode, p->new_mode, p->new_name);
+		else
+			printf(" mode change %06o => %06o\n",
+			       p->old_mode, p->new_mode);
+	}
+}
+
+static void show_rename_copy(struct patch *p)
+{
+	const char *renamecopy = p->is_rename ? "rename" : "copy";
+	const char *old, *new;
+
+	/* Find common prefix */
+	old = p->old_name;
+	new = p->new_name;
+	while (1) {
+		const char *slash_old, *slash_new;
+		slash_old = strchr(old, '/');
+		slash_new = strchr(new, '/');
+		if (!slash_old ||
+		    !slash_new ||
+		    slash_old - old != slash_new - new ||
+		    memcmp(old, new, slash_new - new))
+			break;
+		old = slash_old + 1;
+		new = slash_new + 1;
+	}
+	/* p->old_name thru old is the common prefix, and old and new
+	 * through the end of names are renames
+	 */
+	if (old != p->old_name)
+		printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
+		       (int)(old - p->old_name), p->old_name,
+		       old, new, p->score);
+	else
+		printf(" %s %s => %s (%d%%)\n", renamecopy,
+		       p->old_name, p->new_name, p->score);
+	show_mode_change(p, 0);
+}
+
+static void summary_patch_list(struct patch *patch)
+{
+	struct patch *p;
+
+	for (p = patch; p; p = p->next) {
+		if (p->is_new)
+			show_file_mode_name("create", p->new_mode, p->new_name);
+		else if (p->is_delete)
+			show_file_mode_name("delete", p->old_mode, p->old_name);
+		else {
+			if (p->is_rename || p->is_copy)
+				show_rename_copy(p);
+			else {
+				if (p->score) {
+					printf(" rewrite %s (%d%%)\n",
+					       p->new_name, p->score);
+					show_mode_change(p, 0);
+				}
+				else
+					show_mode_change(p, 1);
+			}
+		}
+	}
+}
+
 static void patch_stats(struct patch *patch)
 {
 	int lines = patch->lines_added + patch->lines_deleted;
@@ -1138,6 +1264,85 @@ static void add_index_file(const char *path, unsigned mode, void *buf, unsigned
 		die("unable to add cache entry for %s", path);
 }
 
+static void create_subdirectories(const char *path)
+{
+	int len = strlen(path);
+	char *buf = xmalloc(len + 1);
+	const char *slash = path;
+
+	while ((slash = strchr(slash+1, '/')) != NULL) {
+		len = slash - path;
+		memcpy(buf, path, len);
+		buf[len] = 0;
+		if (mkdir(buf, 0777) < 0) {
+			if (errno != EEXIST)
+				break;
+		}
+	}
+	free(buf);
+}
+
+static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
+{
+	int fd;
+
+	if (S_ISLNK(mode))
+		return symlink(buf, path);
+	fd = open(path, O_CREAT | O_EXCL | O_WRONLY | O_TRUNC, (mode & 0100) ? 0777 : 0666);
+	if (fd < 0)
+		return -1;
+	while (size) {
+		int written = write(fd, buf, size);
+		if (written < 0) {
+			if (errno == EINTR || errno == EAGAIN)
+				continue;
+			die("writing file %s: %s", path, strerror(errno));
+		}
+		if (!written)
+			die("out of space writing file %s", path);
+		buf += written;
+		size -= written;
+	}
+	if (close(fd) < 0)
+		die("closing file %s: %s", path, strerror(errno));
+	return 0;
+}
+
+/*
+ * We optimistically assume that the directories exist,
+ * which is true 99% of the time anyway. If they don't,
+ * we create them and try again.
+ */
+static void create_one_file(const char *path, unsigned mode, const char *buf, unsigned long size)
+{
+	if (!try_create_file(path, mode, buf, size))
+		return;
+
+	if (errno == ENOENT) {
+		create_subdirectories(path);
+		if (!try_create_file(path, mode, buf, size))
+			return;
+	}
+
+	if (errno == EEXIST) {
+		unsigned int nr = getpid();
+
+		for (;;) {
+			const char *newpath;
+			newpath = mkpath("%s~%u", path, nr);
+			if (!try_create_file(newpath, mode, buf, size)) {
+				if (!rename(newpath, path))
+					return;
+				unlink(newpath);
+				break;
+			}
+			if (errno != EEXIST)
+				break;
+		}			
+	}
+	die("unable to write file %s mode %o", path, mode);
+}
+
 static void create_file(struct patch *patch)
 {
 	const char *path = patch->new_name;
@@ -1147,28 +1352,8 @@ static void create_file(struct patch *patch)
 
 	if (!mode)
 		mode = S_IFREG | 0644;
-	if (S_ISREG(mode)) {
-		int fd;
-		mode = (mode & 0100) ? 0777 : 0666;
-		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
-		if (fd < 0)
-			die("unable to create file %s (%s)", path, strerror(errno));
-		if (write(fd, buf, size) != size)
-			die("unable to write file %s", path);
-		close(fd);
-		add_index_file(path, mode, buf, size);
-		return;
-	}
-	if (S_ISLNK(mode)) {
-		if (size && buf[size-1] == '\n')
-			size--;
-		buf[size] = 0;
-		if (symlink(buf, path) < 0)
-			die("unable to write symlink %s", path);
-		add_index_file(path, mode, buf, size);
-		return;
-	}
-	die("unable to write file mode %o", mode);
+	create_one_file(path, mode, buf, size);	
+	add_index_file(path, mode, buf, size);
 }
 
 static void write_out_one_result(struct patch *patch)
@@ -1189,9 +1374,9 @@ static void write_out_one_result(struct patch *patch)
 	create_file(patch);
 }
 
-static void write_out_results(struct patch *list)
+static void write_out_results(struct patch *list, int skipped_patch)
 {
-	if (!list)
+	if (!list && !skipped_patch)
 		die("No changes");
 
 	while (list) {
@@ -1202,12 +1387,30 @@ static void write_out_results(struct patch *list)
 
 static struct cache_file cache_file;
 
+static struct excludes {
+	struct excludes *next;
+	const char *path;
+} *excludes;
+
+static int use_patch(struct patch *p)
+{
+	const char *pathname = p->new_name ? p->new_name : p->old_name;
+	struct excludes *x = excludes;
+	while (x) {
+		if (fnmatch(x->path, pathname, 0) == 0)
+			return 0;
+		x = x->next;
+	}
+	return 1;
+}
+
 static int apply_patch(int fd)
 {
 	int newfd;
 	unsigned long offset, size;
 	char *buffer = read_patch_file(fd, &size);
 	struct patch *list = NULL, **listp = &list;
+	int skipped_patch = 0;
 
 	if (!buffer)
 		return -1;
@@ -1221,9 +1424,15 @@ static int apply_patch(int fd)
 		nr = parse_chunk(buffer + offset, size, patch);
 		if (nr < 0)
 			break;
-		patch_stats(patch);
-		*listp = patch;
-		listp = &patch->next;
+		if (use_patch(patch)) {
+			patch_stats(patch);
+			*listp = patch;
+			listp = &patch->next;
+		} else {
+			/* perhaps free it a bit better? */
+			free(patch);
+			skipped_patch++;
+		}
 		offset += nr;
 		size -= nr;
 	}
@@ -1241,7 +1450,7 @@ static int apply_patch(int fd)
 		exit(1);
 
 	if (apply)
-		write_out_results(list);
+		write_out_results(list, skipped_patch);
 
 	if (write_index) {
 		if (write_cache(newfd, active_cache, active_nr) ||
@@ -1255,6 +1464,9 @@ static int apply_patch(int fd)
 	if (diffstat)
 		stat_patch_list(list);
 
+	if (summary)
+		summary_patch_list(list);
+
 	free(buffer);
 	return 0;
 }
@@ -1273,6 +1485,14 @@ int main(int argc, char **argv)
 			read_stdin = 0;
 			continue;
 		}
+		if (!strncmp(arg, "--exclude=", 10)) {
+			struct excludes *x = xmalloc(sizeof(*x));
+			x->path = arg + 10;
+			x->next = excludes;
+			excludes = x;
+			continue;
+		}
+		/* NEEDSWORK: this does not do anything at this moment. */
 		if (!strcmp(arg, "--no-merge")) {
 			merge_patch = 0;
 			continue;
@@ -1282,6 +1502,11 @@ int main(int argc, char **argv)
 			diffstat = 1;
 			continue;
 		}
+		if (!strcmp(arg, "--summary")) {
+			apply = 0;
+			summary = 1;
+			continue;
+		}
 		if (!strcmp(arg, "--check")) {
 			apply = 0;
 			check = 1;
@@ -1291,6 +1516,10 @@ int main(int argc, char **argv)
 			check_index = 1;
 			continue;
 		}
+		if (!strcmp(arg, "--apply")) {
+			apply = 1;
+			continue;
+		}
 		if (!strcmp(arg, "--show-files")) {
 			show_files = 1;
 			continue;