refactor: reduce control nesting in AddConstantRule.configure (#1128)

rule/add_constant.go

@@ -202,65 +202,64 @@ func (w *lintAddConstantRule) isStructTag(n *ast.BasicLit) bool {
 }
 
 func (r *AddConstantRule) configure(arguments lint.Arguments) {
-	if r.allowList == nil {
+	r.strLitLimit = defaultStrLitLimit
-		r.strLitLimit = defaultStrLitLimit
+	r.allowList = newAllowList()
-		r.allowList = newAllowList()
+	if len(arguments) == 0 {
-		if len(arguments) > 0 {
+		return
-			args, ok := arguments[0].(map[string]any)
+	}
-			if !ok {
+	args, ok := arguments[0].(map[string]any)
-				panic(fmt.Sprintf("Invalid argument to the add-constant rule. Expecting a k,v map, got %T", arguments[0]))
+	if !ok {
+		panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting a k,v map. Got %T", arguments[0]))
+	}
+	for k, v := range args {
+		kind := ""
+		switch k {
+		case "allowFloats":
+			kind = kindFLOAT
+			fallthrough
+		case "allowInts":
+			if kind == "" {
+				kind = kindINT
+			}
+			fallthrough
+		case "allowStrs":
+			if kind == "" {
+				kind = kindSTRING
+			}
+			list, ok := v.(string)
+			if !ok {
+				panic(fmt.Sprintf("Invalid argument to the add-constant rule, string expected. Got '%v' (%T)", v, v))
+			}
+			r.allowList.add(kind, list)
+		case "maxLitCount":
+			sl, ok := v.(string)
+			if !ok {
+				panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v' (%T)", v, v))
 			}
-			for k, v := range args {
-				kind := ""
-				switch k {
-				case "allowFloats":
-					kind = kindFLOAT
-					fallthrough
-				case "allowInts":
-					if kind == "" {
-						kind = kindINT
-					}
-					fallthrough
-				case "allowStrs":
-					if kind == "" {
-						kind = kindSTRING
-					}
-					list, ok := v.(string)
-					if !ok {
-						panic(fmt.Sprintf("Invalid argument to the add-constant rule, string expected. Got '%v' (%T)", v, v))
-					}
-					r.allowList.add(kind, list)
-				case "maxLitCount":
-					sl, ok := v.(string)
-					if !ok {
-						panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v' (%T)", v, v))
-					}
 
-					limit, err := strconv.Atoi(sl)
+			limit, err := strconv.Atoi(sl)
-					if err != nil {
+			if err != nil {
-						panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v'", v))
+				panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v'", v))
-					}
+			}
-					r.strLitLimit = limit
+			r.strLitLimit = limit
-				case "ignoreFuncs":
+		case "ignoreFuncs":
-					excludes, ok := v.(string)
+			excludes, ok := v.(string)
-					if !ok {
+			if !ok {
-						panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule, string expected. Got '%v' (%T)", v, v))
+				panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule, string expected. Got '%v' (%T)", v, v))
-					}
+			}
 
-					for _, exclude := range strings.Split(excludes, ",") {
+			for _, exclude := range strings.Split(excludes, ",") {
-						exclude = strings.Trim(exclude, " ")
+				exclude = strings.Trim(exclude, " ")
-						if exclude == "" {
+				if exclude == "" {
-							panic("Invalid argument to the ignoreFuncs parameter of add-constant rule, expected regular expression must not be empty.")
+					panic("Invalid argument to the ignoreFuncs parameter of add-constant rule, expected regular expression must not be empty.")
-						}
-
-						exp, err := regexp.Compile(exclude)
-						if err != nil {
-							panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule: regexp %q does not compile: %v", exclude, err))
-						}
-
-						r.ignoreFunctions = append(r.ignoreFunctions, exp)
-					}
 				}
+
+				exp, err := regexp.Compile(exclude)
+				if err != nil {
+					panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule: regexp %q does not compile: %v", exclude, err))
+				}
+
+				r.ignoreFunctions = append(r.ignoreFunctions, exp)
 			}
 		}
 	}

test/add_constant_test.go

@@ -7,16 +7,18 @@ import (
 	"github.com/mgechev/revive/rule"
 )
 
-func TestAddConstant(t *testing.T) {
+func TestAddConstantWithDefaultArguments(t *testing.T) {
-	args := []any{map[string]any{
+	testRule(t, "add_constant_default", &rule.AddConstantRule{}, &lint.RuleConfig{})
-		"maxLitCount": "2",
+}
-		"allowStrs":   "\"\"",
-		"allowInts":   "0,1,2",
-		"allowFloats": "0.0,1.0",
-		"ignoreFuncs": "os\\.(CreateFile|WriteFile|Chmod|FindProcess),\\.Println,ignoredFunc,\\.Info",
-	}}
 
+func TestAddConstantWithArguments(t *testing.T) {
 	testRule(t, "add_constant", &rule.AddConstantRule{}, &lint.RuleConfig{
-		Arguments: args,
+		Arguments: []any{map[string]any{
+			"maxLitCount": "2",
+			"allowStrs":   "\"\"",
+			"allowInts":   "0,1,2",
+			"allowFloats": "0.0,1.0",
+			"ignoreFuncs": "os\\.(CreateFile|WriteFile|Chmod|FindProcess),\\.Println,ignoredFunc,\\.Info",
+		}},
 	})
 }

testdata/add_constant_default.go

@@ -0,0 +1,12 @@
+package fixtures
+
+func foo() {
+	a = "ignore"
+	b = "ignore"
+
+	c = "match"
+	d = "match"
+	e = "match" // MATCH /string literal "match" appears, at least, 3 times, create a named constant for it/
+
+	f = 5 // MATCH /avoid magic numbers like '5', create a named constant for it/
+}