1 files changed, 188 insertions, 66 deletions

diff --git a/src/diff_patch.c b/src/diff_patch.c
index a1e1fe84c..cc45b6ddb 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -10,6 +10,7 @@
 #include "diff_driver.h"
 #include "diff_patch.h"
 #include "diff_xdiff.h"
+#include "fileops.h"
 
 /* cached information about a single span in a diff */
 typedef struct diff_patch_line diff_patch_line;
@@ -41,7 +42,7 @@ struct git_diff_patch {
 	git_array_t(diff_patch_hunk) hunks;
 	git_array_t(diff_patch_line) lines;
 	size_t oldno, newno;
-	size_t content_size;
+	size_t content_size, context_size, header_size;
 	git_pool flattened;
 };
 
@@ -64,12 +65,12 @@ static void diff_patch_update_binary(git_diff_patch *patch)
 	if ((patch->delta->flags & DIFF_FLAGS_KNOWN_BINARY) != 0)
 		return;
 
-	if ((patch->ofile.file.flags & GIT_DIFF_FLAG_BINARY) != 0 ||
-		(patch->nfile.file.flags & GIT_DIFF_FLAG_BINARY) != 0)
+	if ((patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0 ||
+		(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 		patch->delta->flags |= GIT_DIFF_FLAG_BINARY;
 
-	else if ((patch->ofile.file.flags & DIFF_FLAGS_NOT_BINARY) != 0 &&
-			 (patch->nfile.file.flags & DIFF_FLAGS_NOT_BINARY) != 0)
+	else if ((patch->ofile.file->flags & DIFF_FLAGS_NOT_BINARY) != 0 &&
+			 (patch->nfile.file->flags & DIFF_FLAGS_NOT_BINARY) != 0)
 		patch->delta->flags |= GIT_DIFF_FLAG_NOT_BINARY;
 }
 
@@ -143,42 +144,46 @@ static int diff_patch_load(git_diff_patch *patch, git_diff_output *output)
 		output && !output->hunk_cb && !output->data_cb)
 		return 0;
 
-#define DIFF_FLAGS_KNOWN_DATA (GIT_DIFF_FLAG__NO_DATA|GIT_DIFF_FLAG_VALID_OID)
-
 	incomplete_data =
-		((patch->ofile.file.flags & DIFF_FLAGS_KNOWN_DATA) != 0 &&
-		 (patch->nfile.file.flags & DIFF_FLAGS_KNOWN_DATA) != 0);
+		(((patch->ofile.flags & GIT_DIFF_FLAG__NO_DATA) != 0 ||
+		  (patch->ofile.file->flags & GIT_DIFF_FLAG_VALID_OID) != 0) &&
+		 ((patch->nfile.flags & GIT_DIFF_FLAG__NO_DATA) != 0 ||
+		  (patch->nfile.file->flags & GIT_DIFF_FLAG_VALID_OID) != 0));
 
 	/* always try to load workdir content first because filtering may
 	 * need 2x data size and this minimizes peak memory footprint
 	 */
 	if (patch->ofile.src == GIT_ITERATOR_TYPE_WORKDIR) {
 		if ((error = git_diff_file_content__load(&patch->ofile)) < 0 ||
-			(patch->ofile.file.flags & GIT_DIFF_FLAG_BINARY) != 0)
+			(patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 			goto cleanup;
 	}
 	if (patch->nfile.src == GIT_ITERATOR_TYPE_WORKDIR) {
 		if ((error = git_diff_file_content__load(&patch->nfile)) < 0 ||
-			(patch->nfile.file.flags & GIT_DIFF_FLAG_BINARY) != 0)
+			(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 			goto cleanup;
 	}
 
 	/* once workdir has been tried, load other data as needed */
 	if (patch->ofile.src != GIT_ITERATOR_TYPE_WORKDIR) {
 		if ((error = git_diff_file_content__load(&patch->ofile)) < 0 ||
-			(patch->ofile.file.flags & GIT_DIFF_FLAG_BINARY) != 0)
+			(patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 			goto cleanup;
 	}
 	if (patch->nfile.src != GIT_ITERATOR_TYPE_WORKDIR) {
 		if ((error = git_diff_file_content__load(&patch->nfile)) < 0 ||
-			(patch->nfile.file.flags & GIT_DIFF_FLAG_BINARY) != 0)
+			(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 			goto cleanup;
 	}
 
-	/* if we were previously missing an oid, reassess UNMODIFIED state */
+	/* if previously missing an oid, and now that we have it the two sides
+	 * are the same (and not submodules), update MODIFIED -> UNMODIFIED
+	 */
 	if (incomplete_data &&
-		patch->ofile.file.mode == patch->nfile.file.mode &&
-		git_oid_equal(&patch->ofile.file.oid, &patch->nfile.file.oid))
+		patch->ofile.file->mode == patch->nfile.file->mode &&
+		patch->ofile.file->mode != GIT_FILEMODE_COMMIT &&
+		git_oid_equal(&patch->ofile.file->oid, &patch->nfile.file->oid) &&
+		patch->delta->status == GIT_DELTA_MODIFIED) /* not RENAMED/COPIED! */
 		patch->delta->status = GIT_DELTA_UNMODIFIED;
 
 cleanup:
@@ -192,7 +197,7 @@ cleanup:
 			patch->delta->status != GIT_DELTA_UNMODIFIED &&
 			(patch->ofile.map.len || patch->nfile.map.len) &&
 			(patch->ofile.map.len != patch->nfile.map.len ||
-			 !git_oid_equal(&patch->ofile.file.oid, &patch->nfile.file.oid)))
+			 !git_oid_equal(&patch->ofile.file->oid, &patch->nfile.file->oid)))
 			patch->flags |= GIT_DIFF_PATCH_DIFFABLE;
 
 		patch->flags |= GIT_DIFF_PATCH_LOADED;
@@ -225,6 +230,10 @@ static int diff_patch_generate(git_diff_patch *patch, git_diff_output *output)
 	if ((patch->flags & GIT_DIFF_PATCH_DIFFED) != 0)
 		return 0;
 
+	/* if we are not looking at the hunks and lines, don't do the diff */
+	if (!output->hunk_cb && !output->data_cb)
+		return 0;
+
 	if ((patch->flags & GIT_DIFF_PATCH_LOADED) == 0 &&
 		(error = diff_patch_load(patch, output)) < 0)
 		return error;
@@ -279,21 +288,22 @@ int git_diff_foreach(
 	if (diff_required(diff, "git_diff_foreach") < 0)
 		return -1;
 
-	diff_output_init((git_diff_output *)&xo,
-		&diff->opts, file_cb, hunk_cb, data_cb, payload);
+	diff_output_init(
+		&xo.output, &diff->opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, &diff->opts);
 
 	git_vector_foreach(&diff->deltas, idx, patch.delta) {
+
 		/* check flags against patch status */
 		if (git_diff_delta__should_skip(&diff->opts, patch.delta))
 			continue;
 
 		if (!(error = diff_patch_init_from_diff(&patch, diff, idx))) {
 
-			error = diff_patch_file_callback(&patch, (git_diff_output *)&xo);
+			error = diff_patch_file_callback(&patch, &xo.output);
 
 			if (!error)
-				error = diff_patch_generate(&patch, (git_diff_output *)&xo);
+				error = diff_patch_generate(&patch, &xo.output);
 
 			git_diff_patch_free(&patch);
 		}
@@ -310,26 +320,31 @@ int git_diff_foreach(
 typedef struct {
 	git_diff_patch patch;
 	git_diff_delta delta;
+	char paths[GIT_FLEX_ARRAY];
 } diff_patch_with_delta;
 
 static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
 {
 	int error = 0;
 	git_diff_patch *patch = &pd->patch;
-	bool has_old = ((patch->ofile.file.flags & GIT_DIFF_FLAG__NO_DATA) == 0);
-	bool has_new = ((patch->nfile.file.flags & GIT_DIFF_FLAG__NO_DATA) == 0);
+	bool has_old = ((patch->ofile.flags & GIT_DIFF_FLAG__NO_DATA) == 0);
+	bool has_new = ((patch->nfile.flags & GIT_DIFF_FLAG__NO_DATA) == 0);
 
 	pd->delta.status = has_new ?
 		(has_old ? GIT_DELTA_MODIFIED : GIT_DELTA_ADDED) :
 		(has_old ? GIT_DELTA_DELETED : GIT_DELTA_UNTRACKED);
 
-	if (git_oid_equal(&patch->nfile.file.oid, &patch->ofile.file.oid))
+	if (git_oid_equal(&patch->nfile.file->oid, &patch->ofile.file->oid))
 		pd->delta.status = GIT_DELTA_UNMODIFIED;
 
 	patch->delta = &pd->delta;
 
 	diff_patch_init_common(patch);
 
+	if (pd->delta.status == GIT_DELTA_UNMODIFIED &&
+		!(patch->ofile.opts_flags & GIT_DIFF_INCLUDE_UNMODIFIED))
+		return error;
+
 	error = diff_patch_file_callback(patch, (git_diff_output *)xo);
 
 	if (!error)
@@ -345,7 +360,9 @@ static int diff_patch_from_blobs(
 	diff_patch_with_delta *pd,
 	git_xdiff_output *xo,
 	const git_blob *old_blob,
+	const char *old_path,
 	const git_blob *new_blob,
+	const char *new_path,
 	const git_diff_options *opts)
 {
 	int error = 0;
@@ -355,29 +372,61 @@ static int diff_patch_from_blobs(
 
 	GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
 
-	pd->patch.delta = &pd->delta;
-
-	if (!repo) /* return two NULL items as UNMODIFIED delta */
-		return 0;
-
 	if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
-		const git_blob *swap = old_blob;
-		old_blob = new_blob;
-		new_blob = swap;
+		const git_blob *tmp_blob;
+		const char *tmp_path;
+		tmp_blob = old_blob; old_blob = new_blob; new_blob = tmp_blob;
+		tmp_path = old_path; old_path = new_path; new_path = tmp_path;
 	}
 
+	pd->patch.delta = &pd->delta;
+
+	pd->delta.old_file.path = old_path;
+	pd->delta.new_file.path = new_path;
+
 	if ((error = git_diff_file_content__init_from_blob(
-			&pd->patch.ofile, repo, opts, old_blob)) < 0 ||
+			&pd->patch.ofile, repo, opts, old_blob, &pd->delta.old_file)) < 0 ||
 		(error = git_diff_file_content__init_from_blob(
-			&pd->patch.nfile, repo, opts, new_blob)) < 0)
+			&pd->patch.nfile, repo, opts, new_blob, &pd->delta.new_file)) < 0)
 		return error;
 
 	return diff_single_generate(pd, xo);
 }
 
+static int diff_patch_with_delta_alloc(
+	diff_patch_with_delta **out,
+	const char **old_path,
+	const char **new_path)
+{
+	diff_patch_with_delta *pd;
+	size_t old_len = *old_path ? strlen(*old_path) : 0;
+	size_t new_len = *new_path ? strlen(*new_path) : 0;
+
+	*out = pd = git__calloc(1, sizeof(*pd) + old_len + new_len + 2);
+	GITERR_CHECK_ALLOC(pd);
+
+	pd->patch.flags = GIT_DIFF_PATCH_ALLOCATED;
+
+	if (*old_path) {
+		memcpy(&pd->paths[0], *old_path, old_len);
+		*old_path = &pd->paths[0];
+	} else if (*new_path)
+		*old_path = &pd->paths[old_len + 1];
+
+	if (*new_path) {
+		memcpy(&pd->paths[old_len + 1], *new_path, new_len);
+		*new_path = &pd->paths[old_len + 1];
+	} else if (*old_path)
+		*new_path = &pd->paths[0];
+
+	return 0;
+}
+
 int git_diff_blobs(
 	const git_blob *old_blob,
+	const char *old_path,
 	const git_blob *new_blob,
+	const char *new_path,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
@@ -392,12 +441,18 @@ int git_diff_blobs(
 	memset(&xo, 0, sizeof(xo));
 
 	diff_output_init(
-		(git_diff_output *)&xo, opts, file_cb, hunk_cb, data_cb, payload);
+		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, opts);
 
-	error = diff_patch_from_blobs(&pd, &xo, old_blob, new_blob, opts);
+	if (!old_path && new_path)
+		old_path = new_path;
+	else if (!new_path && old_path)
+		new_path = old_path;
 
-	git_diff_patch_free((git_diff_patch *)&pd);
+	error = diff_patch_from_blobs(
+		&pd, &xo, old_blob, old_path, new_blob, new_path, opts);
+
+	git_diff_patch_free(&pd.patch);
 
 	return error;
 }
@@ -405,7 +460,9 @@ int git_diff_blobs(
 int git_diff_patch_from_blobs(
 	git_diff_patch **out,
 	const git_blob *old_blob,
+	const char *old_path,
 	const git_blob *new_blob,
+	const char *new_path,
 	const git_diff_options *opts)
 {
 	int error = 0;
@@ -415,16 +472,18 @@ int git_diff_patch_from_blobs(
 	assert(out);
 	*out = NULL;
 
-	pd = git__calloc(1, sizeof(*pd));
-	GITERR_CHECK_ALLOC(pd);
-	pd->patch.flags = GIT_DIFF_PATCH_ALLOCATED;
+	if (diff_patch_with_delta_alloc(&pd, &old_path, &new_path) < 0)
+		return -1;
 
 	memset(&xo, 0, sizeof(xo));
 
-	diff_output_to_patch((git_diff_output *)&xo, &pd->patch);
+	diff_output_to_patch(&xo.output, &pd->patch);
 	git_xdiff_init(&xo, opts);
 
-	if (!(error = diff_patch_from_blobs(pd, &xo, old_blob, new_blob, opts)))
+	error = diff_patch_from_blobs(
+		pd, &xo, old_blob, old_path, new_blob, new_path, opts);
+
+	if (!error)
 		*out = (git_diff_patch *)pd;
 	else
 		git_diff_patch_free((git_diff_patch *)pd);
@@ -436,8 +495,10 @@ static int diff_patch_from_blob_and_buffer(
 	diff_patch_with_delta *pd,
 	git_xdiff_output *xo,
 	const git_blob *old_blob,
+	const char *old_path,
 	const char *buf,
 	size_t buflen,
+	const char *buf_path,
 	const git_diff_options *opts)
 {
 	int error = 0;
@@ -448,28 +509,36 @@ static int diff_patch_from_blob_and_buffer(
 
 	pd->patch.delta = &pd->delta;
 
-	if (!repo && !buf) /* return two NULL items as UNMODIFIED delta */
-		return 0;
-
 	if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
+		pd->delta.old_file.path = buf_path;
+		pd->delta.new_file.path = old_path;
+
 		if (!(error = git_diff_file_content__init_from_raw(
-				&pd->patch.ofile, repo, opts, buf, buflen)))
+				&pd->patch.ofile, repo, opts, buf, buflen, &pd->delta.old_file)))
 			error = git_diff_file_content__init_from_blob(
-				&pd->patch.nfile, repo, opts, old_blob);
+				&pd->patch.nfile, repo, opts, old_blob, &pd->delta.new_file);
 	} else {
+		pd->delta.old_file.path = old_path;
+		pd->delta.new_file.path = buf_path;
+
 		if (!(error = git_diff_file_content__init_from_blob(
-				&pd->patch.ofile, repo, opts, old_blob)))
+				&pd->patch.ofile, repo, opts, old_blob, &pd->delta.old_file)))
 			error = git_diff_file_content__init_from_raw(
-				&pd->patch.nfile, repo, opts, buf, buflen);
+				&pd->patch.nfile, repo, opts, buf, buflen, &pd->delta.new_file);
 	}
 
+	if (error < 0)
+		return error;
+
 	return diff_single_generate(pd, xo);
 }
 
 int git_diff_blob_to_buffer(
 	const git_blob *old_blob,
+	const char *old_path,
 	const char *buf,
 	size_t buflen,
+	const char *buf_path,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
@@ -484,13 +553,18 @@ int git_diff_blob_to_buffer(
 	memset(&xo, 0, sizeof(xo));
 
 	diff_output_init(
-		(git_diff_output *)&xo, opts, file_cb, hunk_cb, data_cb, payload);
+		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, opts);
 
+	if (!old_path && buf_path)
+		old_path = buf_path;
+	else if (!buf_path && old_path)
+		buf_path = old_path;
+
 	error = diff_patch_from_blob_and_buffer(
-		&pd, &xo, old_blob, buf, buflen, opts);
+		&pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
 
-	git_diff_patch_free((git_diff_patch *)&pd);
+	git_diff_patch_free(&pd.patch);
 
 	return error;
 }
@@ -498,8 +572,10 @@ int git_diff_blob_to_buffer(
 int git_diff_patch_from_blob_and_buffer(
 	git_diff_patch **out,
 	const git_blob *old_blob,
+	const char *old_path,
 	const char *buf,
 	size_t buflen,
+	const char *buf_path,
 	const git_diff_options *opts)
 {
 	int error = 0;
@@ -509,17 +585,18 @@ int git_diff_patch_from_blob_and_buffer(
 	assert(out);
 	*out = NULL;
 
-	pd = git__calloc(1, sizeof(*pd));
-	GITERR_CHECK_ALLOC(pd);
-	pd->patch.flags = GIT_DIFF_PATCH_ALLOCATED;
+	if (diff_patch_with_delta_alloc(&pd, &old_path, &buf_path) < 0)
+		return -1;
 
 	memset(&xo, 0, sizeof(xo));
 
-	diff_output_to_patch((git_diff_output *)&xo, &pd->patch);
+	diff_output_to_patch(&xo.output, &pd->patch);
 	git_xdiff_init(&xo, opts);
 
-	if (!(error = diff_patch_from_blob_and_buffer(
-			pd, &xo, old_blob, buf, buflen, opts)))
+	error = diff_patch_from_blob_and_buffer(
+		pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
+
+	if (!error)
 		*out = (git_diff_patch *)pd;
 	else
 		git_diff_patch_free((git_diff_patch *)pd);
@@ -565,13 +642,13 @@ int git_diff_get_patch(
 	if ((error = diff_patch_alloc_from_diff(&patch, diff, idx)) < 0)
 		return error;
 
-	diff_output_to_patch((git_diff_output *)&xo, patch);
+	diff_output_to_patch(&xo.output, patch);
 	git_xdiff_init(&xo, &diff->opts);
 
-	error = diff_patch_file_callback(patch, (git_diff_output *)&xo);
+	error = diff_patch_file_callback(patch, &xo.output);
 
 	if (!error)
-		error = diff_patch_generate(patch, (git_diff_output *)&xo);
+		error = diff_patch_generate(patch, &xo.output);
 
 	if (!error) {
 		/* if cumulative diff size is < 0.5 total size, flatten the patch */
@@ -733,6 +810,39 @@ notfound:
 	return diff_error_outofrange(thing);
 }
 
+size_t git_diff_patch_size(
+	git_diff_patch *patch,
+	int include_context,
+	int include_hunk_headers,
+	int include_file_headers)
+{
+	size_t out;
+
+	assert(patch);
+
+	out = patch->content_size;
+
+	if (!include_context)
+		out -= patch->context_size;
+
+	if (include_hunk_headers)
+		out += patch->header_size;
+
+	if (include_file_headers) {
+		git_buf file_header = GIT_BUF_INIT;
+
+		if (git_diff_delta__format_file_header(
+				&file_header, patch->delta, NULL, NULL, 0) < 0)
+			giterr_clear();
+		else
+			out += git_buf_len(&file_header);
+
+		git_buf_free(&file_header);
+	}
+
+	return out;
+}
+
 git_diff_list *git_diff_patch__diff(git_diff_patch *patch)
 {
 	return patch->diff;
@@ -827,6 +937,8 @@ static int diff_patch_hunk_cb(
 	hunk->header[header_len] = '\0';
 	hunk->header_len = header_len;
 
+	patch->header_size += header_len;
+
 	hunk->line_start = git_array_size(patch->lines);
 	hunk->line_count = 0;
 
@@ -847,6 +959,7 @@ static int diff_patch_line_cb(
 	git_diff_patch *patch = payload;
 	diff_patch_hunk *hunk;
 	diff_patch_line *line;
+	const char *content_end = content + content_len;
 
 	GIT_UNUSED(delta);
 	GIT_UNUSED(range);
@@ -861,34 +974,43 @@ static int diff_patch_line_cb(
 	line->len = content_len;
 	line->origin = line_origin;
 
-	patch->content_size += content_len;
-
 	/* do some bookkeeping so we can provide old/new line numbers */
 
-	for (line->lines = 0; content_len > 0; --content_len) {
+	line->lines = 0;
+	while (content < content_end)
 		if (*content++ == '\n')
 			++line->lines;
-	}
+
+	patch->content_size += content_len;
 
 	switch (line_origin) {
 	case GIT_DIFF_LINE_ADDITION:
+		patch->content_size += 1;
 	case GIT_DIFF_LINE_DEL_EOFNL:
 		line->oldno = -1;
 		line->newno = patch->newno;
 		patch->newno += line->lines;
 		break;
 	case GIT_DIFF_LINE_DELETION:
+		patch->content_size += 1;
 	case GIT_DIFF_LINE_ADD_EOFNL:
 		line->oldno = patch->oldno;
 		line->newno = -1;
 		patch->oldno += line->lines;
 		break;
-	default:
+	case GIT_DIFF_LINE_CONTEXT:
+		patch->content_size += 1;
+		patch->context_size += 1;
+	case GIT_DIFF_LINE_CONTEXT_EOFNL:
+		patch->context_size += content_len;
 		line->oldno = patch->oldno;
 		line->newno = patch->newno;
 		patch->oldno += line->lines;
 		patch->newno += line->lines;
 		break;
+	default:
+		assert(false);
+		break;
 	}
 
 	hunk->line_count++;