On 4/26/2018 6:52 PM, Elijah Newren wrote:
On Thu, Apr 26, 2018 at 1:52 PM, Ben Peart <Ben.Peart@xxxxxxxxxxxxx> wrote:
+merge.renames::
+ Whether and how Git detects renames. If set to "false",
+ rename detection is disabled. If set to "true", basic rename
+ detection is enabled. If set to "copies" or "copy", Git will
+ detect copies, as well. Defaults to the value of diff.renames.
+
We shouldn't allow users to force copy detection on for merges The
diff side of the code will detect them correctly but the code in
merge-recursive will mishandle the copy pairs. I think fixing it is
somewhere between big can of worms and
it's-a-configuration-that-doesn't-even-make-sense, but it's been a
while since I thought about it.
Color me puzzled. :) The consensus was that the default value for
merge.renames come from diff.renames. diff.renames supports copy
detection which means that merge.renames will inherit that value. My
assumption was that is what was intended so when I reimplemented it, I
fully implemented it that way.
Are you now requesting to only use diff.renames as the default if the
value is true or false but not if it is copy? What should happen if
diff.renames is actually set to copy? Should merge silently change that
to true, display a warning, error out, or something else? Do you have
some other behavior for how to handle copy being inherited from
diff.renames you'd like to see?
Can you write the documentation that clearly explains the exact behavior
you want? That would kill two birds with one stone... :)
diff --git a/merge-recursive.h b/merge-recursive.h
index 80d69d1401..0c5f7eff98 100644
--- a/merge-recursive.h
+++ b/merge-recursive.h
@@ -17,7 +17,8 @@ struct merge_options {
unsigned renormalize : 1;
long xdl_opts;
int verbosity;
- int detect_rename;
+ int diff_detect_rename;
+ int merge_detect_rename;
int diff_rename_limit;
int merge_rename_limit;
int rename_score;
@@ -28,6 +29,11 @@ struct merge_options {
struct hashmap current_file_dir_set;
struct string_list df_conflict_file_set;
};
+inline int merge_detect_rename(struct merge_options *o)
+{
+ return o->merge_detect_rename >= 0 ? o->merge_detect_rename :
+ o->diff_detect_rename >= 0 ? o->diff_detect_rename : 1;
+}
Why did you split o->detect_rename into two fields? You then
recombine them in merge_detect_rename(), and after initial setup only
ever access them through that function. Having two fields worries me
that people will accidentally introduce bugs by using one of them
instead of the merge_detect_rename() function. Is there a reason you
decided against having the initial setup just set a single value and
then use it directly?
The setup of this value is split into 3 places that may or may not all
get called. The initial values, the values that come from the config
settings and then any values passed on the command line.
Because the merge value can now inherit from the diff value, you only
know the final value after you have received all possible inputs. That
makes it necessary to be a calculated value.
If you look at diff_rename_limit/merge_rename_limit, detect_rename
follow the same pattern for the same reasons. It turns out
detect_rename was a little more complex because it is used in 3
different locations (vs just one) which is why I wrapped the inheritance
logic into the helper function merge_detect_rename().
