feat(lint)!: update Lint result APIs

* rename Result to Failure
* rename RuleResult to RuleFailure
* remove Errors, Warns APIs

Author: muthukrishnan24

cmd/lint.go

@@ -27,7 +27,7 @@ func runLint(confFilePath, fileInput string) (lintResult string, hasError bool,
 	if err != nil {
 		return "", false, err
 	}
-	return resStr, res.HasErrors(), nil
+	return resStr, hasErrorSeverity(res), nil
 }
 
 func getLinter(confFilePath string) (*lint.Linter, lint.Formatter, error) {
@@ -70,3 +70,12 @@ func getCommitMsg(fileInput string) (string, error) {
 	}
 	return string(inBytes), nil
 }
+
+func hasErrorSeverity(res *lint.Failure) bool {
+	for _, r := range res.RuleFailures() {
+		if r.Severity() == lint.SeverityError {
+			return true
+		}
+	}
+	return false
+}

formatter/default.go

@@ -15,40 +15,42 @@ type DefaultFormatter struct{}
 // Name returns name of formatter
 func (f *DefaultFormatter) Name() string { return "default" }
 
-// Format formats the lint.Result
-func (f *DefaultFormatter) Format(res *lint.Result) (string, error) {
-	return formatResult(res), nil
+// Format formats the lint.Failure
+func (f *DefaultFormatter) Format(res *lint.Failure) (string, error) {
+	return formatFailure(res), nil
 }
 
-func formatResult(res *lint.Result) string {
+func formatFailure(res *lint.Failure) string {
 	if res.IsOK() {
 		return " ✔ commit message"
 	}
-	return writeResult(res)
+	return writeFailure(res)
 }
 
-func writeResult(res *lint.Result) string {
+func writeFailure(res *lint.Failure) string {
 	str := &strings.Builder{}
 
 	str.WriteString("commitlint")
 	fmt.Fprintf(str, "\n\n→ input: %s", strconv.Quote(truncate(25, res.Input())))
 
-	if res.HasErrors() {
-		writeLintResult(str, "Errors", res.Errors(), "❌")
-	}
+	errs, warns, others := bySeverity(res)
 
-	if res.HasWarns() {
-		writeLintResult(str, "Warnings", res.Warns(), "!")
-	}
+	writeRuleFailure(str, "Errors", errs, "❌")
+	writeRuleFailure(str, "Warnings", warns, "!")
+	writeRuleFailure(str, "Other Severities", others, "?")
 
-	fmt.Fprintf(str, "\n\nTotal %d errors, %d warnings", len(res.Errors()), len(res.Warns()))
+	fmt.Fprintf(str, "\n\nTotal %d errors, %d warnings, %d other severities", len(errs), len(warns), len(others))
 	return str.String()
 }
 
-func writeLintResult(w *strings.Builder, title string, resArr []lint.RuleResult, sign string) {
+func writeRuleFailure(w *strings.Builder, title string, resArr []*lint.RuleFailure, sign string) {
+	if len(resArr) == 0 {
+		return
+	}
+
 	fmt.Fprint(w, "\n\n"+title+":")
 	for _, msg := range resArr {
-		fmt.Fprintf(w, "\n    %s %s: %s", sign, msg.Name, msg.Message)
+		fmt.Fprintf(w, "\n    %s %s: %s", sign, msg.RuleName(), msg.Message())
 	}
 }
 

formatter/json.go

@@ -14,13 +14,17 @@ type JSONFormatter struct{}
 func (f *JSONFormatter) Name() string { return "json" }
 
 // Format formats the lint.Result
-func (f *JSONFormatter) Format(res *lint.Result) (string, error) {
+func (f *JSONFormatter) Format(res *lint.Failure) (string, error) {
 	output := make(map[string]interface{}, 4)
 
+	errs, warns, others := bySeverity(res)
+
 	output["input"] = res.Input()
 	output["status"] = res.IsOK()
-	output["errors"] = f.formRuleResult(res.Errors())
-	output["warnings"] = f.formRuleResult(res.Warns())
+
+	output["errors"] = f.formRuleFailure(errs, false)
+	output["warnings"] = f.formRuleFailure(warns, false)
+	output["others"] = f.formRuleFailure(others, true)
 
 	msg, err := json.Marshal(output)
 	if err != nil {
@@ -29,14 +33,18 @@ func (f *JSONFormatter) Format(res *lint.Result) (string, error) {
 	return strings.Trim(string(msg), "\n"), nil
 }
 
-func (f *JSONFormatter) formRuleResult(res []lint.RuleResult) []map[string]interface{} {
+func (f *JSONFormatter) formRuleFailure(res []*lint.RuleFailure, includeSev bool) []map[string]interface{} {
 	outs := make([]map[string]interface{}, 0, len(res))
 
 	for _, r := range res {
 		output := make(map[string]interface{})
 
-		output["name"] = r.Name
-		output["message"] = r.Message
+		output["name"] = r.RuleName()
+		output["message"] = r.Message()
+
+		if includeSev {
+			output["severity"] = r.Severity()
+		}
 
 		outs = append(outs, output)
 	}

formatter/util.go

@@ -0,0 +1,18 @@
+package formatter
+
+import "github.com/conventionalcommit/commitlint/lint"
+
+// bySeverity returns all messages with given severity
+func bySeverity(res *lint.Failure) (errs, warns, others []*lint.RuleFailure) {
+	for _, r := range res.RuleFailures() {
+		switch r.Severity() {
+		case lint.SeverityError:
+			errs = append(errs, r)
+		case lint.SeverityWarn:
+			warns = append(warns, r)
+		default:
+			others = append(others, r)
+		}
+	}
+	return errs, warns, others
+}

lint/formatter.go

@@ -6,5 +6,5 @@ type Formatter interface {
 	Name() string
 
 	// Format formats the linter result
-	Format(result *Result) (string, error)
+	Format(result *Failure) (string, error)
 }

lint/linter.go

@@ -13,7 +13,7 @@ func New(conf *Config, rules []Rule) (*Linter, error) {
 }
 
 // Lint checks the given commitMsg string against rules
-func (l *Linter) Lint(commitMsg string) (*Result, error) {
+func (l *Linter) Lint(commitMsg string) (*Failure, error) {
 	msg, err := Parse(commitMsg)
 	if err != nil {
 		if isHeaderErr(err) {
@@ -25,8 +25,8 @@ func (l *Linter) Lint(commitMsg string) (*Result, error) {
 }
 
 // LintCommit checks the given Commit against rules
-func (l *Linter) LintCommit(msg *Commit) (*Result, error) {
-	res := newResult(msg.FullCommit)
+func (l *Linter) LintCommit(msg *Commit) (*Failure, error) {
+	res := newFailure(msg.FullCommit)
 
 	for _, rule := range l.rules {
 		currentRule := rule
@@ -40,26 +40,19 @@ func (l *Linter) LintCommit(msg *Commit) (*Result, error) {
 	return res, nil
 }
 
-func (l *Linter) runRule(rule Rule, severity Severity, msg *Commit) (RuleResult, bool) {
-	ruleMsg, isOK := rule.Validate(msg)
+func (l *Linter) runRule(rule Rule, severity Severity, msg *Commit) (*RuleFailure, bool) {
+	failMsg, isOK := rule.Validate(msg)
 	if isOK {
-		return RuleResult{}, true
-	}
-	res := RuleResult{
-		Name:     rule.Name(),
-		Severity: severity,
-		Message:  ruleMsg,
+		return nil, true
 	}
+	res := newRuleFailure(rule.Name(), failMsg, severity)
 	return res, false
 }
 
-func (l *Linter) headerErrorRule(commitMsg string) *Result {
+func (l *Linter) headerErrorRule(commitMsg string) *Failure {
 	// TODO: show more information
-	res := newResult(commitMsg)
-	res.add(RuleResult{
-		Name:     "parser",
-		Severity: SeverityError,
-		Message:  "commit header is not valid",
-	})
+	res := newFailure(commitMsg)
+	ruleFail := newRuleFailure("parser", "commit header is not valid", SeverityError)
+	res.add(ruleFail)
 	return res
 }

lint/result.go

@@ -1,50 +1,52 @@
 package lint
 
-// Result holds result of linter
-type Result struct {
+// Failure holds Failure of linter
+type Failure struct {
 	inputMsg string
 
-	errResults  []RuleResult
-	warnResults []RuleResult
+	failures []*RuleFailure
 }
 
-// RuleResult holds result of a linter rule
-type RuleResult struct {
-	Name     string
-	Severity Severity
-	Message  string
-}
-
-func newResult(inputMsg string) *Result {
-	return &Result{inputMsg: inputMsg}
+func newFailure(inputMsg string) *Failure {
+	return &Failure{
+		inputMsg: inputMsg,
+	}
 }
 
 // AddError adds
-func (res *Result) add(r RuleResult) {
-	if r.Severity == SeverityError {
-		res.errResults = append(res.errResults, r)
-	} else if r.Severity == SeverityWarn {
-		res.warnResults = append(res.warnResults, r)
-	} else {
-		// should not come here
-		res.errResults = append(res.errResults, r)
-	}
+func (res *Failure) add(r *RuleFailure) {
+	res.failures = append(res.failures, r)
 }
 
+// IsOK returns true if commit message passed all the rules
+func (res *Failure) IsOK() bool { return len(res.failures) == 0 }
+
 // Input returns input commit message
-func (res *Result) Input() string { return res.inputMsg }
+func (res *Failure) Input() string { return res.inputMsg }
 
-// Errors returns all error messages
-func (res *Result) Errors() []RuleResult { return res.errResults }
+// RuleFailures returns rule Failures
+func (res *Failure) RuleFailures() []*RuleFailure { return res.failures }
 
-// Warns returns all warning messages
-func (res *Result) Warns() []RuleResult { return res.warnResults }
+// RuleFailure holds Failure of a linter rule
+type RuleFailure struct {
+	name     string
+	severity Severity
+	message  string
+}
 
-// HasErrors returns true if errors found by linter
-func (res *Result) HasErrors() bool { return len(res.errResults) != 0 }
+func newRuleFailure(name, msg string, severity Severity) *RuleFailure {
+	return &RuleFailure{
+		name:     name,
+		message:  msg,
+		severity: severity,
+	}
+}
 
-// HasWarns returns true if warnings found by linter
-func (res *Result) HasWarns() bool { return len(res.warnResults) != 0 }
+// RuleName returns rule name
+func (r *RuleFailure) RuleName() string { return r.name }
 
-// IsOK returns true if commit message passed all the rules
-func (res *Result) IsOK() bool { return !res.HasErrors() && !res.HasWarns() }
+// Severity returns severity of the Rule Failure
+func (r *RuleFailure) Severity() Severity { return r.severity }
+
+// Message returns the error message of failed rule
+func (r *RuleFailure) Message() string { return r.message }