chore: hack to append values on StringSlice

Author: ldez

docs/src/docs/usage/configuration.mdx

@@ -4,6 +4,7 @@ title: Configuration
 
 The config file has lower priority than command-line options. If the same bool/string/int option is provided on the command-line
 and in the config file, the option from command-line will be used.
+Slice options (e.g. list of enabled/disabled linters) are combined from the command-line and config file.
 
 To see a list of linters enabled by your configuration use:
 

pkg/commands/config.go

@@ -51,10 +51,10 @@ func newConfigCommand(log logutils.Log) *configCommand {
 	return c
 }
 
-func (c *configCommand) preRunE(_ *cobra.Command, _ []string) error {
+func (c *configCommand) preRunE(cmd *cobra.Command, _ []string) error {
 	// The command doesn't depend on the real configuration.
 	// It only needs to know the path of the configuration file.
-	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, config.LoaderOptions{}, config.NewDefault())
+	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, cmd.Flags(), config.LoaderOptions{}, config.NewDefault())
 
 	if err := loader.Load(); err != nil {
 		return fmt.Errorf("can't load config: %w", err)

pkg/commands/flagsets.go

@@ -15,16 +15,17 @@ import (
 )
 
 func setupLintersFlagSet(v *viper.Viper, fs *pflag.FlagSet) {
-	internal.VibraP(v, fs, fs.StringSliceP, "disable", "D", "linters.disable", nil, wh("Disable specific linter"))
+	fs.StringSliceP("disable", "D", nil, wh("Disable specific linter")) // Hack see Loader.applyStringSliceHack
 	internal.Vibra(v, fs, fs.Bool, "disable-all", "linters.disable-all", false, wh("Disable all linters"))
 
-	internal.VibraP(v, fs, fs.StringSliceP, "enable", "E", "linters.enable", nil, wh("Enable specific linter"))
+	fs.StringSliceP("enable", "E", nil, wh("Enable specific linter")) // Hack see Loader.applyStringSliceHack
 	internal.Vibra(v, fs, fs.Bool, "enable-all", "linters.enable-all", false, wh("Enable all linters"))
 
 	internal.Vibra(v, fs, fs.Bool, "fast", "linters.fast", false,
 		wh("Enable only fast linters from enabled linters set (first run won't be fast)"))
 
-	internal.VibraP(v, fs, fs.StringSliceP, "presets", "p", "linters.presets", nil,
+	// Hack see Loader.applyStringSliceHack
+	fs.StringSliceP("presets", "p", nil,
 		wh(fmt.Sprintf("Enable presets (%s) of linters. Run 'golangci-lint help linters' to see "+
 			"them. This option implies option --disable-all", strings.Join(lintersdb.AllPresets(), "|"))))
 }
@@ -38,14 +39,14 @@ func setupRunFlagSet(v *viper.Viper, fs *pflag.FlagSet) {
 	internal.Vibra(v, fs, fs.Int, "issues-exit-code", "run.issues-exit-code", exitcodes.IssuesFound,
 		wh("Exit code when issues were found"))
 	internal.Vibra(v, fs, fs.String, "go", "run.go", "", wh("Targeted Go version"))
-	internal.Vibra(v, fs, fs.StringSlice, "build-tags", "run.build-tags", nil, wh("Build tags"))
+	fs.StringSlice("build-tags", nil, wh("Build tags")) // Hack see Loader.applyStringSliceHack
 
 	internal.Vibra(v, fs, fs.Duration, "timeout", "run.timeout", defaultTimeout, wh("Timeout for total work"))
 
 	internal.Vibra(v, fs, fs.Bool, "tests", "run.tests", true, wh("Analyze tests (*_test.go)"))
-	internal.Vibra(v, fs, fs.StringSlice, "skip-dirs", "run.skip-dirs", nil, wh("Regexps of directories to skip"))
+	fs.StringSlice("skip-dirs", nil, wh("Regexps of directories to skip")) // Hack see Loader.applyStringSliceHack
 	internal.Vibra(v, fs, fs.Bool, "skip-dirs-use-default", "run.skip-dirs-use-default", true, getDefaultDirectoryExcludeHelp())
-	internal.Vibra(v, fs, fs.StringSlice, "skip-files", "run.skip-files", nil, wh("Regexps of files to skip"))
+	fs.StringSlice("skip-files", nil, wh("Regexps of files to skip")) // Hack see Loader.applyStringSliceHack
 
 	const allowParallelDesc = "Allow multiple parallel golangci-lint instances running. " +
 		"If false (default) - golangci-lint acquires file lock on start."
@@ -69,7 +70,7 @@ func setupOutputFlagSet(v *viper.Viper, fs *pflag.FlagSet) {
 
 //nolint:gomnd
 func setupIssuesFlagSet(v *viper.Viper, fs *pflag.FlagSet) {
-	internal.VibraP(v, fs, fs.StringSliceP, "exclude", "e", "issues.exclude", nil, wh("Exclude issue by regexp"))
+	fs.StringSliceP("exclude", "e", nil, wh("Exclude issue by regexp")) // Hack see Loader.applyStringSliceHack
 	internal.Vibra(v, fs, fs.Bool, "exclude-use-default", "issues.exclude-use-default", true, getDefaultIssueExcludeHelp())
 	internal.Vibra(v, fs, fs.Bool, "exclude-case-sensitive", "issues.exclude-case-sensitive", false,
 		wh("If set to true exclude and exclude rules regular expressions are case-sensitive"))

pkg/commands/linters.go

@@ -58,8 +58,8 @@ func newLintersCommand(logger logutils.Log, cfg *config.Config) *lintersCommand
 	return c
 }
 
-func (c *lintersCommand) preRunE(_ *cobra.Command, _ []string) error {
-	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, c.opts.LoaderOptions, c.cfg)
+func (c *lintersCommand) preRunE(cmd *cobra.Command, _ []string) error {
+	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, cmd.Flags(), c.opts.LoaderOptions, c.cfg)
 
 	if err := loader.Load(); err != nil {
 		return fmt.Errorf("can't load config: %w", err)

pkg/commands/run.go

@@ -143,12 +143,12 @@ func newRunCommand(logger logutils.Log, cfg *config.Config, reportData *report.D
 	return c
 }
 
-func (c *runCommand) persistentPreRunE(_ *cobra.Command, _ []string) error {
+func (c *runCommand) persistentPreRunE(cmd *cobra.Command, _ []string) error {
 	if err := c.startTracing(); err != nil {
 		return err
 	}
 
-	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, c.opts.LoaderOptions, c.cfg)
+	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, cmd.Flags(), c.opts.LoaderOptions, c.cfg)
 
 	if err := loader.Load(); err != nil {
 		return fmt.Errorf("can't load config: %w", err)

pkg/config/loader.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/go-viper/mapstructure/v2"
 	"github.com/mitchellh/go-homedir"
+	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
 
 	"github.com/golangci/golangci-lint/pkg/exitcodes"
@@ -28,16 +29,18 @@ type Loader struct {
 	opts LoaderOptions
 
 	viper *viper.Viper
+	fs    *pflag.FlagSet
 
 	log logutils.Log
 
 	cfg *Config
 }
 
-func NewLoader(log logutils.Log, v *viper.Viper, opts LoaderOptions, cfg *Config) *Loader {
+func NewLoader(log logutils.Log, v *viper.Viper, fs *pflag.FlagSet, opts LoaderOptions, cfg *Config) *Loader {
 	return &Loader{
 		opts:  opts,
 		viper: v,
+		fs:    fs,
 		log:   log,
 		cfg:   cfg,
 	}
@@ -54,6 +57,8 @@ func (r *Loader) Load() error {
 		return err
 	}
 
+	r.applyStringSliceHack()
+
 	if r.cfg.Run.Go == "" {
 		r.cfg.Run.Go = detectGoVersion()
 	}
@@ -220,6 +225,31 @@ func (r *Loader) setConfigDir() error {
 	return nil
 }
 
+// Hack to append values from StringSlice flags.
+// Viper always overrides StringSlice values.
+// https://github.com/spf13/viper/issues/1448
+// So StringSlice flags are not bind to Viper like that their values are obtain via Cobra Flags.
+func (r *Loader) applyStringSliceHack() {
+	if r.fs == nil {
+		return
+	}
+
+	r.appendStringSlice("enable", &r.cfg.Linters.Enable)
+	r.appendStringSlice("disable", &r.cfg.Linters.Disable)
+	r.appendStringSlice("presets", &r.cfg.Linters.Presets)
+	r.appendStringSlice("build-tags", &r.cfg.Run.BuildTags)
+	r.appendStringSlice("skip-dirs", &r.cfg.Run.SkipDirs)
+	r.appendStringSlice("skip-files", &r.cfg.Run.SkipFiles)
+	r.appendStringSlice("exclude", &r.cfg.Issues.ExcludePatterns)
+}
+
+func (r *Loader) appendStringSlice(name string, current *[]string) {
+	if r.fs.Changed(name) {
+		val, _ := r.fs.GetStringSlice(name)
+		*current = append(*current, val...)
+	}
+}
+
 func fileDecoderHook() viper.DecoderConfigOption {
 	return viper.DecodeHook(mapstructure.ComposeDecodeHookFunc(
 		// Default hooks (https://github.com/spf13/viper/blob/518241257478c557633ab36e474dfcaeb9a3c623/viper.go#L135-L138).

test/enabled_linters_test.go

@@ -53,7 +53,7 @@ func TestEnabledLinters(t *testing.T) {
 				enable:
 					- revive
 			`,
-			enabledLinters: getEnabledByDefaultFastLintersWith("gofmt"),
+			enabledLinters: getEnabledByDefaultFastLintersWith("revive", "gofmt"),
 		},
 		{
 			name: "fast option in config",