mirror of
https://github.com/git/git
synced 2024-08-25 02:35:46 +00:00
![Johannes Schindelin](/assets/img/avatar_default.png)
Just like tbdiff, we now show the diff between matching patches. This is a "diff of two diffs", so it can be a bit daunting to read for the beginner. An alternative would be to display an interdiff, i.e. the hypothetical diff which is the result of first reverting the old diff and then applying the new diff. Especially when rebasing frequently, an interdiff is often not feasible, though: if the old diff cannot be applied in reverse (due to a moving upstream), an interdiff can simply not be inferred. This commit brings `range-diff` closer to feature parity with regard to tbdiff. To make `git range-diff` respect e.g. color.diff.* settings, we have to adjust git_branch_config() accordingly. Note: while we now parse diff options such as --color, the effect is not yet the same as in tbdiff, where also the commit pairs would be colored. This is left for a later commit. Note also: while tbdiff accepts the `--no-patches` option to suppress these diffs between patches, we prefer the `-s` (or `--no-patch`) option that is automatically supported via our use of diff_opt_parse(). And finally note: to support diff options, we have to call `parse_options()` such that it keeps unknown options, and then loop over those and let `diff_opt_parse()` handle them. After that loop, we have to call `parse_options()` again, to make sure that no unknown options are left. Helped-by: Thomas Gummerer <t.gummerer@gmail.com> Helped-by: Eric Sunshine <sunshine@sunshineco.com> Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
361 lines
8.8 KiB
C
361 lines
8.8 KiB
C
#include "cache.h"
|
|
#include "range-diff.h"
|
|
#include "string-list.h"
|
|
#include "run-command.h"
|
|
#include "argv-array.h"
|
|
#include "hashmap.h"
|
|
#include "xdiff-interface.h"
|
|
#include "linear-assignment.h"
|
|
#include "diffcore.h"
|
|
|
|
struct patch_util {
|
|
/* For the search for an exact match */
|
|
struct hashmap_entry e;
|
|
const char *diff, *patch;
|
|
|
|
int i, shown;
|
|
int diffsize;
|
|
size_t diff_offset;
|
|
/* the index of the matching item in the other branch, or -1 */
|
|
int matching;
|
|
struct object_id oid;
|
|
};
|
|
|
|
/*
|
|
* Reads the patches into a string list, with the `util` field being populated
|
|
* as struct object_id (will need to be free()d).
|
|
*/
|
|
static int read_patches(const char *range, struct string_list *list)
|
|
{
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
FILE *in;
|
|
struct strbuf buf = STRBUF_INIT, line = STRBUF_INIT;
|
|
struct patch_util *util = NULL;
|
|
int in_header = 1;
|
|
|
|
argv_array_pushl(&cp.args, "log", "--no-color", "-p", "--no-merges",
|
|
"--reverse", "--date-order", "--decorate=no",
|
|
"--no-abbrev-commit", range,
|
|
NULL);
|
|
cp.out = -1;
|
|
cp.no_stdin = 1;
|
|
cp.git_cmd = 1;
|
|
|
|
if (start_command(&cp))
|
|
return error_errno(_("could not start `log`"));
|
|
in = fdopen(cp.out, "r");
|
|
if (!in) {
|
|
error_errno(_("could not read `log` output"));
|
|
finish_command(&cp);
|
|
return -1;
|
|
}
|
|
|
|
while (strbuf_getline(&line, in) != EOF) {
|
|
const char *p;
|
|
|
|
if (skip_prefix(line.buf, "commit ", &p)) {
|
|
if (util) {
|
|
string_list_append(list, buf.buf)->util = util;
|
|
strbuf_reset(&buf);
|
|
}
|
|
util = xcalloc(sizeof(*util), 1);
|
|
if (get_oid(p, &util->oid)) {
|
|
error(_("could not parse commit '%s'"), p);
|
|
free(util);
|
|
string_list_clear(list, 1);
|
|
strbuf_release(&buf);
|
|
strbuf_release(&line);
|
|
fclose(in);
|
|
finish_command(&cp);
|
|
return -1;
|
|
}
|
|
util->matching = -1;
|
|
in_header = 1;
|
|
continue;
|
|
}
|
|
|
|
if (starts_with(line.buf, "diff --git")) {
|
|
in_header = 0;
|
|
strbuf_addch(&buf, '\n');
|
|
if (!util->diff_offset)
|
|
util->diff_offset = buf.len;
|
|
strbuf_addbuf(&buf, &line);
|
|
} else if (in_header) {
|
|
if (starts_with(line.buf, "Author: ")) {
|
|
strbuf_addbuf(&buf, &line);
|
|
strbuf_addstr(&buf, "\n\n");
|
|
} else if (starts_with(line.buf, " ")) {
|
|
strbuf_addbuf(&buf, &line);
|
|
strbuf_addch(&buf, '\n');
|
|
}
|
|
continue;
|
|
} else if (starts_with(line.buf, "@@ "))
|
|
strbuf_addstr(&buf, "@@");
|
|
else if (!line.buf[0] || starts_with(line.buf, "index "))
|
|
/*
|
|
* A completely blank (not ' \n', which is context)
|
|
* line is not valid in a diff. We skip it
|
|
* silently, because this neatly handles the blank
|
|
* separator line between commits in git-log
|
|
* output.
|
|
*
|
|
* We also want to ignore the diff's `index` lines
|
|
* because they contain exact blob hashes in which
|
|
* we are not interested.
|
|
*/
|
|
continue;
|
|
else
|
|
strbuf_addbuf(&buf, &line);
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
util->diffsize++;
|
|
}
|
|
fclose(in);
|
|
strbuf_release(&line);
|
|
|
|
if (util)
|
|
string_list_append(list, buf.buf)->util = util;
|
|
strbuf_release(&buf);
|
|
|
|
if (finish_command(&cp))
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int patch_util_cmp(const void *dummy, const struct patch_util *a,
|
|
const struct patch_util *b, const char *keydata)
|
|
{
|
|
return strcmp(a->diff, keydata ? keydata : b->diff);
|
|
}
|
|
|
|
static void find_exact_matches(struct string_list *a, struct string_list *b)
|
|
{
|
|
struct hashmap map;
|
|
int i;
|
|
|
|
hashmap_init(&map, (hashmap_cmp_fn)patch_util_cmp, NULL, 0);
|
|
|
|
/* First, add the patches of a to a hash map */
|
|
for (i = 0; i < a->nr; i++) {
|
|
struct patch_util *util = a->items[i].util;
|
|
|
|
util->i = i;
|
|
util->patch = a->items[i].string;
|
|
util->diff = util->patch + util->diff_offset;
|
|
hashmap_entry_init(util, strhash(util->diff));
|
|
hashmap_add(&map, util);
|
|
}
|
|
|
|
/* Now try to find exact matches in b */
|
|
for (i = 0; i < b->nr; i++) {
|
|
struct patch_util *util = b->items[i].util, *other;
|
|
|
|
util->i = i;
|
|
util->patch = b->items[i].string;
|
|
util->diff = util->patch + util->diff_offset;
|
|
hashmap_entry_init(util, strhash(util->diff));
|
|
other = hashmap_remove(&map, util, NULL);
|
|
if (other) {
|
|
if (other->matching >= 0)
|
|
BUG("already assigned!");
|
|
|
|
other->matching = i;
|
|
util->matching = other->i;
|
|
}
|
|
}
|
|
|
|
hashmap_free(&map, 0);
|
|
}
|
|
|
|
static void diffsize_consume(void *data, char *line, unsigned long len)
|
|
{
|
|
(*(int *)data)++;
|
|
}
|
|
|
|
static int diffsize(const char *a, const char *b)
|
|
{
|
|
xpparam_t pp = { 0 };
|
|
xdemitconf_t cfg = { 0 };
|
|
mmfile_t mf1, mf2;
|
|
int count = 0;
|
|
|
|
mf1.ptr = (char *)a;
|
|
mf1.size = strlen(a);
|
|
mf2.ptr = (char *)b;
|
|
mf2.size = strlen(b);
|
|
|
|
cfg.ctxlen = 3;
|
|
if (!xdi_diff_outf(&mf1, &mf2, diffsize_consume, &count, &pp, &cfg))
|
|
return count;
|
|
|
|
error(_("failed to generate diff"));
|
|
return COST_MAX;
|
|
}
|
|
|
|
static void get_correspondences(struct string_list *a, struct string_list *b,
|
|
int creation_factor)
|
|
{
|
|
int n = a->nr + b->nr;
|
|
int *cost, c, *a2b, *b2a;
|
|
int i, j;
|
|
|
|
ALLOC_ARRAY(cost, st_mult(n, n));
|
|
ALLOC_ARRAY(a2b, n);
|
|
ALLOC_ARRAY(b2a, n);
|
|
|
|
for (i = 0; i < a->nr; i++) {
|
|
struct patch_util *a_util = a->items[i].util;
|
|
|
|
for (j = 0; j < b->nr; j++) {
|
|
struct patch_util *b_util = b->items[j].util;
|
|
|
|
if (a_util->matching == j)
|
|
c = 0;
|
|
else if (a_util->matching < 0 && b_util->matching < 0)
|
|
c = diffsize(a_util->diff, b_util->diff);
|
|
else
|
|
c = COST_MAX;
|
|
cost[i + n * j] = c;
|
|
}
|
|
|
|
c = a_util->matching < 0 ?
|
|
a_util->diffsize * creation_factor / 100 : COST_MAX;
|
|
for (j = b->nr; j < n; j++)
|
|
cost[i + n * j] = c;
|
|
}
|
|
|
|
for (j = 0; j < b->nr; j++) {
|
|
struct patch_util *util = b->items[j].util;
|
|
|
|
c = util->matching < 0 ?
|
|
util->diffsize * creation_factor / 100 : COST_MAX;
|
|
for (i = a->nr; i < n; i++)
|
|
cost[i + n * j] = c;
|
|
}
|
|
|
|
for (i = a->nr; i < n; i++)
|
|
for (j = b->nr; j < n; j++)
|
|
cost[i + n * j] = 0;
|
|
|
|
compute_assignment(n, n, cost, a2b, b2a);
|
|
|
|
for (i = 0; i < a->nr; i++)
|
|
if (a2b[i] >= 0 && a2b[i] < b->nr) {
|
|
struct patch_util *a_util = a->items[i].util;
|
|
struct patch_util *b_util = b->items[a2b[i]].util;
|
|
|
|
a_util->matching = a2b[i];
|
|
b_util->matching = i;
|
|
}
|
|
|
|
free(cost);
|
|
free(a2b);
|
|
free(b2a);
|
|
}
|
|
|
|
static const char *short_oid(struct patch_util *util)
|
|
{
|
|
return find_unique_abbrev(&util->oid, DEFAULT_ABBREV);
|
|
}
|
|
|
|
static struct diff_filespec *get_filespec(const char *name, const char *p)
|
|
{
|
|
struct diff_filespec *spec = alloc_filespec(name);
|
|
|
|
fill_filespec(spec, &null_oid, 0, 0644);
|
|
spec->data = (char *)p;
|
|
spec->size = strlen(p);
|
|
spec->should_munmap = 0;
|
|
spec->is_stdin = 1;
|
|
|
|
return spec;
|
|
}
|
|
|
|
static void patch_diff(const char *a, const char *b,
|
|
struct diff_options *diffopt)
|
|
{
|
|
diff_queue(&diff_queued_diff,
|
|
get_filespec("a", a), get_filespec("b", b));
|
|
|
|
diffcore_std(diffopt);
|
|
diff_flush(diffopt);
|
|
}
|
|
|
|
static void output(struct string_list *a, struct string_list *b,
|
|
struct diff_options *diffopt)
|
|
{
|
|
int i = 0, j = 0;
|
|
|
|
/*
|
|
* We assume the user is really more interested in the second argument
|
|
* ("newer" version). To that end, we print the output in the order of
|
|
* the RHS (the `b` parameter). To put the LHS (the `a` parameter)
|
|
* commits that are no longer in the RHS into a good place, we place
|
|
* them once we have shown all of their predecessors in the LHS.
|
|
*/
|
|
|
|
while (i < a->nr || j < b->nr) {
|
|
struct patch_util *a_util, *b_util;
|
|
a_util = i < a->nr ? a->items[i].util : NULL;
|
|
b_util = j < b->nr ? b->items[j].util : NULL;
|
|
|
|
/* Skip all the already-shown commits from the LHS. */
|
|
while (i < a->nr && a_util->shown)
|
|
a_util = ++i < a->nr ? a->items[i].util : NULL;
|
|
|
|
/* Show unmatched LHS commit whose predecessors were shown. */
|
|
if (i < a->nr && a_util->matching < 0) {
|
|
printf("%d: %s < -: --------\n",
|
|
i + 1, short_oid(a_util));
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
/* Show unmatched RHS commits. */
|
|
while (j < b->nr && b_util->matching < 0) {
|
|
printf("-: -------- > %d: %s\n",
|
|
j + 1, short_oid(b_util));
|
|
b_util = ++j < b->nr ? b->items[j].util : NULL;
|
|
}
|
|
|
|
/* Show matching LHS/RHS pair. */
|
|
if (j < b->nr) {
|
|
a_util = a->items[b_util->matching].util;
|
|
printf("%d: %s ! %d: %s\n",
|
|
b_util->matching + 1, short_oid(a_util),
|
|
j + 1, short_oid(b_util));
|
|
if (!(diffopt->output_format & DIFF_FORMAT_NO_OUTPUT))
|
|
patch_diff(a->items[b_util->matching].string,
|
|
b->items[j].string, diffopt);
|
|
a_util->shown = 1;
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
|
|
int show_range_diff(const char *range1, const char *range2,
|
|
int creation_factor, struct diff_options *diffopt)
|
|
{
|
|
int res = 0;
|
|
|
|
struct string_list branch1 = STRING_LIST_INIT_DUP;
|
|
struct string_list branch2 = STRING_LIST_INIT_DUP;
|
|
|
|
if (read_patches(range1, &branch1))
|
|
res = error(_("could not parse log for '%s'"), range1);
|
|
if (!res && read_patches(range2, &branch2))
|
|
res = error(_("could not parse log for '%s'"), range2);
|
|
|
|
if (!res) {
|
|
find_exact_matches(&branch1, &branch2);
|
|
get_correspondences(&branch1, &branch2, creation_factor);
|
|
output(&branch1, &branch2, diffopt);
|
|
}
|
|
|
|
string_list_clear(&branch1, 1);
|
|
string_list_clear(&branch2, 1);
|
|
|
|
return res;
|
|
}
|