2006-08-02 23:51:59 +02:00
|
|
|
#include "builtin.h"
|
2023-03-21 07:25:58 +01:00
|
|
|
#include "abspath.h"
|
2017-06-14 20:07:36 +02:00
|
|
|
#include "config.h"
|
2007-11-28 07:41:05 +01:00
|
|
|
#include "color.h"
|
2023-04-11 09:41:57 +02:00
|
|
|
#include "editor.h"
|
2023-03-21 07:26:03 +01:00
|
|
|
#include "environment.h"
|
2023-05-26 03:33:00 +02:00
|
|
|
#include "repository.h"
|
2023-03-21 07:25:54 +01:00
|
|
|
#include "gettext.h"
|
2023-02-24 01:09:29 +01:00
|
|
|
#include "ident.h"
|
2009-02-21 01:49:25 +01:00
|
|
|
#include "parse-options.h"
|
2013-07-31 20:14:59 +02:00
|
|
|
#include "urlmatch.h"
|
2023-04-22 22:17:20 +02:00
|
|
|
#include "path.h"
|
2016-02-19 10:16:02 +01:00
|
|
|
#include "quote.h"
|
2023-03-21 07:26:05 +01:00
|
|
|
#include "setup.h"
|
2023-05-16 08:34:02 +02:00
|
|
|
#include "strbuf.h"
|
2018-10-21 16:02:28 +02:00
|
|
|
#include "worktree.h"
|
2005-11-17 22:44:55 +01:00
|
|
|
|
2009-02-21 01:49:25 +01:00
|
|
|
static const char *const builtin_config_usage[] = {
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
N_("git config list [<file-option>] [<display-option>] [--includes]"),
|
2024-05-06 10:56:29 +02:00
|
|
|
N_("git config get [<file-option>] [<display-option>] [--includes] [--all] [--regexp=<regexp>] [--value=<value>] [--fixed-value] [--default=<default>] <name>"),
|
2024-05-06 10:56:33 +02:00
|
|
|
N_("git config set [<file-option>] [--type=<type>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),
|
2024-05-06 10:56:38 +02:00
|
|
|
N_("git config unset [<file-option>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),
|
2024-05-06 10:56:43 +02:00
|
|
|
N_("git config rename-section [<file-option>] <old-name> <new-name>"),
|
2024-05-06 10:56:47 +02:00
|
|
|
N_("git config remove-section [<file-option>] <name>"),
|
2024-05-06 10:56:52 +02:00
|
|
|
N_("git config edit [<file-option>]"),
|
2024-05-06 10:56:57 +02:00
|
|
|
N_("git config [<file-option>] --get-colorbool <name> [<stdout-is-tty>]"),
|
2009-02-21 01:49:25 +01:00
|
|
|
NULL
|
|
|
|
};
|
2005-11-20 06:52:22 +01:00
|
|
|
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
static const char *const builtin_config_list_usage[] = {
|
|
|
|
N_("git config list [<file-option>] [<display-option>] [--includes]"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-06 10:56:29 +02:00
|
|
|
static const char *const builtin_config_get_usage[] = {
|
|
|
|
N_("git config get [<file-option>] [<display-option>] [--includes] [--all] [--regexp=<regexp>] [--value=<value>] [--fixed-value] [--default=<default>] <name>"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-06 10:56:33 +02:00
|
|
|
static const char *const builtin_config_set_usage[] = {
|
|
|
|
N_("git config set [<file-option>] [--type=<type>] [--comment=<message>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-06 10:56:38 +02:00
|
|
|
static const char *const builtin_config_unset_usage[] = {
|
|
|
|
N_("git config unset [<file-option>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-06 10:56:43 +02:00
|
|
|
static const char *const builtin_config_rename_section_usage[] = {
|
|
|
|
N_("git config rename-section [<file-option>] <old-name> <new-name>"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-06 10:56:47 +02:00
|
|
|
static const char *const builtin_config_remove_section_usage[] = {
|
|
|
|
N_("git config remove-section [<file-option>] <name>"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-06 10:56:52 +02:00
|
|
|
static const char *const builtin_config_edit_usage[] = {
|
|
|
|
N_("git config edit [<file-option>]"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
#define CONFIG_LOCATION_OPTIONS(opts) \
|
|
|
|
OPT_GROUP(N_("Config file location")), \
|
|
|
|
OPT_BOOL(0, "global", &opts.use_global_config, N_("use global config file")), \
|
|
|
|
OPT_BOOL(0, "system", &opts.use_system_config, N_("use system config file")), \
|
|
|
|
OPT_BOOL(0, "local", &opts.use_local_config, N_("use repository config file")), \
|
|
|
|
OPT_BOOL(0, "worktree", &opts.use_worktree_config, N_("use per-worktree config file")), \
|
|
|
|
OPT_STRING('f', "file", &opts.source.file, N_("file"), N_("use given config file")), \
|
|
|
|
OPT_STRING(0, "blob", &opts.source.blob, N_("blob-id"), N_("read config from given blob object"))
|
|
|
|
|
|
|
|
struct config_location_options {
|
|
|
|
struct git_config_source source;
|
|
|
|
struct config_options options;
|
|
|
|
char *file_to_free;
|
|
|
|
int use_global_config;
|
|
|
|
int use_system_config;
|
|
|
|
int use_local_config;
|
|
|
|
int use_worktree_config;
|
2024-05-15 08:42:35 +02:00
|
|
|
int respect_includes_opt;
|
2024-05-15 08:42:16 +02:00
|
|
|
};
|
2024-05-15 08:42:35 +02:00
|
|
|
#define CONFIG_LOCATION_OPTIONS_INIT { \
|
|
|
|
.respect_includes_opt = -1, \
|
|
|
|
}
|
2024-05-15 08:42:16 +02:00
|
|
|
|
2024-05-15 08:42:25 +02:00
|
|
|
#define CONFIG_TYPE_OPTIONS(type) \
|
|
|
|
OPT_GROUP(N_("Type")), \
|
|
|
|
OPT_CALLBACK('t', "type", &type, N_("type"), N_("value is given this type"), option_parse_type), \
|
|
|
|
OPT_CALLBACK_VALUE(0, "bool", &type, N_("value is \"true\" or \"false\""), TYPE_BOOL), \
|
|
|
|
OPT_CALLBACK_VALUE(0, "int", &type, N_("value is decimal number"), TYPE_INT), \
|
|
|
|
OPT_CALLBACK_VALUE(0, "bool-or-int", &type, N_("value is --bool or --int"), TYPE_BOOL_OR_INT), \
|
|
|
|
OPT_CALLBACK_VALUE(0, "bool-or-str", &type, N_("value is --bool or string"), TYPE_BOOL_OR_STR), \
|
|
|
|
OPT_CALLBACK_VALUE(0, "path", &type, N_("value is a path (file or directory name)"), TYPE_PATH), \
|
|
|
|
OPT_CALLBACK_VALUE(0, "expiry-date", &type, N_("value is an expiry date"), TYPE_EXPIRY_DATE)
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
#define CONFIG_DISPLAY_OPTIONS(opts) \
|
|
|
|
OPT_GROUP(N_("Display options")), \
|
|
|
|
OPT_BOOL('z', "null", &opts.end_nul, N_("terminate values with NUL byte")), \
|
|
|
|
OPT_BOOL(0, "name-only", &opts.omit_values, N_("show variable names only")), \
|
|
|
|
OPT_BOOL(0, "show-origin", &opts.show_origin, N_("show origin of config (file, standard input, blob, command line)")), \
|
|
|
|
OPT_BOOL(0, "show-scope", &opts.show_scope, N_("show scope of config (worktree, local, global, system, command)")), \
|
2024-05-15 08:42:25 +02:00
|
|
|
OPT_BOOL(0, "show-names", &opts.show_keys, N_("show config keys in addition to their values")), \
|
|
|
|
CONFIG_TYPE_OPTIONS(opts.type)
|
2024-05-15 08:42:21 +02:00
|
|
|
|
|
|
|
struct config_display_options {
|
|
|
|
int end_nul;
|
|
|
|
int omit_values;
|
|
|
|
int show_origin;
|
|
|
|
int show_scope;
|
|
|
|
int show_keys;
|
2024-05-15 08:42:25 +02:00
|
|
|
int type;
|
2024-05-15 08:42:30 +02:00
|
|
|
char *default_value;
|
2024-05-15 08:42:21 +02:00
|
|
|
/* Populated via `display_options_init()`. */
|
|
|
|
int term;
|
|
|
|
int delim;
|
|
|
|
int key_delim;
|
|
|
|
};
|
|
|
|
#define CONFIG_DISPLAY_OPTIONS_INIT { \
|
|
|
|
.term = '\n', \
|
|
|
|
.delim = '=', \
|
|
|
|
.key_delim = ' ', \
|
|
|
|
}
|
|
|
|
|
2006-08-15 19:23:48 +02:00
|
|
|
static char *key;
|
|
|
|
static int use_key_regexp;
|
|
|
|
static int do_all;
|
2020-11-25 23:12:53 +01:00
|
|
|
static int fixed_value;
|
2009-02-21 01:49:25 +01:00
|
|
|
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:46:54 +02:00
|
|
|
#define TYPE_BOOL 1
|
|
|
|
#define TYPE_INT 2
|
|
|
|
#define TYPE_BOOL_OR_INT 3
|
|
|
|
#define TYPE_PATH 4
|
|
|
|
#define TYPE_EXPIRY_DATE 5
|
2018-04-10 02:18:31 +02:00
|
|
|
#define TYPE_COLOR 6
|
2020-05-07 01:31:14 +02:00
|
|
|
#define TYPE_BOOL_OR_STR 7
|
2009-02-21 01:49:27 +01:00
|
|
|
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 23:43:35 +02:00
|
|
|
#define OPT_CALLBACK_VALUE(s, l, v, h, i) \
|
|
|
|
{ OPTION_CALLBACK, (s), (l), (v), NULL, (h), PARSE_OPT_NOARG | \
|
|
|
|
PARSE_OPT_NONEG, option_parse_type, (i) }
|
|
|
|
|
|
|
|
static int option_parse_type(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
|
|
|
int new_type, *to_type;
|
|
|
|
|
|
|
|
if (unset) {
|
|
|
|
*((int *) opt->value) = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To support '--<type>' style flags, begin with new_type equal to
|
|
|
|
* opt->defval.
|
|
|
|
*/
|
|
|
|
new_type = opt->defval;
|
|
|
|
if (!new_type) {
|
|
|
|
if (!strcmp(arg, "bool"))
|
|
|
|
new_type = TYPE_BOOL;
|
|
|
|
else if (!strcmp(arg, "int"))
|
|
|
|
new_type = TYPE_INT;
|
|
|
|
else if (!strcmp(arg, "bool-or-int"))
|
|
|
|
new_type = TYPE_BOOL_OR_INT;
|
2020-05-07 01:31:14 +02:00
|
|
|
else if (!strcmp(arg, "bool-or-str"))
|
|
|
|
new_type = TYPE_BOOL_OR_STR;
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 23:43:35 +02:00
|
|
|
else if (!strcmp(arg, "path"))
|
|
|
|
new_type = TYPE_PATH;
|
|
|
|
else if (!strcmp(arg, "expiry-date"))
|
|
|
|
new_type = TYPE_EXPIRY_DATE;
|
2018-04-10 02:18:31 +02:00
|
|
|
else if (!strcmp(arg, "color"))
|
|
|
|
new_type = TYPE_COLOR;
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 23:43:35 +02:00
|
|
|
else
|
|
|
|
die(_("unrecognized --type argument, %s"), arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
to_type = opt->value;
|
|
|
|
if (*to_type && *to_type != new_type) {
|
|
|
|
/*
|
|
|
|
* Complain when there is a new type not equal to the old type.
|
|
|
|
* This allows for combinations like '--int --type=int' and
|
|
|
|
* '--type=int --type=int', but disallows ones like '--type=bool
|
|
|
|
* --int' and '--type=bool
|
|
|
|
* --type=int'.
|
|
|
|
*/
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("only one type at a time"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 23:43:35 +02:00
|
|
|
}
|
|
|
|
*to_type = new_type;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-12-09 11:25:21 +01:00
|
|
|
static void check_argc(int argc, int min, int max)
|
|
|
|
{
|
2009-02-21 01:49:25 +01:00
|
|
|
if (argc >= min && argc <= max)
|
|
|
|
return;
|
2018-07-21 09:49:19 +02:00
|
|
|
if (min == max)
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("wrong number of arguments, should be %d"), min);
|
2018-07-21 09:49:19 +02:00
|
|
|
else
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("wrong number of arguments, should be from %d to %d"),
|
2018-07-21 09:49:19 +02:00
|
|
|
min, max);
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
static void show_config_origin(const struct config_display_options *opts,
|
|
|
|
const struct key_value_info *kvi,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
struct strbuf *buf)
|
2016-02-19 10:16:02 +01:00
|
|
|
{
|
2024-05-15 08:42:21 +02:00
|
|
|
const char term = opts->end_nul ? '\0' : '\t';
|
2016-02-19 10:16:02 +01:00
|
|
|
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
strbuf_addstr(buf, config_origin_type_name(kvi->origin_type));
|
2016-02-19 10:16:02 +01:00
|
|
|
strbuf_addch(buf, ':');
|
2024-05-15 08:42:21 +02:00
|
|
|
if (opts->end_nul)
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
strbuf_addstr(buf, kvi->filename ? kvi->filename : "");
|
2016-02-19 10:16:02 +01:00
|
|
|
else
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
quote_c_style(kvi->filename ? kvi->filename : "", buf, NULL, 0);
|
2016-02-19 10:16:02 +01:00
|
|
|
strbuf_addch(buf, term);
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
static void show_config_scope(const struct config_display_options *opts,
|
|
|
|
const struct key_value_info *kvi,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
struct strbuf *buf)
|
2020-02-10 01:30:59 +01:00
|
|
|
{
|
2024-05-15 08:42:21 +02:00
|
|
|
const char term = opts->end_nul ? '\0' : '\t';
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const char *scope = config_scope_name(kvi->scope);
|
2020-02-10 01:30:59 +01:00
|
|
|
|
|
|
|
strbuf_addstr(buf, N_(scope));
|
|
|
|
strbuf_addch(buf, term);
|
|
|
|
}
|
|
|
|
|
2022-08-19 12:08:44 +02:00
|
|
|
static int show_all_config(const char *key_, const char *value_,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const struct config_context *ctx,
|
2024-05-15 08:42:21 +02:00
|
|
|
void *cb)
|
2006-04-25 00:59:25 +02:00
|
|
|
{
|
2024-05-15 08:42:21 +02:00
|
|
|
const struct config_display_options *opts = cb;
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const struct key_value_info *kvi = ctx->kvi;
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
if (opts->show_origin || opts->show_scope) {
|
2016-02-19 10:16:02 +01:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2024-05-15 08:42:21 +02:00
|
|
|
if (opts->show_scope)
|
|
|
|
show_config_scope(opts, kvi, &buf);
|
|
|
|
if (opts->show_origin)
|
|
|
|
show_config_origin(opts, kvi, &buf);
|
2016-02-19 10:16:02 +01:00
|
|
|
/* Use fwrite as "buf" can contain \0's if "end_null" is set. */
|
|
|
|
fwrite(buf.buf, 1, buf.len, stdout);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
2024-05-15 08:42:21 +02:00
|
|
|
if (!opts->omit_values && value_)
|
|
|
|
printf("%s%c%s%c", key_, opts->delim, value_, opts->term);
|
2006-04-25 00:59:25 +02:00
|
|
|
else
|
2024-05-15 08:42:21 +02:00
|
|
|
printf("%s%c", key_, opts->term);
|
2006-04-25 00:59:25 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-23 21:51:50 +02:00
|
|
|
struct strbuf_list {
|
|
|
|
struct strbuf *items;
|
|
|
|
int nr;
|
|
|
|
int alloc;
|
|
|
|
};
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
static int format_config(const struct config_display_options *opts,
|
|
|
|
struct strbuf *buf, const char *key_,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const char *value_, const struct key_value_info *kvi)
|
2005-11-20 06:52:22 +01:00
|
|
|
{
|
2024-05-15 08:42:21 +02:00
|
|
|
if (opts->show_scope)
|
|
|
|
show_config_scope(opts, kvi, buf);
|
|
|
|
if (opts->show_origin)
|
|
|
|
show_config_origin(opts, kvi, buf);
|
|
|
|
if (opts->show_keys)
|
2012-10-23 21:51:50 +02:00
|
|
|
strbuf_addstr(buf, key_);
|
2024-05-15 08:42:21 +02:00
|
|
|
if (!opts->omit_values) {
|
|
|
|
if (opts->show_keys)
|
|
|
|
strbuf_addch(buf, opts->key_delim);
|
2015-08-20 16:14:22 +02:00
|
|
|
|
2024-05-15 08:42:25 +02:00
|
|
|
if (opts->type == TYPE_INT)
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_addf(buf, "%"PRId64,
|
config: pass kvi to die_bad_number()
Plumb "struct key_value_info" through all code paths that end in
die_bad_number(), which lets us remove the helper functions that read
analogous values from "struct config_reader". As a result, nothing reads
config_reader.config_kvi any more, so remove that too.
In config.c, this requires changing the signature of
git_configset_get_value() to 'return' "kvi" in an out parameter so that
git_configset_get_<type>() can pass it to git_config_<type>(). Only
numeric types will use "kvi", so for non-numeric types (e.g.
git_configset_get_string()), pass NULL to indicate that the out
parameter isn't needed.
Outside of config.c, config callbacks now need to pass "ctx->kvi" to any
of the git_config_<type>() functions that parse a config string into a
number type. Included is a .cocci patch to make that refactor.
The only exceptional case is builtin/config.c, where git_config_<type>()
is called outside of a config callback (namely, on user-provided input),
so config source information has never been available. In this case,
die_bad_number() defaults to a generic, but perfectly descriptive
message. Let's provide a safe, non-NULL for "kvi" anyway, but make sure
not to change the message.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:27 +02:00
|
|
|
git_config_int64(key_, value_ ? value_ : "", kvi));
|
2024-05-15 08:42:25 +02:00
|
|
|
else if (opts->type == TYPE_BOOL)
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_addstr(buf, git_config_bool(key_, value_) ?
|
|
|
|
"true" : "false");
|
2024-05-15 08:42:25 +02:00
|
|
|
else if (opts->type == TYPE_BOOL_OR_INT) {
|
2015-08-20 16:14:22 +02:00
|
|
|
int is_bool, v;
|
config: pass kvi to die_bad_number()
Plumb "struct key_value_info" through all code paths that end in
die_bad_number(), which lets us remove the helper functions that read
analogous values from "struct config_reader". As a result, nothing reads
config_reader.config_kvi any more, so remove that too.
In config.c, this requires changing the signature of
git_configset_get_value() to 'return' "kvi" in an out parameter so that
git_configset_get_<type>() can pass it to git_config_<type>(). Only
numeric types will use "kvi", so for non-numeric types (e.g.
git_configset_get_string()), pass NULL to indicate that the out
parameter isn't needed.
Outside of config.c, config callbacks now need to pass "ctx->kvi" to any
of the git_config_<type>() functions that parse a config string into a
number type. Included is a .cocci patch to make that refactor.
The only exceptional case is builtin/config.c, where git_config_<type>()
is called outside of a config callback (namely, on user-provided input),
so config source information has never been available. In this case,
die_bad_number() defaults to a generic, but perfectly descriptive
message. Let's provide a safe, non-NULL for "kvi" anyway, but make sure
not to change the message.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:27 +02:00
|
|
|
v = git_config_bool_or_int(key_, value_, kvi,
|
|
|
|
&is_bool);
|
2015-08-20 16:14:22 +02:00
|
|
|
if (is_bool)
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_addstr(buf, v ? "true" : "false");
|
2015-08-20 16:14:22 +02:00
|
|
|
else
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_addf(buf, "%d", v);
|
2024-05-15 08:42:25 +02:00
|
|
|
} else if (opts->type == TYPE_BOOL_OR_STR) {
|
2020-05-07 01:31:14 +02:00
|
|
|
int v = git_parse_maybe_bool(value_);
|
|
|
|
if (v < 0)
|
|
|
|
strbuf_addstr(buf, value_);
|
|
|
|
else
|
|
|
|
strbuf_addstr(buf, v ? "true" : "false");
|
2024-05-15 08:42:25 +02:00
|
|
|
} else if (opts->type == TYPE_PATH) {
|
2015-08-20 16:47:34 +02:00
|
|
|
const char *v;
|
|
|
|
if (git_config_pathname(&v, key_, value_) < 0)
|
2015-08-20 16:14:22 +02:00
|
|
|
return -1;
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_addstr(buf, v);
|
|
|
|
free((char *)v);
|
2024-05-15 08:42:25 +02:00
|
|
|
} else if (opts->type == TYPE_EXPIRY_DATE) {
|
2017-11-18 03:27:27 +01:00
|
|
|
timestamp_t t;
|
|
|
|
if (git_config_expiry_date(&t, key_, value_) < 0)
|
|
|
|
return -1;
|
|
|
|
strbuf_addf(buf, "%"PRItime, t);
|
2024-05-15 08:42:25 +02:00
|
|
|
} else if (opts->type == TYPE_COLOR) {
|
2018-04-10 02:18:31 +02:00
|
|
|
char v[COLOR_MAXLEN];
|
|
|
|
if (git_config_color(v, key_, value_) < 0)
|
|
|
|
return -1;
|
|
|
|
strbuf_addstr(buf, v);
|
2015-08-20 16:14:22 +02:00
|
|
|
} else if (value_) {
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_addstr(buf, value_);
|
2015-08-20 16:14:22 +02:00
|
|
|
} else {
|
2015-08-20 16:47:34 +02:00
|
|
|
/* Just show the key name; back out delimiter */
|
2024-05-15 08:42:21 +02:00
|
|
|
if (opts->show_keys)
|
2015-08-20 16:47:34 +02:00
|
|
|
strbuf_setlen(buf, buf->len - 1);
|
2015-08-20 16:14:22 +02:00
|
|
|
}
|
2015-08-10 11:46:06 +02:00
|
|
|
}
|
2024-05-15 08:42:21 +02:00
|
|
|
strbuf_addch(buf, opts->term);
|
2005-11-20 06:52:22 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
struct collect_config_data {
|
|
|
|
const struct config_display_options *display_opts;
|
|
|
|
struct strbuf_list *values;
|
2024-05-15 08:42:44 +02:00
|
|
|
const char *value_pattern;
|
2024-05-15 08:42:49 +02:00
|
|
|
regex_t *regexp;
|
2024-05-15 08:42:53 +02:00
|
|
|
regex_t *key_regexp;
|
2024-05-15 08:42:39 +02:00
|
|
|
int do_not_match;
|
2024-05-15 08:42:21 +02:00
|
|
|
};
|
|
|
|
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:22 +02:00
|
|
|
static int collect_config(const char *key_, const char *value_,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const struct config_context *ctx, void *cb)
|
2013-07-29 23:23:16 +02:00
|
|
|
{
|
2024-05-15 08:42:21 +02:00
|
|
|
struct collect_config_data *data = cb;
|
|
|
|
struct strbuf_list *values = data->values;
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const struct key_value_info *kvi = ctx->kvi;
|
2013-07-29 23:23:16 +02:00
|
|
|
|
|
|
|
if (!use_key_regexp && strcmp(key_, key))
|
|
|
|
return 0;
|
2024-05-15 08:42:53 +02:00
|
|
|
if (use_key_regexp && regexec(data->key_regexp, key_, 0, NULL, 0))
|
2013-07-29 23:23:16 +02:00
|
|
|
return 0;
|
2024-05-15 08:42:44 +02:00
|
|
|
if (fixed_value && strcmp(data->value_pattern, (value_?value_:"")))
|
2020-11-25 23:12:55 +01:00
|
|
|
return 0;
|
2024-05-15 08:42:49 +02:00
|
|
|
if (data->regexp &&
|
|
|
|
(data->do_not_match ^ !!regexec(data->regexp, (value_?value_:""), 0, NULL, 0)))
|
2013-07-29 23:23:16 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
ALLOC_GROW(values->items, values->nr + 1, values->alloc);
|
2015-08-20 16:46:04 +02:00
|
|
|
strbuf_init(&values->items[values->nr], 0);
|
2013-07-29 23:23:16 +02:00
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
return format_config(data->display_opts, &values->items[values->nr++],
|
|
|
|
key_, value_, kvi);
|
2013-07-29 23:23:16 +02:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static int get_value(const struct config_location_options *opts,
|
2024-05-15 08:42:21 +02:00
|
|
|
const struct config_display_options *display_opts,
|
2024-05-15 08:42:16 +02:00
|
|
|
const char *key_, const char *regex_, unsigned flags)
|
2005-11-20 06:52:22 +01:00
|
|
|
{
|
2012-07-29 22:43:21 +02:00
|
|
|
int ret = CONFIG_GENERIC_ERROR;
|
2012-10-28 22:05:25 +01:00
|
|
|
struct strbuf_list values = {NULL};
|
2024-05-15 08:42:21 +02:00
|
|
|
struct collect_config_data data = {
|
|
|
|
.display_opts = display_opts,
|
|
|
|
.values = &values,
|
|
|
|
};
|
2012-10-23 21:51:50 +02:00
|
|
|
int i;
|
2005-11-20 06:52:22 +01:00
|
|
|
|
2006-05-02 14:22:48 +02:00
|
|
|
if (use_key_regexp) {
|
2011-01-30 20:40:41 +01:00
|
|
|
char *tl;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: this naive pattern lowercasing obviously does not
|
|
|
|
* work for more complex patterns like "^[^.]*Foo.*bar".
|
|
|
|
* Perhaps we should deprecate this altogether someday.
|
|
|
|
*/
|
|
|
|
|
|
|
|
key = xstrdup(key_);
|
|
|
|
for (tl = key + strlen(key) - 1;
|
|
|
|
tl >= key && *tl != '.';
|
|
|
|
tl--)
|
|
|
|
*tl = tolower(*tl);
|
|
|
|
for (tl = key; *tl && *tl != '.'; tl++)
|
|
|
|
*tl = tolower(*tl);
|
|
|
|
|
2024-05-15 08:42:53 +02:00
|
|
|
data.key_regexp = (regex_t*)xmalloc(sizeof(regex_t));
|
|
|
|
if (regcomp(data.key_regexp, key, REG_EXTENDED)) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("invalid key pattern: %s"), key_);
|
2024-05-15 08:42:53 +02:00
|
|
|
FREE_AND_NULL(data.key_regexp);
|
2012-07-29 22:43:21 +02:00
|
|
|
ret = CONFIG_INVALID_PATTERN;
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 01:48:03 +02:00
|
|
|
goto free_strings;
|
2006-05-02 14:22:48 +02:00
|
|
|
}
|
2011-01-30 20:40:41 +01:00
|
|
|
} else {
|
2012-07-29 22:43:21 +02:00
|
|
|
if (git_config_parse_key(key_, &key, NULL)) {
|
|
|
|
ret = CONFIG_INVALID_KEY;
|
2011-01-30 20:40:41 +01:00
|
|
|
goto free_strings;
|
2012-07-29 22:43:21 +02:00
|
|
|
}
|
2006-05-02 14:22:48 +02:00
|
|
|
}
|
|
|
|
|
2020-11-25 23:12:55 +01:00
|
|
|
if (regex_ && (flags & CONFIG_FLAGS_FIXED_VALUE))
|
2024-05-15 08:42:44 +02:00
|
|
|
data.value_pattern = regex_;
|
2020-11-25 23:12:55 +01:00
|
|
|
else if (regex_) {
|
2005-11-20 13:24:18 +01:00
|
|
|
if (regex_[0] == '!') {
|
2024-05-15 08:42:39 +02:00
|
|
|
data.do_not_match = 1;
|
2005-11-20 13:24:18 +01:00
|
|
|
regex_++;
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:49 +02:00
|
|
|
data.regexp = (regex_t*)xmalloc(sizeof(regex_t));
|
|
|
|
if (regcomp(data.regexp, regex_, REG_EXTENDED)) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("invalid pattern: %s"), regex_);
|
2024-05-15 08:42:49 +02:00
|
|
|
FREE_AND_NULL(data.regexp);
|
2012-07-29 22:43:21 +02:00
|
|
|
ret = CONFIG_INVALID_PATTERN;
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 01:48:03 +02:00
|
|
|
goto free_strings;
|
2005-11-20 06:52:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
config_with_options(collect_config, &data,
|
2024-05-15 08:42:16 +02:00
|
|
|
&opts->source, the_repository,
|
|
|
|
&opts->options);
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 01:48:03 +02:00
|
|
|
|
2024-05-15 08:42:30 +02:00
|
|
|
if (!values.nr && display_opts->default_value) {
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
struct key_value_info kvi = KVI_INIT;
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 02:18:26 +02:00
|
|
|
struct strbuf *item;
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
|
|
|
|
kvi_from_param(&kvi);
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 02:18:26 +02:00
|
|
|
ALLOC_GROW(values.items, values.nr + 1, values.alloc);
|
|
|
|
item = &values.items[values.nr++];
|
|
|
|
strbuf_init(item, 0);
|
2024-05-15 08:42:30 +02:00
|
|
|
if (format_config(display_opts, item, key_,
|
|
|
|
display_opts->default_value, &kvi) < 0)
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 02:18:26 +02:00
|
|
|
die(_("failed to format default config value: %s"),
|
2024-05-15 08:42:30 +02:00
|
|
|
display_opts->default_value);
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 02:18:26 +02:00
|
|
|
}
|
|
|
|
|
git-config: do not complain about duplicate entries
If git-config is asked for a single value, it will complain
and exit with an error if it finds multiple instances of
that value. This is unlike the usual internal config
parsing, however, which will generally overwrite previous
values, leaving only the final one. For example:
[set a multivar]
$ git config user.email one@example.com
$ git config --add user.email two@example.com
[use the internal parser to fetch it]
$ git var GIT_AUTHOR_IDENT
Your Name <two@example.com> ...
[use git-config to fetch it]
$ git config user.email
one@example.com
error: More than one value for the key user.email: two@example.com
This overwriting behavior is critical for the regular
parser, which starts with the lowest-priority file (e.g.,
/etc/gitconfig) and proceeds to the highest-priority file
($GIT_DIR/config). Overwriting yields the highest priority
value at the end.
Git-config solves this problem by implementing its own
parsing. It goes from highest to lowest priorty, but does
not proceed to the next file if it has seen a value.
So in practice, this distinction never mattered much,
because it only triggered for values in the same file. And
there was not much point in doing that; the real value is in
overwriting values from lower-priority files.
However, this changed with the implementation of config
include files. Now we might see an include overriding a
value from the parent file, which is a sensible thing to do,
but git-config will flag as a duplication.
This patch drops the duplicate detection for git-config and
switches to a pure-overwrite model (for the single case;
--get-all can still be used if callers want to do something
more fancy).
As is shown by the modifications to the test suite, this is
a user-visible change in behavior. An alternative would be
to just change the include case, but this is much cleaner
for a few reasons:
1. If you change the include case, then to what? If you
just stop parsing includes after getting a value, then
you will get a _different_ answer than the regular
config parser (you'll get the first value instead of
the last value). So you'd want to implement overwrite
semantics anyway.
2. Even though it is a change in behavior for git-config,
it is bringing us in line with what the internal
parsers already do.
3. The file-order reimplementation is the only thing
keeping us from sharing more code with the internal
config parser, which will help keep differences to a
minimum.
Going under the assumption that the primary purpose of
git-config is to behave identically to how git's internal
parsing works, this change can be seen as a bug-fix.
Signed-off-by: Jeff King <peff@peff.net>
2012-10-23 22:52:44 +02:00
|
|
|
ret = !values.nr;
|
config: add include directive
It can be useful to split your ~/.gitconfig across multiple
files. For example, you might have a "main" file which is
used on many machines, but a small set of per-machine
tweaks. Or you may want to make some of your config public
(e.g., clever aliases) while keeping other data back (e.g.,
your name or other identifying information). Or you may want
to include a number of config options in some subset of your
repos without copying and pasting (e.g., you want to
reference them from the .git/config of participating repos).
This patch introduces an include directive for config files.
It looks like:
[include]
path = /path/to/file
This is syntactically backwards-compatible with existing git
config parsers (i.e., they will see it as another config
entry and ignore it unless you are looking up include.path).
The implementation provides a "git_config_include" callback
which wraps regular config callbacks. Callers can pass it to
git_config_from_file, and it will transparently follow any
include directives, passing all of the discovered options to
the real callback.
Include directives are turned on automatically for "regular"
git config parsing. This includes calls to git_config, as
well as calls to the "git config" program that do not
specify a single file (e.g., using "-f", "--global", etc).
They are not turned on in other cases, including:
1. Parsing of other config-like files, like .gitmodules.
There isn't a real need, and I'd rather be conservative
and avoid unnecessary incompatibility or confusion.
2. Reading single files via "git config". This is for two
reasons:
a. backwards compatibility with scripts looking at
config-like files.
b. inspection of a specific file probably means you
care about just what's in that file, not a general
lookup for "do we have this value anywhere at
all". If that is not the case, the caller can
always specify "--includes".
3. Writing files via "git config"; we want to treat
include.* variables as literal items to be copied (or
modified), and not expand them. So "git config
--unset-all foo.bar" would operate _only_ on
.git/config, not any of its included files (just as it
also does not operate on ~/.gitconfig).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-06 10:54:04 +01:00
|
|
|
|
2012-10-23 21:51:50 +02:00
|
|
|
for (i = 0; i < values.nr; i++) {
|
|
|
|
struct strbuf *buf = values.items + i;
|
git-config: do not complain about duplicate entries
If git-config is asked for a single value, it will complain
and exit with an error if it finds multiple instances of
that value. This is unlike the usual internal config
parsing, however, which will generally overwrite previous
values, leaving only the final one. For example:
[set a multivar]
$ git config user.email one@example.com
$ git config --add user.email two@example.com
[use the internal parser to fetch it]
$ git var GIT_AUTHOR_IDENT
Your Name <two@example.com> ...
[use git-config to fetch it]
$ git config user.email
one@example.com
error: More than one value for the key user.email: two@example.com
This overwriting behavior is critical for the regular
parser, which starts with the lowest-priority file (e.g.,
/etc/gitconfig) and proceeds to the highest-priority file
($GIT_DIR/config). Overwriting yields the highest priority
value at the end.
Git-config solves this problem by implementing its own
parsing. It goes from highest to lowest priorty, but does
not proceed to the next file if it has seen a value.
So in practice, this distinction never mattered much,
because it only triggered for values in the same file. And
there was not much point in doing that; the real value is in
overwriting values from lower-priority files.
However, this changed with the implementation of config
include files. Now we might see an include overriding a
value from the parent file, which is a sensible thing to do,
but git-config will flag as a duplication.
This patch drops the duplicate detection for git-config and
switches to a pure-overwrite model (for the single case;
--get-all can still be used if callers want to do something
more fancy).
As is shown by the modifications to the test suite, this is
a user-visible change in behavior. An alternative would be
to just change the include case, but this is much cleaner
for a few reasons:
1. If you change the include case, then to what? If you
just stop parsing includes after getting a value, then
you will get a _different_ answer than the regular
config parser (you'll get the first value instead of
the last value). So you'd want to implement overwrite
semantics anyway.
2. Even though it is a change in behavior for git-config,
it is bringing us in line with what the internal
parsers already do.
3. The file-order reimplementation is the only thing
keeping us from sharing more code with the internal
config parser, which will help keep differences to a
minimum.
Going under the assumption that the primary purpose of
git-config is to behave identically to how git's internal
parsing works, this change can be seen as a bug-fix.
Signed-off-by: Jeff King <peff@peff.net>
2012-10-23 22:52:44 +02:00
|
|
|
if (do_all || i == values.nr - 1)
|
|
|
|
fwrite(buf->buf, 1, buf->len, stdout);
|
2012-10-23 21:51:50 +02:00
|
|
|
strbuf_release(buf);
|
|
|
|
}
|
|
|
|
free(values.items);
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 01:48:03 +02:00
|
|
|
|
2012-10-23 21:40:06 +02:00
|
|
|
free_strings:
|
2005-11-20 06:52:22 +01:00
|
|
|
free(key);
|
2024-05-15 08:42:53 +02:00
|
|
|
if (data.key_regexp) {
|
|
|
|
regfree(data.key_regexp);
|
|
|
|
free(data.key_regexp);
|
2012-10-23 21:36:12 +02:00
|
|
|
}
|
2024-05-15 08:42:49 +02:00
|
|
|
if (data.regexp) {
|
|
|
|
regfree(data.regexp);
|
|
|
|
free(data.regexp);
|
2005-11-20 06:52:22 +01:00
|
|
|
}
|
|
|
|
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 01:48:03 +02:00
|
|
|
return ret;
|
2005-11-20 06:52:22 +01:00
|
|
|
}
|
2005-11-17 22:44:55 +01:00
|
|
|
|
config: pass kvi to die_bad_number()
Plumb "struct key_value_info" through all code paths that end in
die_bad_number(), which lets us remove the helper functions that read
analogous values from "struct config_reader". As a result, nothing reads
config_reader.config_kvi any more, so remove that too.
In config.c, this requires changing the signature of
git_configset_get_value() to 'return' "kvi" in an out parameter so that
git_configset_get_<type>() can pass it to git_config_<type>(). Only
numeric types will use "kvi", so for non-numeric types (e.g.
git_configset_get_string()), pass NULL to indicate that the out
parameter isn't needed.
Outside of config.c, config callbacks now need to pass "ctx->kvi" to any
of the git_config_<type>() functions that parse a config string into a
number type. Included is a .cocci patch to make that refactor.
The only exceptional case is builtin/config.c, where git_config_<type>()
is called outside of a config callback (namely, on user-provided input),
so config source information has never been available. In this case,
die_bad_number() defaults to a generic, but perfectly descriptive
message. Let's provide a safe, non-NULL for "kvi" anyway, but make sure
not to change the message.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:27 +02:00
|
|
|
static char *normalize_value(const char *key, const char *value,
|
2024-05-15 08:42:25 +02:00
|
|
|
int type, struct key_value_info *kvi)
|
2007-06-25 16:00:24 +02:00
|
|
|
{
|
|
|
|
if (!value)
|
|
|
|
return NULL;
|
|
|
|
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:46:54 +02:00
|
|
|
if (type == 0 || type == TYPE_PATH || type == TYPE_EXPIRY_DATE)
|
2009-12-30 17:51:53 +01:00
|
|
|
/*
|
|
|
|
* We don't do normalization for TYPE_PATH here: If
|
|
|
|
* the path is like ~/foobar/, we prefer to store
|
|
|
|
* "~/foobar/" in the config file, and to expand the ~
|
|
|
|
* when retrieving the value.
|
2017-11-18 03:27:27 +01:00
|
|
|
* Also don't do normalization for expiry dates.
|
2009-12-30 17:51:53 +01:00
|
|
|
*/
|
2015-09-24 23:07:05 +02:00
|
|
|
return xstrdup(value);
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:46:54 +02:00
|
|
|
if (type == TYPE_INT)
|
config: pass kvi to die_bad_number()
Plumb "struct key_value_info" through all code paths that end in
die_bad_number(), which lets us remove the helper functions that read
analogous values from "struct config_reader". As a result, nothing reads
config_reader.config_kvi any more, so remove that too.
In config.c, this requires changing the signature of
git_configset_get_value() to 'return' "kvi" in an out parameter so that
git_configset_get_<type>() can pass it to git_config_<type>(). Only
numeric types will use "kvi", so for non-numeric types (e.g.
git_configset_get_string()), pass NULL to indicate that the out
parameter isn't needed.
Outside of config.c, config callbacks now need to pass "ctx->kvi" to any
of the git_config_<type>() functions that parse a config string into a
number type. Included is a .cocci patch to make that refactor.
The only exceptional case is builtin/config.c, where git_config_<type>()
is called outside of a config callback (namely, on user-provided input),
so config source information has never been available. In this case,
die_bad_number() defaults to a generic, but perfectly descriptive
message. Let's provide a safe, non-NULL for "kvi" anyway, but make sure
not to change the message.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:27 +02:00
|
|
|
return xstrfmt("%"PRId64, git_config_int64(key, value, kvi));
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:46:54 +02:00
|
|
|
if (type == TYPE_BOOL)
|
2015-09-24 23:07:05 +02:00
|
|
|
return xstrdup(git_config_bool(key, value) ? "true" : "false");
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:46:54 +02:00
|
|
|
if (type == TYPE_BOOL_OR_INT) {
|
2015-09-24 23:07:05 +02:00
|
|
|
int is_bool, v;
|
config: pass kvi to die_bad_number()
Plumb "struct key_value_info" through all code paths that end in
die_bad_number(), which lets us remove the helper functions that read
analogous values from "struct config_reader". As a result, nothing reads
config_reader.config_kvi any more, so remove that too.
In config.c, this requires changing the signature of
git_configset_get_value() to 'return' "kvi" in an out parameter so that
git_configset_get_<type>() can pass it to git_config_<type>(). Only
numeric types will use "kvi", so for non-numeric types (e.g.
git_configset_get_string()), pass NULL to indicate that the out
parameter isn't needed.
Outside of config.c, config callbacks now need to pass "ctx->kvi" to any
of the git_config_<type>() functions that parse a config string into a
number type. Included is a .cocci patch to make that refactor.
The only exceptional case is builtin/config.c, where git_config_<type>()
is called outside of a config callback (namely, on user-provided input),
so config source information has never been available. In this case,
die_bad_number() defaults to a generic, but perfectly descriptive
message. Let's provide a safe, non-NULL for "kvi" anyway, but make sure
not to change the message.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:27 +02:00
|
|
|
v = git_config_bool_or_int(key, value, kvi, &is_bool);
|
2015-09-24 23:07:05 +02:00
|
|
|
if (!is_bool)
|
|
|
|
return xstrfmt("%d", v);
|
|
|
|
else
|
|
|
|
return xstrdup(v ? "true" : "false");
|
2007-06-25 16:00:24 +02:00
|
|
|
}
|
2020-05-07 01:31:14 +02:00
|
|
|
if (type == TYPE_BOOL_OR_STR) {
|
|
|
|
int v = git_parse_maybe_bool(value);
|
|
|
|
if (v < 0)
|
|
|
|
return xstrdup(value);
|
|
|
|
else
|
|
|
|
return xstrdup(v ? "true" : "false");
|
|
|
|
}
|
2018-04-10 02:18:31 +02:00
|
|
|
if (type == TYPE_COLOR) {
|
|
|
|
char v[COLOR_MAXLEN];
|
|
|
|
if (git_config_color(v, key, value))
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("cannot parse color '%s'"), value);
|
2018-04-10 02:18:31 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The contents of `v` now contain an ANSI escape
|
|
|
|
* sequence, not suitable for including within a
|
|
|
|
* configuration file. Treat the above as a
|
|
|
|
* "sanity-check", and return the given value, which we
|
|
|
|
* know is representable as valid color code.
|
|
|
|
*/
|
|
|
|
return xstrdup(value);
|
|
|
|
}
|
2007-06-25 16:00:24 +02:00
|
|
|
|
2018-05-30 07:04:07 +02:00
|
|
|
BUG("cannot normalize type %d", type);
|
2007-06-25 16:00:24 +02:00
|
|
|
}
|
|
|
|
|
2007-11-28 07:41:05 +01:00
|
|
|
static int get_color_found;
|
|
|
|
static const char *get_color_slot;
|
2009-02-21 01:48:56 +01:00
|
|
|
static const char *get_colorbool_slot;
|
2007-11-28 07:41:05 +01:00
|
|
|
static char parsed_color[COLOR_MAXLEN];
|
|
|
|
|
2022-08-19 12:08:44 +02:00
|
|
|
static int git_get_color_config(const char *var, const char *value,
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:22 +02:00
|
|
|
const struct config_context *ctx UNUSED,
|
2022-08-25 19:09:48 +02:00
|
|
|
void *cb UNUSED)
|
2007-11-28 07:41:05 +01:00
|
|
|
{
|
|
|
|
if (!strcmp(var, get_color_slot)) {
|
2008-02-11 19:48:12 +01:00
|
|
|
if (!value)
|
|
|
|
config_error_nonbool(var);
|
2014-10-07 21:33:09 +02:00
|
|
|
if (color_parse(value, parsed_color) < 0)
|
|
|
|
return -1;
|
2007-11-28 07:41:05 +01:00
|
|
|
get_color_found = 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static void get_color(const struct config_location_options *opts,
|
|
|
|
const char *var, const char *def_color)
|
2007-11-28 07:41:05 +01:00
|
|
|
{
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 16:15:51 +01:00
|
|
|
get_color_slot = var;
|
2007-11-28 07:41:05 +01:00
|
|
|
get_color_found = 0;
|
|
|
|
parsed_color[0] = '\0';
|
2017-06-14 20:07:39 +02:00
|
|
|
config_with_options(git_get_color_config, NULL,
|
2024-05-15 08:42:16 +02:00
|
|
|
&opts->source, the_repository,
|
|
|
|
&opts->options);
|
2007-11-28 07:41:05 +01:00
|
|
|
|
2014-10-07 21:33:09 +02:00
|
|
|
if (!get_color_found && def_color) {
|
|
|
|
if (color_parse(def_color, parsed_color) < 0)
|
|
|
|
die(_("unable to parse default color value"));
|
|
|
|
}
|
2007-11-28 07:41:05 +01:00
|
|
|
|
|
|
|
fputs(parsed_color, stdout);
|
|
|
|
}
|
|
|
|
|
2007-12-06 02:26:11 +01:00
|
|
|
static int get_colorbool_found;
|
2007-12-06 07:12:07 +01:00
|
|
|
static int get_diff_color_found;
|
config: refactor get_colorbool function
For "git config --get-colorbool color.foo", we use a custom
callback that looks not only for the key that the user gave
us, but also for "diff.color" (for backwards compatibility)
and "color.ui" (as a fallback).
For the former, we use a custom variable to store the
diff.color value. For the latter, though, we store it in the
main "git_use_color_default" variable, turning on color.ui
for any other parts of git that respect this value.
In practice, this doesn't cause any bugs, because git-config
runs without caring about git_use_color_default, and then
exits. But it crosses module boundaries in an unusual and
confusing way, and it makes refactoring color handling
harder than it needs to be.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 07:04:56 +02:00
|
|
|
static int get_color_ui_found;
|
2008-05-14 19:46:53 +02:00
|
|
|
static int git_get_colorbool_config(const char *var, const char *value,
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:22 +02:00
|
|
|
const struct config_context *ctx UNUSED,
|
2022-08-25 19:09:48 +02:00
|
|
|
void *data UNUSED)
|
2007-12-06 02:26:11 +01:00
|
|
|
{
|
2011-08-18 07:03:48 +02:00
|
|
|
if (!strcmp(var, get_colorbool_slot))
|
|
|
|
get_colorbool_found = git_config_colorbool(var, value);
|
|
|
|
else if (!strcmp(var, "diff.color"))
|
|
|
|
get_diff_color_found = git_config_colorbool(var, value);
|
|
|
|
else if (!strcmp(var, "color.ui"))
|
config: refactor get_colorbool function
For "git config --get-colorbool color.foo", we use a custom
callback that looks not only for the key that the user gave
us, but also for "diff.color" (for backwards compatibility)
and "color.ui" (as a fallback).
For the former, we use a custom variable to store the
diff.color value. For the latter, though, we store it in the
main "git_use_color_default" variable, turning on color.ui
for any other parts of git that respect this value.
In practice, this doesn't cause any bugs, because git-config
runs without caring about git_use_color_default, and then
exits. But it crosses module boundaries in an unusual and
confusing way, and it makes refactoring color handling
harder than it needs to be.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 07:04:56 +02:00
|
|
|
get_color_ui_found = git_config_colorbool(var, value);
|
2007-12-06 02:26:11 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static int get_colorbool(const struct config_location_options *opts,
|
|
|
|
const char *var, int print)
|
2007-12-06 02:26:11 +01:00
|
|
|
{
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 16:15:51 +01:00
|
|
|
get_colorbool_slot = var;
|
2007-12-06 07:12:07 +01:00
|
|
|
get_colorbool_found = -1;
|
|
|
|
get_diff_color_found = -1;
|
2013-05-15 19:00:55 +02:00
|
|
|
get_color_ui_found = -1;
|
2017-06-14 20:07:39 +02:00
|
|
|
config_with_options(git_get_colorbool_config, NULL,
|
2024-05-15 08:42:16 +02:00
|
|
|
&opts->source, the_repository,
|
|
|
|
&opts->options);
|
2007-12-06 02:26:11 +01:00
|
|
|
|
2007-12-06 07:12:07 +01:00
|
|
|
if (get_colorbool_found < 0) {
|
2009-02-21 01:48:56 +01:00
|
|
|
if (!strcmp(get_colorbool_slot, "color.diff"))
|
2007-12-06 07:12:07 +01:00
|
|
|
get_colorbool_found = get_diff_color_found;
|
|
|
|
if (get_colorbool_found < 0)
|
config: refactor get_colorbool function
For "git config --get-colorbool color.foo", we use a custom
callback that looks not only for the key that the user gave
us, but also for "diff.color" (for backwards compatibility)
and "color.ui" (as a fallback).
For the former, we use a custom variable to store the
diff.color value. For the latter, though, we store it in the
main "git_use_color_default" variable, turning on color.ui
for any other parts of git that respect this value.
In practice, this doesn't cause any bugs, because git-config
runs without caring about git_use_color_default, and then
exits. But it crosses module boundaries in an unusual and
confusing way, and it makes refactoring color handling
harder than it needs to be.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 07:04:56 +02:00
|
|
|
get_colorbool_found = get_color_ui_found;
|
2007-12-06 07:12:07 +01:00
|
|
|
}
|
|
|
|
|
2013-05-15 19:00:55 +02:00
|
|
|
if (get_colorbool_found < 0)
|
|
|
|
/* default value if none found in config */
|
make color.ui default to 'auto'
Most users seem to like having colors enabled, and colors can help
beginners to understand the output of some commands (e.g. notice
immediately the boundary between commits in the output of "git log").
Many tutorials tell the users to set color.ui=auto as a very first step,
which tend to indicate that color.ui=none is not the recommanded value,
hence should not be the default.
These tutorials would benefit from skipping this step and starting the
real Git manipulations earlier. Other beginners do not know about
color.ui=auto, and may not discover it by themselves, hence live with
black&white outputs while they may have preferred colors.
A few people (e.g. color-blind) prefer having no colors, but they can
easily set color.ui=never for this (and googling "disable colors in git"
already tells them how to do so), but this needs not occupy space in
beginner-oriented documentations.
A transition period with Git emitting a warning when color.ui is unset
would be possible, but the discomfort of having the warning seems
superior to the benefit: users may be surprised by the change, but not
harmed by it.
The default value is changed, and the documentation is reworded to
mention "color.ui=false" first, since the primary use of color.ui after
this change is to disable colors, not to enable it.
Signed-off-by: Matthieu Moy <Matthieu.Moy@imag.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-10 16:26:09 +02:00
|
|
|
get_colorbool_found = GIT_COLOR_AUTO;
|
2013-05-15 19:00:55 +02:00
|
|
|
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 07:04:23 +02:00
|
|
|
get_colorbool_found = want_color(get_colorbool_found);
|
|
|
|
|
2009-02-21 01:48:57 +01:00
|
|
|
if (print) {
|
2007-12-06 02:26:11 +01:00
|
|
|
printf("%s\n", get_colorbool_found ? "true" : "false");
|
|
|
|
return 0;
|
2009-02-21 01:48:57 +01:00
|
|
|
} else
|
|
|
|
return get_colorbool_found ? 0 : 1;
|
2007-12-06 02:26:11 +01:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static void check_write(const struct git_config_source *source)
|
2013-07-12 00:46:47 +02:00
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
if (!source->file && !startup_info->have_repository)
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("not in a git directory"));
|
2016-02-24 13:48:11 +01:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
if (source->use_stdin)
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("writing to stdin is not supported"));
|
2014-02-18 23:58:55 +01:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
if (source->blob)
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("writing config blobs is not supported"));
|
2013-07-12 00:46:47 +02:00
|
|
|
}
|
|
|
|
|
2013-07-31 20:14:59 +02:00
|
|
|
struct urlmatch_current_candidate_value {
|
|
|
|
char value_is_null;
|
|
|
|
struct strbuf value;
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
struct key_value_info kvi;
|
2013-07-31 20:14:59 +02:00
|
|
|
};
|
|
|
|
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:22 +02:00
|
|
|
static int urlmatch_collect_fn(const char *var, const char *value,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const struct config_context *ctx,
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:22 +02:00
|
|
|
void *cb)
|
2013-07-31 20:14:59 +02:00
|
|
|
{
|
|
|
|
struct string_list *values = cb;
|
|
|
|
struct string_list_item *item = string_list_insert(values, var);
|
|
|
|
struct urlmatch_current_candidate_value *matched = item->util;
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
const struct key_value_info *kvi = ctx->kvi;
|
2013-07-31 20:14:59 +02:00
|
|
|
|
|
|
|
if (!matched) {
|
|
|
|
matched = xmalloc(sizeof(*matched));
|
|
|
|
strbuf_init(&matched->value, 0);
|
|
|
|
item->util = matched;
|
|
|
|
} else {
|
|
|
|
strbuf_reset(&matched->value);
|
|
|
|
}
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
matched->kvi = *kvi;
|
2013-07-31 20:14:59 +02:00
|
|
|
|
|
|
|
if (value) {
|
|
|
|
strbuf_addstr(&matched->value, value);
|
|
|
|
matched->value_is_null = 0;
|
|
|
|
} else {
|
|
|
|
matched->value_is_null = 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static int get_urlmatch(const struct config_location_options *opts,
|
2024-05-15 08:42:21 +02:00
|
|
|
const struct config_display_options *_display_opts,
|
2024-05-15 08:42:16 +02:00
|
|
|
const char *var, const char *url)
|
2013-07-31 20:14:59 +02:00
|
|
|
{
|
2016-02-28 12:54:35 +01:00
|
|
|
int ret;
|
2013-07-31 20:14:59 +02:00
|
|
|
char *section_tail;
|
2024-05-15 08:42:21 +02:00
|
|
|
struct config_display_options display_opts = *_display_opts;
|
2013-07-31 20:14:59 +02:00
|
|
|
struct string_list_item *item;
|
2021-10-01 12:27:33 +02:00
|
|
|
struct urlmatch_config config = URLMATCH_CONFIG_INIT;
|
2013-07-31 20:14:59 +02:00
|
|
|
struct string_list values = STRING_LIST_INIT_DUP;
|
|
|
|
|
|
|
|
config.collect_fn = urlmatch_collect_fn;
|
|
|
|
config.cascade_fn = NULL;
|
|
|
|
config.cb = &values;
|
|
|
|
|
|
|
|
if (!url_normalize(url, &config.url))
|
2013-08-09 06:41:44 +02:00
|
|
|
die("%s", config.url.err);
|
2013-07-31 20:14:59 +02:00
|
|
|
|
2014-05-22 11:44:09 +02:00
|
|
|
config.section = xstrdup_tolower(var);
|
2013-07-31 20:14:59 +02:00
|
|
|
section_tail = strchr(config.section, '.');
|
|
|
|
if (section_tail) {
|
|
|
|
*section_tail = '\0';
|
|
|
|
config.key = section_tail + 1;
|
2024-05-15 08:42:21 +02:00
|
|
|
display_opts.show_keys = 0;
|
2013-07-31 20:14:59 +02:00
|
|
|
} else {
|
|
|
|
config.key = NULL;
|
2024-05-15 08:42:21 +02:00
|
|
|
display_opts.show_keys = 1;
|
2013-07-31 20:14:59 +02:00
|
|
|
}
|
|
|
|
|
2017-06-14 20:07:39 +02:00
|
|
|
config_with_options(urlmatch_config_entry, &config,
|
2024-05-15 08:42:16 +02:00
|
|
|
&opts->source, the_repository,
|
|
|
|
&opts->options);
|
2013-07-31 20:14:59 +02:00
|
|
|
|
2016-02-28 12:54:35 +01:00
|
|
|
ret = !values.nr;
|
|
|
|
|
2013-07-31 20:14:59 +02:00
|
|
|
for_each_string_list_item(item, &values) {
|
|
|
|
struct urlmatch_current_candidate_value *matched = item->util;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
format_config(&display_opts, &buf, item->string,
|
config.c: pass ctx with CLI config
Pass config_context when parsing CLI config. To provide the .kvi member,
refactor out kvi_from_param() from the logic that caches CLI config in
configsets. Now that config_context and config_context.kvi is always
present when config machinery calls config callbacks, plumb "kvi" so
that we can remove all calls of current_config_scope() except for
trace2/*.c (which will be handled in a later commit), and remove all
other current_config_*() (the functions themselves and their calls).
Note that this results in .kvi containing a different, more complete
set of information than the mocked up "struct config_source" in
git_config_from_parameters().
Plumbing "kvi" reveals a few places where we've been doing the wrong
thing:
* git_config_parse_parameter() hasn't been setting config source
information, so plumb "kvi" there too.
* Several sites in builtin/config.c have been calling current_config_*()
functions outside of config callbacks (indirectly, via the
format_config() helper), which means they're reading state that isn't
set correctly:
* "git config --get-urlmatch --show-scope" iterates config to collect
values, but then attempts to display the scope after config
iteration, causing the "unknown" scope to be shown instead of the
config file's scope. It's clear that this wasn't intended: we knew
that "--get-urlmatch" couldn't show config source metadata, which is
why "--show-origin" was marked incompatible with "--get-urlmatch"
when it was introduced [1]. It was most likely a mistake that we
allowed "--show-scope" to sneak through.
Fix this by copying the "kvi" value in the collection phase so that
it can be read back later. This means that we can now support "git
config --get-urlmatch --show-origin", but that is left unchanged
for now.
* "git config --default" doesn't have config source metadata when
displaying the default value, so "--show-scope" also results in
"unknown", and "--show-origin" results in a BUG(). Fix this by
treating the default value as if it came from the command line (e.g.
like we do with "git -c" or "git config --file"), using
kvi_from_param().
[1] https://lore.kernel.org/git/20160205112001.GA13397@sigill.intra.peff.net/
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 21:26:25 +02:00
|
|
|
matched->value_is_null ? NULL : matched->value.buf,
|
|
|
|
&matched->kvi);
|
2013-07-31 20:14:59 +02:00
|
|
|
fwrite(buf.buf, 1, buf.len, stdout);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
strbuf_release(&matched->value);
|
|
|
|
}
|
2022-03-04 19:32:07 +01:00
|
|
|
urlmatch_config_release(&config);
|
2013-07-31 20:14:59 +02:00
|
|
|
string_list_clear(&values, 1);
|
|
|
|
free(config.url.url);
|
|
|
|
|
|
|
|
free((void *)config.section);
|
2016-02-28 12:54:35 +01:00
|
|
|
return ret;
|
2013-07-31 20:14:59 +02:00
|
|
|
}
|
|
|
|
|
2014-07-25 21:11:34 +02:00
|
|
|
static char *default_user_config(void)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_addf(&buf,
|
|
|
|
_("# This is Git's per-user configuration file.\n"
|
2015-04-17 16:50:10 +02:00
|
|
|
"[user]\n"
|
2014-07-25 21:11:34 +02:00
|
|
|
"# Please adapt and uncomment the following lines:\n"
|
2015-04-17 16:50:10 +02:00
|
|
|
"# name = %s\n"
|
2014-07-25 21:11:34 +02:00
|
|
|
"# email = %s\n"),
|
|
|
|
ident_default_name(),
|
|
|
|
ident_default_email());
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static void location_options_init(struct config_location_options *opts,
|
|
|
|
const char *prefix)
|
2024-05-06 10:56:00 +02:00
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
if (!opts->source.file)
|
|
|
|
opts->source.file = opts->file_to_free =
|
|
|
|
xstrdup_or_null(getenv(CONFIG_ENVIRONMENT));
|
|
|
|
|
|
|
|
if (opts->use_global_config + opts->use_system_config +
|
|
|
|
opts->use_local_config + opts->use_worktree_config +
|
|
|
|
!!opts->source.file + !!opts->source.blob > 1) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("only one config file at a time"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2009-02-21 01:49:26 +01:00
|
|
|
}
|
|
|
|
|
2024-05-06 10:56:14 +02:00
|
|
|
if (!startup_info->have_repository) {
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->use_local_config)
|
2020-09-09 15:16:08 +02:00
|
|
|
die(_("--local can only be used inside a git repository"));
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->source.blob)
|
2020-09-09 15:16:08 +02:00
|
|
|
die(_("--blob can only be used inside a git repository"));
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->use_worktree_config)
|
2020-09-09 15:16:08 +02:00
|
|
|
die(_("--worktree can only be used inside a git repository"));
|
|
|
|
}
|
2018-05-19 00:27:04 +02:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->source.file &&
|
|
|
|
!strcmp(opts->source.file, "-")) {
|
|
|
|
opts->source.file = NULL;
|
|
|
|
opts->source.use_stdin = 1;
|
|
|
|
opts->source.scope = CONFIG_SCOPE_COMMAND;
|
2014-02-18 23:58:55 +01:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->use_global_config) {
|
|
|
|
opts->source.file = opts->file_to_free = git_global_config();
|
|
|
|
if (!opts->source.file)
|
2024-01-28 19:31:40 +01:00
|
|
|
/*
|
|
|
|
* It is unknown if HOME/.gitconfig exists, so
|
|
|
|
* we do not know if we should write to XDG
|
|
|
|
* location; error out even if XDG_CONFIG_HOME
|
|
|
|
* is set and points at a sane location.
|
|
|
|
*/
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("$HOME not set"));
|
2024-05-15 08:42:16 +02:00
|
|
|
opts->source.scope = CONFIG_SCOPE_GLOBAL;
|
|
|
|
} else if (opts->use_system_config) {
|
|
|
|
opts->source.file = opts->file_to_free = git_system_config();
|
|
|
|
opts->source.scope = CONFIG_SCOPE_SYSTEM;
|
|
|
|
} else if (opts->use_local_config) {
|
|
|
|
opts->source.file = opts->file_to_free = git_pathdup("config");
|
|
|
|
opts->source.scope = CONFIG_SCOPE_LOCAL;
|
|
|
|
} else if (opts->use_worktree_config) {
|
2020-06-20 01:35:44 +02:00
|
|
|
struct worktree **worktrees = get_worktrees();
|
2023-05-26 03:33:00 +02:00
|
|
|
if (the_repository->repository_format_worktree_config)
|
2024-05-15 08:42:16 +02:00
|
|
|
opts->source.file = opts->file_to_free =
|
|
|
|
git_pathdup("config.worktree");
|
2018-10-21 16:02:28 +02:00
|
|
|
else if (worktrees[0] && worktrees[1])
|
|
|
|
die(_("--worktree cannot be used with multiple "
|
|
|
|
"working trees unless the config\n"
|
|
|
|
"extension worktreeConfig is enabled. "
|
|
|
|
"Please read \"CONFIGURATION FILE\"\n"
|
|
|
|
"section in \"git help worktree\" for details"));
|
|
|
|
else
|
2024-05-15 08:42:16 +02:00
|
|
|
opts->source.file = opts->file_to_free =
|
|
|
|
git_pathdup("config");
|
|
|
|
opts->source.scope = CONFIG_SCOPE_LOCAL;
|
2018-10-21 16:02:28 +02:00
|
|
|
free_worktrees(worktrees);
|
2024-05-15 08:42:16 +02:00
|
|
|
} else if (opts->source.file) {
|
|
|
|
if (!is_absolute_path(opts->source.file) && prefix)
|
|
|
|
opts->source.file = opts->file_to_free =
|
|
|
|
prefix_filename(prefix, opts->source.file);
|
|
|
|
opts->source.scope = CONFIG_SCOPE_COMMAND;
|
|
|
|
} else if (opts->source.blob) {
|
|
|
|
opts->source.scope = CONFIG_SCOPE_COMMAND;
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:35 +02:00
|
|
|
if (opts->respect_includes_opt == -1)
|
2024-05-15 08:42:16 +02:00
|
|
|
opts->options.respect_includes = !opts->source.file;
|
2017-04-17 12:10:00 +02:00
|
|
|
else
|
2024-05-15 08:42:35 +02:00
|
|
|
opts->options.respect_includes = opts->respect_includes_opt;
|
2024-05-06 10:56:14 +02:00
|
|
|
if (startup_info->have_repository) {
|
2024-05-15 08:42:16 +02:00
|
|
|
opts->options.commondir = get_git_common_dir();
|
|
|
|
opts->options.git_dir = get_git_dir();
|
2017-06-14 20:07:39 +02:00
|
|
|
}
|
2024-05-06 10:56:14 +02:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static void location_options_release(struct config_location_options *opts)
|
|
|
|
{
|
|
|
|
free(opts->file_to_free);
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
static void display_options_init(struct config_display_options *opts)
|
|
|
|
{
|
|
|
|
if (opts->end_nul) {
|
|
|
|
opts->term = '\0';
|
|
|
|
opts->delim = '\n';
|
|
|
|
opts->key_delim = '\n';
|
2024-05-06 10:56:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
static int cmd_config_list(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-15 08:42:21 +02:00
|
|
|
struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-15 08:42:21 +02:00
|
|
|
CONFIG_DISPLAY_OPTIONS(display_opts),
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
OPT_GROUP(N_("Other")),
|
2024-05-15 08:42:35 +02:00
|
|
|
OPT_BOOL(0, "includes", &location_opts.respect_includes_opt,
|
|
|
|
N_("respect include directives on lookup")),
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_list_usage, 0);
|
|
|
|
check_argc(argc, 0, 0);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
2024-05-15 08:42:21 +02:00
|
|
|
display_options_init(&display_opts);
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
|
|
|
|
setup_auto_pager("config", 1);
|
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
if (config_with_options(show_all_config, &display_opts,
|
2024-05-15 08:42:16 +02:00
|
|
|
&location_opts.source, the_repository,
|
|
|
|
&location_opts.options) < 0) {
|
|
|
|
if (location_opts.source.file)
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
die_errno(_("unable to read config file '%s'"),
|
2024-05-15 08:42:16 +02:00
|
|
|
location_opts.source.file);
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
else
|
|
|
|
die(_("error processing config file(s)"));
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
builtin/config: introduce "list" subcommand
While git-config(1) has several modes, those modes are not exposed with
subcommands but instead by specifying action flags like `--unset` or
`--list`. This user interface is not really in line with how our more
modern commands work, where it is a lot more customary to say e.g. `git
remote list`. Furthermore, to add to the confusion, git-config(1) also
allows the user to request modes implicitly by just specifying the
correct number of arguments. Thus, `git config foo.bar` will retrieve
the value of "foo.bar" while `git config foo.bar baz` will set it to
"baz".
Overall, this makes for a confusing interface that could really use a
makeover. It hurts discoverability of what you can do with git-config(1)
and is comparatively easy to get wrong. Converting the command to have
subcommands instead would go a long way to help address these issues.
One concern in this context is backwards compatibility. Luckily, we can
introduce subcommands without breaking backwards compatibility at all.
This is because all the implicit modes of git-config(1) require that the
first argument is a properly formatted config key. And as config keys
_must_ have a dot in their name, any value without a dot would have been
discarded by git-config(1) previous to this change. Thus, given that
none of the subcommands do have a dot, they are unambiguous.
Introduce the first such new subcommand, which is "git config list". To
retain backwards compatibility we only conditionally use subcommands and
will fall back to the old syntax in case no subcommand was detected.
This should help to transition to the new-style syntax until we
eventually deprecate and remove the old-style syntax.
Note that the way we handle this we're duplicating some functionality
across old and new syntax. While this isn't pretty, it helps us to
ensure that there really is no change in behaviour for the old syntax.
Amend tests such that we run them both with old and new style syntax.
As tests are now run twice, state from the first run may be still be
around in the second run and thus cause tests to fail. Add cleanup logic
as required to fix such tests.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-05-06 10:56:24 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-05-06 10:56:29 +02:00
|
|
|
static int cmd_config_get(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-15 08:42:21 +02:00
|
|
|
struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;
|
2024-05-06 10:56:29 +02:00
|
|
|
const char *value_pattern = NULL, *url = NULL;
|
|
|
|
int flags = 0;
|
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-06 10:56:29 +02:00
|
|
|
OPT_GROUP(N_("Filter options")),
|
|
|
|
OPT_BOOL(0, "all", &do_all, N_("return all values for multi-valued config options")),
|
|
|
|
OPT_BOOL(0, "regexp", &use_key_regexp, N_("interpret the name as a regular expression")),
|
|
|
|
OPT_STRING(0, "value", &value_pattern, N_("pattern"), N_("show config with values matching the pattern")),
|
|
|
|
OPT_BIT(0, "fixed-value", &flags, N_("use string equality when comparing values to value pattern"), CONFIG_FLAGS_FIXED_VALUE),
|
|
|
|
OPT_STRING(0, "url", &url, N_("URL"), N_("show config matching the given URL")),
|
2024-05-15 08:42:21 +02:00
|
|
|
CONFIG_DISPLAY_OPTIONS(display_opts),
|
2024-05-06 10:56:29 +02:00
|
|
|
OPT_GROUP(N_("Other")),
|
2024-05-15 08:42:35 +02:00
|
|
|
OPT_BOOL(0, "includes", &location_opts.respect_includes_opt,
|
|
|
|
N_("respect include directives on lookup")),
|
2024-05-15 08:42:30 +02:00
|
|
|
OPT_STRING(0, "default", &display_opts.default_value,
|
|
|
|
N_("value"), N_("use default value when missing entry")),
|
2024-05-06 10:56:29 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
2024-05-15 08:42:11 +02:00
|
|
|
int ret;
|
2024-05-06 10:56:29 +02:00
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_get_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
check_argc(argc, 1, 1);
|
|
|
|
|
|
|
|
if ((flags & CONFIG_FLAGS_FIXED_VALUE) && !value_pattern)
|
|
|
|
die(_("--fixed-value only applies with 'value-pattern'"));
|
2024-05-15 08:42:30 +02:00
|
|
|
if (display_opts.default_value && (do_all || url))
|
2024-05-06 10:56:29 +02:00
|
|
|
die(_("--default= cannot be used with --all or --url="));
|
|
|
|
if (url && (do_all || use_key_regexp || value_pattern))
|
|
|
|
die(_("--url= cannot be used with --all, --regexp or --value"));
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
2024-05-15 08:42:21 +02:00
|
|
|
display_options_init(&display_opts);
|
2024-05-06 10:56:29 +02:00
|
|
|
|
|
|
|
setup_auto_pager("config", 1);
|
|
|
|
|
|
|
|
if (url)
|
2024-05-15 08:42:21 +02:00
|
|
|
ret = get_urlmatch(&location_opts, &display_opts, argv[0], url);
|
2024-05-15 08:42:11 +02:00
|
|
|
else
|
2024-05-15 08:42:21 +02:00
|
|
|
ret = get_value(&location_opts, &display_opts, argv[0], value_pattern, flags);
|
2024-05-15 08:42:11 +02:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
2024-05-15 08:42:11 +02:00
|
|
|
return ret;
|
2024-05-06 10:56:29 +02:00
|
|
|
}
|
|
|
|
|
2024-05-06 10:56:33 +02:00
|
|
|
static int cmd_config_set(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-06 10:56:33 +02:00
|
|
|
const char *value_pattern = NULL, *comment_arg = NULL;
|
|
|
|
char *comment = NULL;
|
2024-05-15 08:42:25 +02:00
|
|
|
int flags = 0, append = 0, type = 0;
|
2024-05-06 10:56:33 +02:00
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-15 08:42:25 +02:00
|
|
|
CONFIG_TYPE_OPTIONS(type),
|
2024-05-06 10:56:33 +02:00
|
|
|
OPT_GROUP(N_("Filter")),
|
|
|
|
OPT_BIT(0, "all", &flags, N_("replace multi-valued config option with new value"), CONFIG_FLAGS_MULTI_REPLACE),
|
|
|
|
OPT_STRING(0, "value", &value_pattern, N_("pattern"), N_("show config with values matching the pattern")),
|
|
|
|
OPT_BIT(0, "fixed-value", &flags, N_("use string equality when comparing values to value pattern"), CONFIG_FLAGS_FIXED_VALUE),
|
|
|
|
OPT_GROUP(N_("Other")),
|
|
|
|
OPT_STRING(0, "comment", &comment_arg, N_("value"), N_("human-readable comment string (# will be prepended as needed)")),
|
|
|
|
OPT_BOOL(0, "append", &append, N_("add a new line without altering any existing values")),
|
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
struct key_value_info default_kvi = KVI_INIT;
|
|
|
|
char *value;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_set_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
check_argc(argc, 2, 2);
|
|
|
|
|
|
|
|
if ((flags & CONFIG_FLAGS_FIXED_VALUE) && !value_pattern)
|
|
|
|
die(_("--fixed-value only applies with --value=<pattern>"));
|
|
|
|
if (append && value_pattern)
|
|
|
|
die(_("--append cannot be used with --value=<pattern>"));
|
|
|
|
if (append)
|
|
|
|
value_pattern = CONFIG_REGEX_NONE;
|
|
|
|
|
|
|
|
comment = git_config_prepare_comment_string(comment_arg);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
|
|
|
check_write(&location_opts.source);
|
2024-05-06 10:56:33 +02:00
|
|
|
|
2024-05-15 08:42:25 +02:00
|
|
|
value = normalize_value(argv[0], argv[1], type, &default_kvi);
|
2024-05-06 10:56:33 +02:00
|
|
|
|
|
|
|
if ((flags & CONFIG_FLAGS_MULTI_REPLACE) || value_pattern) {
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
2024-05-06 10:56:33 +02:00
|
|
|
argv[0], value, value_pattern,
|
|
|
|
comment, flags);
|
|
|
|
} else {
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_in_file_gently(location_opts.source.file,
|
2024-05-06 10:56:33 +02:00
|
|
|
argv[0], comment, value);
|
|
|
|
if (ret == CONFIG_NOTHING_SET)
|
|
|
|
error(_("cannot overwrite multiple values with a single value\n"
|
|
|
|
" Use a regexp, --add or --replace-all to change %s."), argv[0]);
|
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
2024-05-06 10:56:33 +02:00
|
|
|
free(comment);
|
|
|
|
free(value);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2024-05-06 10:56:38 +02:00
|
|
|
static int cmd_config_unset(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-06 10:56:38 +02:00
|
|
|
const char *value_pattern = NULL;
|
|
|
|
int flags = 0;
|
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-06 10:56:38 +02:00
|
|
|
OPT_GROUP(N_("Filter")),
|
|
|
|
OPT_BIT(0, "all", &flags, N_("replace multi-valued config option with new value"), CONFIG_FLAGS_MULTI_REPLACE),
|
|
|
|
OPT_STRING(0, "value", &value_pattern, N_("pattern"), N_("show config with values matching the pattern")),
|
|
|
|
OPT_BIT(0, "fixed-value", &flags, N_("use string equality when comparing values to value pattern"), CONFIG_FLAGS_FIXED_VALUE),
|
|
|
|
OPT_END(),
|
|
|
|
};
|
2024-05-15 08:42:11 +02:00
|
|
|
int ret;
|
2024-05-06 10:56:38 +02:00
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_unset_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
check_argc(argc, 1, 1);
|
|
|
|
|
|
|
|
if ((flags & CONFIG_FLAGS_FIXED_VALUE) && !value_pattern)
|
|
|
|
die(_("--fixed-value only applies with 'value-pattern'"));
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
|
|
|
check_write(&location_opts.source);
|
2024-05-06 10:56:38 +02:00
|
|
|
|
|
|
|
if ((flags & CONFIG_FLAGS_MULTI_REPLACE) || value_pattern)
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
2024-05-15 08:42:11 +02:00
|
|
|
argv[0], NULL, value_pattern,
|
|
|
|
NULL, flags);
|
2024-05-06 10:56:38 +02:00
|
|
|
else
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_in_file_gently(location_opts.source.file, argv[0],
|
2024-05-15 08:42:11 +02:00
|
|
|
NULL, NULL);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
2024-05-15 08:42:11 +02:00
|
|
|
return ret;
|
2024-05-06 10:56:38 +02:00
|
|
|
}
|
|
|
|
|
2024-05-06 10:56:43 +02:00
|
|
|
static int cmd_config_rename_section(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-06 10:56:43 +02:00
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-06 10:56:43 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_rename_section_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
check_argc(argc, 2, 2);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
|
|
|
check_write(&location_opts.source);
|
2024-05-06 10:56:43 +02:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_rename_section_in_file(location_opts.source.file,
|
2024-05-06 10:56:43 +02:00
|
|
|
argv[0], argv[1]);
|
|
|
|
if (ret < 0)
|
2024-05-15 08:42:11 +02:00
|
|
|
goto out;
|
2024-05-06 10:56:43 +02:00
|
|
|
else if (!ret)
|
|
|
|
die(_("no such section: %s"), argv[0]);
|
2024-05-15 08:42:11 +02:00
|
|
|
ret = 0;
|
2024-05-06 10:56:43 +02:00
|
|
|
|
2024-05-15 08:42:11 +02:00
|
|
|
out:
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
2024-05-15 08:42:11 +02:00
|
|
|
return ret;
|
2024-05-06 10:56:43 +02:00
|
|
|
}
|
|
|
|
|
2024-05-06 10:56:47 +02:00
|
|
|
static int cmd_config_remove_section(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-06 10:56:47 +02:00
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-06 10:56:47 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_remove_section_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
check_argc(argc, 1, 1);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
|
|
|
check_write(&location_opts.source);
|
2024-05-06 10:56:47 +02:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_rename_section_in_file(location_opts.source.file,
|
2024-05-06 10:56:47 +02:00
|
|
|
argv[0], NULL);
|
|
|
|
if (ret < 0)
|
2024-05-15 08:42:11 +02:00
|
|
|
goto out;
|
2024-05-06 10:56:47 +02:00
|
|
|
else if (!ret)
|
|
|
|
die(_("no such section: %s"), argv[0]);
|
2024-05-15 08:42:11 +02:00
|
|
|
ret = 0;
|
2024-05-06 10:56:47 +02:00
|
|
|
|
2024-05-15 08:42:11 +02:00
|
|
|
out:
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
2024-05-15 08:42:11 +02:00
|
|
|
return ret;
|
2024-05-06 10:56:47 +02:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
static int show_editor(struct config_location_options *opts)
|
2024-05-06 10:56:52 +02:00
|
|
|
{
|
|
|
|
char *config_file;
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
if (!opts->source.file && !startup_info->have_repository)
|
2024-05-06 10:56:52 +02:00
|
|
|
die(_("not in a git directory"));
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->source.use_stdin)
|
2024-05-06 10:56:52 +02:00
|
|
|
die(_("editing stdin is not supported"));
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->source.blob)
|
2024-05-06 10:56:52 +02:00
|
|
|
die(_("editing blobs is not supported"));
|
|
|
|
git_config(git_default_config, NULL);
|
2024-05-15 08:42:16 +02:00
|
|
|
config_file = opts->source.file ?
|
|
|
|
xstrdup(opts->source.file) :
|
2024-05-06 10:56:52 +02:00
|
|
|
git_pathdup("config");
|
2024-05-15 08:42:16 +02:00
|
|
|
if (opts->use_global_config) {
|
2024-05-06 10:56:52 +02:00
|
|
|
int fd = open(config_file, O_CREAT | O_EXCL | O_WRONLY, 0666);
|
|
|
|
if (fd >= 0) {
|
|
|
|
char *content = default_user_config();
|
|
|
|
write_str_in_full(fd, content);
|
|
|
|
free(content);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
else if (errno != EEXIST)
|
|
|
|
die_errno(_("cannot create configuration file %s"), config_file);
|
|
|
|
}
|
|
|
|
launch_editor(config_file, NULL, NULL);
|
|
|
|
free(config_file);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmd_config_edit(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-06 10:56:52 +02:00
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-06 10:56:52 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
2024-05-15 08:42:16 +02:00
|
|
|
int ret;
|
2024-05-06 10:56:52 +02:00
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, opts, builtin_config_edit_usage, 0);
|
|
|
|
check_argc(argc, 0, 0);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
|
|
|
check_write(&location_opts.source);
|
2024-05-06 10:56:52 +02:00
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = show_editor(&location_opts);
|
|
|
|
location_options_release(&location_opts);
|
|
|
|
return ret;
|
2024-05-06 10:56:52 +02:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:41:43 +02:00
|
|
|
static int cmd_config_actions(int argc, const char **argv, const char *prefix)
|
2024-05-06 10:56:14 +02:00
|
|
|
{
|
2024-05-15 08:41:57 +02:00
|
|
|
enum {
|
|
|
|
ACTION_GET = (1<<0),
|
|
|
|
ACTION_GET_ALL = (1<<1),
|
|
|
|
ACTION_GET_REGEXP = (1<<2),
|
|
|
|
ACTION_REPLACE_ALL = (1<<3),
|
|
|
|
ACTION_ADD = (1<<4),
|
|
|
|
ACTION_UNSET = (1<<5),
|
|
|
|
ACTION_UNSET_ALL = (1<<6),
|
|
|
|
ACTION_RENAME_SECTION = (1<<7),
|
|
|
|
ACTION_REMOVE_SECTION = (1<<8),
|
|
|
|
ACTION_LIST = (1<<9),
|
|
|
|
ACTION_EDIT = (1<<10),
|
|
|
|
ACTION_SET = (1<<11),
|
|
|
|
ACTION_SET_ALL = (1<<12),
|
|
|
|
ACTION_GET_COLOR = (1<<13),
|
|
|
|
ACTION_GET_COLORBOOL = (1<<14),
|
|
|
|
ACTION_GET_URLMATCH = (1<<15),
|
|
|
|
};
|
2024-05-15 08:42:16 +02:00
|
|
|
struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;
|
2024-05-15 08:42:21 +02:00
|
|
|
struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;
|
2024-05-15 08:41:52 +02:00
|
|
|
const char *comment_arg = NULL;
|
|
|
|
int actions = 0;
|
|
|
|
struct option opts[] = {
|
2024-05-15 08:42:16 +02:00
|
|
|
CONFIG_LOCATION_OPTIONS(location_opts),
|
2024-05-15 08:41:52 +02:00
|
|
|
OPT_GROUP(N_("Action")),
|
|
|
|
OPT_CMDMODE(0, "get", &actions, N_("get value: name [<value-pattern>]"), ACTION_GET),
|
|
|
|
OPT_CMDMODE(0, "get-all", &actions, N_("get all values: key [<value-pattern>]"), ACTION_GET_ALL),
|
|
|
|
OPT_CMDMODE(0, "get-regexp", &actions, N_("get values for regexp: name-regex [<value-pattern>]"), ACTION_GET_REGEXP),
|
|
|
|
OPT_CMDMODE(0, "get-urlmatch", &actions, N_("get value specific for the URL: section[.var] URL"), ACTION_GET_URLMATCH),
|
|
|
|
OPT_CMDMODE(0, "replace-all", &actions, N_("replace all matching variables: name value [<value-pattern>]"), ACTION_REPLACE_ALL),
|
|
|
|
OPT_CMDMODE(0, "add", &actions, N_("add a new variable: name value"), ACTION_ADD),
|
|
|
|
OPT_CMDMODE(0, "unset", &actions, N_("remove a variable: name [<value-pattern>]"), ACTION_UNSET),
|
|
|
|
OPT_CMDMODE(0, "unset-all", &actions, N_("remove all matches: name [<value-pattern>]"), ACTION_UNSET_ALL),
|
|
|
|
OPT_CMDMODE(0, "rename-section", &actions, N_("rename section: old-name new-name"), ACTION_RENAME_SECTION),
|
|
|
|
OPT_CMDMODE(0, "remove-section", &actions, N_("remove a section: name"), ACTION_REMOVE_SECTION),
|
|
|
|
OPT_CMDMODE('l', "list", &actions, N_("list all"), ACTION_LIST),
|
|
|
|
OPT_CMDMODE('e', "edit", &actions, N_("open an editor"), ACTION_EDIT),
|
|
|
|
OPT_CMDMODE(0, "get-color", &actions, N_("find the color configured: slot [<default>]"), ACTION_GET_COLOR),
|
|
|
|
OPT_CMDMODE(0, "get-colorbool", &actions, N_("find the color setting: slot [<stdout-is-tty>]"), ACTION_GET_COLORBOOL),
|
2024-05-15 08:42:21 +02:00
|
|
|
CONFIG_DISPLAY_OPTIONS(display_opts),
|
2024-05-15 08:41:52 +02:00
|
|
|
OPT_GROUP(N_("Other")),
|
2024-05-15 08:42:30 +02:00
|
|
|
OPT_STRING(0, "default", &display_opts.default_value,
|
|
|
|
N_("value"), N_("with --get, use default value when missing entry")),
|
2024-05-15 08:41:52 +02:00
|
|
|
OPT_STRING(0, "comment", &comment_arg, N_("value"), N_("human-readable comment string (# will be prepended as needed)")),
|
|
|
|
OPT_BOOL(0, "fixed-value", &fixed_value, N_("use string equality when comparing values to 'value-pattern'")),
|
2024-05-15 08:42:35 +02:00
|
|
|
OPT_BOOL(0, "includes", &location_opts.respect_includes_opt,
|
|
|
|
N_("respect include directives on lookup")),
|
2024-05-15 08:41:52 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
2024-05-06 10:56:14 +02:00
|
|
|
char *value = NULL, *comment = NULL;
|
|
|
|
int flags = 0;
|
|
|
|
int ret = 0;
|
|
|
|
struct key_value_info default_kvi = KVI_INIT;
|
|
|
|
|
2024-05-15 08:41:52 +02:00
|
|
|
argc = parse_options(argc, argv, prefix, opts,
|
2024-05-06 10:56:14 +02:00
|
|
|
builtin_config_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_init(&location_opts, prefix);
|
2024-05-15 08:42:21 +02:00
|
|
|
display_options_init(&display_opts);
|
2009-02-21 01:49:25 +01:00
|
|
|
|
2024-05-15 08:42:25 +02:00
|
|
|
if ((actions & (ACTION_GET_COLOR|ACTION_GET_COLORBOOL)) && display_opts.type) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("--get-color and variable type are incoherent"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2009-02-21 01:49:29 +01:00
|
|
|
}
|
|
|
|
|
2009-02-21 01:49:25 +01:00
|
|
|
if (actions == 0)
|
|
|
|
switch (argc) {
|
|
|
|
case 1: actions = ACTION_GET; break;
|
|
|
|
case 2: actions = ACTION_SET; break;
|
|
|
|
case 3: actions = ACTION_SET_ALL; break;
|
|
|
|
default:
|
2024-05-15 08:41:38 +02:00
|
|
|
error(_("no action specified"));
|
|
|
|
exit(129);
|
2007-06-25 16:00:24 +02:00
|
|
|
}
|
2024-05-15 08:42:21 +02:00
|
|
|
if (display_opts.omit_values &&
|
2015-08-10 11:46:06 +02:00
|
|
|
!(actions == ACTION_LIST || actions == ACTION_GET_REGEXP)) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("--name-only is only applicable to --list or --get-regexp"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2015-08-10 11:46:06 +02:00
|
|
|
}
|
2016-02-19 10:16:02 +01:00
|
|
|
|
2024-05-15 08:42:21 +02:00
|
|
|
if (display_opts.show_origin && !(actions &
|
2016-02-19 10:16:02 +01:00
|
|
|
(ACTION_GET|ACTION_GET_ALL|ACTION_GET_REGEXP|ACTION_LIST))) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("--show-origin is only applicable to --get, --get-all, "
|
|
|
|
"--get-regexp, and --list"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2016-02-19 10:16:02 +01:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:30 +02:00
|
|
|
if (display_opts.default_value && !(actions & ACTION_GET)) {
|
2018-07-21 09:49:22 +02:00
|
|
|
error(_("--default is only applicable to --get"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 02:18:26 +02:00
|
|
|
}
|
|
|
|
|
2024-05-06 10:55:56 +02:00
|
|
|
if (comment_arg &&
|
config: fix --comment formatting
When git adds comments itself (like "rebase -i" todo list and
"commit -e" log message editor), it always gives a comment
introducer "#" followed by a Space before the message, except for
the recently introduced "git config --comment", where the users are
forced to say " this is my comment" if they want to add their
comment in this usual format; otherwise their comment string will
end up without a space after the "#".
Make it more ergonomic, while keeping it possible to also use this
unusual style, by massaging the comment string at the UI layer with
a set of simple rules:
* If the given comment string begins with '#', it is passed intact.
* Otherwise, "# " is prefixed.
* A string with LF in it cannot be used as a comment string.
Right now there is only one "front-end" that accepts end-user
comment string and calls the underlying machinery to add or modify
configuration file with comments, but to make sure that the future
callers perform similar massaging as they see fit, add a sanity
check logic in git_config_set_multivar_in_file_gently(), which is
the single choke point in the codepaths that consumes the comment
string.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-03-15 20:43:58 +01:00
|
|
|
!(actions & (ACTION_ADD|ACTION_SET|ACTION_SET_ALL|ACTION_REPLACE_ALL))) {
|
|
|
|
error(_("--comment is only applicable to add/set/replace operations"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2024-03-12 22:47:00 +01:00
|
|
|
}
|
|
|
|
|
2020-11-25 23:12:53 +01:00
|
|
|
/* check usage of --fixed-value */
|
|
|
|
if (fixed_value) {
|
|
|
|
int allowed_usage = 0;
|
|
|
|
|
|
|
|
switch (actions) {
|
|
|
|
/* git config --get <name> <value-pattern> */
|
|
|
|
case ACTION_GET:
|
|
|
|
/* git config --get-all <name> <value-pattern> */
|
|
|
|
case ACTION_GET_ALL:
|
|
|
|
/* git config --get-regexp <name-pattern> <value-pattern> */
|
|
|
|
case ACTION_GET_REGEXP:
|
|
|
|
/* git config --unset <name> <value-pattern> */
|
|
|
|
case ACTION_UNSET:
|
|
|
|
/* git config --unset-all <name> <value-pattern> */
|
|
|
|
case ACTION_UNSET_ALL:
|
|
|
|
allowed_usage = argc > 1 && !!argv[1];
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* git config <name> <value> <value-pattern> */
|
|
|
|
case ACTION_SET_ALL:
|
|
|
|
/* git config --replace-all <name> <value> <value-pattern> */
|
|
|
|
case ACTION_REPLACE_ALL:
|
|
|
|
allowed_usage = argc > 2 && !!argv[2];
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* other options don't allow --fixed-value */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!allowed_usage) {
|
|
|
|
error(_("--fixed-value only applies with 'value-pattern'"));
|
2024-05-15 08:41:38 +02:00
|
|
|
exit(129);
|
2020-11-25 23:12:53 +01:00
|
|
|
}
|
2020-11-25 23:12:54 +01:00
|
|
|
|
|
|
|
flags |= CONFIG_FLAGS_FIXED_VALUE;
|
2020-11-25 23:12:53 +01:00
|
|
|
}
|
|
|
|
|
2024-05-06 10:55:56 +02:00
|
|
|
comment = git_config_prepare_comment_string(comment_arg);
|
config: fix --comment formatting
When git adds comments itself (like "rebase -i" todo list and
"commit -e" log message editor), it always gives a comment
introducer "#" followed by a Space before the message, except for
the recently introduced "git config --comment", where the users are
forced to say " this is my comment" if they want to add their
comment in this usual format; otherwise their comment string will
end up without a space after the "#".
Make it more ergonomic, while keeping it possible to also use this
unusual style, by massaging the comment string at the UI layer with
a set of simple rules:
* If the given comment string begins with '#', it is passed intact.
* Otherwise, "# " is prefixed.
* A string with LF in it cannot be used as a comment string.
Right now there is only one "front-end" that accepts end-user
comment string and calls the underlying machinery to add or modify
configuration file with comments, but to make sure that the future
callers perform similar massaging as they see fit, add a sanity
check logic in git_config_set_multivar_in_file_gently(), which is
the single choke point in the codepaths that consumes the comment
string.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-03-15 20:43:58 +01:00
|
|
|
|
2024-05-15 08:41:57 +02:00
|
|
|
/*
|
|
|
|
* The following actions may produce more than one line of output and
|
|
|
|
* should therefore be paged.
|
|
|
|
*/
|
|
|
|
if (actions & (ACTION_LIST | ACTION_GET_ALL | ACTION_GET_REGEXP | ACTION_GET_URLMATCH))
|
2018-02-21 19:51:44 +01:00
|
|
|
setup_auto_pager("config", 1);
|
2018-02-21 19:51:43 +01:00
|
|
|
|
2009-02-21 01:49:25 +01:00
|
|
|
if (actions == ACTION_LIST) {
|
2009-02-21 01:49:28 +01:00
|
|
|
check_argc(argc, 0, 0);
|
2024-05-15 08:42:21 +02:00
|
|
|
if (config_with_options(show_all_config, &display_opts,
|
2024-05-15 08:42:16 +02:00
|
|
|
&location_opts.source, the_repository,
|
|
|
|
&location_opts.options) < 0) {
|
|
|
|
if (location_opts.source.file)
|
2018-07-21 09:49:22 +02:00
|
|
|
die_errno(_("unable to read config file '%s'"),
|
2024-05-15 08:42:16 +02:00
|
|
|
location_opts.source.file);
|
2009-02-21 01:49:25 +01:00
|
|
|
else
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("error processing config file(s)"));
|
2007-06-25 16:00:24 +02:00
|
|
|
}
|
2005-11-17 22:44:55 +01:00
|
|
|
}
|
2009-02-21 01:49:25 +01:00
|
|
|
else if (actions == ACTION_EDIT) {
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = show_editor(&location_opts);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_SET) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 2, 2);
|
2024-05-15 08:42:25 +02:00
|
|
|
value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_in_file_gently(location_opts.source.file, argv[0], comment, value);
|
2011-05-17 17:38:53 +02:00
|
|
|
if (ret == CONFIG_NOTHING_SET)
|
2016-09-15 16:59:00 +02:00
|
|
|
error(_("cannot overwrite multiple values with a single value\n"
|
|
|
|
" Use a regexp, --add or --replace-all to change %s."), argv[0]);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_SET_ALL) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 2, 3);
|
2024-05-15 08:42:25 +02:00
|
|
|
value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
argv[0], value, argv[2],
|
2024-03-12 22:47:00 +01:00
|
|
|
comment, flags);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_ADD) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 2, 2);
|
2024-05-15 08:42:25 +02:00
|
|
|
value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
argv[0], value,
|
|
|
|
CONFIG_REGEX_NONE,
|
2024-03-12 22:47:00 +01:00
|
|
|
comment, flags);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_REPLACE_ALL) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 2, 3);
|
2024-05-15 08:42:25 +02:00
|
|
|
value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
argv[0], value, argv[2],
|
2024-03-12 22:47:00 +01:00
|
|
|
comment, flags | CONFIG_FLAGS_MULTI_REPLACE);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET) {
|
|
|
|
check_argc(argc, 1, 2);
|
2024-05-15 08:42:21 +02:00
|
|
|
ret = get_value(&location_opts, &display_opts, argv[0], argv[1], flags);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_ALL) {
|
|
|
|
do_all = 1;
|
|
|
|
check_argc(argc, 1, 2);
|
2024-05-15 08:42:21 +02:00
|
|
|
ret = get_value(&location_opts, &display_opts, argv[0], argv[1], flags);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_REGEXP) {
|
2024-05-15 08:42:21 +02:00
|
|
|
display_opts.show_keys = 1;
|
2009-02-21 01:49:25 +01:00
|
|
|
use_key_regexp = 1;
|
|
|
|
do_all = 1;
|
|
|
|
check_argc(argc, 1, 2);
|
2024-05-15 08:42:21 +02:00
|
|
|
ret = get_value(&location_opts, &display_opts, argv[0], argv[1], flags);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
2013-07-31 20:14:59 +02:00
|
|
|
else if (actions == ACTION_GET_URLMATCH) {
|
|
|
|
check_argc(argc, 2, 2);
|
2024-05-15 08:42:21 +02:00
|
|
|
ret = get_urlmatch(&location_opts, &display_opts, argv[0], argv[1]);
|
2013-07-31 20:14:59 +02:00
|
|
|
}
|
2009-02-21 01:49:25 +01:00
|
|
|
else if (actions == ACTION_UNSET) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
if (argc == 2)
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
2024-05-15 08:42:11 +02:00
|
|
|
argv[0], NULL, argv[1],
|
|
|
|
NULL, flags);
|
2009-02-21 01:49:25 +01:00
|
|
|
else
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_in_file_gently(location_opts.source.file,
|
2024-05-15 08:42:11 +02:00
|
|
|
argv[0], NULL, NULL);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_UNSET_ALL) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 1, 2);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_set_multivar_in_file_gently(location_opts.source.file,
|
2024-05-15 08:42:11 +02:00
|
|
|
argv[0], NULL, argv[1],
|
|
|
|
NULL, flags | CONFIG_FLAGS_MULTI_REPLACE);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_RENAME_SECTION) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 2, 2);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_rename_section_in_file(location_opts.source.file,
|
config: stop using config_exclusive_filename
The git-config command sometimes operates on the default set
of config files (either reading from all, or writing to repo
config), and sometimes operates on a specific file. In the
latter case, we set the magic global config_exclusive_filename,
and the code in config.c does the right thing.
Instead, let's have git-config use the "advanced" variants
of config.c's functions which let it specify an individual
filename (or NULL for the default). This makes the code a
lot more obvious, and fixes two small bugs:
1. A relative path specified by GIT_CONFIG=foo will look
in the wrong directory if we have to chdir as part of
repository setup. We already handle this properly for
"git config -f foo", but the GIT_CONFIG lookup used
config_exclusive_filename directly. By dropping to a
single magic variable, the GIT_CONFIG case now just
works.
2. Calling "git config -f foo --edit" would not respect
core.editor. This is because just before editing, we
called git_config, which would respect the
config_exclusive_filename setting, even though this
particular git_config call was not about looking in the
user's specified file, but rather about loading actual
git config, just as any other git program would.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 09:07:32 +01:00
|
|
|
argv[0], argv[1]);
|
2009-02-21 01:49:25 +01:00
|
|
|
if (ret < 0)
|
2024-05-15 08:42:11 +02:00
|
|
|
goto out;
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
else if (!ret)
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("no such section: %s"), argv[0]);
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
else
|
|
|
|
ret = 0;
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_REMOVE_SECTION) {
|
2024-05-15 08:42:16 +02:00
|
|
|
check_write(&location_opts.source);
|
2009-02-21 01:49:25 +01:00
|
|
|
check_argc(argc, 1, 1);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = git_config_rename_section_in_file(location_opts.source.file,
|
config: stop using config_exclusive_filename
The git-config command sometimes operates on the default set
of config files (either reading from all, or writing to repo
config), and sometimes operates on a specific file. In the
latter case, we set the magic global config_exclusive_filename,
and the code in config.c does the right thing.
Instead, let's have git-config use the "advanced" variants
of config.c's functions which let it specify an individual
filename (or NULL for the default). This makes the code a
lot more obvious, and fixes two small bugs:
1. A relative path specified by GIT_CONFIG=foo will look
in the wrong directory if we have to chdir as part of
repository setup. We already handle this properly for
"git config -f foo", but the GIT_CONFIG lookup used
config_exclusive_filename directly. By dropping to a
single magic variable, the GIT_CONFIG case now just
works.
2. Calling "git config -f foo --edit" would not respect
core.editor. This is because just before editing, we
called git_config, which would respect the
config_exclusive_filename setting, even though this
particular git_config call was not about looking in the
user's specified file, but rather about loading actual
git config, just as any other git program would.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 09:07:32 +01:00
|
|
|
argv[0], NULL);
|
2009-02-21 01:49:25 +01:00
|
|
|
if (ret < 0)
|
2024-05-15 08:42:11 +02:00
|
|
|
goto out;
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
else if (!ret)
|
2018-07-21 09:49:22 +02:00
|
|
|
die(_("no such section: %s"), argv[0]);
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
else
|
|
|
|
ret = 0;
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_COLOR) {
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 16:15:51 +01:00
|
|
|
check_argc(argc, 1, 2);
|
2024-05-15 08:42:16 +02:00
|
|
|
get_color(&location_opts, argv[0], argv[1]);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_COLORBOOL) {
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 16:15:51 +01:00
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
if (argc == 2)
|
|
|
|
color_stdout_is_tty = git_config_bool("command line", argv[1]);
|
2024-05-15 08:42:16 +02:00
|
|
|
ret = get_colorbool(&location_opts, argv[0], argc == 2);
|
2009-02-21 01:49:25 +01:00
|
|
|
}
|
|
|
|
|
2024-05-15 08:42:11 +02:00
|
|
|
out:
|
2024-05-15 08:42:16 +02:00
|
|
|
location_options_release(&location_opts);
|
2024-05-06 10:55:56 +02:00
|
|
|
free(comment);
|
built-ins: use free() not UNLEAK() if trivial, rm dead code
For a lot of uses of UNLEAK() it would be quite tricky to release the
memory involved, or we're missing the relevant *_(release|clear)()
functions. But in these cases we have them already, and can just
invoke them on the variable(s) involved, instead of UNLEAK().
For "builtin/worktree.c" the UNLEAK() was also added in [1], but the
struct member it's unleaking was removed in [2]. The only non-"int"
member of that structure is "const char *keep_locked", which comes to
us via "argv" or a string literal[3].
We have good visibility via the compiler and
tooling (e.g. SANITIZE=address) on bad free()-ing, but none on
UNLEAK() we don't need anymore. So let's prefer releasing the memory
when it's easy.
For "bugreport", "worktree" and "config" we need to start using a "ret
= ..." return pattern. For "builtin/bugreport.c" these UNLEAK() were
added in [4], and for "builtin/config.c" in [1].
For "config" the code seen here was the only user of the "value"
variable. For "ACTION_{RENAME,REMOVE}_SECTION" we need to be sure to
return the right exit code in the cases where we were relying on
falling through to the top-level.
I think there's still a use-case for UNLEAK(), but hat it's changed
since then. Using it so that "we can see the real leaks" is
counter-productive in these cases.
It's more useful to have UNLEAK() be a marker of the remaining odd
cases where it's hard to free() the memory for whatever reason. With
this change less than 20 of them remain in-tree.
1. 0e5bba53af7 (add UNLEAK annotation for reducing leak false
positives, 2017-09-08)
2. d861d34a6ed (worktree: remove extra members from struct add_opts,
2018-04-24)
3. 0db4961c49b (worktree: teach `add` to accept --reason <string> with
--lock, 2021-07-15)
4. 0e5bba53af7 and 00d8c311050 (commit: fix "author_ident" leak,
2022-05-12).
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-11-08 19:17:51 +01:00
|
|
|
free(value);
|
|
|
|
return ret;
|
2005-11-17 22:44:55 +01:00
|
|
|
}
|
2024-05-15 08:41:43 +02:00
|
|
|
|
|
|
|
int cmd_config(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2024-05-15 08:41:47 +02:00
|
|
|
parse_opt_subcommand_fn *subcommand = NULL;
|
|
|
|
struct option subcommand_opts[] = {
|
|
|
|
OPT_SUBCOMMAND("list", &subcommand, cmd_config_list),
|
|
|
|
OPT_SUBCOMMAND("get", &subcommand, cmd_config_get),
|
|
|
|
OPT_SUBCOMMAND("set", &subcommand, cmd_config_set),
|
|
|
|
OPT_SUBCOMMAND("unset", &subcommand, cmd_config_unset),
|
|
|
|
OPT_SUBCOMMAND("rename-section", &subcommand, cmd_config_rename_section),
|
|
|
|
OPT_SUBCOMMAND("remove-section", &subcommand, cmd_config_remove_section),
|
|
|
|
OPT_SUBCOMMAND("edit", &subcommand, cmd_config_edit),
|
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
2024-05-15 08:41:43 +02:00
|
|
|
/*
|
|
|
|
* This is somewhat hacky: we first parse the command line while
|
|
|
|
* keeping all args intact in order to determine whether a subcommand
|
|
|
|
* has been specified. If so, we re-parse it a second time, but this
|
|
|
|
* time we drop KEEP_ARGV0. This is so that we don't munge the command
|
|
|
|
* line in case no subcommand was given, which would otherwise confuse
|
|
|
|
* us when parsing the legacy-style modes that don't use subcommands.
|
|
|
|
*/
|
2024-05-15 08:41:47 +02:00
|
|
|
argc = parse_options(argc, argv, prefix, subcommand_opts, builtin_config_usage,
|
2024-05-15 08:41:43 +02:00
|
|
|
PARSE_OPT_SUBCOMMAND_OPTIONAL|PARSE_OPT_KEEP_ARGV0|PARSE_OPT_KEEP_UNKNOWN_OPT);
|
|
|
|
if (subcommand) {
|
2024-05-15 08:41:47 +02:00
|
|
|
argc = parse_options(argc, argv, prefix, subcommand_opts, builtin_config_usage,
|
2024-05-15 08:41:43 +02:00
|
|
|
PARSE_OPT_SUBCOMMAND_OPTIONAL|PARSE_OPT_KEEP_UNKNOWN_OPT);
|
|
|
|
return subcommand(argc, argv, prefix);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cmd_config_actions(argc, argv, prefix);
|
|
|
|
}
|