fixup! feat: include/exclude with text/template filters

Simplifies the Matcher approach, removing the complicated Matcher types in favour of simple functions.

Signed-off-by: Brian McGee <[email protected]>

Author: brianmcgee

cmd/root_test.go

@@ -437,7 +437,7 @@ func TestIncludesAndExcludes(t *testing.T) {
 	echo.Excludes = []string{"*.py"}
 
 	treefmt(t,
-		withArgs("-c"),
+		withArgs("-c", "-vv"),
 		withConfig(configPath, cfg),
 		withNoError(t),
 		withStats(t, map[stats.Type]int{

format/composite.go

@@ -27,7 +27,7 @@ var ErrFormattingFailures = errors.New("formatting failures detected")
 type CompositeFormatter struct {
 	cfg           *config.Config
 	stats         *stats.Stats
-	globalMatcher *matcher.CompositeMatcher
+	globalMatchFn matcher.MatchFn
 
 	unmatchedLevel log.Level
 
@@ -38,7 +38,7 @@ type CompositeFormatter struct {
 // match filters the file against global excludes and returns a list of formatters that want to process the file.
 func (c *CompositeFormatter) match(file *walk.File) (bool, []*Formatter, error) {
 	// first check if this file has been globally excluded
-	result, err := c.globalMatcher.Wants(file)
+	result, err := c.globalMatchFn(file)
 	if err != nil {
 		return false, nil, fmt.Errorf("error applying global excludes to %s: %w", file.RelPath, err)
 	}
@@ -160,22 +160,23 @@ func NewCompositeFormatter(
 	statz *stats.Stats,
 	batchSize int,
 ) (*CompositeFormatter, error) {
-	matchers := make([]matcher.Matcher, 2)
+	var (
+		err      error
+		matchers = make([]matcher.MatchFn, 2)
+	)
 
-	var err error
-
-	// compile global exclude globs
-	matchers[0], err = matcher.NewGlobExclusionMatcher(cfg.Excludes)
+	// create global exclusion matcher based on globs and templates
+	matchers[0], err = matcher.ExcludeGlobs(cfg.Excludes)
 	if err != nil {
 		return nil, fmt.Errorf("failed to compile global excludes: %w", err)
 	}
 
-	matchers[1], err = matcher.NewTemplateExclusionMatcher(cfg.Reject)
+	matchers[1], err = matcher.ExcludeTemplates(cfg.Reject)
 	if err != nil {
 		return nil, fmt.Errorf("failed to compile global reject: %w", err)
 	}
 
-	globalMatcher := matcher.NewCompositeMatcher(matchers)
+	globalMatcher := matcher.Combine(nil, matchers)
 
 	// parse unmatched log level
 	unmatchedLevel, err := log.ParseLevel(cfg.OnUnmatched)
@@ -215,7 +216,7 @@ func NewCompositeFormatter(
 	return &CompositeFormatter{
 		cfg:            cfg,
 		stats:          statz,
-		globalMatcher:  globalMatcher,
+		globalMatchFn:  globalMatcher,
 		unmatchedLevel: unmatchedLevel,
 
 		scheduler:  scheduler,

format/formatter.go

@@ -38,7 +38,7 @@ type Formatter struct {
 	workingDir string
 
 	// internal, compiled versions of inclusion and exclusion matchers.
-	matcher *matcher.CompositeMatcher
+	matchFn matcher.MatchFn
 }
 
 func (f *Formatter) Name() string {
@@ -126,7 +126,7 @@ func (f *Formatter) Apply(ctx context.Context, files []*walk.File) error {
 // its configured Includes and Excludes patterns and Select and Reject
 // templates.
 func (f *Formatter) Wants(file *walk.File) (matcher.Result, error) {
-	result, err := f.matcher.Wants(file)
+	result, err := f.matchFn(file)
 	if err != nil {
 		return result, fmt.Errorf("error applying matcher to %s: %w", file.RelPath, err)
 	}
@@ -179,29 +179,30 @@ func newFormatter(
 		return nil, fmt.Errorf("formatter '%v' has no includes or select filters", f.name)
 	}
 
-	matchers := make([]matcher.Matcher, 4)
+	includes := make([]matcher.MatchFn, 2)
+	excludes := make([]matcher.MatchFn, 2)
 
-	matchers[0], err = matcher.NewGlobInclusionMatcher(cfg.Includes)
+	includes[0], err = matcher.IncludeGlobs(cfg.Includes)
 	if err != nil {
 		return nil, fmt.Errorf("failed to compile formatter '%v' includes: %w", f.name, err)
 	}
 
-	matchers[1], err = matcher.NewGlobExclusionMatcher(cfg.Excludes)
+	includes[1], err = matcher.IncludeTemplates(cfg.Select)
 	if err != nil {
-		return nil, fmt.Errorf("failed to compile formatter '%v' excludes: %w", f.name, err)
+		return nil, fmt.Errorf("failed to compile formatter '%v' select: %w", f.name, err)
 	}
 
-	matchers[2], err = matcher.NewTemplateInclusionMatcher(cfg.Select)
+	excludes[0], err = matcher.ExcludeGlobs(cfg.Excludes)
 	if err != nil {
-		return nil, fmt.Errorf("failed to compile formatter '%v' select: %w", f.name, err)
+		return nil, fmt.Errorf("failed to compile formatter '%v' excludes: %w", f.name, err)
 	}
 
-	matchers[3], err = matcher.NewTemplateExclusionMatcher(cfg.Reject)
+	excludes[1], err = matcher.ExcludeTemplates(cfg.Reject)
 	if err != nil {
 		return nil, fmt.Errorf("failed to compile formatter '%v' reject: %w", f.name, err)
 	}
 
-	f.matcher = matcher.NewCompositeMatcher(matchers)
+	f.matchFn = matcher.Combine(includes, excludes)
 
 	return &f, nil
 }

matcher/composite.go

@@ -7,66 +7,35 @@ import (
 	"github.com/numtide/treefmt/v2/walk"
 )
 
-type globMatcher struct {
-	globs    []glob.Glob
-	patterns []string
-}
+func IncludeGlobs(patterns []string) (MatchFn, error) {
+	if len(patterns) == 0 {
+		return noOp, nil
+	}
 
-func newGlobMatcher(patterns []string) (*globMatcher, error) {
 	globs := make([]glob.Glob, len(patterns))
 
 	for i, pattern := range patterns {
 		g, err := glob.Compile(pattern)
 		if err != nil {
-			return nil, fmt.Errorf("failed to compile include pattern '%v': %w", pattern, err)
+			return nil, fmt.Errorf("failed to compile glob pattern '%v': %w", pattern, err)
 		}
 
 		globs[i] = g
 	}
 
-	return &globMatcher{globs: globs, patterns: patterns}, nil
-}
-
-func (gm *globMatcher) Ignore() bool {
-	return len(gm.globs) < 1
-}
-
-func (gm *globMatcher) Matches(file *walk.File) (bool, error) {
-	for _, g := range gm.globs {
-		if g.Match(file.RelPath) {
-			return true, nil
+	return func(file *walk.File) (Result, error) {
+		for _, g := range globs {
+			if g.Match(file.RelPath) {
+				return Wanted, nil
+			}
 		}
-	}
-
-	return false, nil
-}
-
-type GlobInclusionMatcher struct {
-	*inclusionMatcher
-	globMatcher
-}
-
-//nolint:ireturn
-func NewGlobInclusionMatcher(patterns []string) (Matcher, error) {
-	gm, err := newGlobMatcher(patterns)
-	if err != nil {
-		return nil, err
-	}
-
-	return &GlobInclusionMatcher{globMatcher: *gm}, nil
-}
 
-type GlobExclusionMatcher struct {
-	*exclusionMatcher
-	globMatcher
+		return Indifferent, nil
+	}, nil
 }
 
-//nolint:ireturn
-func NewGlobExclusionMatcher(patterns []string) (Matcher, error) {
-	gm, err := newGlobMatcher(patterns)
-	if err != nil {
-		return nil, err
-	}
+func ExcludeGlobs(patterns []string) (MatchFn, error) {
+	includeFn, err := IncludeGlobs(patterns)
 
-	return &GlobExclusionMatcher{globMatcher: *gm}, nil
+	return invert(includeFn), err
 }

matcher/glob.go

@@ -9,67 +9,59 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func testGlobMatcher(t *testing.T, as *require.Assertions, create func([]string) (matcher.Matcher, error)) {
+func mockFile(t *testing.T, path string) *walk.File {
 	t.Helper()
 
-	f := func(path string) *walk.File {
-		return &walk.File{
-			Path:    path,
-			RelPath: path,
-		}
+	return &walk.File{
+		Path:    path,
+		RelPath: path,
 	}
+}
+
+func testGlobMatcher(t *testing.T, factory func(patterns []string) (matcher.MatchFn, error), expected matcher.Result) {
+	t.Helper()
 
-	var (
-		m      matcher.Matcher
-		err    error
-		target matcher.Result
-	)
+	as := require.New(t)
 
 	// Empty list; `Wants` should always return `true`.
-	m, err = create([]string{})
+	matchFn, err := factory(nil)
 	as.NoError(err)
-	testutil.MatcherTestEmpty(t, as, m)
 
-	if m.Invert() {
-		target = matcher.Unwanted
-	} else {
-		target = matcher.Wanted
-	}
+	result, err := matchFn(&walk.File{RelPath: "test/foo/bar.txt"})
+	as.NoError(err)
+	as.Equal(matcher.Indifferent, result)
 
 	// File extension
-	m, err = create([]string{"*.txt"})
+	matchFn, err = factory([]string{"*.txt"})
 	as.NoError(err)
-	testutil.MatcherTestResults(t, as, m, map[matcher.Result][]*walk.File{
-		target:              {f("test/foo/bar.txt")},
-		matcher.Indifferent: {f("test/foo/bar.txtz"), f("test/foo/bar.flob")},
+
+	testutil.MatcherTestResults(t, as, matchFn, map[matcher.Result][]*walk.File{
+		expected:            {mockFile(t, "test/foo/bar.txt")},
+		matcher.Indifferent: {mockFile(t, "test/foo/bar.txtz"), mockFile(t, "test/foo/bar.flob")},
 	})
 
 	// Prefix matching
-	m, err = create([]string{"test/*"})
+	matchFn, err = factory([]string{"test/*"})
 	as.NoError(err)
-	testutil.MatcherTestResults(t, as, m, map[matcher.Result][]*walk.File{
-		target:              {f("test/bar.txt"), f("test/foo/bar.txt")},
-		matcher.Indifferent: {f("/test/foo/bar.txt")},
+	testutil.MatcherTestResults(t, as, matchFn, map[matcher.Result][]*walk.File{
+		expected:            {mockFile(t, "test/bar.txt"), mockFile(t, "test/foo/bar.txt")},
+		matcher.Indifferent: {mockFile(t, "/test/foo/bar.txt")},
 	})
 
 	// Exact matches
 	// File extension
-	m, err = create([]string{"LICENSE"})
+	matchFn, err = factory([]string{"LICENSE"})
 	as.NoError(err)
-	testutil.MatcherTestResults(t, as, m, map[matcher.Result][]*walk.File{
-		target:              {f("LICENSE")},
-		matcher.Indifferent: {f("test/LICENSE"), f("LICENSE.txt")},
+	testutil.MatcherTestResults(t, as, matchFn, map[matcher.Result][]*walk.File{
+		expected:            {mockFile(t, "LICENSE")},
+		matcher.Indifferent: {mockFile(t, "test/LICENSE"), mockFile(t, "LICENSE.txt")},
 	})
 }
 
-func TestIncludes(t *testing.T) {
-	r := require.New(t)
-
-	testGlobMatcher(t, r, matcher.NewGlobInclusionMatcher)
+func TestIncludeGlobs(t *testing.T) {
+	testGlobMatcher(t, matcher.IncludeGlobs, matcher.Wanted)
 }
 
-func TestExcludes(t *testing.T) {
-	r := require.New(t)
-
-	testGlobMatcher(t, r, matcher.NewGlobExclusionMatcher)
+func TestExcludeGlobs(t *testing.T) {
+	testGlobMatcher(t, matcher.ExcludeGlobs, matcher.Unwanted)
 }

matcher/glob_test.go

@@ -33,29 +33,17 @@ func MatcherTestSetup(t *testing.T, as *require.Assertions) func(string) *walk.F
 	return testfile
 }
 
-func MatcherTestEmpty(t *testing.T, as *require.Assertions, m matcher.Matcher) {
-	t.Helper()
-
-	as.True(m.Ignore(), "matcher is not configured to be ignored")
-
-	result, err := matcher.Wants(m, &walk.File{RelPath: "ENOENT"})
-	as.NoError(err)
-	as.Equal(matcher.Indifferent, result)
-}
-
 func MatcherTestResults(
 	t *testing.T,
 	as *require.Assertions,
-	m matcher.Matcher,
+	matchFn matcher.MatchFn,
 	results map[matcher.Result][]*walk.File,
 ) {
 	t.Helper()
 
-	as.False(m.Ignore(), "matcher is configured to be ignored")
-
 	for expected, paths := range results {
 		for _, path := range paths {
-			actual, err := matcher.Wants(m, path)
+			actual, err := matchFn(path)
 			as.NoError(err)
 			as.Equal(expected, actual, "expected %v for path %s; got %v", expected, path, actual)
 		}