feat: add verify command

.github/workflows/pr.yml

@@ -166,6 +166,7 @@ jobs:
 
       - run: ./golangci-lint config
       - run: ./golangci-lint config path
+      - run: ./golangci-lint config verify --schema jsonschema/golangci.next.jsonschema.json
 
       - run: ./golangci-lint help
       - run: ./golangci-lint help linters

.golangci.yml

@@ -163,6 +163,8 @@ issues:
       text: "SA1019: c.cfg.Run.ShowStats is deprecated: use Output.ShowStats instead."
     - path: pkg/golinters/govet.go
       text: "SA1019: cfg.CheckShadowing is deprecated: the linter should be enabled inside `Enable`."
+    - path: pkg/commands/config.go
+      text: "SA1019: cfg.Run.UseDefaultSkipDirs is deprecated: use Issues.UseDefaultExcludeDirs instead."
 
     - path: pkg/golinters
       linters:

Makefile

@@ -89,7 +89,7 @@ go.mod: FORCE
 go.sum: go.mod
 
 website_copy_jsonschema:
-	 cp -r ./jsonschema ./docs/static
+	 go run  ./scripts/website/copy_jsonschema/
 .PHONY: website_copy_jsonschema
 
 website_expand_templates:

go.mod

@@ -80,6 +80,7 @@ require (
 	github.com/nishanths/exhaustive v0.12.0
 	github.com/nishanths/predeclared v0.2.2
 	github.com/nunnatsa/ginkgolinter v0.16.1
+	github.com/pelletier/go-toml/v2 v2.1.1
 	github.com/polyfloyd/go-errorlint v1.4.8
 	github.com/quasilyte/go-ruleguard/dsl v0.3.22
 	github.com/ryancurrah/gomodguard v1.3.1
@@ -161,7 +162,6 @@ require (
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
 	github.com/prometheus/client_golang v1.12.1 // indirect

pkg/commands/config.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
@@ -13,17 +14,27 @@ import (
 	"github.com/golangci/golangci-lint/pkg/logutils"
 )
 
+type verifyOptions struct {
+	schemaURL string // For debugging purpose only (Flag only).
+}
+
 type configCommand struct {
 	viper *viper.Viper
 	cmd   *cobra.Command
 
+	opts       config.LoaderOptions
+	verifyOpts verifyOptions
+
+	buildInfo BuildInfo
+
 	log logutils.Log
 }
 
-func newConfigCommand(log logutils.Log) *configCommand {
+func newConfigCommand(log logutils.Log, info BuildInfo) *configCommand {
 	c := &configCommand{
-		viper: viper.New(),
-		log:   log,
+		viper:     viper.New(),
+		log:       log,
+		buildInfo: info,
 	}
 
 	configCmd := &cobra.Command{
@@ -33,6 +44,16 @@ func newConfigCommand(log logutils.Log) *configCommand {
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},
+		PersistentPreRunE: c.preRunE,
+	}
+
+	verifyCommand := &cobra.Command{
+		Use:               "verify",
+		Short:             "Verify configuration against JSON schema",
+		Args:              cobra.NoArgs,
+		ValidArgsFunction: cobra.NoFileCompletions,
+		RunE:              c.executeVerify,
+		SilenceUsage:      true,
 	}
 
 	configCmd.AddCommand(
@@ -41,11 +62,21 @@ func newConfigCommand(log logutils.Log) *configCommand {
 			Short:             "Print used config path",
 			Args:              cobra.NoArgs,
 			ValidArgsFunction: cobra.NoFileCompletions,
-			Run:               c.execute,
-			PreRunE:           c.preRunE,
+			Run:               c.executePath,
 		},
+		verifyCommand,
 	)
 
+	flagSet := configCmd.PersistentFlags()
+	flagSet.SortFlags = false // sort them as they are defined here
+
+	setupConfigFileFlagSet(flagSet, &c.opts)
+
+	// ex: --schema jsonschema/golangci.next.jsonschema.json
+	verifyFlagSet := verifyCommand.Flags()
+	verifyFlagSet.StringVar(&c.verifyOpts.schemaURL, "schema", "", color.GreenString("JSON schema URL"))
+	_ = verifyFlagSet.MarkHidden("schema")
+
 	c.cmd = configCmd
 
 	return c
@@ -54,7 +85,16 @@ func newConfigCommand(log logutils.Log) *configCommand {
 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, cmd.Flags(), config.LoaderOptions{}, config.NewDefault())
+	cfg := config.NewDefault()
+
+	// Hack to hide deprecation messages related to `--skip-dirs-use-default`:
+	// Flags are not bound then the default values, defined only through flags, are not applied.
+	// In this command, file path and file information are the only requirements, i.e. it don't need flag values.
+	//
+	// TODO(ldez) add an option (check deprecation) to `Loader.Load()` but this require a dedicated PR.
+	cfg.Run.UseDefaultSkipDirs = true
+
+	loader := config.NewLoader(c.log.Child(logutils.DebugKeyConfigReader), c.viper, cmd.Flags(), c.opts, cfg)
 
 	if err := loader.Load(); err != nil {
 		return fmt.Errorf("can't load config: %w", err)
@@ -63,14 +103,14 @@ func (c *configCommand) preRunE(cmd *cobra.Command, _ []string) error {
 	return nil
 }
 
-func (c *configCommand) execute(_ *cobra.Command, _ []string) {
+func (c *configCommand) executePath(cmd *cobra.Command, _ []string) {
 	usedConfigFile := c.getUsedConfig()
 	if usedConfigFile == "" {
 		c.log.Warnf("No config file detected")
 		os.Exit(exitcodes.NoConfigFileDetected)
 	}
 
-	fmt.Println(usedConfigFile)
+	cmd.Println(usedConfigFile)
 }
 
 // getUsedConfig returns the resolved path to the golangci config file,

pkg/commands/config_verify.go

@@ -0,0 +1,175 @@
+package commands
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	hcversion "github.com/hashicorp/go-version"
+	"github.com/pelletier/go-toml/v2"
+	"github.com/santhosh-tekuri/jsonschema/v5"
+	_ "github.com/santhosh-tekuri/jsonschema/v5/httploader"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"gopkg.in/yaml.v3"
+
+	"github.com/golangci/golangci-lint/pkg/exitcodes"
+)
+
+func (c *configCommand) executeVerify(cmd *cobra.Command, _ []string) error {
+	usedConfigFile := c.getUsedConfig()
+	if usedConfigFile == "" {
+		c.log.Warnf("No config file detected")
+		os.Exit(exitcodes.NoConfigFileDetected)
+	}
+
+	schemaURL, err := getSchemaURL(cmd.Flags(), c.buildInfo)
+	if err != nil {
+		return fmt.Errorf("get JSON schema: %w", err)
+	}
+
+	err = validateConfiguration(schemaURL, usedConfigFile)
+	if err != nil {
+		var v *jsonschema.ValidationError
+		if !errors.As(err, &v) {
+			return fmt.Errorf("[%s] validate: %w", usedConfigFile, err)
+		}
+
+		detail := v.DetailedOutput()
+
+		printValidationDetail(cmd, &detail)
+	}
+
+	return nil
+}
+
+func printValidationDetail(cmd *cobra.Command, detail *jsonschema.Detailed) {
+	if detail.Error != "" {
+		cmd.PrintErrf("jsonschema: %s does not validate with %s: %s\n",
+			strings.ReplaceAll(strings.TrimPrefix(detail.InstanceLocation, "/"), "/", "."), detail.KeywordLocation, detail.Error)
+	}
+
+	for _, d := range detail.Errors {
+		d := d
+		printValidationDetail(cmd, &d)
+	}
+}
+
+func getSchemaURL(flags *pflag.FlagSet, buildInfo BuildInfo) (string, error) {
+	schemaURL, err := flags.GetString("schema")
+	if err != nil {
+		return "", fmt.Errorf("get schema flag: %w", err)
+	}
+
+	if schemaURL != "" {
+		return schemaURL, nil
+	}
+
+	switch {
+	case buildInfo.Version != "" && buildInfo.Version != "(devel)":
+		version, err := hcversion.NewVersion(buildInfo.Version)
+		if err != nil {
+			return "", fmt.Errorf("parse version: %w", err)
+		}
+
+		schemaURL = fmt.Sprintf("https://golangci-lint.run/jsonschema/golangci.v%d.%d.jsonschema.json",
+			version.Segments()[0], version.Segments()[1])
+
+	case buildInfo.Commit != "" && buildInfo.Commit != "?":
+		if buildInfo.Commit != "unknown" {
+			return "", errors.New("unknown commit information")
+		}
+
+		commit := buildInfo.Commit
+
+		if strings.HasPrefix(commit, "(") {
+			c, _, ok := strings.Cut(strings.TrimPrefix(commit, "("), ",")
+			if !ok {
+				return "", errors.New("commit information not found")
+			}
+
+			commit = c
+		}
+
+		schemaURL = fmt.Sprintf("https://raw.githubusercontent.com/golangci/golangci-lint/%s/jsonschema/golangci.next.jsonschema.json",
+			commit)
+
+	default:
+		return "", errors.New("version not found")
+	}
+
+	return schemaURL, nil
+}
+
+func validateConfiguration(schemaPath, targetFile string) error {
+	compiler := jsonschema.NewCompiler()
+	compiler.Draft = jsonschema.Draft7
+
+	schema, err := compiler.Compile(schemaPath)
+	if err != nil {
+		return fmt.Errorf("compile schema: %w", err)
+	}
+
+	var m any
+
+	switch strings.ToLower(filepath.Ext(targetFile)) {
+	case ".yaml", ".yml", ".json":
+		m, err = decodeYamlFile(targetFile)
+		if err != nil {
+			return err
+		}
+
+	case ".toml":
+		m, err = decodeTomlFile(targetFile)
+		if err != nil {
+			return err
+		}
+
+	default:
+		// unsupported
+		return errors.New("unsupported configuration format")
+	}
+
+	err = schema.Validate(m)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func decodeYamlFile(filename string) (any, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("[%s] file open: %w", filename, err)
+	}
+
+	defer func() { _ = file.Close() }()
+
+	var m any
+	err = yaml.NewDecoder(file).Decode(&m)
+	if err != nil {
+		return nil, fmt.Errorf("[%s] YAML decode: %w", filename, err)
+	}
+
+	return m, nil
+}
+
+func decodeTomlFile(filename string) (any, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("[%s] file open: %w", filename, err)
+	}
+
+	defer func() { _ = file.Close() }()
+
+	var m any
+	err = toml.NewDecoder(file).Decode(&m)
+	if err != nil {
+		return nil, fmt.Errorf("[%s] TOML decode: %w", filename, err)
+	}
+
+	return m, nil
+}

pkg/commands/custom.go

@@ -25,11 +25,12 @@ func newCustomCommand(logger logutils.Log) *customCommand {
 	c := &customCommand{log: logger}
 
 	customCmd := &cobra.Command{
-		Use:     "custom",
-		Short:   "Build a version of golangci-lint with custom linters",
-		Args:    cobra.NoArgs,
-		PreRunE: c.preRunE,
-		RunE:    c.runE,
+		Use:          "custom",
+		Short:        "Build a version of golangci-lint with custom linters",
+		Args:         cobra.NoArgs,
+		PreRunE:      c.preRunE,
+		RunE:         c.runE,
+		SilenceUsage: true,
 	}
 
 	c.cmd = customCmd

pkg/commands/linters.go

@@ -44,6 +44,7 @@ func newLintersCommand(logger logutils.Log) *lintersCommand {
 		ValidArgsFunction: cobra.NoFileCompletions,
 		RunE:              c.execute,
 		PreRunE:           c.preRunE,
+		SilenceUsage:      true,
 	}
 
 	fs := lintersCmd.Flags()

pkg/commands/root.go

@@ -61,7 +61,7 @@ func newRootCommand(info BuildInfo) *rootCommand {
 		newLintersCommand(log).cmd,
 		newRunCommand(log, info).cmd,
 		newCacheCommand().cmd,
-		newConfigCommand(log).cmd,
+		newConfigCommand(log, info).cmd,
 		newVersionCommand(info).cmd,
 		newCustomCommand(log).cmd,
 	)

pkg/commands/run.go

@@ -118,6 +118,7 @@ func newRunCommand(logger logutils.Log, info BuildInfo) *runCommand {
 		PostRun:            c.postRun,
 		PersistentPreRunE:  c.persistentPreRunE,
 		PersistentPostRunE: c.persistentPostRunE,
+		SilenceUsage:       true,
 	}
 
 	runCmd.SetOut(logutils.StdOut) // use custom output to properly color it in Windows terminals