Allow to specify option with dashes

alexandear · alexandear · commit 1be88553f3f8 · 2025-03-16T11:32:08.000+02:00
diff --git a/rule/add_constant_test.go b/rule/add_constant_test.go
@@ -32,11 +32,11 @@ func TestAddConstantRule_Configure(t *testing.T) {
 			name: "valid arguments",
 			arguments: lint.Arguments{
 				map[string]any{
-					"allowfloats": "1.0,2.0",
-					"allowints":   "1,2",
-					"allowstrs":   "a,b",
-					"maxlitcount": "3",
-					"ignorefuncs": "fmt.Println,fmt.Printf",
+					"allowFloats": "1.0,2.0",
+					"allowInts":   "1,2",
+					"allowStrs":   "a,b",
+					"maxLitCount": "3",
+					"ignoreFuncs": "fmt.Println,fmt.Printf",
 				},
 			},
 			wantErr: nil,
diff --git a/rule/context_as_argument.go b/rule/context_as_argument.go
@@ -74,7 +74,7 @@ func (*ContextAsArgumentRule) getAllowTypesFromArguments(args lint.Arguments) (m
 			return nil, fmt.Errorf("invalid argument to the context-as-argument rule. Expecting a k,v map, got %T", args[0])
 		}
 		for k, v := range argKV {
-			switch strings.ToLower(k) {
+			switch ruleOptionFromArg(k) {
 			case "allowtypesbefore":
 				typesBefore, ok := v.(string)
 				if !ok {
diff --git a/rule/context_as_argument_test.go b/rule/context_as_argument_test.go
@@ -19,7 +19,7 @@ func TestContextAsArgumentRule_Configure(t *testing.T) {
 			name: "valid arguments",
 			arguments: lint.Arguments{
 				map[string]any{
-					"allowtypesbefore": "AllowedBeforeType,AllowedBeforeStruct,*AllowedBeforePtrStruct,*testing.T",
+					"allowTypesBefore": "AllowedBeforeType,AllowedBeforeStruct,*AllowedBeforePtrStruct,*testing.T",
 				},
 			},
 			wantErr: nil,
diff --git a/rule/enforce_repeated_arg_type_style.go b/rule/enforce_repeated_arg_type_style.go
@@ -3,7 +3,6 @@ package rule
 import (
 	"fmt"
 	"go/ast"
-	"strings"
 
 	"github.com/mgechev/revive/lint"
 )
@@ -70,7 +69,7 @@ func (r *EnforceRepeatedArgTypeStyleRule) Configure(arguments lint.Arguments) er
 		r.funcRetValStyle = valstyle
 	case map[string]any: // expecting map[string]string
 		for k, v := range funcArgStyle {
-			switch strings.ToLower(k) {
+			switch ruleOptionFromArg(k) {
 			case "funcargstyle":
 				val, ok := v.(string)
 				if !ok {
diff --git a/rule/exported.go b/rule/exported.go
@@ -78,7 +78,7 @@ func (r *ExportedRule) Configure(arguments lint.Arguments) error {
 	for _, flag := range arguments {
 		switch flag := flag.(type) {
 		case string:
-			switch strings.ToLower(flag) {
+			switch ruleOptionFromArg(flag) {
 			case "checkprivatereceivers":
 				r.disabledChecks.PrivateReceivers = false
 			case "disablestutteringcheck":
diff --git a/rule/exported_test.go b/rule/exported_test.go
@@ -24,63 +24,63 @@ func TestExportedRule_Configure(t *testing.T) {
 		},
 		{
 			name:               "checkPrivateReceivers",
-			arguments:          lint.Arguments{"checkprivatereceivers"},
+			arguments:          lint.Arguments{"checkPrivateReceivers"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: false, PublicInterfaces: true},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "disableStutteringCheck",
-			arguments:          lint.Arguments{"disablestutteringcheck"},
+			arguments:          lint.Arguments{"disableStutteringCheck"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true, Stuttering: true},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "sayRepetitiveInsteadOfStutters",
-			arguments:          lint.Arguments{"sayrepetitiveinsteadofstutters"},
+			arguments:          lint.Arguments{"sayRepetitiveInsteadOfStutters"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true},
 			wantStuttersMsg:    "is repetitive",
 		},
 		{
 			name:               "checkPublicInterface",
-			arguments:          lint.Arguments{"checkpublicinterface"},
+			arguments:          lint.Arguments{"checkPublicInterface"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: false},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "disableChecksOnConstants",
-			arguments:          lint.Arguments{"disablechecksonconstants"},
+			arguments:          lint.Arguments{"disableChecksOnConstants"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true, Const: true},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "disableChecksOnFunctions",
-			arguments:          lint.Arguments{"disablechecksonfunctions"},
+			arguments:          lint.Arguments{"disableChecksOnFunctions"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true, Function: true},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "disableChecksOnMethods",
-			arguments:          lint.Arguments{"disablechecksonmethods"},
+			arguments:          lint.Arguments{"disableChecksOnMethods"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true, Method: true},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "disableChecksOnTypes",
-			arguments:          lint.Arguments{"disablechecksontypes"},
+			arguments:          lint.Arguments{"disableChecksOnTypes"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true, Type: true},
 			wantStuttersMsg:    "stutters",
 		},
 		{
 			name:               "disableChecksOnVariables",
-			arguments:          lint.Arguments{"disablechecksonvariables"},
+			arguments:          lint.Arguments{"disableChecksOnVariables"},
 			wantErr:            nil,
 			wantDisabledChecks: disabledChecks{PrivateReceivers: true, PublicInterfaces: true, Var: true},
 			wantStuttersMsg:    "stutters",
diff --git a/rule/unused_param.go b/rule/unused_param.go
@@ -28,25 +28,31 @@ func (r *UnusedParamRule) Configure(args lint.Arguments) error {
 	if len(args) == 0 {
 		return nil
 	}
-	// Arguments = [{}]
-	options := args[0].(map[string]any)
 
-	allowRegexParam, ok := options["allowRegex"]
-	if !ok {
+	switch options := args[0].(type) {
+	case map[string]any: // Arguments = [{}]
+		for k, v := range options {
+			switch ruleOptionFromArg(k) {
+			case "allowregex":
+				// Arguments = [{allowRegex="_"}]
+				allowRegexStr, ok := v.(string)
+				if !ok {
+					return fmt.Errorf("error configuring %s rule: allowRegex is not string but [%T]", r.Name(), v)
+				}
+				var err error
+				r.allowRegex, err = regexp.Compile(allowRegexStr)
+				if err != nil {
+					return fmt.Errorf("error configuring %s rule: allowRegex is not valid regex [%s]: %w", r.Name(), allowRegexStr, err)
+				}
+				r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it to match " + r.allowRegex.String()
+			default:
+				return nil
+			}
+		}
+		return nil
+	default:
 		return nil
 	}
-	// Arguments = [{allowRegex="^_"}]
-	allowRegexStr, ok := allowRegexParam.(string)
-	if !ok {
-		return fmt.Errorf("error configuring %s rule: allowRegex is not string but [%T]", r.Name(), allowRegexParam)
-	}
-	var err error
-	r.allowRegex, err = regexp.Compile(allowRegexStr)
-	if err != nil {
-		return fmt.Errorf("error configuring %s rule: allowRegex is not valid regex [%s]: %w", r.Name(), allowRegexStr, err)
-	}
-	r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it to match " + r.allowRegex.String()
-	return nil
 }
 
 // Apply applies the rule to given file.
diff --git a/rule/unused_param_test.go b/rule/unused_param_test.go
@@ -0,0 +1,96 @@
+package rule
+
+import (
+	"errors"
+	"reflect"
+	"regexp"
+	"testing"
+
+	"github.com/mgechev/revive/lint"
+)
+
+func TestUnusedParamRule_Configure(t *testing.T) {
+	tests := []struct {
+		name           string
+		arguments      lint.Arguments
+		wantErr        error
+		wantAllowRegex *regexp.Regexp
+		wantFailureMsg string
+	}{
+		{
+			name:           "no arguments",
+			arguments:      lint.Arguments{},
+			wantErr:        nil,
+			wantAllowRegex: regexp.MustCompile("^_$"),
+			wantFailureMsg: "parameter '%s' seems to be unused, consider removing or renaming it as _",
+		},
+		{
+			name: "valid arguments",
+			arguments: lint.Arguments{
+				map[string]any{
+					"allowRegex": "^_",
+				},
+			},
+			wantErr:        nil,
+			wantAllowRegex: regexp.MustCompile("^_"),
+			wantFailureMsg: "parameter '%s' seems to be unused, consider removing or renaming it to match ^_",
+		},
+		{
+			name: "missed allowRegex value",
+			arguments: lint.Arguments{
+				map[string]any{
+					"unknownKey": "123",
+				},
+			},
+			wantErr:        nil,
+			wantAllowRegex: regexp.MustCompile("^_$"),
+			wantFailureMsg: "parameter '%s' seems to be unused, consider removing or renaming it as _",
+		},
+		{
+			name: "invalid allowRegex: not a string",
+			arguments: lint.Arguments{
+				map[string]any{
+					"allowRegex": 123,
+				},
+			},
+			wantErr: errors.New("error configuring unused-parameter rule: allowRegex is not string but [int]"),
+		},
+		{
+			name: "invalid allowRegex: not a valid regex",
+			arguments: lint.Arguments{
+				map[string]any{
+					"allowRegex": "[",
+				},
+			},
+			wantErr: errors.New("error configuring unused-parameter rule: allowRegex is not valid regex [[]: error parsing regexp: missing closing ]: " + "`[`"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var rule UnusedParamRule
+
+			err := rule.Configure(tt.arguments)
+
+			if tt.wantErr != nil {
+				if err == nil {
+					t.Errorf("unexpected error: got = nil, want = %v", tt.wantErr)
+					return
+				}
+				if err.Error() != tt.wantErr.Error() {
+					t.Errorf("unexpected error: got = %v, want = %v", err, tt.wantErr)
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("unexpected error: got = %v, want = nil", err)
+			}
+			if !reflect.DeepEqual(rule.allowRegex, tt.wantAllowRegex) {
+				t.Errorf("unexpected allowRegex: got = %v, want %v", rule.allowRegex, tt.wantAllowRegex)
+			}
+			if rule.failureMsg != tt.wantFailureMsg {
+				t.Errorf("unexpected failureMessage: got = %v, want %v", rule.failureMsg, tt.wantFailureMsg)
+			}
+		})
+	}
+}
diff --git a/rule/utils.go b/rule/utils.go
@@ -7,6 +7,7 @@ import (
 	"go/printer"
 	"go/token"
 	"regexp"
+	"strings"
 
 	"github.com/mgechev/revive/lint"
 )
@@ -112,6 +113,12 @@ func checkNumberOfArguments(expected int, args lint.Arguments, ruleName string)
 	return nil
 }
 
+// ruleOptionFromArg returns an option name from the argument. It is lowercased and without dashes.
+// This function is used in the Rule.Configure method.
+func ruleOptionFromArg(arg string) string {
+	return strings.ToLower(strings.ReplaceAll(arg, "-", ""))
+}
+
 var directiveCommentRE = regexp.MustCompile("^//(line |extern |export |[a-z0-9]+:[a-z0-9])") // see https://go-review.googlesource.com/c/website/+/442516/1..2/_content/doc/comment.md#494
 
 func isDirectiveComment(line string) bool {

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ func (*ContextAsArgumentRule) getAllowTypesFromArguments(args lint.Arguments) (m`
`74`	`74`	`return nil, fmt.Errorf("invalid argument to the context-as-argument rule. Expecting a k,v map, got %T", args[0])`
`75`	`75`	`}`
`76`	`76`	`for k, v := range argKV {`
`77`		`- switch strings.ToLower(k) {`
	`77`	`+ switch ruleOptionFromArg(k) {`
`78`	`78`	`case "allowtypesbefore":`
`79`	`79`	`typesBefore, ok := v.(string)`
`80`	`80`	`if !ok {`