refactor(rule): change error message

muthukrishnan24 · muthukrishnan24 · commit 5d1e1f6528a1 · 2021-09-30T09:11:26.000+05:30
diff --git a/rule/charset.go b/rule/charset.go
@@ -27,7 +27,11 @@ func (r *ScopeCharsetRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *ScopeCharsetRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setStringArg(&r.Charset, arg, r.Name())
+	err := setStringArg(&r.Charset, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // TypeCharsetRule to validate max length of header
@@ -50,7 +54,11 @@ func (r *TypeCharsetRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *TypeCharsetRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setStringArg(&r.Charset, arg, r.Name())
+	err := setStringArg(&r.Charset, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 func checkCharset(charset, toCheck string) (string, bool) {
diff --git a/rule/enum.go b/rule/enum.go
@@ -37,17 +37,18 @@ func (r *ScopeEnumRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *ScopeEnumRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	err := setStringArrArg(&r.Scopes, arg, r.Name())
+	err := setStringArrArg(&r.Scopes, arg)
 	if err != nil {
-		return err
+		return errInvalidArg(r.Name(), err)
 	}
 
 	allowEmpty, ok := flags["allow-empty"]
 	if ok {
-		err := setBoolArg(&r.AllowEmpty, allowEmpty, r.Name())
+		err := setBoolArg(&r.AllowEmpty, allowEmpty)
 		if err != nil {
-			return err
+			return errInvalidFlag(r.Name(), "allow-empty", err)
 		}
+		return nil
 	}
 
 	// sorting the string elements for binary search
@@ -75,9 +76,9 @@ func (r *TypeEnumRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *TypeEnumRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	err := setStringArrArg(&r.Types, arg, r.Name())
+	err := setStringArrArg(&r.Types, arg)
 	if err != nil {
-		return err
+		return errInvalidArg(r.Name(), err)
 	}
 	// sorting the string elements for binary search
 	sort.Strings(r.Types)
diff --git a/rule/errors.go b/rule/errors.go
@@ -0,0 +1,11 @@
+package rule
+
+import "fmt"
+
+func errInvalidArg(ruleName string, err error) error {
+	return fmt.Errorf("%s: invalid argument: %v", ruleName, err)
+}
+
+func errInvalidFlag(ruleName, flagName string, err error) error {
+	return fmt.Errorf("%s: invalid flag '%s': %v", ruleName, flagName, err)
+}
diff --git a/rule/max_length.go b/rule/max_length.go
@@ -21,7 +21,11 @@ func (r *HeadMaxLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *HeadMaxLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // BodyMaxLenRule to validate max length of body
@@ -39,7 +43,11 @@ func (r *BodyMaxLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *BodyMaxLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // FooterMaxLenRule to validate max length of footer
@@ -57,7 +65,11 @@ func (r *FooterMaxLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *FooterMaxLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // TypeMaxLenRule to validate max length of type
@@ -75,7 +87,11 @@ func (r *TypeMaxLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *TypeMaxLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // ScopeMaxLenRule to validate max length of type
@@ -93,7 +109,11 @@ func (r *ScopeMaxLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *ScopeMaxLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // DescriptionMaxLenRule to validate max length of type
@@ -111,7 +131,11 @@ func (r *DescriptionMaxLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *DescriptionMaxLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 func checkMaxLen(checkLen int, toCheck string) (string, bool) {
diff --git a/rule/max_line_length.go b/rule/max_line_length.go
@@ -22,7 +22,11 @@ func (r *BodyMaxLineLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *BodyMaxLineLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // FooterMaxLineLenRule to validate max line length of footer
@@ -40,7 +44,11 @@ func (r *FooterMaxLineLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *FooterMaxLineLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 func checkMaxLineLength(checkLen int, toCheck string) (string, bool) {
diff --git a/rule/min_length.go b/rule/min_length.go
@@ -21,7 +21,11 @@ func (r *HeadMinLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *HeadMinLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // BodyMinLenRule to validate min length of body
@@ -39,7 +43,11 @@ func (r *BodyMinLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *BodyMinLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // FooterMinLenRule to validate min length of footer
@@ -57,7 +65,11 @@ func (r *FooterMinLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *FooterMinLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // TypeMinLenRule to validate min length of type
@@ -75,7 +87,11 @@ func (r *TypeMinLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *TypeMinLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // ScopeMinLenRule to validate min length of scope
@@ -93,7 +109,11 @@ func (r *ScopeMinLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *ScopeMinLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 // DescriptionMinLenRule to validate min length of description
@@ -111,7 +131,11 @@ func (r *DescriptionMinLenRule) Validate(msg *lint.Commit) (string, bool) {
 
 // Apply sets the needed argument for the rule
 func (r *DescriptionMinLenRule) Apply(arg interface{}, flags map[string]interface{}) error {
-	return setIntArg(&r.CheckLen, arg, r.Name())
+	err := setIntArg(&r.CheckLen, arg)
+	if err != nil {
+		return errInvalidArg(r.Name(), err)
+	}
+	return nil
 }
 
 func checkMinLen(checkLen int, toCheck string) (string, bool) {
diff --git a/rule/util.go b/rule/util.go
@@ -4,80 +4,80 @@ import (
 	"fmt"
 )
 
-func setBoolArg(retVal *bool, arg interface{}, ruleName string) error {
-	boolVal, err := toBool(arg, ruleName)
+func setBoolArg(retVal *bool, arg interface{}) error {
+	boolVal, err := toBool(arg)
 	if err != nil {
 		return err
 	}
 	*retVal = boolVal
 	return nil
 }
 
-func setIntArg(retVal *int, arg interface{}, ruleName string) error {
-	intVal, err := toInt(arg, ruleName)
+func setIntArg(retVal *int, arg interface{}) error {
+	intVal, err := toInt(arg)
 	if err != nil {
 		return err
 	}
 	*retVal = intVal
 	return nil
 }
 
-func setStringArg(retVal *string, arg interface{}, ruleName string) error {
-	strVal, err := toString(arg, ruleName)
+func setStringArg(retVal *string, arg interface{}) error {
+	strVal, err := toString(arg)
 	if err != nil {
 		return err
 	}
 	*retVal = strVal
 	return nil
 }
 
-func setStringArrArg(retVal *[]string, arg interface{}, ruleName string) error {
-	arrVal, err := toStringArr(arg, ruleName)
+func setStringArrArg(retVal *[]string, arg interface{}) error {
+	arrVal, err := toStringArr(arg)
 	if err != nil {
 		return err
 	}
 	*retVal = arrVal
 	return nil
 }
 
-func toBool(arg interface{}, ruleName string) (bool, error) {
+func toBool(arg interface{}) (bool, error) {
 	boolVal, ok := arg.(bool)
 	if !ok {
-		return false, fmt.Errorf("%s expects bool value, but got %#v", ruleName, arg)
+		return false, fmt.Errorf("expects bool value, but got %#v", arg)
 	}
 	return boolVal, nil
 }
 
-func toInt(arg interface{}, ruleName string) (int, error) {
+func toInt(arg interface{}) (int, error) {
 	intVal, ok := arg.(int)
 	if !ok {
-		return 0, fmt.Errorf("%s expects int value, but got %#v", ruleName, arg)
+		return 0, fmt.Errorf("expects int value, but got %#v", arg)
 	}
 	return intVal, nil
 }
 
-func toString(arg interface{}, ruleName string) (string, error) {
+func toString(arg interface{}) (string, error) {
 	strVal, ok := arg.(string)
 	if !ok {
-		return "", fmt.Errorf("%s expects string value, but got %#v", ruleName, arg)
+		return "", fmt.Errorf("expects string value, but got %#v", arg)
 	}
 	return strVal, nil
 }
 
-func toStringArr(arg interface{}, ruleName string) ([]string, error) {
+func toStringArr(arg interface{}) ([]string, error) {
 	switch argVal := arg.(type) {
 	case []interface{}:
 		strArr := make([]string, len(argVal))
 		for index, a := range argVal {
 			strVal, ok := a.(string)
 			if !ok {
-				return nil, fmt.Errorf("%s expects array of string value, but got %#v", ruleName, arg)
+				return nil, fmt.Errorf("expects array of string value, but got %#v", arg)
 			}
 			strArr[index] = strVal
 		}
 		return strArr, nil
 	case []string:
 		return argVal, nil
 	}
-	return nil, fmt.Errorf("%s expects array of string value, but got %#v", ruleName, arg)
+	return nil, fmt.Errorf("expects array of string value, but got %#v", arg)
 }

Original file line number	Diff line number	Diff line change
`@@ -4,80 +4,80 @@ import (`
`4`	`4`	`"fmt"`
`5`	`5`	`)`
`6`	`6`
`7`		`-func setBoolArg(retVal *bool, arg interface{}, ruleName string) error {`
`8`		`- boolVal, err := toBool(arg, ruleName)`
	`7`	`+func setBoolArg(retVal *bool, arg interface{}) error {`
	`8`	`+ boolVal, err := toBool(arg)`
`9`	`9`	`if err != nil {`
`10`	`10`	`return err`
`11`	`11`	`}`
`12`	`12`	`*retVal = boolVal`
`13`	`13`	`return nil`
`14`	`14`	`}`
`15`	`15`
`16`		`-func setIntArg(retVal *int, arg interface{}, ruleName string) error {`
`17`		`- intVal, err := toInt(arg, ruleName)`
	`16`	`+func setIntArg(retVal *int, arg interface{}) error {`
	`17`	`+ intVal, err := toInt(arg)`
`18`	`18`	`if err != nil {`
`19`	`19`	`return err`
`20`	`20`	`}`
`21`	`21`	`*retVal = intVal`
`22`	`22`	`return nil`
`23`	`23`	`}`
`24`	`24`
`25`		`-func setStringArg(retVal *string, arg interface{}, ruleName string) error {`
`26`		`- strVal, err := toString(arg, ruleName)`
	`25`	`+func setStringArg(retVal *string, arg interface{}) error {`
	`26`	`+ strVal, err := toString(arg)`
`27`	`27`	`if err != nil {`
`28`	`28`	`return err`
`29`	`29`	`}`
`30`	`30`	`*retVal = strVal`
`31`	`31`	`return nil`
`32`	`32`	`}`
`33`	`33`
`34`		`-func setStringArrArg(retVal *[]string, arg interface{}, ruleName string) error {`
`35`		`- arrVal, err := toStringArr(arg, ruleName)`
	`34`	`+func setStringArrArg(retVal *[]string, arg interface{}) error {`
	`35`	`+ arrVal, err := toStringArr(arg)`
`36`	`36`	`if err != nil {`
`37`	`37`	`return err`
`38`	`38`	`}`
`39`	`39`	`*retVal = arrVal`
`40`	`40`	`return nil`
`41`	`41`	`}`
`42`	`42`
`43`		`-func toBool(arg interface{}, ruleName string) (bool, error) {`
	`43`	`+func toBool(arg interface{}) (bool, error) {`
`44`	`44`	`boolVal, ok := arg.(bool)`
`45`	`45`	`if !ok {`
`46`		`- return false, fmt.Errorf("%s expects bool value, but got %#v", ruleName, arg)`
	`46`	`+ return false, fmt.Errorf("expects bool value, but got %#v", arg)`
`47`	`47`	`}`
`48`	`48`	`return boolVal, nil`
`49`	`49`	`}`
`50`	`50`
`51`		`-func toInt(arg interface{}, ruleName string) (int, error) {`
	`51`	`+func toInt(arg interface{}) (int, error) {`
`52`	`52`	`intVal, ok := arg.(int)`
`53`	`53`	`if !ok {`
`54`		`- return 0, fmt.Errorf("%s expects int value, but got %#v", ruleName, arg)`
	`54`	`+ return 0, fmt.Errorf("expects int value, but got %#v", arg)`
`55`	`55`	`}`
`56`	`56`	`return intVal, nil`
`57`	`57`	`}`
`58`	`58`
`59`		`-func toString(arg interface{}, ruleName string) (string, error) {`
	`59`	`+func toString(arg interface{}) (string, error) {`
`60`	`60`	`strVal, ok := arg.(string)`
`61`	`61`	`if !ok {`
`62`		`- return "", fmt.Errorf("%s expects string value, but got %#v", ruleName, arg)`
	`62`	`+ return "", fmt.Errorf("expects string value, but got %#v", arg)`
`63`	`63`	`}`
`64`	`64`	`return strVal, nil`
`65`	`65`	`}`
`66`	`66`
`67`		`-func toStringArr(arg interface{}, ruleName string) ([]string, error) {`
	`67`	`+func toStringArr(arg interface{}) ([]string, error) {`
`68`	`68`	`switch argVal := arg.(type) {`
`69`	`69`	`case []interface{}:`
`70`	`70`	`strArr := make([]string, len(argVal))`
`71`	`71`	`for index, a := range argVal {`
`72`	`72`	`strVal, ok := a.(string)`
`73`	`73`	`if !ok {`
`74`		`- return nil, fmt.Errorf("%s expects array of string value, but got %#v", ruleName, arg)`
	`74`	`+ return nil, fmt.Errorf("expects array of string value, but got %#v", arg)`
`75`	`75`	`}`
`76`	`76`	`strArr[index] = strVal`
`77`	`77`	`}`
`78`	`78`	`return strArr, nil`
`79`	`79`	`case []string:`
`80`	`80`	`return argVal, nil`
`81`	`81`	`}`
`82`		`- return nil, fmt.Errorf("%s expects array of string value, but got %#v", ruleName, arg)`
	`82`	`+ return nil, fmt.Errorf("expects array of string value, but got %#v", arg)`
`83`	`83`	`}`