2018-08-13 11:33:02 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "builtin.h"
|
|
|
|
#include "parse-options.h"
|
2018-08-13 11:33:04 +00:00
|
|
|
#include "range-diff.h"
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
#include "config.h"
|
2018-08-13 11:33:02 +00:00
|
|
|
|
|
|
|
static const char * const builtin_range_diff_usage[] = {
|
|
|
|
N_("git range-diff [<options>] <old-base>..<old-tip> <new-base>..<new-tip>"),
|
|
|
|
N_("git range-diff [<options>] <old-tip>...<new-tip>"),
|
|
|
|
N_("git range-diff [<options>] <base> <old-tip> <new-tip>"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2018-08-13 11:33:10 +00:00
|
|
|
static struct strbuf *output_prefix_cb(struct diff_options *opt, void *data)
|
|
|
|
{
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2018-08-13 11:33:02 +00:00
|
|
|
int cmd_range_diff(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int creation_factor = 60;
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
struct diff_options diffopt = { NULL };
|
2018-08-13 11:33:30 +00:00
|
|
|
int simple_color = -1;
|
2018-08-13 11:33:02 +00:00
|
|
|
struct option options[] = {
|
|
|
|
OPT_INTEGER(0, "creation-factor", &creation_factor,
|
|
|
|
N_("Percentage by which creation is weighted")),
|
2018-08-13 11:33:30 +00:00
|
|
|
OPT_BOOL(0, "no-dual-color", &simple_color,
|
2018-08-23 21:57:48 +00:00
|
|
|
N_("use simple diff colors")),
|
2018-08-13 11:33:02 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
int i, j, res = 0;
|
2018-08-13 11:33:10 +00:00
|
|
|
struct strbuf four_spaces = STRBUF_INIT;
|
2018-08-13 11:33:04 +00:00
|
|
|
struct strbuf range1 = STRBUF_INIT, range2 = STRBUF_INIT;
|
2018-08-13 11:33:02 +00:00
|
|
|
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
git_config(git_diff_ui_config, NULL);
|
|
|
|
|
2018-09-21 15:57:24 +00:00
|
|
|
repo_diff_setup(the_repository, &diffopt);
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
diffopt.output_format = DIFF_FORMAT_PATCH;
|
2018-08-13 11:33:11 +00:00
|
|
|
diffopt.flags.suppress_diff_headers = 1;
|
2018-08-13 11:33:10 +00:00
|
|
|
diffopt.output_prefix = output_prefix_cb;
|
|
|
|
strbuf_addstr(&four_spaces, " ");
|
|
|
|
diffopt.output_prefix_data = &four_spaces;
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
|
2018-08-13 11:33:02 +00:00
|
|
|
argc = parse_options(argc, argv, NULL, options,
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
builtin_range_diff_usage, PARSE_OPT_KEEP_UNKNOWN |
|
|
|
|
PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0);
|
|
|
|
|
|
|
|
for (i = j = 1; i < argc && strcmp("--", argv[i]); ) {
|
|
|
|
int c = diff_opt_parse(&diffopt, argv + i, argc - i, prefix);
|
|
|
|
|
|
|
|
if (!c)
|
|
|
|
argv[j++] = argv[i++];
|
|
|
|
else
|
|
|
|
i += c;
|
|
|
|
}
|
|
|
|
while (i < argc)
|
|
|
|
argv[j++] = argv[i++];
|
|
|
|
argc = j;
|
|
|
|
diff_setup_done(&diffopt);
|
|
|
|
|
|
|
|
/* Make sure that there are no unparsed options */
|
|
|
|
argc = parse_options(argc, argv, NULL,
|
|
|
|
options + ARRAY_SIZE(options) - 1, /* OPT_END */
|
2018-08-13 11:33:02 +00:00
|
|
|
builtin_range_diff_usage, 0);
|
|
|
|
|
2018-08-13 11:33:30 +00:00
|
|
|
if (simple_color < 1) {
|
|
|
|
if (!simple_color)
|
|
|
|
/* force color when --dual-color was used */
|
|
|
|
diffopt.use_color = 1;
|
2018-08-13 11:33:22 +00:00
|
|
|
diffopt.flags.dual_color_diffed_diffs = 1;
|
|
|
|
}
|
|
|
|
|
2018-08-13 11:33:04 +00:00
|
|
|
if (argc == 2) {
|
|
|
|
if (!strstr(argv[0], ".."))
|
|
|
|
die(_("no .. in range: '%s'"), argv[0]);
|
|
|
|
strbuf_addstr(&range1, argv[0]);
|
|
|
|
|
|
|
|
if (!strstr(argv[1], ".."))
|
|
|
|
die(_("no .. in range: '%s'"), argv[1]);
|
|
|
|
strbuf_addstr(&range2, argv[1]);
|
|
|
|
} else if (argc == 3) {
|
|
|
|
strbuf_addf(&range1, "%s..%s", argv[0], argv[1]);
|
|
|
|
strbuf_addf(&range2, "%s..%s", argv[0], argv[2]);
|
|
|
|
} else if (argc == 1) {
|
|
|
|
const char *b = strstr(argv[0], "..."), *a = argv[0];
|
|
|
|
int a_len;
|
|
|
|
|
|
|
|
if (!b) {
|
|
|
|
error(_("single arg format must be symmetric range"));
|
|
|
|
usage_with_options(builtin_range_diff_usage, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
a_len = (int)(b - a);
|
|
|
|
if (!a_len) {
|
|
|
|
a = "HEAD";
|
|
|
|
a_len = strlen(a);
|
|
|
|
}
|
|
|
|
b += 3;
|
|
|
|
if (!*b)
|
|
|
|
b = "HEAD";
|
|
|
|
strbuf_addf(&range1, "%s..%.*s", b, a_len, a);
|
|
|
|
strbuf_addf(&range2, "%.*s..%s", a_len, a, b);
|
|
|
|
} else {
|
|
|
|
error(_("need two commit ranges"));
|
|
|
|
usage_with_options(builtin_range_diff_usage, options);
|
|
|
|
}
|
|
|
|
|
range-diff: also show the diff between patches
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>
2018-08-13 11:33:07 +00:00
|
|
|
res = show_range_diff(range1.buf, range2.buf, creation_factor,
|
|
|
|
&diffopt);
|
2018-08-13 11:33:04 +00:00
|
|
|
|
|
|
|
strbuf_release(&range1);
|
|
|
|
strbuf_release(&range2);
|
2018-08-13 11:33:10 +00:00
|
|
|
strbuf_release(&four_spaces);
|
2018-08-13 11:33:04 +00:00
|
|
|
|
|
|
|
return res;
|
2018-08-13 11:33:02 +00:00
|
|
|
}
|