lint: enable modernize

System-Glitch · System-Glitch · commit 574c1348560a · 2025-11-04T15:24:18.000+01:00
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -40,7 +40,7 @@ jobs:
       - name: Run lint
         uses: golangci/golangci-lint-action@v8
         with:
-          version: v2.4
+          version: v2.6
           args: --timeout 5m
 
   govulncheck:
diff --git a/.golangci.yml b/.golangci.yml
@@ -15,6 +15,7 @@ linters:
     - ineffassign
     - govet
     - sqlclosecheck
+    - modernize
   settings:
     gocyclo:
       min-complexity: 18
diff --git a/auth/jwt.go b/auth/jwt.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"io/fs"
+	"maps"
 	"reflect"
 	"sync"
 	"time"
@@ -108,9 +109,7 @@ func (s *JWTService) GenerateTokenWithClaims(claims jwt.MapClaims, signingMethod
 		"nbf": now.Unix(),          // Not Before
 		"exp": now.Add(exp).Unix(), // Expiry
 	}
-	for k, c := range claims {
-		customClaims[k] = c
-	}
+	maps.Copy(customClaims, claims)
 	token := jwt.NewWithClaims(signingMethod, customClaims)
 
 	key, err := s.GetPrivateKey(signingMethod)
diff --git a/config/config.go b/config/config.go
@@ -320,7 +320,7 @@ func override(src object, dst object) error {
 }
 
 func (o object) validate(key string) error {
-	message := ""
+	var message strings.Builder
 	valid := true
 	for k, entry := range o {
 		var subKey string
@@ -331,17 +331,17 @@ func (o object) validate(key string) error {
 		}
 		if category, ok := entry.(object); ok {
 			if err := category.validate(subKey); err != nil {
-				message += err.Error()
+				message.WriteString(err.Error())
 				valid = false
 			}
 		} else if err := entry.(*Entry).validate(subKey); err != nil {
-			message += "\n\t- " + err.Error()
+			message.WriteString("\n\t- " + err.Error())
 			valid = false
 		}
 	}
 
 	if !valid {
-		return fmt.Errorf("%s", message)
+		return fmt.Errorf("%s", message.String())
 	}
 	return nil
 }
diff --git a/config/default.go b/config/default.go
@@ -65,7 +65,7 @@ func loadDefaults(src object, dst object) {
 				list := reflect.ValueOf(value)
 				length := list.Len()
 				slice := reflect.MakeSlice(reflect.SliceOf(t.Elem()), 0, length)
-				for i := 0; i < length; i++ {
+				for i := range length {
 					slice = reflect.Append(slice, list.Index(i))
 				}
 				value = slice.Interface()
diff --git a/config/entry.go b/config/entry.go
@@ -67,7 +67,7 @@ func (e *Entry) validate(key string) error {
 			// Accepted values for slices define the values that can be used inside the slice
 			// It doesn't represent the value of the slice itself (content and order)
 			length := v.Len()
-			for i := 0; i < length; i++ {
+			for i := range length {
 				if !lo.Contains(e.AuthorizedValues, v.Index(i).Interface()) {
 					return errors.Errorf("%q elements must have one of the following values: %v", key, e.AuthorizedValues)
 				}
diff --git a/database/factory.go b/database/factory.go
@@ -41,7 +41,7 @@ func (f *Factory[T]) Generate(count int) []*T {
 
 	slice := make([]*T, 0, count)
 
-	for i := 0; i < count; i++ {
+	for range count {
 		record := f.generator()
 		if f.override != nil {
 			if err := copier.CopyWithOption(record, f.override, copier.Option{IgnoreEmpty: true, DeepCopy: true, CaseSensitive: true}); err != nil {
diff --git a/database/timeout_test.go b/database/timeout_test.go
@@ -180,7 +180,7 @@ func TestTimeoutPlugin(t *testing.T) {
 			return fmt.Sprintf("foobar_%d@example.org", index)
 		})
 		err = db.Transaction(func(_ *gorm.DB) error {
-			for i := 0; i < 5000; i++ {
+			for range 5000 {
 				users := []*TestUser{}
 				res := db.Select("*").Where("email IN (?)", args).Find(&users)
 				if res.Error != nil {
diff --git a/lang/lang.go b/lang/lang.go
@@ -2,6 +2,7 @@ package lang
 
 import (
 	"encoding/json"
+	"maps"
 	"strings"
 
 	"github.com/samber/lo"
@@ -229,13 +230,7 @@ func readLangFile(fs fsutil.FS, path string, dest any) (err error) {
 }
 
 func mergeLang(dst *Language, src *Language) {
-	mergeMap(dst.lines, src.lines)
-	mergeMap(dst.validation.rules, src.validation.rules)
-	mergeMap(dst.validation.fields, src.validation.fields)
-}
-
-func mergeMap(dst map[string]string, src map[string]string) {
-	for key, value := range src {
-		dst[key] = value
-	}
+	maps.Copy(dst.lines, src.lines)
+	maps.Copy(dst.validation.rules, src.validation.rules)
+	maps.Copy(dst.validation.fields, src.validation.fields)
 }
diff --git a/lang/language.go b/lang/language.go
@@ -1,6 +1,9 @@
 package lang
 
-import "strings"
+import (
+	"maps"
+	"strings"
+)
 
 type validationLines struct {
 	// Default messages for rules
@@ -32,9 +35,9 @@ func (l *Language) clone() *Language {
 		},
 	}
 
-	mergeMap(cpy.lines, l.lines)
-	mergeMap(cpy.validation.rules, l.validation.rules)
-	mergeMap(cpy.validation.fields, l.validation.fields)
+	maps.Copy(cpy.lines, l.lines)
+	maps.Copy(cpy.validation.rules, l.validation.rules)
+	maps.Copy(cpy.validation.fields, l.validation.fields)
 
 	return cpy
 }
diff --git a/log/log_bench_test.go b/log/log_bench_test.go
@@ -28,7 +28,7 @@ func BenchmarkServeHTTPWithLogs(b *testing.B) {
 
 	b.ReportAllocs()
 	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for b.Loop() {
 		s.Router().ServeHTTP(httptest.NewRecorder(), req)
 	}
 }
diff --git a/route.go b/route.go
@@ -3,6 +3,7 @@ package goyave
 import (
 	"fmt"
 	"net/http"
+	"slices"
 	"strings"
 
 	"github.com/samber/lo"
@@ -73,12 +74,7 @@ func (r *Route) match(method string, match *routeMatch) bool {
 }
 
 func (r *Route) checkMethod(method string) bool {
-	for _, m := range r.methods {
-		if m == method {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(r.methods, method)
 }
 
 func (r *Route) makeParameters(match []string) map[string]string {
diff --git a/router.go b/router.go
@@ -61,9 +61,7 @@ func (rm *routeMatch) mergeParams(params map[string]string) {
 		rm.parameters = params
 		return
 	}
-	for k, v := range params {
-		rm.parameters[k] = v
-	}
+	maps.Copy(rm.parameters, params)
 }
 
 func (rm *routeMatch) trimCurrentPath(fullMatch string) {
@@ -339,7 +337,7 @@ func (r *Router) match(method string, match *routeMatch) bool {
 
 func nthIndex(str, substr string, n int) int {
 	index := -1
-	for nth := 0; nth < n; nth++ {
+	for range n {
 		i := strings.Index(str, substr)
 		if i == -1 || i == len(str) {
 			return -1
diff --git a/router_bench_test.go b/router_bench_test.go
@@ -21,7 +21,7 @@ func BenchmarkServeHTTP(b *testing.B) {
 
 	b.ReportAllocs()
 	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for b.Loop() {
 		s.router.ServeHTTP(httptest.NewRecorder(), req)
 	}
 }
diff --git a/server_test.go b/server_test.go
@@ -646,7 +646,7 @@ func TestServer(t *testing.T) {
 			assert.NoError(t, err)
 			respBody, err := io.ReadAll(res.Body)
 			assert.NoError(t, err)
-			assert.Equal(t, []byte(fmt.Sprintf("%v|%v", "base-ctx-value", "conn-ctx-value")), respBody)
+			assert.Equal(t, fmt.Appendf(nil, "%v|%v", "base-ctx-value", "conn-ctx-value"), respBody)
 
 			// Stop the server, goroutine should return
 			server.Stop()
diff --git a/slog/slog.go b/slog/slog.go
@@ -172,7 +172,7 @@ func structValue(v reflect.Value) slog.Value {
 		t := v.Type()
 		numField := t.NumField()
 		attrs = make([]slog.Attr, 0, numField)
-		for i := 0; i < numField; i++ {
+		for i := range numField {
 			fieldType := t.Field(i)
 			fieldValue := v.Field(i)
 			if !fieldType.IsExported() {
diff --git a/util/errors/error.go b/util/errors/error.go
@@ -190,7 +190,7 @@ func (e Error) MarshalJSON() ([]byte, error) {
 		}
 		marshaledErrors = append(marshaledErrors, string(res))
 	}
-	return []byte(fmt.Sprintf("[%s]", strings.Join(marshaledErrors, ","))), nil
+	return fmt.Appendf(nil, "[%s]", strings.Join(marshaledErrors, ",")), nil
 }
 
 func (Error) marshalReason(e error) ([]byte, error) {
diff --git a/util/httputil/httputil_bench_test.go b/util/httputil/httputil_bench_test.go
@@ -7,7 +7,7 @@ import (
 func BenchmarkParseMultiValuesHeader(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for b.Loop() {
 		ParseMultiValuesHeader("text/html,text/*;q=0.5,*/*;q=0.7")
 	}
 }
diff --git a/util/walk/walk.go b/util/walk/walk.go
@@ -204,7 +204,7 @@ func (p *Path) walkArray(element any, parent any, index int, trackPath *Path, la
 		f(ctx)
 		return !ctx.stop
 	}
-	for i := 0; i < length; i++ {
+	for i := range length {
 		j := i
 		trackClone := trackPath.Clone()
 		tail := trackClone.Tail()
diff --git a/validation/array.go b/validation/array.go
@@ -65,7 +65,7 @@ func convertArray(array any, parentType reflect.Type) any {
 	}
 
 	convertedArray := reflect.MakeSlice(reflect.SliceOf(elemType), 0, length)
-	for i := 0; i < length; i++ {
+	for i := range length {
 		convertedArray = reflect.Append(convertedArray, list.Index(i).Elem())
 	}
 
diff --git a/validation/ruleset_test.go b/validation/ruleset_test.go
@@ -15,7 +15,7 @@ func requiredIfTestFunction(_ *Context) bool { return true }
 
 func BenchmarkRuleSet(b *testing.B) {
 	b.ReportAllocs()
-	for n := 0; n < b.N; n++ {
+	for b.Loop() {
 		ruleset := RuleSet{
 			{Path: CurrentElement, Rules: List{
 				Object(),
diff --git a/validation/unique.go b/validation/unique.go
@@ -19,23 +19,23 @@ import (
 // https://github.com/ClickHouse/clickhouse-go/blob/main/TYPES.md
 // Go types uint and int are not specified, default to 'UInt64' and 'Int64', respectively
 var clickhouseTypes = map[reflect.Type]string{
-	reflect.TypeOf(uint64(0)):     "UInt64",
-	reflect.TypeOf(uint32(0)):     "UInt32",
-	reflect.TypeOf(uint16(0)):     "UInt16",
-	reflect.TypeOf(uint8(0)):      "UInt8",
-	reflect.TypeOf(uint(0)):       "UInt64",
-	reflect.TypeOf(int64(0)):      "Int64",
-	reflect.TypeOf(int32(0)):      "Int32",
-	reflect.TypeOf(int16(0)):      "Int16",
-	reflect.TypeOf(int8(0)):       "Int8",
-	reflect.TypeOf(int(0)):        "Int64",
-	reflect.TypeOf(float32(0)):    "Float32",
-	reflect.TypeOf(float64(0)):    "Float64",
-	reflect.TypeOf(""):            "String",
-	reflect.TypeOf(true):          "Bool",
-	reflect.TypeOf(uuid.New()):    "UUID",
-	reflect.TypeOf(time.Now()):    "DateTime64",
-	reflect.TypeOf(big.NewInt(0)): "Int256",
+	reflect.TypeFor[uint64]():    "UInt64",
+	reflect.TypeFor[uint32]():    "UInt32",
+	reflect.TypeFor[uint16]():    "UInt16",
+	reflect.TypeFor[uint8]():     "UInt8",
+	reflect.TypeFor[uint]():      "UInt64",
+	reflect.TypeFor[int64]():     "Int64",
+	reflect.TypeFor[int32]():     "Int32",
+	reflect.TypeFor[int16]():     "Int16",
+	reflect.TypeFor[int8]():      "Int8",
+	reflect.TypeFor[int]():       "Int64",
+	reflect.TypeFor[float32]():   "Float32",
+	reflect.TypeFor[float64]():   "Float64",
+	reflect.TypeFor[string]():    "String",
+	reflect.TypeFor[bool]():      "Bool",
+	reflect.TypeFor[uuid.UUID](): "UUID",
+	reflect.TypeFor[time.Time](): "DateTime64",
+	reflect.TypeFor[*big.Int]():  "Int256",
 }
 
 // UniqueValidator validates the field under validation must have a unique value in database
diff --git a/validation/validator.go b/validation/validator.go
@@ -563,7 +563,7 @@ func makeGenericSlice(original any) ([]any, bool) {
 	}
 	length := list.Len()
 	newSlice := make([]any, 0, length)
-	for i := 0; i < length; i++ {
+	for i := range length {
 		newSlice = append(newSlice, list.Index(i).Interface())
 	}
 	return newSlice, true

Original file line number	Diff line number	Diff line change
`@@ -320,7 +320,7 @@ func override(src object, dst object) error {`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`func (o object) validate(key string) error {`
`323`		`- message := ""`
	`323`	`+ var message strings.Builder`
`324`	`324`	`valid := true`
`325`	`325`	`for k, entry := range o {`
`326`	`326`	`var subKey string`
`@@ -331,17 +331,17 @@ func (o object) validate(key string) error {`
`331`	`331`	`}`
`332`	`332`	`if category, ok := entry.(object); ok {`
`333`	`333`	`if err := category.validate(subKey); err != nil {`
`334`		`- message += err.Error()`
	`334`	`+ message.WriteString(err.Error())`
`335`	`335`	`valid = false`
`336`	`336`	`}`
`337`	`337`	`} else if err := entry.(*Entry).validate(subKey); err != nil {`
`338`		`- message += "\n\t- " + err.Error()`
	`338`	`+ message.WriteString("\n\t- " + err.Error())`
`339`	`339`	`valid = false`
`340`	`340`	`}`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`if !valid {`
`344`		`- return fmt.Errorf("%s", message)`
	`344`	`+ return fmt.Errorf("%s", message.String())`
`345`	`345`	`}`
`346`	`346`	`return nil`
`347`	`347`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ func loadDefaults(src object, dst object) {`
`65`	`65`	`list := reflect.ValueOf(value)`
`66`	`66`	`length := list.Len()`
`67`	`67`	`slice := reflect.MakeSlice(reflect.SliceOf(t.Elem()), 0, length)`
`68`		`- for i := 0; i < length; i++ {`
	`68`	`+ for i := range length {`
`69`	`69`	`slice = reflect.Append(slice, list.Index(i))`
`70`	`70`	`}`
`71`	`71`	`value = slice.Interface()`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func (e *Entry) validate(key string) error {`
`67`	`67`	`// Accepted values for slices define the values that can be used inside the slice`
`68`	`68`	`// It doesn't represent the value of the slice itself (content and order)`
`69`	`69`	`length := v.Len()`
`70`		`- for i := 0; i < length; i++ {`
	`70`	`+ for i := range length {`
`71`	`71`	`if !lo.Contains(e.AuthorizedValues, v.Index(i).Interface()) {`
`72`	`72`	`return errors.Errorf("%q elements must have one of the following values: %v", key, e.AuthorizedValues)`
`73`	`73`	`}`