Abhinav Gupta
a86bda490b
The golangci-lint being used was quite dated. This change upgrades to the latest version. Adds and updates exclusions based on new failures. Note on revive: I've included an opt-out for unused parameters for revive because turning `newThing(required bool)` to `newThing(_ bool)` is a loss of useful information. The changes to the Go files are to fix the following issues: ``` camelcase.go:16: File is not `gofmt`-ed with `-s` (gofmt) config_test.go:50:18: directive `//nolint: gosec` is unused for linter "gosec" (nolintlint) defaults_test.go:28:25: G601: Implicit memory aliasing in for loop. (gosec) doc.go:5: File is not `gofmt`-ed with `-s` (gofmt) kong.go:446:18: directive `//nolint: gosec` is unused for linter "gosec" (nolintlint) kong_test.go:503:20: G601: Implicit memory aliasing in for loop. (gosec) model.go:493:10: composites: reflect.ValueError struct literal uses unkeyed fields (govet) scanner.go:112: File is not `gofmt`-ed with `-s` (gofmt) ``` And to address broken nolint directives reported as follows by golangci-lint. ``` [.. skipped .. ] tag.go:65:1: directive `// nolint:gocyclo` should be written without leading space as `//nolint:gocyclo` (nolintlint) tag.go:206:51: directive `// nolint: gocyclo` should be written without leading space as `//nolint: gocyclo` (nolintlint) util_test.go:23:43: directive `// nolint: errcheck` should be written without leading space as `//nolint: errcheck` (nolintlint) util_test.go:51:22: directive `// nolint: errcheck` should be written without leading space as `//nolint: errcheck` (nolintlint) ```
69 lines
1.9 KiB
Go
69 lines
1.9 KiB
Go
package kong
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
// A Resolver resolves a Flag value from an external source.
|
|
type Resolver interface {
|
|
// Validate configuration against Application.
|
|
//
|
|
// This can be used to validate that all provided configuration is valid within this application.
|
|
Validate(app *Application) error
|
|
|
|
// Resolve the value for a Flag.
|
|
Resolve(context *Context, parent *Path, flag *Flag) (interface{}, error)
|
|
}
|
|
|
|
// ResolverFunc is a convenience type for non-validating Resolvers.
|
|
type ResolverFunc func(context *Context, parent *Path, flag *Flag) (interface{}, error)
|
|
|
|
var _ Resolver = ResolverFunc(nil)
|
|
|
|
func (r ResolverFunc) Resolve(context *Context, parent *Path, flag *Flag) (interface{}, error) { //nolint: revive
|
|
return r(context, parent, flag)
|
|
}
|
|
func (r ResolverFunc) Validate(app *Application) error { return nil } //nolint: revive
|
|
|
|
// JSON returns a Resolver that retrieves values from a JSON source.
|
|
//
|
|
// Flag names are used as JSON keys indirectly, by tring snake_case and camelCase variants.
|
|
func JSON(r io.Reader) (Resolver, error) {
|
|
values := map[string]interface{}{}
|
|
err := json.NewDecoder(r).Decode(&values)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var f ResolverFunc = func(context *Context, parent *Path, flag *Flag) (interface{}, error) {
|
|
name := strings.ReplaceAll(flag.Name, "-", "_")
|
|
snakeCaseName := snakeCase(flag.Name)
|
|
raw, ok := values[name]
|
|
if ok {
|
|
return raw, nil
|
|
} else if raw, ok = values[snakeCaseName]; ok {
|
|
return raw, nil
|
|
}
|
|
raw = values
|
|
for _, part := range strings.Split(name, ".") {
|
|
if values, ok := raw.(map[string]interface{}); ok {
|
|
raw, ok = values[part]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
} else {
|
|
return nil, nil
|
|
}
|
|
}
|
|
return raw, nil
|
|
}
|
|
|
|
return f, nil
|
|
}
|
|
|
|
func snakeCase(name string) string {
|
|
name = strings.Join(strings.Split(strings.Title(name), "-"), "") //nolint: staticcheck
|
|
return strings.ToLower(name[:1]) + name[1:]
|
|
}
|