Do: Return tuple ([]UnsatisfiedRule, error) (#10)

* Use `log.Fatalln`

* `Do`: Return tuple `([]UnsatisfiedRule, error)`

* Update main.go

* Add `UnsatisfiedRules.String()`

* `[]UnsatisfiedRule` to `UnsatisfiedRules`

Author: EthanThatOneKid

cli/main.go

@@ -76,9 +76,14 @@ func action(ctx *cli.Context) error {
 	exclude := ctx.StringSlice("exclude")
 	extMapPath := ctx.String("ext_map")
 
-	if err := difflint.Do(ctx.App.Reader, include, exclude, extMapPath); err != nil {
+	unsatisfiedRules, err := difflint.Do(ctx.App.Reader, include, exclude, extMapPath)
+	if err != nil {
 		return err
 	}
 
+	if len(unsatisfiedRules) > 0 {
+		return cli.Exit(unsatisfiedRules.String(), 1)
+	}
+
 	return nil
 }

difflint.go

@@ -1,8 +1,8 @@
 package difflint
 
 import (
+	"fmt"
 	"io"
-	"log"
 	"path/filepath"
 	"strings"
 
@@ -87,10 +87,39 @@ type UnsatisfiedRule struct {
 	UnsatisfiedTargets map[int]struct{}
 }
 
+type UnsatisfiedRules []UnsatisfiedRule
+
+// String returns a string representation of the unsatisfied rules.
+func (r *UnsatisfiedRules) String() string {
+	var b strings.Builder
+	for _, rule := range *r {
+		b.WriteString("rule (")
+		b.WriteString(rule.Rule.Hunk.File)
+		b.WriteString(":")
+		b.WriteString(fmt.Sprintf("%d", rule.Rule.Hunk.Range.Start))
+		b.WriteString(",")
+		b.WriteString(rule.Rule.Hunk.File)
+		b.WriteString(":")
+		b.WriteString(fmt.Sprintf("%d", rule.Rule.Hunk.Range.End))
+		b.WriteString(") not satisfied for targets:\n")
+		for i, target := range rule.Targets {
+			if _, ok := rule.UnsatisfiedTargets[i]; !ok {
+				continue
+			}
+
+			key := TargetKey(rule.Rule.Hunk.File, target)
+			b.WriteString("  ")
+			b.WriteString(key)
+			b.WriteString("\n")
+		}
+	}
+	return b.String()
+}
+
 // Result of a linting operation.
 type LintResult struct {
 	// List of rules that were not satisfied.
-	UnsatisfiedRules []UnsatisfiedRule
+	UnsatisfiedRules UnsatisfiedRules
 }
 
 // Lint lints the given hunks against the given rules and returns the result.
@@ -147,8 +176,8 @@ func isRelativeToCurrentDirectory(path string) bool {
 }
 
 // Check returns the list of unsatisfied rules for the given map of rules.
-func Check(rulesMap map[string][]Rule) ([]UnsatisfiedRule, error) {
-	var unsatisfiedRules []UnsatisfiedRule
+func Check(rulesMap map[string][]Rule) (UnsatisfiedRules, error) {
+	var unsatisfiedRules UnsatisfiedRules
 	for pathnameA, rulesA := range rulesMap {
 	outer:
 		for i, ruleA := range rulesA {
@@ -193,7 +222,7 @@ func Check(rulesMap map[string][]Rule) ([]UnsatisfiedRule, error) {
 }
 
 // Entrypoint for the difflint command.
-func Do(r io.Reader, include, exclude []string, extMapPath string) error {
+func Do(r io.Reader, include, exclude []string, extMapPath string) (UnsatisfiedRules, error) {
 	// Parse options.
 	extMap := NewExtMap(extMapPath)
 
@@ -207,38 +236,29 @@ func Do(r io.Reader, include, exclude []string, extMapPath string) error {
 		FileExtMap:      extMap.FileExtMap,
 	})
 	if err != nil {
-		return errors.Wrap(err, "failed to lint hunks")
+		return nil, errors.Wrap(err, "failed to lint hunks")
 	}
 
 	// If there are no unsatisfied rules, return nil.
 	if len(result.UnsatisfiedRules) == 0 {
-		return nil
+		return nil, nil
 	}
 
 	// Print the unsatisfied rules.
+	var included bool
 	for _, rule := range result.UnsatisfiedRules {
 		// Skip if the rule is not intended to be included in the output.
-		if ok, err := Include(rule.Hunk.File, include, exclude); err != nil {
-			return errors.Wrap(err, "failed to check if file is included")
-		} else if !ok {
-			continue
+		included, err = Include(rule.Hunk.File, include, exclude)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to check if file is included")
 		}
 
-		// Print the unsatisfied rule.
-		log.Printf("Rule (%s:%d,%s:%d) unsatisfied", rule.Rule.Hunk.File, rule.Rule.Hunk.Range.Start, rule.Rule.Hunk.File, rule.Rule.Hunk.Range.End)
-
-		// Print the unsatisfied target keys.
-		for i, target := range rule.Targets {
-			if _, ok := rule.UnsatisfiedTargets[i]; !ok {
-				continue
-			}
-
-			key := TargetKey(rule.Hunk.File, target)
-			log.Printf("  %s", key)
+		if !included {
+			continue
 		}
 	}
 
-	return nil
+	return result.UnsatisfiedRules, nil
 }
 
 // ParseHunks parses the input diff and returns the extracted file paths along