refactor(lint): add Description, Infos to Issue

Author: muthukrishnan24

formatter/default.go

@@ -63,12 +63,12 @@ func (f *DefaultFormatter) writeIssues(w *strings.Builder, sign, title string, i
 func (f *DefaultFormatter) writeIssue(w *strings.Builder, sign string, issue *lint.Issue) {
 	space := "  "
 
-	// ❌ rule-name:
-	//    - message1
-	//    - message2
+	// ❌ rule-name: description
+	//    - info1
+	//    - info2
 
-	fmt.Fprintf(w, "\n%s %s:", space+sign, issue.Name())
-	for _, msg := range issue.Message() {
+	fmt.Fprintf(w, "\n%s %s: %s", space+sign, issue.RuleName(), issue.Description())
+	for _, msg := range issue.Infos() {
 		fmt.Fprintf(w, "\n%s - %s", space+space, msg)
 	}
 }

formatter/json.go

@@ -19,7 +19,6 @@ func (f *JSONFormatter) Format(result *lint.Result) (string, error) {
 	output := make(map[string]interface{}, 4)
 
 	output["input"] = result.Input()
-	output["valid"] = result.IsOK()
 	output["issues"] = f.formatIssue(result.Issues())
 
 	formatted, err := json.Marshal(output)
@@ -35,11 +34,12 @@ func (f *JSONFormatter) formatIssue(issues []*lint.Issue) []interface{} {
 	for _, issue := range issues {
 		output := make(map[string]interface{})
 
-		output["name"] = issue.Name()
+		output["name"] = issue.RuleName()
 		output["severity"] = issue.Severity()
+		output["description"] = issue.Description()
 
-		if len(issue.Message()) > 0 {
-			output["messages"] = issue.Message()
+		if len(issue.Infos()) > 0 {
+			output["infos"] = issue.Infos()
 		}
 
 		formattedIssues = append(formattedIssues, output)

internal/cmd/lint.go

@@ -46,16 +46,16 @@ func runLint(confFilePath, fileInput string) (lintResult string, hasError bool,
 		return "", false, err
 	}
 
-	res, err := linter.Lint(commitMsg)
+	result, err := linter.Lint(commitMsg)
 	if err != nil {
 		return "", false, err
 	}
 
-	resStr, err := format.Format(res)
+	output, err := format.Format(result)
 	if err != nil {
 		return "", false, err
 	}
-	return resStr, hasErrorSeverity(res), nil
+	return output, hasErrorSeverity(result), nil
 }
 
 func getLinter(confParam string) (*lint.Linter, lint.Formatter, error) {
@@ -136,9 +136,9 @@ func readStdInPipe() (string, error) {
 	return strings.TrimSpace(s), nil
 }
 
-func hasErrorSeverity(res *lint.Result) bool {
-	for _, r := range res.Issues() {
-		if r.Severity() == lint.SeverityError {
+func hasErrorSeverity(result *lint.Result) bool {
+	for _, i := range result.Issues() {
+		if i.Severity() == lint.SeverityError {
 			return true
 		}
 	}

lint/lint.go

@@ -66,5 +66,5 @@ type Rule interface {
 	// Validate validates the rule for given commit message
 	// if given commit is valid, return true and messages slice are ignored
 	// if invalid, return a error messages with false
-	Validate(msg Commit) (messages []string, isValid bool)
+	Validate(msg Commit) (issue *Issue, isValid bool)
 }

lint/linter.go

@@ -23,43 +23,42 @@ func New(conf *Config, rules []Rule) (*Linter, error) {
 func (l *Linter) Lint(commitMsg string) (*Result, error) {
 	msg, err := l.parser.Parse(commitMsg)
 	if err != nil {
-		return l.parserErrorRule(commitMsg, err)
+		issues := l.parserErrorRule(commitMsg, err)
+		return newResult(commitMsg, issues...), nil
 	}
 	return l.LintCommit(msg)
 }
 
 // LintCommit checks the given Commit against rules
 func (l *Linter) LintCommit(msg Commit) (*Result, error) {
-	res := newResult(msg.Message())
+	issues := make([]*Issue, 0, len(l.rules))
 
 	for _, rule := range l.rules {
 		currentRule := rule
 		severity := l.conf.GetSeverity(currentRule.Name())
-		ruleRes, isValid := l.runRule(currentRule, severity, msg)
+		issue, isValid := l.runRule(currentRule, severity, msg)
 		if !isValid {
-			res.add(ruleRes)
+			issues = append(issues, issue)
 		}
 	}
 
-	return res, nil
+	return newResult(msg.Message(), issues...), nil
 }
 
 func (l *Linter) runRule(rule Rule, severity Severity, msg Commit) (*Issue, bool) {
-	failMsgs, isOK := rule.Validate(msg)
-	if isOK {
+	issue, isValid := rule.Validate(msg)
+	if isValid {
 		return nil, true
 	}
-	res := newIssue(rule.Name(), failMsgs, severity)
-	return res, false
-}
-
-func (l *Linter) parserErrorRule(commitMsg string, err error) (*Result, error) {
-	res := newResult(commitMsg)
 
-	errMsg := err.Error()
-
-	ruleFail := newIssue("parser", []string{errMsg}, SeverityError)
-	res.add(ruleFail)
+	issue.ruleName = rule.Name()
+	issue.severity = severity
+	return issue, false
+}
 
-	return res, nil
+func (l *Linter) parserErrorRule(commitMsg string, err error) []*Issue {
+	issue := NewIssue(err.Error())
+	issue.ruleName = "parser"
+	issue.severity = SeverityError
+	return []*Issue{issue}
 }

lint/result.go

@@ -1,52 +1,51 @@
 package lint
 
-// Result holds Result of linter
+// Result holds a linter result
 type Result struct {
-	inputMsg string
-
+	input  string
 	issues []*Issue
 }
 
-func newResult(inputMsg string) *Result {
+func newResult(input string, issues ...*Issue) *Result {
 	return &Result{
-		inputMsg: inputMsg,
+		input:  input,
+		issues: issues,
 	}
 }
 
-// AddError adds
-func (res *Result) add(r *Issue) {
-	res.issues = append(res.issues, r)
-}
-
-// IsOK returns true if commit message passed all the rules
-func (res *Result) IsOK() bool { return len(res.issues) == 0 }
-
-// Input returns input commit message
-func (res *Result) Input() string { return res.inputMsg }
+// Input returns the input commit message
+func (r *Result) Input() string { return r.input }
 
-// Issues returns rule Issues
-func (res *Result) Issues() []*Issue { return res.issues }
+// Issues returns linter issues
+func (r *Result) Issues() []*Issue { return r.issues }
 
-// Issue holds Failure of a linter rule
+// Issue holds a rule result
 type Issue struct {
-	name     string
+	ruleName string
+
 	severity Severity
-	messages []string
+
+	description string
+
+	additionalInfos []string
 }
 
-func newIssue(name string, msgs []string, severity Severity) *Issue {
+// NewIssue returns a new issue
+func NewIssue(desc string, infos ...string) *Issue {
 	return &Issue{
-		name:     name,
-		messages: msgs,
-		severity: severity,
+		description:     desc,
+		additionalInfos: infos,
 	}
 }
 
-// Name returns rule name
-func (r *Issue) Name() string { return r.name }
+// RuleName returns rule name
+func (r *Issue) RuleName() string { return r.ruleName }
 
 // Severity returns severity of the Rule Failure
 func (r *Issue) Severity() Severity { return r.severity }
 
-// Message returns the error messages of failed rule
-func (r *Issue) Message() []string { return r.messages }
+// Description returns description of the issue
+func (r *Issue) Description() string { return r.description }
+
+// Infos returns additional infos about the issue
+func (r *Issue) Infos() []string { return r.additionalInfos }

rule/body_max_length.go

@@ -22,6 +22,6 @@ func (r *BodyMaxLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates BodyMaxLenRule
-func (r *BodyMaxLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLen(r.CheckLen, msg.Body())
+func (r *BodyMaxLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLen("body", r.CheckLen, msg.Body())
 }

rule/body_max_line_length.go

@@ -24,6 +24,6 @@ func (r *BodyMaxLineLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates BodyMaxLineLenRule rule
-func (r *BodyMaxLineLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLineLength(r.CheckLen, msg.Body())
+func (r *BodyMaxLineLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLineLength("body", r.CheckLen, msg.Body())
 }

rule/body_min_length.go

@@ -22,6 +22,6 @@ func (r *BodyMinLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates BodyMinLenRule
-func (r *BodyMinLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMinLen(r.CheckLen, msg.Body())
+func (r *BodyMinLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMinLen("body", r.CheckLen, msg.Body())
 }

rule/desc_max_length.go

@@ -22,6 +22,6 @@ func (r *DescriptionMaxLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates DescriptionMaxLenRule
-func (r *DescriptionMaxLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLen(r.CheckLen, msg.Description())
+func (r *DescriptionMaxLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLen("description", r.CheckLen, msg.Description())
 }

rule/desc_min_length.go

@@ -22,6 +22,6 @@ func (r *DescriptionMinLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates DescriptionMinLenRule
-func (r *DescriptionMinLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMinLen(r.CheckLen, msg.Description())
+func (r *DescriptionMinLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMinLen("description", r.CheckLen, msg.Description())
 }

rule/footer_enum.go

@@ -3,6 +3,7 @@ package rule
 import (
 	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/conventionalcommit/commitlint/lint"
 )
@@ -29,20 +30,21 @@ func (r *FooterEnumRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates FooterEnumRule
-func (r *FooterEnumRule) Validate(msg lint.Commit) ([]string, bool) {
-	msgs := []string{}
+func (r *FooterEnumRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	var invalids []string
 
 	for _, note := range msg.Notes() {
 		isFound := search(r.Tokens, note.Token())
 		if !isFound {
-			errMsg := fmt.Sprintf("footer token '%s' is not allowed, you can use one of %v", note.Token(), r.Tokens)
-			msgs = append(msgs, errMsg)
+			invalids = append(invalids, note.Token())
 		}
 	}
 
-	if len(msgs) == 0 {
+	if len(invalids) == 0 {
 		return nil, true
 	}
 
-	return msgs, false
+	desc := fmt.Sprintf("you can use one of %v", r.Tokens)
+	info := fmt.Sprintf("[%s] tokens are not allowed", strings.Join(invalids, ", "))
+	return lint.NewIssue(desc, info), false
 }

rule/footer_max_length.go

@@ -22,6 +22,6 @@ func (r *FooterMaxLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates FooterMaxLenRule
-func (r *FooterMaxLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLen(r.CheckLen, msg.Footer())
+func (r *FooterMaxLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLen("footer", r.CheckLen, msg.Footer())
 }

rule/footer_max_line_length.go

@@ -22,6 +22,6 @@ func (r *FooterMaxLineLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates FooterMaxLineLenRule rule
-func (r *FooterMaxLineLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLineLength(r.CheckLen, msg.Footer())
+func (r *FooterMaxLineLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLineLength("footer", r.CheckLen, msg.Footer())
 }

rule/footer_min_length.go

@@ -22,6 +22,6 @@ func (r *FooterMinLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates FooterMinLenRule
-func (r *FooterMinLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMinLen(r.CheckLen, msg.Footer())
+func (r *FooterMinLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMinLen("footer", r.CheckLen, msg.Footer())
 }

rule/header_max_length.go

@@ -22,6 +22,6 @@ func (r *HeadMaxLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates HeadMaxLenRule
-func (r *HeadMaxLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLen(r.CheckLen, msg.Header())
+func (r *HeadMaxLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLen("header", r.CheckLen, msg.Header())
 }

rule/header_min_length.go

@@ -24,6 +24,6 @@ func (r *HeadMinLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates HeadMinLenRule
-func (r *HeadMinLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMinLen(r.CheckLen, msg.Header())
+func (r *HeadMinLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMinLen("header", r.CheckLen, msg.Header())
 }

rule/rule.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+
+	"github.com/conventionalcommit/commitlint/lint"
 )
 
 func errInvalidArg(ruleName string, err error) error {
@@ -15,66 +17,80 @@ func errInvalidFlag(ruleName, flagName string, err error) error {
 	return fmt.Errorf("%s: invalid flag '%s': %v", ruleName, flagName, err)
 }
 
-func checkCharset(charset, toCheck string) (string, bool) {
+func formMinLenMsg(typ string, actualLen, expectedLen int) string {
+	return fmt.Sprintf("%s length is %d, should have atleast %d chars", typ, actualLen, expectedLen)
+}
+
+func formMaxLenDesc(typ string, actualLen, expectedLen int) string {
+	return fmt.Sprintf("%s length is %d, should have less than %d chars", typ, actualLen, expectedLen)
+}
+
+func formMaxLineLenDesc(typ string, expectedLen int) string {
+	return fmt.Sprintf("each %s line should have less than %d chars", typ, expectedLen)
+}
+
+func search(arr []string, toFind string) bool {
+	ind := sort.Search(len(arr), func(i int) bool {
+		return arr[i] >= toFind
+	})
+	return ind < len(arr) && arr[ind] == toFind
+}
+
+func validateCharset(allowedCharset, toCheck string) (string, bool) {
 	invalidRunes := ""
 	for _, ch := range toCheck {
-		if !strings.ContainsRune(charset, ch) {
+		if !strings.ContainsRune(allowedCharset, ch) {
 			invalidRunes += string(ch)
 		}
 	}
 
 	if invalidRunes == "" {
 		return "", true
 	}
-
 	return invalidRunes, false
 }
 
-func search(arr []string, toFind string) bool {
-	ind := sort.Search(len(arr), func(i int) bool {
-		return arr[i] >= toFind
-	})
-	return ind < len(arr) && arr[ind] == toFind
+func validateMinLen(typ string, expectedLen int, toCheck string) (*lint.Issue, bool) {
+	actualLen := len(toCheck)
+	if actualLen >= expectedLen {
+		return nil, true
+	}
+
+	desc := formMinLenMsg(typ, actualLen, expectedLen)
+	return lint.NewIssue(desc), false
 }
 
-func checkMaxLen(checkLen int, toCheck string) ([]string, bool) {
-	if checkLen < 0 {
+func validateMaxLen(typ string, expectedLen int, toCheck string) (*lint.Issue, bool) {
+	if expectedLen < 0 {
 		return nil, true
 	}
 
-	if len(toCheck) <= checkLen {
+	if len(toCheck) <= expectedLen {
 		return nil, true
 	}
 
-	errMsg := fmt.Sprintf("length is %d, should have less than %d chars", len(toCheck), checkLen)
-	return []string{errMsg}, false
+	desc := formMaxLenDesc(typ, len(toCheck), expectedLen)
+	return lint.NewIssue(desc), false
 }
 
-func checkMaxLineLength(checkLen int, toCheck string) ([]string, bool) {
+func validateMaxLineLength(typ string, expectedLen int, toCheck string) (*lint.Issue, bool) {
 	lines := strings.Split(toCheck, "\n")
 
 	msgs := []string{}
 	for index, line := range lines {
 		actualLen := len(line)
-		if actualLen > checkLen {
-			errMsg := fmt.Sprintf("in line %d, length is %d, should have less than %d chars", index+1, actualLen, checkLen)
+		if actualLen > expectedLen {
+			errMsg := fmt.Sprintf("in line %d, length is %d", index+1, actualLen)
 			msgs = append(msgs, errMsg)
 		}
 	}
 
 	if len(msgs) == 0 {
 		return nil, true
 	}
-	return msgs, false
-}
 
-func checkMinLen(checkLen int, toCheck string) ([]string, bool) {
-	actualLen := len(toCheck)
-	if actualLen >= checkLen {
-		return nil, true
-	}
-	errMsg := fmt.Sprintf("length is %d, should have atleast %d chars", actualLen, checkLen)
-	return []string{errMsg}, false
+	desc := formMaxLineLenDesc(typ, expectedLen)
+	return lint.NewIssue(desc, msgs...), false
 }
 
 func setBoolArg(retVal *bool, arg interface{}) error {
@@ -151,6 +167,7 @@ func toStringArr(arg interface{}) ([]string, error) {
 		return strArr, nil
 	case []string:
 		return argVal, nil
+	default:
+		return nil, fmt.Errorf("expects array of string value, but got %#v", arg)
 	}
-	return nil, fmt.Errorf("expects array of string value, but got %#v", arg)
 }

rule/scope_charset.go

@@ -1,8 +1,6 @@
 package rule
 
 import (
-	"fmt"
-
 	"github.com/conventionalcommit/commitlint/lint"
 )
 
@@ -26,12 +24,13 @@ func (r *ScopeCharsetRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates ScopeCharsetRule
-func (r *ScopeCharsetRule) Validate(msg lint.Commit) ([]string, bool) {
-	invalidChars, isValid := checkCharset(r.Charset, msg.Scope())
+func (r *ScopeCharsetRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	invalidChars, isValid := validateCharset(r.Charset, msg.Scope())
 	if isValid {
 		return nil, true
 	}
 
-	errMsg := fmt.Sprintf("scope contains invalid char '%s', allowed chars are [%s]", invalidChars, r.Charset)
-	return []string{errMsg}, false
+	desc := "type can only have these chars [" + r.Charset + "]"
+	err := "invalid characters [" + invalidChars + "]"
+	return lint.NewIssue(desc, err), false
 }

rule/scope_enum.go

@@ -40,19 +40,20 @@ func (r *ScopeEnumRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates ScopeEnumRule
-func (r *ScopeEnumRule) Validate(msg lint.Commit) ([]string, bool) {
+func (r *ScopeEnumRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
 	if msg.Scope() == "" {
 		if r.AllowEmpty {
 			return nil, true
 		}
 		errMsg := fmt.Sprintf("empty scope is not allowed, you can use one of %v", r.Scopes)
-		return []string{errMsg}, false
+		return lint.NewIssue(errMsg), false
 	}
 
 	isFound := search(r.Scopes, msg.Scope())
-	if !isFound {
-		errMsg := fmt.Sprintf("scope '%s' is not allowed, you can use one of %v", msg.Scope(), r.Scopes)
-		return []string{errMsg}, false
+	if isFound {
+		return nil, true
 	}
-	return nil, true
+
+	errMsg := fmt.Sprintf("scope '%s' is not allowed, you can use one of %v", msg.Scope(), r.Scopes)
+	return lint.NewIssue(errMsg), false
 }

rule/scope_max_length.go

@@ -22,6 +22,6 @@ func (r *ScopeMaxLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates ScopeMaxLenRule
-func (r *ScopeMaxLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLen(r.CheckLen, msg.Scope())
+func (r *ScopeMaxLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLen("scope", r.CheckLen, msg.Scope())
 }

rule/scope_min_length.go

@@ -22,6 +22,6 @@ func (r *ScopeMinLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates ScopeMinLenRule
-func (r *ScopeMinLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMinLen(r.CheckLen, msg.Scope())
+func (r *ScopeMinLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMinLen("scope", r.CheckLen, msg.Scope())
 }

rule/type_charset.go

@@ -1,8 +1,6 @@
 package rule
 
 import (
-	"fmt"
-
 	"github.com/conventionalcommit/commitlint/lint"
 )
 
@@ -26,12 +24,14 @@ func (r *TypeCharsetRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates TypeCharsetRule
-func (r *TypeCharsetRule) Validate(msg lint.Commit) ([]string, bool) {
-	invalidChars, isValid := checkCharset(r.Charset, msg.Type())
+func (r *TypeCharsetRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	invalidChars, isValid := validateCharset(r.Charset, msg.Type())
 	if isValid {
 		return nil, true
 	}
 
-	errMsg := fmt.Sprintf("type contains invalid char '%s', allowed chars are [%s]", invalidChars, r.Charset)
-	return []string{errMsg}, false
+	desc := "type can only have chars [" + r.Charset + "]"
+	info := "invalid characters [" + invalidChars + "]"
+
+	return lint.NewIssue(desc, info), false
 }

rule/type_enum.go

@@ -29,11 +29,11 @@ func (r *TypeEnumRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates TypeEnumRule
-func (r *TypeEnumRule) Validate(msg lint.Commit) ([]string, bool) {
+func (r *TypeEnumRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
 	isFound := search(r.Types, msg.Type())
-	if !isFound {
-		errMsg := fmt.Sprintf("type '%s' is not allowed, you can use one of %v", msg.Type(), r.Types)
-		return []string{errMsg}, false
+	if isFound {
+		return nil, true
 	}
-	return nil, true
+	desc := fmt.Sprintf("type '%s' is not allowed, you can use one of %v", msg.Type(), r.Types)
+	return lint.NewIssue(desc), false
 }

rule/type_max_length.go

@@ -22,6 +22,6 @@ func (r *TypeMaxLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates TypeMaxLenRule
-func (r *TypeMaxLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMaxLen(r.CheckLen, msg.Type())
+func (r *TypeMaxLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMaxLen("type", r.CheckLen, msg.Type())
 }

rule/type_min_length.go

@@ -22,6 +22,6 @@ func (r *TypeMinLenRule) Apply(setting lint.RuleSetting) error {
 }
 
 // Validate validates TypeMinLenRule
-func (r *TypeMinLenRule) Validate(msg lint.Commit) ([]string, bool) {
-	return checkMinLen(r.CheckLen, msg.Type())
+func (r *TypeMinLenRule) Validate(msg lint.Commit) (*lint.Issue, bool) {
+	return validateMinLen("type", r.CheckLen, msg.Type())
 }