Add .wokeignore functionality

Author: caitlinelfring

Diff for: cmd/root.go

@@ -29,6 +29,7 @@ import (
 	"time"
 
 	"github.com/caitlinelfring/woke/pkg/config"
+	"github.com/caitlinelfring/woke/pkg/ignore"
 	"github.com/caitlinelfring/woke/pkg/parser"
 	"github.com/caitlinelfring/woke/pkg/rule"
 	"github.com/rs/zerolog"
@@ -82,11 +83,8 @@ Provide a list file globs for files you'd like to check.`,
 		if stdin {
 			results, _ = p.Parse(os.Stdin)
 		} else {
-			if len(args) == 0 {
-				args = []string{defaultGlob}
-			}
-			c.SetFiles(args)
-			results = p.ParseFiles(c.GetFiles())
+			ignorer, _ := ignore.NewIgnore(c.IgnoreFiles)
+			results = p.ParseFiles(args, ignorer)
 		}
 
 		cmd.Println(results.String())

Diff for: pkg/config/config.go

@@ -3,9 +3,7 @@ package config
 import (
 	"io/ioutil"
 
-	"github.com/caitlinelfring/woke/pkg/ignore"
 	"github.com/caitlinelfring/woke/pkg/rule"
-	"github.com/caitlinelfring/woke/pkg/util"
 
 	"gopkg.in/yaml.v2"
 )
@@ -14,51 +12,23 @@ import (
 type Config struct {
 	Rules       []*rule.Rule `yaml:"rules"`
 	IgnoreFiles []string     `yaml:"ignore_files"`
-
-	hasAbsolutePath bool
-
-	ignoreMatcherFunc func(string) bool
-
-	files []string
 }
 
 func NewConfig(filename string) (*Config, error) {
 	var c Config
+	c.AddDefaultRules()
 
 	if filename != "" {
 		if err := c.load(filename); err != nil {
 			return &c, err
 		}
+		// Ignore the config filename, it will always match on its own rules
+		c.IgnoreFiles = append(c.IgnoreFiles, filename)
 	}
-	c.AddDefaultRules()
-
-	// Ignore the config filename, it will always match on its own rules
-	ignorer, err := ignore.NewIgnore(append(c.IgnoreFiles, filename))
-	if err != nil {
-		return &c, err
-	}
-	c.ignoreMatcherFunc = ignorer.Match
 
 	return &c, nil
 }
 
-// SetFiles computes the list of files that will be checked
-func (c *Config) SetFiles(fileGlobs []string) {
-	allFiles, hasAbsolutePath, _ := util.GetFilesInGlobs(fileGlobs)
-	c.hasAbsolutePath = hasAbsolutePath
-	for _, f := range allFiles {
-		if c.ignoreMatcherFunc(f) {
-			continue
-		}
-		c.files = append(c.files, f)
-	}
-}
-
-// GetFiles returns files that may be parsed
-func (c *Config) GetFiles() []string {
-	return c.files
-}
-
 // AddDefaultRules adds the config Rules to DefaultRules
 func (c *Config) AddDefaultRules() {
 	c.Rules = append(c.Rules, rule.DefaultRules...)

Diff for: pkg/ignore/ignore.go

@@ -1,9 +1,12 @@
 package ignore
 
 import (
+	"errors"
 	"io/ioutil"
+	"os"
 	"strings"
 
+	"github.com/rs/zerolog/log"
 	gitignore "github.com/sabhiram/go-gitignore"
 )
 
@@ -33,10 +36,21 @@ func (i *Ignore) Match(f string) bool {
 
 func compileIgnoreLines(lines []string) (*gitignore.GitIgnore, error) {
 	lines = append(lines, DefaultIgnores...)
+	lines = append(lines, readIgnoreFile(".gitignore")...)
+	lines = append(lines, readIgnoreFile(".wokeignore")...)
 
-	if buffer, err := ioutil.ReadFile(".gitignore"); err == nil {
-		lines = append(lines, strings.Split(string(buffer), "\n")...)
+	return gitignore.CompileIgnoreLines(lines...)
+}
+
+func readIgnoreFile(file string) []string {
+	buffer, err := ioutil.ReadFile(file)
+	if err != nil {
+		_event := log.Warn()
+		if errors.Is(err, os.ErrNotExist) {
+			_event = log.Debug()
+		}
+		_event.Err(err).Str("file", file).Msg("skipping ignorefile")
 	}
 
-	return gitignore.CompileIgnoreLines(lines...)
+	return strings.Split(string(buffer), "\n")
 }

Diff for: pkg/parser/files.go

@@ -0,0 +1,32 @@
+package parser
+
+import (
+	"github.com/caitlinelfring/woke/pkg/ignore"
+	"github.com/caitlinelfring/woke/pkg/util"
+)
+
+const defaultGlob = "**"
+
+// Parsable contains the list of files that can be parsed
+type Parsable struct {
+	Files []string
+}
+
+// ParsableFiles returns a list of files that can be parsed after the ignorer has
+// excluded files that should be ignored
+func ParsableFiles(fileGlobs []string, ignorer *ignore.Ignore) *Parsable {
+	if len(fileGlobs) == 0 {
+		fileGlobs = []string{defaultGlob}
+	}
+
+	var p Parsable
+	allFiles, _, _ := util.GetFilesInGlobs(fileGlobs)
+	for _, f := range allFiles {
+		if ignorer.Match(f) {
+			continue
+		}
+		p.Files = append(p.Files, f)
+	}
+
+	return &p
+}

Diff for: pkg/parser/parser.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"time"
 
+	"github.com/caitlinelfring/woke/pkg/ignore"
 	"github.com/caitlinelfring/woke/pkg/rule"
 	"github.com/caitlinelfring/woke/pkg/util"
 	"github.com/rs/zerolog/log"
@@ -16,30 +17,9 @@ type Parser struct {
 }
 
 // ParseFiles parses all files provided and returns the results
-func (p *Parser) ParseFiles(files []string) rule.Results {
-	results := rule.Results{}
-
-	for _, f := range files {
-		file, err := os.Open(f)
-		if err != nil {
-			log.Error().Err(err).Str("file", file.Name()).Msg("could not open file")
-			continue
-		}
-		defer file.Close()
-
-		if err = util.IsTextFile(file); err != nil {
-			log.Debug().Err(err).Str("file", file.Name()).Msg("not a text file")
-			continue
-		}
-
-		r, err := p.Parse(file)
-		if err != nil {
-			log.Debug().Err(err).Msg("parser failed")
-			continue
-		}
-		results.Push(r.Results...)
-	}
-	return results
+func (p *Parser) ParseFiles(files []string, ignorer *ignore.Ignore) rule.Results {
+	parsable := ParsableFiles(files, ignorer)
+	return p.parseFiles(parsable.Files)
 }
 
 // Parse reads the file and returns results of places where rules are broken
@@ -70,3 +50,31 @@ func (p *Parser) Parse(file *os.File) (results rule.Results, err error) {
 
 	return results, scanner.Err()
 }
+
+func (p *Parser) parseFiles(files []string) rule.Results {
+	results := rule.Results{}
+
+	for _, f := range files {
+		file, err := os.Open(f)
+		if err != nil {
+			log.Error().Err(err).Str("file", f).Msg("could not open file")
+			continue
+		}
+		defer file.Close()
+
+		if err = util.IsTextFile(file); err != nil {
+			log.Debug().Err(err).Str("file", file.Name()).Msg("not a text file")
+			continue
+		}
+
+		r, err := p.Parse(file)
+		if err != nil {
+			log.Debug().Err(err).Msg("parser failed")
+			continue
+		}
+
+		results.Push(r.Results...)
+	}
+
+	return results
+}