[PATCH v2] log: add log.excludeDecoration config option

From: Derrick Stolee <dstolee@microsoft.com>

In 'git log', the --decorate-refs-exclude option appends a pattern to a string_list. This list is used to prevent showing some refs in the decoration output, or even by --simplify-by-decoration.

Users may want to use their refs space to store utility refs that should not appear in the decoration output. For example, Scalar [1] runs a background fetch but places the "new" refs inside the refs/scalar/hidden/<remote>/* refspace instead of refs/<remote>/* to avoid updating remote refs when the user is not looking. However, these "hidden" refs appear during regular 'git log' queries.

A similar idea to use "hidden" refs is under consideration for core Git [2].

Add the 'log.excludeDecoration' config option so users can exclude some refs from decorations by default instead of needing to use --decorate-refs-exclude manually. The config value is multi-valued much like the command-line option. The documentation is careful to point out that the config value can be overridden by the --decorate-refs option, even though --decorate-refs-exclude would always "win" over --decorate-refs.

Since the 'log.excludeDecoration' takes lower precedence to --decorate-refs, and --decorate-refs-exclude takes higher precedence, the struct decoration_filter needed another field. This led also to new logic in load_ref_decorations() and ref_filter_match().

There are several tests in t4202-log.sh that test the --decorate-refs-(include|exclude) options, so these are extended. Since the expected output is already stored as a file, most tests could simply replace a "--decorate-refs-exclude" option with an in-line config setting. Other tests involve the precedence of the config option compared to command-line options and needed more modification.

[1] https://github.com/microsoft/scalar [2] https://lore.kernel.org/git/77b1da5d3063a2404cd750adfe3bb8be9b6c497d.1585946894.git.gitgitgadget@gmail.com/

Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
---
    log: add log.excludeDecoration config option
    
    This was something hinted at in the "fetch" step of the background
    maintenance RFC. Should be a relatively minor addition to our config
    options.
    
    We definitely want this feature for microsoft/git (we would set
    log.excludeDecoration=refs/scalar/* in all Scalar repos), but we will
    wait for feedback from the community.
    
    Updates in v2:
    
     * Use for_each_string_list_item()
       
       
     * Update the matching logic to allow --decorate-refs to override the
       config option.
       
       
    
    Thanks, -Stolee

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-610%2Fderrickstolee%2Flog-exclude-decoration-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-610/derrickstolee/log-exclude-decoration-v2
Pull-Request: https://github.com/gitgitgadget/git/pull/610

Range-diff vs v1:

 1:  6aa81243c1f ! 1:  cbdaef4a8e1 log: add log.excludeDecoration config option
     @@ Commit message
          Add the 'log.excludeDecoration' config option so users can exclude
          some refs from decorations by default instead of needing to use
          --decorate-refs-exclude manually. The config value is multi-valued
     -    much like the command-line option.
     +    much like the command-line option. The documentation is careful to
     +    point out that the config value can be overridden by the
     +    --decorate-refs option, even though --decorate-refs-exclude would
     +    always "win" over --decorate-refs.
     +
     +    Since the 'log.excludeDecoration' takes lower precedence to
     +    --decorate-refs, and --decorate-refs-exclude takes higher
     +    precedence, the struct decoration_filter needed another field.
     +    This led also to new logic in load_ref_decorations() and
     +    ref_filter_match().
      
          There are several tests in t4202-log.sh that test the
          --decorate-refs-(include|exclude) options, so these are extended.
     -    Since the expected output is already stored as a file, simply add
     -    new calls that replace a "--decorate-refs-exclude" option with an
     -    in-line config setting.
     +    Since the expected output is already stored as a file, most tests
     +    could simply replace a "--decorate-refs-exclude" option with an
     +    in-line config setting. Other tests involve the precedence of
     +    the config option compared to command-line options and needed more
     +    modification.
      
          [1] https://github.com/microsoft/scalar
          [2] https://lore.kernel.org/git/77b1da5d3063a2404cd750adfe3bb8be9b6c497d.1585946894.git.gitgitgadget@gmail.com/
     @@ Documentation/config/log.txt: log.decorate::
       	If `true`, `git log` will act as if the `--follow` option was used when
       	a single <path> is given.  This has the same limitations as `--follow`,
      
     + ## Documentation/git-log.txt ##
     +@@ Documentation/git-log.txt: OPTIONS
     + 	If no `--decorate-refs` is given, pretend as if all refs were
     + 	included.  For each candidate, do not use it for decoration if it
     + 	matches any patterns given to `--decorate-refs-exclude` or if it
     +-	doesn't match any of the patterns given to `--decorate-refs`.
     ++	doesn't match any of the patterns given to `--decorate-refs`. The
     ++	`log.excludeDecoration` config option allows excluding refs from
     ++	the decorations, but an explicit `--decorate-refs` pattern will
     ++	override a match in `log.excludeDecoration`.
     + 
     + --source::
     + 	Print out the ref name given on the command line by which each
     +
       ## builtin/log.c ##
     +@@ builtin/log.c: static void cmd_log_init_finish(int argc, const char **argv, const char *prefix,
     + 	int quiet = 0, source = 0, mailmap;
     + 	static struct line_opt_callback_data line_cb = {NULL, NULL, STRING_LIST_INIT_DUP};
     + 	static struct string_list decorate_refs_exclude = STRING_LIST_INIT_NODUP;
     ++	static struct string_list decorate_refs_exclude_config = STRING_LIST_INIT_NODUP;
     + 	static struct string_list decorate_refs_include = STRING_LIST_INIT_NODUP;
     + 	struct decoration_filter decoration_filter = {&decorate_refs_include,
     +-						      &decorate_refs_exclude};
     ++						      &decorate_refs_exclude,
     ++						      &decorate_refs_exclude_config};
     + 	static struct revision_sources revision_sources;
     + 
     + 	const struct option builtin_log_options[] = {
      @@ builtin/log.c: static void cmd_log_init_finish(int argc, const char **argv, const char *prefix,
       	}
       
     @@ builtin/log.c: static void cmd_log_init_finish(int argc, const char **argv, cons
      +
      +		if (config_exclude) {
      +			struct string_list_item *item;
     -+			for (item = config_exclude->items;
     -+			     item && item < config_exclude->items + config_exclude->nr;
     -+			     item++)
     -+				string_list_append(&decorate_refs_exclude,
     -+						item->string);
     ++			for_each_string_list_item(item, config_exclude)
     ++				string_list_append(&decorate_refs_exclude_config,
     ++						   item->string);
      +		}
      +
       		rev->show_decorations = 1;
     @@ builtin/log.c: static void cmd_log_init_finish(int argc, const char **argv, cons
       	}
       
      
     + ## log-tree.c ##
     +@@ log-tree.c: static int add_ref_decoration(const char *refname, const struct object_id *oid,
     + 
     + 	if (filter && !ref_filter_match(refname,
     + 			      filter->include_ref_pattern,
     +-			      filter->exclude_ref_pattern))
     ++			      filter->exclude_ref_pattern,
     ++			      filter->exclude_ref_config_pattern))
     + 		return 0;
     + 
     + 	if (starts_with(refname, git_replace_ref_base)) {
     +@@ log-tree.c: void load_ref_decorations(struct decoration_filter *filter, int flags)
     + 			for_each_string_list_item(item, filter->include_ref_pattern) {
     + 				normalize_glob_ref(item, NULL, item->string);
     + 			}
     ++			for_each_string_list_item(item, filter->exclude_ref_config_pattern) {
     ++				normalize_glob_ref(item, NULL, item->string);
     ++			}
     + 		}
     + 		decoration_loaded = 1;
     + 		decoration_flags = flags;
     +
     + ## log-tree.h ##
     +@@ log-tree.h: struct log_info {
     + };
     + 
     + struct decoration_filter {
     +-	struct string_list *include_ref_pattern, *exclude_ref_pattern;
     ++	struct string_list *include_ref_pattern;
     ++	struct string_list *exclude_ref_pattern;
     ++	struct string_list *exclude_ref_config_pattern;
     + };
     + 
     + int parse_decorate_color_config(const char *var, const char *slot_name, const char *value);
     +
     + ## refs.c ##
     +@@ refs.c: static int match_ref_pattern(const char *refname,
     + 
     + int ref_filter_match(const char *refname,
     + 		     const struct string_list *include_patterns,
     +-		     const struct string_list *exclude_patterns)
     ++		     const struct string_list *exclude_patterns,
     ++		     const struct string_list *exclude_patterns_config)
     + {
     + 	struct string_list_item *item;
     ++	int found = 0;
     + 
     + 	if (exclude_patterns && exclude_patterns->nr) {
     + 		for_each_string_list_item(item, exclude_patterns) {
     +@@ refs.c: int ref_filter_match(const char *refname,
     + 	}
     + 
     + 	if (include_patterns && include_patterns->nr) {
     +-		int found = 0;
     + 		for_each_string_list_item(item, include_patterns) {
     + 			if (match_ref_pattern(refname, item)) {
     + 				found = 1;
     +@@ refs.c: int ref_filter_match(const char *refname,
     + 		if (!found)
     + 			return 0;
     + 	}
     ++
     ++	if (!found &&
     ++	    exclude_patterns_config &&
     ++	    exclude_patterns_config->nr) {
     ++		for_each_string_list_item(item, exclude_patterns_config) {
     ++			if (match_ref_pattern(refname, item))
     ++				return 0;
     ++		}
     ++	}
     ++
     + 	return 1;
     + }
     + 
     +
     + ## refs.h ##
     +@@ refs.h: void normalize_glob_ref(struct string_list_item *item, const char *prefix,
     + 			const char *pattern);
     + 
     + /*
     +- * Returns 0 if refname matches any of the exclude_patterns, or if it doesn't
     +- * match any of the include_patterns. Returns 1 otherwise.
     ++ * Returns 0 if the refname matches any of the exclude_patterns.
     ++ *
     ++ * Returns 0 if include_patterns is non-empty but refname does not match
     ++ * any of those patterns.
     ++ *
     ++ * Returns 0 if refname matches a pattern in exclude_patterns_config but
     ++ * does not match any pattern in inclue_patterns.
     ++ *
     ++ * Otherwise, returns 1.
     +  *
     +- * If pattern list is NULL or empty, matching against that list is skipped.
     +  * This has the effect of matching everything by default, unless the user
     +  * specifies rules otherwise.
     +  */
     + int ref_filter_match(const char *refname,
     + 		     const struct string_list *include_patterns,
     +-		     const struct string_list *exclude_patterns);
     ++		     const struct string_list *exclude_patterns,
     ++		     const struct string_list *exclude_patterns_config);
     + 
     + static inline const char *has_glob_specials(const char *pattern)
     + {
     +
       ## t/t4202-log.sh ##
     +@@ t/t4202-log.sh: test_expect_success 'decorate-refs with glob' '
     + 	octopus-a (octopus-a)
     + 	reach
     + 	EOF
     ++	cat >expect.no-decorate <<-\EOF &&
     ++	Merge-tag-reach
     ++	Merge-tags-octopus-a-and-octopus-b
     ++	seventh
     ++	octopus-b
     ++	octopus-a
     ++	reach
     ++	EOF
     ++	git log -n6 --decorate=short --pretty="tformat:%f%d" \
     ++		--decorate-refs="heads/octopus*" >actual &&
     ++	test_cmp expect.decorate actual &&
     + 	git log -n6 --decorate=short --pretty="tformat:%f%d" \
     ++		--decorate-refs-exclude="heads/octopus*" \
     ++		--decorate-refs="heads/octopus*" >actual &&
     ++	test_cmp expect.no-decorate actual &&
     ++	git -c log.excludeDecoration="heads/octopus*" log \
     ++		-n6 --decorate=short --pretty="tformat:%f%d" \
     + 		--decorate-refs="heads/octopus*" >actual &&
     + 	test_cmp expect.decorate actual
     + '
      @@ t/t4202-log.sh: test_expect_success 'decorate-refs-exclude with glob' '
       	EOF
       	git log -n6 --decorate=short --pretty="tformat:%f%d" \
     @@ t/t4202-log.sh: test_expect_success 'multiple decorate-refs-exclude' '
       	test_cmp expect.decorate actual
       '
       
     + test_expect_success 'decorate-refs and decorate-refs-exclude' '
     +-	cat >expect.decorate <<-\EOF &&
     ++	cat >expect.no-decorate <<-\EOF &&
     + 	Merge-tag-reach (master)
     + 	Merge-tags-octopus-a-and-octopus-b
     + 	seventh
      @@ t/t4202-log.sh: test_expect_success 'decorate-refs and decorate-refs-exclude' '
       	git log -n6 --decorate=short --pretty="tformat:%f%d" \
       		--decorate-refs="heads/*" \
       		--decorate-refs-exclude="heads/oc*" >actual &&
     -+	test_cmp expect.decorate actual &&
     ++	test_cmp expect.no-decorate actual
     ++'
     ++
     ++test_expect_success 'deocrate-refs and log.excludeDecoration' '
     ++	cat >expect.decorate <<-\EOF &&
     ++	Merge-tag-reach (master)
     ++	Merge-tags-octopus-a-and-octopus-b
     ++	seventh
     ++	octopus-b (octopus-b)
     ++	octopus-a (octopus-a)
     ++	reach (reach)
     ++	EOF
      +	git -c log.excludeDecoration="heads/oc*" log \
      +		--decorate-refs="heads/*" \
      +		-n6 --decorate=short --pretty="tformat:%f%d" >actual &&

 Documentation/config/log.txt |  5 ++++
 Documentation/git-log.txt    |  5 +++-
 builtin/log.c                | 16 ++++++++++-
 log-tree.c                   |  6 ++++-
 log-tree.h                   |  4 ++-
 refs.c                       | 15 +++++++++--
 refs.h                       | 15 ++++++++---
 t/t4202-log.sh               | 51 +++++++++++++++++++++++++++++++++++-
 8 files changed, 106 insertions(+), 11 deletions(-)