chore: update dependencies and fix new lint rules

Author: krostar

.gitignore

@@ -1,5 +1,6 @@
 /.direnv
 /result
+testdata/fuzz/
 
 # nixago: ignore-linked-files
 /.editorconfig

README.md

@@ -22,6 +22,10 @@ Changing frameworks can require extensive rewrites.
 - **Flexibility**: Allowing you to choose (and change) the underlying CLI framework that best suits your needs.
 - **Simplicity**: Focusing on core CLI functionality, avoiding unnecessary complexity.
 
+## API Stability
+
+This project follows [Semantic Versioning](https://semver.org/).
+
 ## Usage
 
 ### Basic Command

cfg/cfg.go

@@ -49,6 +49,7 @@ func BeforeCommandExecutionHook[T any](dest *T, source SourceFunc[T], sources ..
 		}
 
 		*dest = *cfg
+
 		return nil
 	}
 }

cfg/cfg_test.go

@@ -12,6 +12,7 @@ func Test_BeforeCommandExecutionHook(t *testing.T) {
 	type config struct {
 		A string
 	}
+
 	var cfg config
 
 	t.Run("ok", func(t *testing.T) {

cfg/source/default/default.go

@@ -15,6 +15,7 @@ func Source[T any]() clicfg.SourceFunc[T] {
 		}); ok {
 			cfgDefault.SetDefault()
 		}
+
 		return nil
 	}
 }

cfg/source/env/env.go

@@ -21,6 +21,7 @@ import (
 func Source[T any](envPrefix string) clicfg.SourceFunc[T] {
 	return func(_ context.Context, cfg *T) error {
 		_, err := recursivelyWalkThroughReflectValue(os.LookupEnv, reflect.ValueOf(cfg).Elem(), envPrefix, nil)
+
 		return err
 	}
 }
@@ -50,13 +51,15 @@ func recursivelyWalkThroughReflectValue(lookupEnv func(string) (string, bool), v
 		if atLeastOneEnvFound {
 			v.Set(newV)
 		}
+
 		return atLeastOneEnvFound, err
 
 	case reflect.Struct: // if it's a struct, iterate over its fields
 		var (
 			errs            []error
 			atLeastOneFound bool
 		)
+
 		for i := range v.NumField() {
 			tfield := t.Field(i)
 			tag := tfield.Tag.Get("env")
@@ -80,12 +83,15 @@ func recursivelyWalkThroughReflectValue(lookupEnv func(string) (string, bool), v
 			if envFound {
 				atLeastOneFound = true
 			}
+
 			errs = append(errs, err)
 		}
+
 		return atLeastOneFound, multierr.Combine(errs...)
 
 	default: // for primitive types, try to find the corresponding environment variable
 		var rawEnv string
+
 		for _, envToLookup := range append(additionalEnvsToLookup, envPrefix) {
 			envToLookup = strings.TrimSpace(envToLookup)
 			if envToLookup != "" {
@@ -105,65 +111,81 @@ func recursivelyWalkThroughReflectValue(lookupEnv func(string) (string, bool), v
 		case reflect.Bool:
 			vv, err := strconv.ParseBool(rawEnv)
 			v.SetBool(vv)
+
 			return true, err
 		case reflect.Int:
 			vv, err := strconv.ParseInt(rawEnv, 10, 0)
 			v.SetInt(vv)
+
 			return true, err
 		case reflect.Int8:
 			vv, err := strconv.ParseInt(rawEnv, 10, 8)
 			v.SetInt(vv)
+
 			return true, err
 		case reflect.Int16:
 			vv, err := strconv.ParseInt(rawEnv, 10, 16)
 			v.SetInt(vv)
+
 			return true, err
 		case reflect.Int32:
 			vv, err := strconv.ParseInt(rawEnv, 10, 32)
 			v.SetInt(vv)
+
 			return true, err
 		case reflect.Int64:
 			vv, err := strconv.ParseInt(rawEnv, 10, 64)
 			v.SetInt(vv)
+
 			return true, err
 		case reflect.Uint:
 			vv, err := strconv.ParseUint(rawEnv, 10, 0)
 			v.SetUint(vv)
+
 			return true, err
 		case reflect.Uint8:
 			vv, err := strconv.ParseUint(rawEnv, 10, 8)
 			v.SetUint(vv)
+
 			return true, err
 		case reflect.Uint16:
 			vv, err := strconv.ParseUint(rawEnv, 10, 16)
 			v.SetUint(vv)
+
 			return true, err
 		case reflect.Uint32:
 			vv, err := strconv.ParseUint(rawEnv, 10, 32)
 			v.SetUint(vv)
+
 			return true, err
 		case reflect.Uint64:
 			vv, err := strconv.ParseUint(rawEnv, 10, 64)
 			v.SetUint(vv)
+
 			return true, err
 		case reflect.Float32:
 			vv, err := strconv.ParseFloat(rawEnv, 32)
 			v.SetFloat(vv)
+
 			return true, err
 		case reflect.Float64:
 			vv, err := strconv.ParseFloat(rawEnv, 64)
 			v.SetFloat(vv)
+
 			return true, err
 		case reflect.Complex64:
 			vv, err := strconv.ParseComplex(rawEnv, 64)
 			v.SetComplex(vv)
+
 			return true, err
 		case reflect.Complex128:
 			vv, err := strconv.ParseComplex(rawEnv, 128)
 			v.SetComplex(vv)
+
 			return true, err
 		case reflect.String:
 			v.SetString(rawEnv)
+
 			return true, nil
 		default:
 			return true, fmt.Errorf("unhandled type %s", k)

cfg/source/env/env_test.go

@@ -174,12 +174,14 @@ func Test_Source(t *testing.T) {
 		}
 
 		type foo1 struct {
-			bar   `env:"notbar"`
+			bar `env:"notbar"`
+
 			Hello string
 		}
 
 		type foo2 struct {
-			bar   `env:"^"`
+			bar `env:"^"`
+
 			Hello string
 		}
 

cfg/source/file/file.go

@@ -18,9 +18,10 @@ func Source[T any](getFilename func(cfg T) string, unmarshaler func(reader io.Re
 			if errors.Is(err, os.ErrNotExist) && allowNonExisting {
 				return nil
 			}
+
 			return fmt.Errorf("unable to open config file: %w", err)
 		}
-		defer file.Close() //nolint:errcheck // standard library don't care about this error
+		defer file.Close()
 
 		if err := unmarshaler(file, cfg); err != nil {
 			return fmt.Errorf("unable to decode config: %w", err)

cfg/source/file/file_test.go

@@ -22,6 +22,7 @@ func Test_Source(t *testing.T) {
 		configFile, err := os.CreateTemp(t.TempDir(), "*.yaml")
 		test.Require(t, err == nil)
 		t.Cleanup(func() { _ = os.Remove(configFile.Name()) })
+
 		_, _ = configFile.WriteString(`
 awesome: avalue
 `)
@@ -33,6 +34,7 @@ awesome: avalue
 			func(r io.Reader, cfg *configWithFile) error {
 				decoder := yaml.NewDecoder(r)
 				decoder.KnownFields(true)
+
 				return decoder.Decode(&cfg)
 			},
 			false,

cfg/source/flag/flag.go

@@ -63,6 +63,7 @@ func Source[T any](flagDest *T) clicfg.SourceFunc[T] {
 					pointersToValuesSetByFlags[uintptr(reflect.ValueOf(flag.Destination()).UnsafePointer())] = struct{}{}
 				}
 			}
+
 			if len(pointersToValuesSetByFlags) == 0 {
 				return nil
 			}
@@ -120,13 +121,15 @@ func recursivelyWalkThroughReflectValue(pointers map[uintptr]struct{}, v1, v2 re
 
 		v2.Set(v1)
 		delete(pointers, v1ptr)
+
 		return nil
 
 	case reflect.Struct:
 		var errs []error
 		for i := range v1.NumField() {
 			errs = append(errs, recursivelyWalkThroughReflectValue(pointers, v1.Field(i), v2.Field(i)))
 		}
+
 		return multierr.Combine(errs...)
 
 	default:
@@ -141,6 +144,7 @@ func recursivelyWalkThroughReflectValue(pointers map[uintptr]struct{}, v1, v2 re
 
 		v2.Set(v1)
 		delete(pointers, v1ptr)
+
 		return nil
 	}
 }