Merge branch 'mh/diff-indent-heuristic'
Output from "git diff" can be made easier to read by selecting which lines are common and which lines are added/deleted intelligently when the lines before and after the changed section are the same. A command line option is added to help with the experiment to find a good heuristics. * mh/diff-indent-heuristic: blame: honor the diff heuristic options and config parse-options: add parse_opt_unknown_cb() diff: improve positioning of add/delete blocks in diffs xdl_change_compact(): introduce the concept of a change group recs_match(): take two xrecord_t pointers as arguments is_blank_line(): take a single xrecord_t as argument xdl_change_compact(): only use heuristic if group can't be matched xdl_change_compact(): fix compaction heuristic to adjust ixo
This commit is contained in:
commit
b7af6ae5cf
@ -171,10 +171,11 @@ diff.tool::
|
|||||||
|
|
||||||
include::mergetools-diff.txt[]
|
include::mergetools-diff.txt[]
|
||||||
|
|
||||||
|
diff.indentHeuristic::
|
||||||
diff.compactionHeuristic::
|
diff.compactionHeuristic::
|
||||||
Set this option to `true` to enable an experimental heuristic that
|
Set one of these options to `true` to enable one of two
|
||||||
shifts the hunk boundary in an attempt to make the resulting
|
experimental heuristics that shift diff hunk boundaries to
|
||||||
patch easier to read.
|
make patches easier to read.
|
||||||
|
|
||||||
diff.algorithm::
|
diff.algorithm::
|
||||||
Choose a diff algorithm. The variants are as follows:
|
Choose a diff algorithm. The variants are as follows:
|
||||||
|
7
Documentation/diff-heuristic-options.txt
Normal file
7
Documentation/diff-heuristic-options.txt
Normal file
@ -0,0 +1,7 @@
|
|||||||
|
--indent-heuristic::
|
||||||
|
--no-indent-heuristic::
|
||||||
|
--compaction-heuristic::
|
||||||
|
--no-compaction-heuristic::
|
||||||
|
These are to help debugging and tuning experimental heuristics
|
||||||
|
(which are off by default) that shift diff hunk boundaries to
|
||||||
|
make patches easier to read.
|
@ -63,12 +63,7 @@ ifndef::git-format-patch[]
|
|||||||
Synonym for `-p --raw`.
|
Synonym for `-p --raw`.
|
||||||
endif::git-format-patch[]
|
endif::git-format-patch[]
|
||||||
|
|
||||||
--compaction-heuristic::
|
include::diff-heuristic-options.txt[]
|
||||||
--no-compaction-heuristic::
|
|
||||||
These are to help debugging and tuning an experimental
|
|
||||||
heuristic (which is off by default) that shifts the hunk
|
|
||||||
boundary in an attempt to make the resulting patch easier
|
|
||||||
to read.
|
|
||||||
|
|
||||||
--minimal::
|
--minimal::
|
||||||
Spend extra time to make sure the smallest possible
|
Spend extra time to make sure the smallest possible
|
||||||
|
@ -23,6 +23,7 @@ familiar command name for people coming from other SCM systems.
|
|||||||
OPTIONS
|
OPTIONS
|
||||||
-------
|
-------
|
||||||
include::blame-options.txt[]
|
include::blame-options.txt[]
|
||||||
|
include::diff-heuristic-options.txt[]
|
||||||
|
|
||||||
SEE ALSO
|
SEE ALSO
|
||||||
--------
|
--------
|
||||||
|
@ -89,6 +89,8 @@ include::blame-options.txt[]
|
|||||||
abbreviated object name, use <n>+1 digits. Note that 1 column
|
abbreviated object name, use <n>+1 digits. Note that 1 column
|
||||||
is used for a caret to mark the boundary commit.
|
is used for a caret to mark the boundary commit.
|
||||||
|
|
||||||
|
include::diff-heuristic-options.txt[]
|
||||||
|
|
||||||
|
|
||||||
THE PORCELAIN FORMAT
|
THE PORCELAIN FORMAT
|
||||||
--------------------
|
--------------------
|
||||||
|
@ -2220,6 +2220,8 @@ static int git_blame_config(const char *var, const char *value, void *cb)
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (git_diff_heuristic_config(var, value, cb) < 0)
|
||||||
|
return -1;
|
||||||
if (userdiff_config(var, value) < 0)
|
if (userdiff_config(var, value) < 0)
|
||||||
return -1;
|
return -1;
|
||||||
|
|
||||||
@ -2550,6 +2552,15 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
|
|||||||
OPT_BIT('s', NULL, &output_option, N_("Suppress author name and timestamp (Default: off)"), OUTPUT_NO_AUTHOR),
|
OPT_BIT('s', NULL, &output_option, N_("Suppress author name and timestamp (Default: off)"), OUTPUT_NO_AUTHOR),
|
||||||
OPT_BIT('e', "show-email", &output_option, N_("Show author email instead of name (Default: off)"), OUTPUT_SHOW_EMAIL),
|
OPT_BIT('e', "show-email", &output_option, N_("Show author email instead of name (Default: off)"), OUTPUT_SHOW_EMAIL),
|
||||||
OPT_BIT('w', NULL, &xdl_opts, N_("Ignore whitespace differences"), XDF_IGNORE_WHITESPACE),
|
OPT_BIT('w', NULL, &xdl_opts, N_("Ignore whitespace differences"), XDF_IGNORE_WHITESPACE),
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The following two options are parsed by parse_revision_opt()
|
||||||
|
* and are only included here to get included in the "-h"
|
||||||
|
* output:
|
||||||
|
*/
|
||||||
|
{ OPTION_LOWLEVEL_CALLBACK, 0, "indent-heuristic", NULL, NULL, N_("Use an experimental indent-based heuristic to improve diffs"), PARSE_OPT_NOARG, parse_opt_unknown_cb },
|
||||||
|
{ OPTION_LOWLEVEL_CALLBACK, 0, "compaction-heuristic", NULL, NULL, N_("Use an experimental blank-line-based heuristic to improve diffs"), PARSE_OPT_NOARG, parse_opt_unknown_cb },
|
||||||
|
|
||||||
OPT_BIT(0, "minimal", &xdl_opts, N_("Spend extra cycles to find better match"), XDF_NEED_MINIMAL),
|
OPT_BIT(0, "minimal", &xdl_opts, N_("Spend extra cycles to find better match"), XDF_NEED_MINIMAL),
|
||||||
OPT_STRING('S', NULL, &revs_file, N_("file"), N_("Use revisions from <file> instead of calling git-rev-list")),
|
OPT_STRING('S', NULL, &revs_file, N_("file"), N_("Use revisions from <file> instead of calling git-rev-list")),
|
||||||
OPT_STRING(0, "contents", &contents_from, N_("file"), N_("Use <file>'s contents as the final image")),
|
OPT_STRING(0, "contents", &contents_from, N_("file"), N_("Use <file>'s contents as the final image")),
|
||||||
@ -2596,6 +2607,7 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
|
|||||||
}
|
}
|
||||||
parse_done:
|
parse_done:
|
||||||
no_whole_file_rename = !DIFF_OPT_TST(&revs.diffopt, FOLLOW_RENAMES);
|
no_whole_file_rename = !DIFF_OPT_TST(&revs.diffopt, FOLLOW_RENAMES);
|
||||||
|
xdl_opts |= revs.diffopt.xdl_opts & (XDF_COMPACTION_HEURISTIC | XDF_INDENT_HEURISTIC);
|
||||||
DIFF_OPT_CLR(&revs.diffopt, FOLLOW_RENAMES);
|
DIFF_OPT_CLR(&revs.diffopt, FOLLOW_RENAMES);
|
||||||
argc = parse_options_end(&ctx);
|
argc = parse_options_end(&ctx);
|
||||||
|
|
||||||
|
36
diff.c
36
diff.c
@ -27,6 +27,7 @@
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
static int diff_detect_rename_default;
|
static int diff_detect_rename_default;
|
||||||
|
static int diff_indent_heuristic; /* experimental */
|
||||||
static int diff_compaction_heuristic; /* experimental */
|
static int diff_compaction_heuristic; /* experimental */
|
||||||
static int diff_rename_limit_default = 400;
|
static int diff_rename_limit_default = 400;
|
||||||
static int diff_suppress_blank_empty;
|
static int diff_suppress_blank_empty;
|
||||||
@ -177,6 +178,21 @@ void init_diff_ui_defaults(void)
|
|||||||
diff_detect_rename_default = 1;
|
diff_detect_rename_default = 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int git_diff_heuristic_config(const char *var, const char *value, void *cb)
|
||||||
|
{
|
||||||
|
if (!strcmp(var, "diff.indentheuristic")) {
|
||||||
|
diff_indent_heuristic = git_config_bool(var, value);
|
||||||
|
if (diff_indent_heuristic)
|
||||||
|
diff_compaction_heuristic = 0;
|
||||||
|
}
|
||||||
|
if (!strcmp(var, "diff.compactionheuristic")) {
|
||||||
|
diff_compaction_heuristic = git_config_bool(var, value);
|
||||||
|
if (diff_compaction_heuristic)
|
||||||
|
diff_indent_heuristic = 0;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
int git_diff_ui_config(const char *var, const char *value, void *cb)
|
int git_diff_ui_config(const char *var, const char *value, void *cb)
|
||||||
{
|
{
|
||||||
if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
|
if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
|
||||||
@ -193,10 +209,6 @@ int git_diff_ui_config(const char *var, const char *value, void *cb)
|
|||||||
diff_detect_rename_default = git_config_rename(var, value);
|
diff_detect_rename_default = git_config_rename(var, value);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (!strcmp(var, "diff.compactionheuristic")) {
|
|
||||||
diff_compaction_heuristic = git_config_bool(var, value);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if (!strcmp(var, "diff.autorefreshindex")) {
|
if (!strcmp(var, "diff.autorefreshindex")) {
|
||||||
diff_auto_refresh_index = git_config_bool(var, value);
|
diff_auto_refresh_index = git_config_bool(var, value);
|
||||||
return 0;
|
return 0;
|
||||||
@ -237,6 +249,8 @@ int git_diff_ui_config(const char *var, const char *value, void *cb)
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (git_diff_heuristic_config(var, value, cb) < 0)
|
||||||
|
return -1;
|
||||||
if (git_color_config(var, value, cb) < 0)
|
if (git_color_config(var, value, cb) < 0)
|
||||||
return -1;
|
return -1;
|
||||||
|
|
||||||
@ -3296,7 +3310,9 @@ void diff_setup(struct diff_options *options)
|
|||||||
options->use_color = diff_use_color_default;
|
options->use_color = diff_use_color_default;
|
||||||
options->detect_rename = diff_detect_rename_default;
|
options->detect_rename = diff_detect_rename_default;
|
||||||
options->xdl_opts |= diff_algorithm;
|
options->xdl_opts |= diff_algorithm;
|
||||||
if (diff_compaction_heuristic)
|
if (diff_indent_heuristic)
|
||||||
|
DIFF_XDL_SET(options, INDENT_HEURISTIC);
|
||||||
|
else if (diff_compaction_heuristic)
|
||||||
DIFF_XDL_SET(options, COMPACTION_HEURISTIC);
|
DIFF_XDL_SET(options, COMPACTION_HEURISTIC);
|
||||||
|
|
||||||
options->orderfile = diff_order_file_cfg;
|
options->orderfile = diff_order_file_cfg;
|
||||||
@ -3818,9 +3834,15 @@ int diff_opt_parse(struct diff_options *options,
|
|||||||
DIFF_XDL_SET(options, IGNORE_WHITESPACE_AT_EOL);
|
DIFF_XDL_SET(options, IGNORE_WHITESPACE_AT_EOL);
|
||||||
else if (!strcmp(arg, "--ignore-blank-lines"))
|
else if (!strcmp(arg, "--ignore-blank-lines"))
|
||||||
DIFF_XDL_SET(options, IGNORE_BLANK_LINES);
|
DIFF_XDL_SET(options, IGNORE_BLANK_LINES);
|
||||||
else if (!strcmp(arg, "--compaction-heuristic"))
|
else if (!strcmp(arg, "--indent-heuristic")) {
|
||||||
|
DIFF_XDL_SET(options, INDENT_HEURISTIC);
|
||||||
|
DIFF_XDL_CLR(options, COMPACTION_HEURISTIC);
|
||||||
|
} else if (!strcmp(arg, "--no-indent-heuristic"))
|
||||||
|
DIFF_XDL_CLR(options, INDENT_HEURISTIC);
|
||||||
|
else if (!strcmp(arg, "--compaction-heuristic")) {
|
||||||
DIFF_XDL_SET(options, COMPACTION_HEURISTIC);
|
DIFF_XDL_SET(options, COMPACTION_HEURISTIC);
|
||||||
else if (!strcmp(arg, "--no-compaction-heuristic"))
|
DIFF_XDL_CLR(options, INDENT_HEURISTIC);
|
||||||
|
} else if (!strcmp(arg, "--no-compaction-heuristic"))
|
||||||
DIFF_XDL_CLR(options, COMPACTION_HEURISTIC);
|
DIFF_XDL_CLR(options, COMPACTION_HEURISTIC);
|
||||||
else if (!strcmp(arg, "--patience"))
|
else if (!strcmp(arg, "--patience"))
|
||||||
options->xdl_opts = DIFF_WITH_ALG(options, PATIENCE_DIFF);
|
options->xdl_opts = DIFF_WITH_ALG(options, PATIENCE_DIFF);
|
||||||
|
1
diff.h
1
diff.h
@ -273,6 +273,7 @@ extern int parse_long_opt(const char *opt, const char **argv,
|
|||||||
const char **optarg);
|
const char **optarg);
|
||||||
|
|
||||||
extern int git_diff_basic_config(const char *var, const char *value, void *cb);
|
extern int git_diff_basic_config(const char *var, const char *value, void *cb);
|
||||||
|
extern int git_diff_heuristic_config(const char *var, const char *value, void *cb);
|
||||||
extern void init_diff_ui_defaults(void);
|
extern void init_diff_ui_defaults(void);
|
||||||
extern int git_diff_ui_config(const char *var, const char *value, void *cb);
|
extern int git_diff_ui_config(const char *var, const char *value, void *cb);
|
||||||
extern void diff_setup(struct diff_options *);
|
extern void diff_setup(struct diff_options *);
|
||||||
|
@ -45,6 +45,7 @@ my ($diff_new_color) =
|
|||||||
my $normal_color = $repo->get_color("", "reset");
|
my $normal_color = $repo->get_color("", "reset");
|
||||||
|
|
||||||
my $diff_algorithm = $repo->config('diff.algorithm');
|
my $diff_algorithm = $repo->config('diff.algorithm');
|
||||||
|
my $diff_indent_heuristic = $repo->config_bool('diff.indentheuristic');
|
||||||
my $diff_compaction_heuristic = $repo->config_bool('diff.compactionheuristic');
|
my $diff_compaction_heuristic = $repo->config_bool('diff.compactionheuristic');
|
||||||
my $diff_filter = $repo->config('interactive.difffilter');
|
my $diff_filter = $repo->config('interactive.difffilter');
|
||||||
|
|
||||||
@ -750,7 +751,9 @@ sub parse_diff {
|
|||||||
if (defined $diff_algorithm) {
|
if (defined $diff_algorithm) {
|
||||||
splice @diff_cmd, 1, 0, "--diff-algorithm=${diff_algorithm}";
|
splice @diff_cmd, 1, 0, "--diff-algorithm=${diff_algorithm}";
|
||||||
}
|
}
|
||||||
if ($diff_compaction_heuristic) {
|
if ($diff_indent_heuristic) {
|
||||||
|
splice @diff_cmd, 1, 0, "--indent-heuristic";
|
||||||
|
} elsif ($diff_compaction_heuristic) {
|
||||||
splice @diff_cmd, 1, 0, "--compaction-heuristic";
|
splice @diff_cmd, 1, 0, "--compaction-heuristic";
|
||||||
}
|
}
|
||||||
if (defined $patch_mode_revision) {
|
if (defined $patch_mode_revision) {
|
||||||
|
@ -158,6 +158,18 @@ int parse_opt_noop_cb(const struct option *opt, const char *arg, int unset)
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Report that the option is unknown, so that other code can handle
|
||||||
|
* it. This can be used as a callback together with
|
||||||
|
* OPTION_LOWLEVEL_CALLBACK to allow an option to be documented in the
|
||||||
|
* "-h" output even if it's not being handled directly by
|
||||||
|
* parse_options().
|
||||||
|
*/
|
||||||
|
int parse_opt_unknown_cb(const struct option *opt, const char *arg, int unset)
|
||||||
|
{
|
||||||
|
return -2;
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Recreates the command-line option in the strbuf.
|
* Recreates the command-line option in the strbuf.
|
||||||
*/
|
*/
|
||||||
|
@ -228,6 +228,7 @@ extern int parse_opt_commits(const struct option *, const char *, int);
|
|||||||
extern int parse_opt_tertiary(const struct option *, const char *, int);
|
extern int parse_opt_tertiary(const struct option *, const char *, int);
|
||||||
extern int parse_opt_string_list(const struct option *, const char *, int);
|
extern int parse_opt_string_list(const struct option *, const char *, int);
|
||||||
extern int parse_opt_noop_cb(const struct option *, const char *, int);
|
extern int parse_opt_noop_cb(const struct option *, const char *, int);
|
||||||
|
extern int parse_opt_unknown_cb(const struct option *, const char *, int);
|
||||||
extern int parse_opt_passthru(const struct option *, const char *, int);
|
extern int parse_opt_passthru(const struct option *, const char *, int);
|
||||||
extern int parse_opt_passthru_argv(const struct option *, const char *, int);
|
extern int parse_opt_passthru_argv(const struct option *, const char *, int);
|
||||||
|
|
||||||
|
216
t/t4061-diff-indent.sh
Executable file
216
t/t4061-diff-indent.sh
Executable file
@ -0,0 +1,216 @@
|
|||||||
|
#!/bin/sh
|
||||||
|
|
||||||
|
test_description='Test diff indent heuristic.
|
||||||
|
|
||||||
|
'
|
||||||
|
. ./test-lib.sh
|
||||||
|
. "$TEST_DIRECTORY"/diff-lib.sh
|
||||||
|
|
||||||
|
# Compare two diff outputs. Ignore "index" lines, because we don't
|
||||||
|
# care about SHA-1s or file modes.
|
||||||
|
compare_diff () {
|
||||||
|
sed -e "/^index /d" <"$1" >.tmp-1
|
||||||
|
sed -e "/^index /d" <"$2" >.tmp-2
|
||||||
|
test_cmp .tmp-1 .tmp-2 && rm -f .tmp-1 .tmp-2
|
||||||
|
}
|
||||||
|
|
||||||
|
# Compare blame output using the expectation for a diff as reference.
|
||||||
|
# Only look for the lines coming from non-boundary commits.
|
||||||
|
compare_blame () {
|
||||||
|
sed -n -e "1,4d" -e "s/^\+//p" <"$1" >.tmp-1
|
||||||
|
sed -ne "s/^[^^][^)]*) *//p" <"$2" >.tmp-2
|
||||||
|
test_cmp .tmp-1 .tmp-2 && rm -f .tmp-1 .tmp-2
|
||||||
|
}
|
||||||
|
|
||||||
|
test_expect_success 'prepare' '
|
||||||
|
cat <<-\EOF >spaces.txt &&
|
||||||
|
1
|
||||||
|
2
|
||||||
|
a
|
||||||
|
|
||||||
|
b
|
||||||
|
3
|
||||||
|
4
|
||||||
|
EOF
|
||||||
|
|
||||||
|
cat <<-\EOF >functions.c &&
|
||||||
|
1
|
||||||
|
2
|
||||||
|
/* function */
|
||||||
|
foo() {
|
||||||
|
foo
|
||||||
|
}
|
||||||
|
|
||||||
|
3
|
||||||
|
4
|
||||||
|
EOF
|
||||||
|
|
||||||
|
git add spaces.txt functions.c &&
|
||||||
|
test_tick &&
|
||||||
|
git commit -m initial &&
|
||||||
|
git branch old &&
|
||||||
|
|
||||||
|
cat <<-\EOF >spaces.txt &&
|
||||||
|
1
|
||||||
|
2
|
||||||
|
a
|
||||||
|
|
||||||
|
b
|
||||||
|
a
|
||||||
|
|
||||||
|
b
|
||||||
|
3
|
||||||
|
4
|
||||||
|
EOF
|
||||||
|
|
||||||
|
cat <<-\EOF >functions.c &&
|
||||||
|
1
|
||||||
|
2
|
||||||
|
/* function */
|
||||||
|
bar() {
|
||||||
|
foo
|
||||||
|
}
|
||||||
|
|
||||||
|
/* function */
|
||||||
|
foo() {
|
||||||
|
foo
|
||||||
|
}
|
||||||
|
|
||||||
|
3
|
||||||
|
4
|
||||||
|
EOF
|
||||||
|
|
||||||
|
git add spaces.txt functions.c &&
|
||||||
|
test_tick &&
|
||||||
|
git commit -m initial &&
|
||||||
|
git branch new &&
|
||||||
|
|
||||||
|
tr "_" " " <<-\EOF >spaces-expect &&
|
||||||
|
diff --git a/spaces.txt b/spaces.txt
|
||||||
|
--- a/spaces.txt
|
||||||
|
+++ b/spaces.txt
|
||||||
|
@@ -3,5 +3,8 @@
|
||||||
|
a
|
||||||
|
_
|
||||||
|
b
|
||||||
|
+a
|
||||||
|
+
|
||||||
|
+b
|
||||||
|
3
|
||||||
|
4
|
||||||
|
EOF
|
||||||
|
|
||||||
|
tr "_" " " <<-\EOF >spaces-compacted-expect &&
|
||||||
|
diff --git a/spaces.txt b/spaces.txt
|
||||||
|
--- a/spaces.txt
|
||||||
|
+++ b/spaces.txt
|
||||||
|
@@ -2,6 +2,9 @@
|
||||||
|
2
|
||||||
|
a
|
||||||
|
_
|
||||||
|
+b
|
||||||
|
+a
|
||||||
|
+
|
||||||
|
b
|
||||||
|
3
|
||||||
|
4
|
||||||
|
EOF
|
||||||
|
|
||||||
|
tr "_" " " <<-\EOF >functions-expect &&
|
||||||
|
diff --git a/functions.c b/functions.c
|
||||||
|
--- a/functions.c
|
||||||
|
+++ b/functions.c
|
||||||
|
@@ -1,6 +1,11 @@
|
||||||
|
1
|
||||||
|
2
|
||||||
|
/* function */
|
||||||
|
+bar() {
|
||||||
|
+ foo
|
||||||
|
+}
|
||||||
|
+
|
||||||
|
+/* function */
|
||||||
|
foo() {
|
||||||
|
foo
|
||||||
|
}
|
||||||
|
EOF
|
||||||
|
|
||||||
|
tr "_" " " <<-\EOF >functions-compacted-expect
|
||||||
|
diff --git a/functions.c b/functions.c
|
||||||
|
--- a/functions.c
|
||||||
|
+++ b/functions.c
|
||||||
|
@@ -1,5 +1,10 @@
|
||||||
|
1
|
||||||
|
2
|
||||||
|
+/* function */
|
||||||
|
+bar() {
|
||||||
|
+ foo
|
||||||
|
+}
|
||||||
|
+
|
||||||
|
/* function */
|
||||||
|
foo() {
|
||||||
|
foo
|
||||||
|
EOF
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: ugly spaces' '
|
||||||
|
git diff old new -- spaces.txt >out &&
|
||||||
|
compare_diff spaces-expect out
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: nice spaces with --indent-heuristic' '
|
||||||
|
git diff --indent-heuristic old new -- spaces.txt >out-compacted &&
|
||||||
|
compare_diff spaces-compacted-expect out-compacted
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: nice spaces with diff.indentHeuristic' '
|
||||||
|
git -c diff.indentHeuristic=true diff old new -- spaces.txt >out-compacted2 &&
|
||||||
|
compare_diff spaces-compacted-expect out-compacted2
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: --no-indent-heuristic overrides config' '
|
||||||
|
git -c diff.indentHeuristic=true diff --no-indent-heuristic old new -- spaces.txt >out2 &&
|
||||||
|
compare_diff spaces-expect out2
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: --indent-heuristic with --patience' '
|
||||||
|
git diff --indent-heuristic --patience old new -- spaces.txt >out-compacted3 &&
|
||||||
|
compare_diff spaces-compacted-expect out-compacted3
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: --indent-heuristic with --histogram' '
|
||||||
|
git diff --indent-heuristic --histogram old new -- spaces.txt >out-compacted4 &&
|
||||||
|
compare_diff spaces-compacted-expect out-compacted4
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: ugly functions' '
|
||||||
|
git diff old new -- functions.c >out &&
|
||||||
|
compare_diff functions-expect out
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'diff: nice functions with --indent-heuristic' '
|
||||||
|
git diff --indent-heuristic old new -- functions.c >out-compacted &&
|
||||||
|
compare_diff functions-compacted-expect out-compacted
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'blame: ugly spaces' '
|
||||||
|
git blame old..new -- spaces.txt >out-blame &&
|
||||||
|
compare_blame spaces-expect out-blame
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'blame: nice spaces with --indent-heuristic' '
|
||||||
|
git blame --indent-heuristic old..new -- spaces.txt >out-blame-compacted &&
|
||||||
|
compare_blame spaces-compacted-expect out-blame-compacted
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'blame: nice spaces with diff.indentHeuristic' '
|
||||||
|
git -c diff.indentHeuristic=true blame old..new -- spaces.txt >out-blame-compacted2 &&
|
||||||
|
compare_blame spaces-compacted-expect out-blame-compacted2
|
||||||
|
'
|
||||||
|
|
||||||
|
test_expect_success 'blame: --no-indent-heuristic overrides config' '
|
||||||
|
git -c diff.indentHeuristic=true blame --no-indent-heuristic old..new -- spaces.txt >out-blame2 &&
|
||||||
|
git blame old..new -- spaces.txt >out-blame &&
|
||||||
|
compare_blame spaces-expect out-blame2
|
||||||
|
'
|
||||||
|
|
||||||
|
test_done
|
@ -42,6 +42,7 @@ extern "C" {
|
|||||||
#define XDF_IGNORE_BLANK_LINES (1 << 7)
|
#define XDF_IGNORE_BLANK_LINES (1 << 7)
|
||||||
|
|
||||||
#define XDF_COMPACTION_HEURISTIC (1 << 8)
|
#define XDF_COMPACTION_HEURISTIC (1 << 8)
|
||||||
|
#define XDF_INDENT_HEURISTIC (1 << 9)
|
||||||
|
|
||||||
#define XDL_EMIT_FUNCNAMES (1 << 0)
|
#define XDL_EMIT_FUNCNAMES (1 << 0)
|
||||||
#define XDL_EMIT_FUNCCONTEXT (1 << 2)
|
#define XDL_EMIT_FUNCCONTEXT (1 << 2)
|
||||||
|
675
xdiff/xdiffi.c
675
xdiff/xdiffi.c
@ -400,138 +400,577 @@ static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1,
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static int is_blank_line(xrecord_t **recs, long ix, long flags)
|
static int is_blank_line(xrecord_t *rec, long flags)
|
||||||
{
|
{
|
||||||
return xdl_blankline(recs[ix]->ptr, recs[ix]->size, flags);
|
return xdl_blankline(rec->ptr, rec->size, flags);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int recs_match(xrecord_t **recs, long ixs, long ix, long flags)
|
static int recs_match(xrecord_t *rec1, xrecord_t *rec2, long flags)
|
||||||
{
|
{
|
||||||
return (recs[ixs]->ha == recs[ix]->ha &&
|
return (rec1->ha == rec2->ha &&
|
||||||
xdl_recmatch(recs[ixs]->ptr, recs[ixs]->size,
|
xdl_recmatch(rec1->ptr, rec1->size,
|
||||||
recs[ix]->ptr, recs[ix]->size,
|
rec2->ptr, rec2->size,
|
||||||
flags));
|
flags));
|
||||||
}
|
}
|
||||||
|
|
||||||
int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
|
/*
|
||||||
long ix, ixo, ixs, ixref, grpsiz, nrec = xdf->nrec;
|
* If a line is indented more than this, get_indent() just returns this value.
|
||||||
char *rchg = xdf->rchg, *rchgo = xdfo->rchg;
|
* This avoids having to do absurd amounts of work for data that are not
|
||||||
unsigned int blank_lines;
|
* human-readable text, and also ensures that the output of get_indent fits within
|
||||||
xrecord_t **recs = xdf->recs;
|
* an int.
|
||||||
|
*/
|
||||||
|
#define MAX_INDENT 200
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Return the amount of indentation of the specified line, treating TAB as 8
|
||||||
|
* columns. Return -1 if line is empty or contains only whitespace. Clamp the
|
||||||
|
* output value at MAX_INDENT.
|
||||||
|
*/
|
||||||
|
static int get_indent(xrecord_t *rec)
|
||||||
|
{
|
||||||
|
long i;
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
for (i = 0; i < rec->size; i++) {
|
||||||
|
char c = rec->ptr[i];
|
||||||
|
|
||||||
|
if (!XDL_ISSPACE(c))
|
||||||
|
return ret;
|
||||||
|
else if (c == ' ')
|
||||||
|
ret += 1;
|
||||||
|
else if (c == '\t')
|
||||||
|
ret += 8 - ret % 8;
|
||||||
|
/* ignore other whitespace characters */
|
||||||
|
|
||||||
|
if (ret >= MAX_INDENT)
|
||||||
|
return MAX_INDENT;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The line contains only whitespace. */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If more than this number of consecutive blank rows are found, just return this
|
||||||
|
* value. This avoids requiring O(N^2) work for pathological cases, and also
|
||||||
|
* ensures that the output of score_split fits in an int.
|
||||||
|
*/
|
||||||
|
#define MAX_BLANKS 20
|
||||||
|
|
||||||
|
/* Characteristics measured about a hypothetical split position. */
|
||||||
|
struct split_measurement {
|
||||||
|
/*
|
||||||
|
* Is the split at the end of the file (aside from any blank lines)?
|
||||||
|
*/
|
||||||
|
int end_of_file;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* This is the same of what GNU diff does. Move back and forward
|
* How much is the line immediately following the split indented (or -1 if
|
||||||
* change groups for a consistent and pretty diff output. This also
|
* the line is blank):
|
||||||
* helps in finding joinable change groups and reduce the diff size.
|
|
||||||
*/
|
*/
|
||||||
for (ix = ixo = 0;;) {
|
int indent;
|
||||||
/*
|
|
||||||
* Find the first changed line in the to-be-compacted file.
|
/*
|
||||||
* We need to keep track of both indexes, so if we find a
|
* How many consecutive lines above the split are blank?
|
||||||
* changed lines group on the other file, while scanning the
|
*/
|
||||||
* to-be-compacted file, we need to skip it properly. Note
|
int pre_blank;
|
||||||
* that loops that are testing for changed lines on rchg* do
|
|
||||||
* not need index bounding since the array is prepared with
|
/*
|
||||||
* a zero at position -1 and N.
|
* How much is the nearest non-blank line above the split indented (or -1
|
||||||
*/
|
* if there is no such line)?
|
||||||
for (; ix < nrec && !rchg[ix]; ix++)
|
*/
|
||||||
while (rchgo[ixo++]);
|
int pre_indent;
|
||||||
if (ix == nrec)
|
|
||||||
|
/*
|
||||||
|
* How many lines after the line following the split are blank?
|
||||||
|
*/
|
||||||
|
int post_blank;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* How much is the nearest non-blank line after the line following the
|
||||||
|
* split indented (or -1 if there is no such line)?
|
||||||
|
*/
|
||||||
|
int post_indent;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct split_score {
|
||||||
|
/* The effective indent of this split (smaller is preferred). */
|
||||||
|
int effective_indent;
|
||||||
|
|
||||||
|
/* Penalty for this split (smaller is preferred). */
|
||||||
|
int penalty;
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Fill m with information about a hypothetical split of xdf above line split.
|
||||||
|
*/
|
||||||
|
static void measure_split(const xdfile_t *xdf, long split,
|
||||||
|
struct split_measurement *m)
|
||||||
|
{
|
||||||
|
long i;
|
||||||
|
|
||||||
|
if (split >= xdf->nrec) {
|
||||||
|
m->end_of_file = 1;
|
||||||
|
m->indent = -1;
|
||||||
|
} else {
|
||||||
|
m->end_of_file = 0;
|
||||||
|
m->indent = get_indent(xdf->recs[split]);
|
||||||
|
}
|
||||||
|
|
||||||
|
m->pre_blank = 0;
|
||||||
|
m->pre_indent = -1;
|
||||||
|
for (i = split - 1; i >= 0; i--) {
|
||||||
|
m->pre_indent = get_indent(xdf->recs[i]);
|
||||||
|
if (m->pre_indent != -1)
|
||||||
|
break;
|
||||||
|
m->pre_blank += 1;
|
||||||
|
if (m->pre_blank == MAX_BLANKS) {
|
||||||
|
m->pre_indent = 0;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
/*
|
|
||||||
* Record the start of a changed-group in the to-be-compacted file
|
|
||||||
* and find the end of it, on both to-be-compacted and other file
|
|
||||||
* indexes (ix and ixo).
|
|
||||||
*/
|
|
||||||
ixs = ix;
|
|
||||||
for (ix++; rchg[ix]; ix++);
|
|
||||||
for (; rchgo[ixo]; ixo++);
|
|
||||||
|
|
||||||
do {
|
|
||||||
grpsiz = ix - ixs;
|
|
||||||
blank_lines = 0;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If the line before the current change group, is equal to
|
|
||||||
* the last line of the current change group, shift backward
|
|
||||||
* the group.
|
|
||||||
*/
|
|
||||||
while (ixs > 0 && recs_match(recs, ixs - 1, ix - 1, flags)) {
|
|
||||||
rchg[--ixs] = 1;
|
|
||||||
rchg[--ix] = 0;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This change might have joined two change groups,
|
|
||||||
* so we try to take this scenario in account by moving
|
|
||||||
* the start index accordingly (and so the other-file
|
|
||||||
* end-of-group index).
|
|
||||||
*/
|
|
||||||
for (; rchg[ixs - 1]; ixs--);
|
|
||||||
while (rchgo[--ixo]);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Record the end-of-group position in case we are matched
|
|
||||||
* with a group of changes in the other file (that is, the
|
|
||||||
* change record before the end-of-group index in the other
|
|
||||||
* file is set).
|
|
||||||
*/
|
|
||||||
ixref = rchgo[ixo - 1] ? ix: nrec;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If the first line of the current change group, is equal to
|
|
||||||
* the line next of the current change group, shift forward
|
|
||||||
* the group.
|
|
||||||
*/
|
|
||||||
while (ix < nrec && recs_match(recs, ixs, ix, flags)) {
|
|
||||||
blank_lines += is_blank_line(recs, ix, flags);
|
|
||||||
|
|
||||||
rchg[ixs++] = 0;
|
|
||||||
rchg[ix++] = 1;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This change might have joined two change groups,
|
|
||||||
* so we try to take this scenario in account by moving
|
|
||||||
* the start index accordingly (and so the other-file
|
|
||||||
* end-of-group index). Keep tracking the reference
|
|
||||||
* index in case we are shifting together with a
|
|
||||||
* corresponding group of changes in the other file.
|
|
||||||
*/
|
|
||||||
for (; rchg[ix]; ix++);
|
|
||||||
while (rchgo[++ixo])
|
|
||||||
ixref = ix;
|
|
||||||
}
|
|
||||||
} while (grpsiz != ix - ixs);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Try to move back the possibly merged group of changes, to match
|
|
||||||
* the recorded position in the other file.
|
|
||||||
*/
|
|
||||||
while (ixref < ix) {
|
|
||||||
rchg[--ixs] = 1;
|
|
||||||
rchg[--ix] = 0;
|
|
||||||
while (rchgo[--ixo]);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If a group can be moved back and forth, see if there is a
|
|
||||||
* blank line in the moving space. If there is a blank line,
|
|
||||||
* make sure the last blank line is the end of the group.
|
|
||||||
*
|
|
||||||
* As we already shifted the group forward as far as possible
|
|
||||||
* in the earlier loop, we need to shift it back only if at all.
|
|
||||||
*/
|
|
||||||
if ((flags & XDF_COMPACTION_HEURISTIC) && blank_lines) {
|
|
||||||
while (ixs > 0 &&
|
|
||||||
!is_blank_line(recs, ix - 1, flags) &&
|
|
||||||
recs_match(recs, ixs - 1, ix - 1, flags)) {
|
|
||||||
rchg[--ixs] = 1;
|
|
||||||
rchg[--ix] = 0;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
m->post_blank = 0;
|
||||||
|
m->post_indent = -1;
|
||||||
|
for (i = split + 1; i < xdf->nrec; i++) {
|
||||||
|
m->post_indent = get_indent(xdf->recs[i]);
|
||||||
|
if (m->post_indent != -1)
|
||||||
|
break;
|
||||||
|
m->post_blank += 1;
|
||||||
|
if (m->post_blank == MAX_BLANKS) {
|
||||||
|
m->post_indent = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The empirically-determined weight factors used by score_split() below.
|
||||||
|
* Larger values means that the position is a less favorable place to split.
|
||||||
|
*
|
||||||
|
* Note that scores are only ever compared against each other, so multiplying
|
||||||
|
* all of these weight/penalty values by the same factor wouldn't change the
|
||||||
|
* heuristic's behavior. Still, we need to set that arbitrary scale *somehow*.
|
||||||
|
* In practice, these numbers are chosen to be large enough that they can be
|
||||||
|
* adjusted relative to each other with sufficient precision despite using
|
||||||
|
* integer math.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Penalty if there are no non-blank lines before the split */
|
||||||
|
#define START_OF_FILE_PENALTY 1
|
||||||
|
|
||||||
|
/* Penalty if there are no non-blank lines after the split */
|
||||||
|
#define END_OF_FILE_PENALTY 21
|
||||||
|
|
||||||
|
/* Multiplier for the number of blank lines around the split */
|
||||||
|
#define TOTAL_BLANK_WEIGHT (-30)
|
||||||
|
|
||||||
|
/* Multiplier for the number of blank lines after the split */
|
||||||
|
#define POST_BLANK_WEIGHT 6
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Penalties applied if the line is indented more than its predecessor
|
||||||
|
*/
|
||||||
|
#define RELATIVE_INDENT_PENALTY (-4)
|
||||||
|
#define RELATIVE_INDENT_WITH_BLANK_PENALTY 10
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Penalties applied if the line is indented less than both its predecessor and
|
||||||
|
* its successor
|
||||||
|
*/
|
||||||
|
#define RELATIVE_OUTDENT_PENALTY 24
|
||||||
|
#define RELATIVE_OUTDENT_WITH_BLANK_PENALTY 17
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Penalties applied if the line is indented less than its predecessor but not
|
||||||
|
* less than its successor
|
||||||
|
*/
|
||||||
|
#define RELATIVE_DEDENT_PENALTY 23
|
||||||
|
#define RELATIVE_DEDENT_WITH_BLANK_PENALTY 17
|
||||||
|
|
||||||
|
/*
|
||||||
|
* We only consider whether the sum of the effective indents for splits are
|
||||||
|
* less than (-1), equal to (0), or greater than (+1) each other. The resulting
|
||||||
|
* value is multiplied by the following weight and combined with the penalty to
|
||||||
|
* determine the better of two scores.
|
||||||
|
*/
|
||||||
|
#define INDENT_WEIGHT 60
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Compute a badness score for the hypothetical split whose measurements are
|
||||||
|
* stored in m. The weight factors were determined empirically using the tools and
|
||||||
|
* corpus described in
|
||||||
|
*
|
||||||
|
* https://github.com/mhagger/diff-slider-tools
|
||||||
|
*
|
||||||
|
* Also see that project if you want to improve the weights based on, for example,
|
||||||
|
* a larger or more diverse corpus.
|
||||||
|
*/
|
||||||
|
static void score_add_split(const struct split_measurement *m, struct split_score *s)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* A place to accumulate penalty factors (positive makes this index more
|
||||||
|
* favored):
|
||||||
|
*/
|
||||||
|
int post_blank, total_blank, indent, any_blanks;
|
||||||
|
|
||||||
|
if (m->pre_indent == -1 && m->pre_blank == 0)
|
||||||
|
s->penalty += START_OF_FILE_PENALTY;
|
||||||
|
|
||||||
|
if (m->end_of_file)
|
||||||
|
s->penalty += END_OF_FILE_PENALTY;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Set post_blank to the number of blank lines following the split,
|
||||||
|
* including the line immediately after the split:
|
||||||
|
*/
|
||||||
|
post_blank = (m->indent == -1) ? 1 + m->post_blank : 0;
|
||||||
|
total_blank = m->pre_blank + post_blank;
|
||||||
|
|
||||||
|
/* Penalties based on nearby blank lines: */
|
||||||
|
s->penalty += TOTAL_BLANK_WEIGHT * total_blank;
|
||||||
|
s->penalty += POST_BLANK_WEIGHT * post_blank;
|
||||||
|
|
||||||
|
if (m->indent != -1)
|
||||||
|
indent = m->indent;
|
||||||
|
else
|
||||||
|
indent = m->post_indent;
|
||||||
|
|
||||||
|
any_blanks = (total_blank != 0);
|
||||||
|
|
||||||
|
/* Note that the effective indent is -1 at the end of the file: */
|
||||||
|
s->effective_indent += indent;
|
||||||
|
|
||||||
|
if (indent == -1) {
|
||||||
|
/* No additional adjustments needed. */
|
||||||
|
} else if (m->pre_indent == -1) {
|
||||||
|
/* No additional adjustments needed. */
|
||||||
|
} else if (indent > m->pre_indent) {
|
||||||
|
/*
|
||||||
|
* The line is indented more than its predecessor.
|
||||||
|
*/
|
||||||
|
s->penalty += any_blanks ?
|
||||||
|
RELATIVE_INDENT_WITH_BLANK_PENALTY :
|
||||||
|
RELATIVE_INDENT_PENALTY;
|
||||||
|
} else if (indent == m->pre_indent) {
|
||||||
|
/*
|
||||||
|
* The line has the same indentation level as its predecessor.
|
||||||
|
* No additional adjustments needed.
|
||||||
|
*/
|
||||||
|
} else {
|
||||||
|
/*
|
||||||
|
* The line is indented less than its predecessor. It could be
|
||||||
|
* the block terminator of the previous block, but it could
|
||||||
|
* also be the start of a new block (e.g., an "else" block, or
|
||||||
|
* maybe the previous block didn't have a block terminator).
|
||||||
|
* Try to distinguish those cases based on what comes next:
|
||||||
|
*/
|
||||||
|
if (m->post_indent != -1 && m->post_indent > indent) {
|
||||||
|
/*
|
||||||
|
* The following line is indented more. So it is likely
|
||||||
|
* that this line is the start of a block.
|
||||||
|
*/
|
||||||
|
s->penalty += any_blanks ?
|
||||||
|
RELATIVE_OUTDENT_WITH_BLANK_PENALTY :
|
||||||
|
RELATIVE_OUTDENT_PENALTY;
|
||||||
|
} else {
|
||||||
|
/*
|
||||||
|
* That was probably the end of a block.
|
||||||
|
*/
|
||||||
|
s->penalty += any_blanks ?
|
||||||
|
RELATIVE_DEDENT_WITH_BLANK_PENALTY :
|
||||||
|
RELATIVE_DEDENT_PENALTY;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int score_cmp(struct split_score *s1, struct split_score *s2)
|
||||||
|
{
|
||||||
|
/* -1 if s1.effective_indent < s2->effective_indent, etc. */
|
||||||
|
int cmp_indents = ((s1->effective_indent > s2->effective_indent) -
|
||||||
|
(s1->effective_indent < s2->effective_indent));
|
||||||
|
|
||||||
|
return INDENT_WEIGHT * cmp_indents + (s1->penalty - s2->penalty);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Represent a group of changed lines in an xdfile_t (i.e., a contiguous group
|
||||||
|
* of lines that was inserted or deleted from the corresponding version of the
|
||||||
|
* file). We consider there to be such a group at the beginning of the file, at
|
||||||
|
* the end of the file, and between any two unchanged lines, though most such
|
||||||
|
* groups will usually be empty.
|
||||||
|
*
|
||||||
|
* If the first line in a group is equal to the line following the group, then
|
||||||
|
* the group can be slid down. Similarly, if the last line in a group is equal
|
||||||
|
* to the line preceding the group, then the group can be slid up. See
|
||||||
|
* group_slide_down() and group_slide_up().
|
||||||
|
*
|
||||||
|
* Note that loops that are testing for changed lines in xdf->rchg do not need
|
||||||
|
* index bounding since the array is prepared with a zero at position -1 and N.
|
||||||
|
*/
|
||||||
|
struct group {
|
||||||
|
/*
|
||||||
|
* The index of the first changed line in the group, or the index of
|
||||||
|
* the unchanged line above which the (empty) group is located.
|
||||||
|
*/
|
||||||
|
long start;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The index of the first unchanged line after the group. For an empty
|
||||||
|
* group, end is equal to start.
|
||||||
|
*/
|
||||||
|
long end;
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Initialize g to point at the first group in xdf.
|
||||||
|
*/
|
||||||
|
static void group_init(xdfile_t *xdf, struct group *g)
|
||||||
|
{
|
||||||
|
g->start = g->end = 0;
|
||||||
|
while (xdf->rchg[g->end])
|
||||||
|
g->end++;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Move g to describe the next (possibly empty) group in xdf and return 0. If g
|
||||||
|
* is already at the end of the file, do nothing and return -1.
|
||||||
|
*/
|
||||||
|
static inline int group_next(xdfile_t *xdf, struct group *g)
|
||||||
|
{
|
||||||
|
if (g->end == xdf->nrec)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
g->start = g->end + 1;
|
||||||
|
for (g->end = g->start; xdf->rchg[g->end]; g->end++)
|
||||||
|
;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Move g to describe the previous (possibly empty) group in xdf and return 0.
|
||||||
|
* If g is already at the beginning of the file, do nothing and return -1.
|
||||||
|
*/
|
||||||
|
static inline int group_previous(xdfile_t *xdf, struct group *g)
|
||||||
|
{
|
||||||
|
if (g->start == 0)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
g->end = g->start - 1;
|
||||||
|
for (g->start = g->end; xdf->rchg[g->start - 1]; g->start--)
|
||||||
|
;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If g can be slid toward the end of the file, do so, and if it bumps into a
|
||||||
|
* following group, expand this group to include it. Return 0 on success or -1
|
||||||
|
* if g cannot be slid down.
|
||||||
|
*/
|
||||||
|
static int group_slide_down(xdfile_t *xdf, struct group *g, long flags)
|
||||||
|
{
|
||||||
|
if (g->end < xdf->nrec &&
|
||||||
|
recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) {
|
||||||
|
xdf->rchg[g->start++] = 0;
|
||||||
|
xdf->rchg[g->end++] = 1;
|
||||||
|
|
||||||
|
while (xdf->rchg[g->end])
|
||||||
|
g->end++;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
} else {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If g can be slid toward the beginning of the file, do so, and if it bumps
|
||||||
|
* into a previous group, expand this group to include it. Return 0 on success
|
||||||
|
* or -1 if g cannot be slid up.
|
||||||
|
*/
|
||||||
|
static int group_slide_up(xdfile_t *xdf, struct group *g, long flags)
|
||||||
|
{
|
||||||
|
if (g->start > 0 &&
|
||||||
|
recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) {
|
||||||
|
xdf->rchg[--g->start] = 1;
|
||||||
|
xdf->rchg[--g->end] = 0;
|
||||||
|
|
||||||
|
while (xdf->rchg[g->start - 1])
|
||||||
|
g->start--;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
} else {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void xdl_bug(const char *msg)
|
||||||
|
{
|
||||||
|
fprintf(stderr, "BUG: %s\n", msg);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Move back and forward change groups for a consistent and pretty diff output.
|
||||||
|
* This also helps in finding joinable change groups and reducing the diff
|
||||||
|
* size.
|
||||||
|
*/
|
||||||
|
int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
|
||||||
|
struct group g, go;
|
||||||
|
long earliest_end, end_matching_other;
|
||||||
|
long groupsize;
|
||||||
|
unsigned int blank_lines;
|
||||||
|
|
||||||
|
group_init(xdf, &g);
|
||||||
|
group_init(xdfo, &go);
|
||||||
|
|
||||||
|
while (1) {
|
||||||
|
/* If the group is empty in the to-be-compacted file, skip it: */
|
||||||
|
if (g.end == g.start)
|
||||||
|
goto next;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Now shift the change up and then down as far as possible in
|
||||||
|
* each direction. If it bumps into any other changes, merge them.
|
||||||
|
*/
|
||||||
|
do {
|
||||||
|
groupsize = g.end - g.start;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Keep track of the last "end" index that causes this
|
||||||
|
* group to align with a group of changed lines in the
|
||||||
|
* other file. -1 indicates that we haven't found such
|
||||||
|
* a match yet:
|
||||||
|
*/
|
||||||
|
end_matching_other = -1;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Boolean value that records whether there are any blank
|
||||||
|
* lines that could be made to be the last line of this
|
||||||
|
* group.
|
||||||
|
*/
|
||||||
|
blank_lines = 0;
|
||||||
|
|
||||||
|
/* Shift the group backward as much as possible: */
|
||||||
|
while (!group_slide_up(xdf, &g, flags))
|
||||||
|
if (group_previous(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken sliding up");
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This is this highest that this group can be shifted.
|
||||||
|
* Record its end index:
|
||||||
|
*/
|
||||||
|
earliest_end = g.end;
|
||||||
|
|
||||||
|
if (go.end > go.start)
|
||||||
|
end_matching_other = g.end;
|
||||||
|
|
||||||
|
/* Now shift the group forward as far as possible: */
|
||||||
|
while (1) {
|
||||||
|
if (!blank_lines)
|
||||||
|
blank_lines = is_blank_line(
|
||||||
|
xdf->recs[g.end - 1],
|
||||||
|
flags);
|
||||||
|
|
||||||
|
if (group_slide_down(xdf, &g, flags))
|
||||||
|
break;
|
||||||
|
if (group_next(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken sliding down");
|
||||||
|
|
||||||
|
if (go.end > go.start)
|
||||||
|
end_matching_other = g.end;
|
||||||
|
}
|
||||||
|
} while (groupsize != g.end - g.start);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If the group can be shifted, then we can possibly use this
|
||||||
|
* freedom to produce a more intuitive diff.
|
||||||
|
*
|
||||||
|
* The group is currently shifted as far down as possible, so the
|
||||||
|
* heuristics below only have to handle upwards shifts.
|
||||||
|
*/
|
||||||
|
|
||||||
|
if (g.end == earliest_end) {
|
||||||
|
/* no shifting was possible */
|
||||||
|
} else if (end_matching_other != -1) {
|
||||||
|
/*
|
||||||
|
* Move the possibly merged group of changes back to line
|
||||||
|
* up with the last group of changes from the other file
|
||||||
|
* that it can align with.
|
||||||
|
*/
|
||||||
|
while (go.end == go.start) {
|
||||||
|
if (group_slide_up(xdf, &g, flags))
|
||||||
|
xdl_bug("match disappeared");
|
||||||
|
if (group_previous(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken sliding to match");
|
||||||
|
}
|
||||||
|
} else if ((flags & XDF_COMPACTION_HEURISTIC) && blank_lines) {
|
||||||
|
/*
|
||||||
|
* Compaction heuristic: if it is possible to shift the
|
||||||
|
* group to make its bottom line a blank line, do so.
|
||||||
|
*
|
||||||
|
* As we already shifted the group forward as far as
|
||||||
|
* possible in the earlier loop, we only need to handle
|
||||||
|
* backward shifts, not forward ones.
|
||||||
|
*/
|
||||||
|
while (!is_blank_line(xdf->recs[g.end - 1], flags)) {
|
||||||
|
if (group_slide_up(xdf, &g, flags))
|
||||||
|
xdl_bug("blank line disappeared");
|
||||||
|
if (group_previous(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken sliding to blank line");
|
||||||
|
}
|
||||||
|
} else if (flags & XDF_INDENT_HEURISTIC) {
|
||||||
|
/*
|
||||||
|
* Indent heuristic: a group of pure add/delete lines
|
||||||
|
* implies two splits, one between the end of the "before"
|
||||||
|
* context and the start of the group, and another between
|
||||||
|
* the end of the group and the beginning of the "after"
|
||||||
|
* context. Some splits are aesthetically better and some
|
||||||
|
* are worse. We compute a badness "score" for each split,
|
||||||
|
* and add the scores for the two splits to define a
|
||||||
|
* "score" for each position that the group can be shifted
|
||||||
|
* to. Then we pick the shift with the lowest score.
|
||||||
|
*/
|
||||||
|
long shift, best_shift = -1;
|
||||||
|
struct split_score best_score;
|
||||||
|
|
||||||
|
for (shift = earliest_end; shift <= g.end; shift++) {
|
||||||
|
struct split_measurement m;
|
||||||
|
struct split_score score = {0, 0};
|
||||||
|
|
||||||
|
measure_split(xdf, shift, &m);
|
||||||
|
score_add_split(&m, &score);
|
||||||
|
measure_split(xdf, shift - groupsize, &m);
|
||||||
|
score_add_split(&m, &score);
|
||||||
|
if (best_shift == -1 ||
|
||||||
|
score_cmp(&score, &best_score) <= 0) {
|
||||||
|
best_score.effective_indent = score.effective_indent;
|
||||||
|
best_score.penalty = score.penalty;
|
||||||
|
best_shift = shift;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
while (g.end > best_shift) {
|
||||||
|
if (group_slide_up(xdf, &g, flags))
|
||||||
|
xdl_bug("best shift unreached");
|
||||||
|
if (group_previous(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken sliding to blank line");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
next:
|
||||||
|
/* Move past the just-processed group: */
|
||||||
|
if (group_next(xdf, &g))
|
||||||
|
break;
|
||||||
|
if (group_next(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken moving to next group");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!group_next(xdfo, &go))
|
||||||
|
xdl_bug("group sync broken at end of file");
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Loading…
Reference in New Issue
Block a user