git/builtin/diff-pairs.c

#include "builtin.h"
#include "config.h"
#include "diff.h"
#include "diffcore.h"
#include "gettext.h"
#include "hash.h"
#include "hex.h"
#include "object.h"
#include "parse-options.h"
#include "revision.h"
#include "strbuf.h"

static unsigned parse_mode_or_die(const char *mode, const char **end)
{
	uint16_t ret;

	*end = parse_mode(mode, &ret);
	if (!*end)
		die(_("unable to parse mode: %s"), mode);
	return ret;
}

static void parse_oid_or_die(const char *hex, struct object_id *oid,
			     const char **end, const struct git_hash_algo *algop)
{
	if (parse_oid_hex_algop(hex, oid, end, algop) || *(*end)++ != ' ')
		die(_("unable to parse object id: %s"), hex);
}

int cmd_diff_pairs(int argc, const char **argv, const char *prefix,
		   struct repository *repo)
{
	struct strbuf path_dst = STRBUF_INIT;
	struct strbuf path = STRBUF_INIT;
	struct strbuf meta = STRBUF_INIT;
	struct option *parseopts;
	struct rev_info revs;
	int line_term = '\0';
	int ret;

	const char * const builtin_diff_pairs_usage[] = {
		N_("git diff-pairs -z [<diff-options>]"),
		NULL
	};
	struct option builtin_diff_pairs_options[] = {
		OPT_END()
	};

	repo_init_revisions(repo, &revs, prefix);

	/*
	 * Diff options are usually parsed implicitly as part of
	 * setup_revisions(). Explicitly handle parsing to ensure options are
	 * printed in the usage message.
	 */
	parseopts = add_diff_options(builtin_diff_pairs_options, &revs.diffopt);
	show_usage_with_options_if_asked(argc, argv, builtin_diff_pairs_usage, parseopts);

	repo_config(repo, git_diff_basic_config, NULL);
	revs.diffopt.no_free = 1;
	revs.disable_stdin = 1;
	revs.abbrev = 0;
	revs.diff = 1;

	argc = parse_options(argc, argv, prefix, parseopts, builtin_diff_pairs_usage,
			     PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_DASHDASH);

	if (setup_revisions(argc, argv, &revs, NULL) > 1)
		usagef(_("unrecognized argument: %s"), argv[0]);

	/*
	 * With the -z option, both command input and raw output are
	 * NUL-delimited (this mode does not affect patch output). At present
	 * only NUL-delimited raw diff formatted input is supported.
	 */
	if (revs.diffopt.line_termination)
		usage(_("working without -z is not supported"));

	if (revs.prune_data.nr)
		usage(_("pathspec arguments not supported"));

	if (revs.pending.nr || revs.max_count != -1 ||
	    revs.min_age != (timestamp_t)-1 ||
	    revs.max_age != (timestamp_t)-1)
		usage(_("revision arguments not allowed"));

	if (!revs.diffopt.output_format)
		revs.diffopt.output_format = DIFF_FORMAT_PATCH;

	/*
	 * If rename detection is not requested, use rename information from the
	 * raw diff formatted input. Setting skip_resolving_statuses ensures
	 * diffcore_std() does not mess with rename information already present
	 * in queued filepairs.
	 */
	if (!revs.diffopt.detect_rename)
		revs.diffopt.skip_resolving_statuses = 1;

	while (1) {
		struct object_id oid_a, oid_b;
		struct diff_filepair *pair;
		unsigned mode_a, mode_b;
		const char *p;
		char status;

		if (strbuf_getwholeline(&meta, stdin, line_term) == EOF)
			break;

		p = meta.buf;
		if (!*p) {
			diffcore_std(&revs.diffopt);
			diff_flush(&revs.diffopt);
			/*
			 * When the diff queue is explicitly flushed, append a
			 * NUL byte to separate batches of diffs.
			 */
			fputc('\0', revs.diffopt.file);
			fflush(revs.diffopt.file);
			continue;
		}

		if (*p != ':')
			die(_("invalid raw diff input"));
		p++;

		mode_a = parse_mode_or_die(p, &p);
		mode_b = parse_mode_or_die(p, &p);

		if (S_ISDIR(mode_a) || S_ISDIR(mode_b))
			die(_("tree objects not supported"));

		parse_oid_or_die(p, &oid_a, &p, repo->hash_algo);
		parse_oid_or_die(p, &oid_b, &p, repo->hash_algo);

		status = *p++;

		if (strbuf_getwholeline(&path, stdin, line_term) == EOF)
			die(_("got EOF while reading path"));

		switch (status) {
		case DIFF_STATUS_ADDED:
			pair = diff_queue_addremove(&diff_queued_diff,
						    &revs.diffopt, '+', mode_b,
						    &oid_b, 1, path.buf, 0);
			if (pair)
				pair->status = status;
			break;

		case DIFF_STATUS_DELETED:
			pair = diff_queue_addremove(&diff_queued_diff,
						    &revs.diffopt, '-', mode_a,
						    &oid_a, 1, path.buf, 0);
			if (pair)
				pair->status = status;
			break;

		case DIFF_STATUS_TYPE_CHANGED:
		case DIFF_STATUS_MODIFIED:
			pair = diff_queue_change(&diff_queued_diff, &revs.diffopt,
						 mode_a, mode_b, &oid_a, &oid_b,
						 1, 1, path.buf, 0, 0);
			if (pair)
				pair->status = status;
			break;

		case DIFF_STATUS_RENAMED:
		case DIFF_STATUS_COPIED: {
				struct diff_filespec *a, *b;
				unsigned int score;

				if (strbuf_getwholeline(&path_dst, stdin, line_term) == EOF)
					die(_("got EOF while reading destination path"));

				a = alloc_filespec(path.buf);
				b = alloc_filespec(path_dst.buf);
				fill_filespec(a, &oid_a, 1, mode_a);
				fill_filespec(b, &oid_b, 1, mode_b);

				pair = diff_queue(&diff_queued_diff, a, b);

				if (strtoul_ui(p, 10, &score))
					die(_("unable to parse rename/copy score: %s"), p);

				pair->score = score * MAX_SCORE / 100;
				pair->status = status;
				pair->renamed_pair = 1;
			}
			break;

		default:
			die(_("unknown diff status: %c"), status);
		}
	}

	revs.diffopt.no_free = 0;
	diffcore_std(&revs.diffopt);
	diff_flush(&revs.diffopt);
	ret = diff_result_code(&revs);

	strbuf_release(&path_dst);
	strbuf_release(&path);
	strbuf_release(&meta);
	release_revisions(&revs);
	FREE_AND_NULL(parseopts);

	return ret;
}