feat: new exclusion paths processor

Author: ldez

pkg/lint/runner.go

@@ -46,6 +46,11 @@ func NewRunner(log logutils.Log, cfg *config.Config, args []string, goenv *gouti
 		return nil, fmt.Errorf("error creating path relativity processor: %w", err)
 	}
 
+	exclusionPaths, err := processors.NewExclusionPaths(log, &cfg.Linters.LinterExclusions)
+	if err != nil {
+		return nil, err
+	}
+
 	skipFilesProcessor, err := processors.NewSkipFiles(cfg.Issues.ExcludeFiles, cfg.Output.PathPrefix)
 	if err != nil {
 		return nil, err
@@ -88,6 +93,7 @@ func NewRunner(log logutils.Log, cfg *config.Config, args []string, goenv *gouti
 			pathRelativity,
 
 			// Must be after PathRelativity.
+			exclusionPaths,
 			skipFilesProcessor,
 			skipDirsProcessor,
 

pkg/logutils/logutils.go

@@ -42,6 +42,7 @@ const (
 
 // Processors.
 const (
+	DebugKeyExclusionPaths      = "exclusion_paths"
 	DebugKeyExclusionRules      = "exclusion_rules"
 	DebugKeyFilenameUnadjuster  = "filename_unadjuster"
 	DebugKeyGeneratedFileFilter = "generated_file_filter" // Debugs a filter excluding autogenerated source code.

pkg/result/processors/exclusion_paths.go

@@ -0,0 +1,79 @@
+package processors
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/golangci/golangci-lint/pkg/config"
+	"github.com/golangci/golangci-lint/pkg/fsutils"
+	"github.com/golangci/golangci-lint/pkg/logutils"
+	"github.com/golangci/golangci-lint/pkg/result"
+)
+
+var _ Processor = (*ExclusionPaths)(nil)
+
+type ExclusionPaths struct {
+	patterns []*regexp.Regexp
+
+	warnUnused         bool
+	skippedPathCounter map[*regexp.Regexp]int
+
+	log logutils.Log
+}
+
+func NewExclusionPaths(log logutils.Log, cfg *config.LinterExclusions) (*ExclusionPaths, error) {
+	var counter = make(map[*regexp.Regexp]int)
+
+	var patternsRe []*regexp.Regexp
+	for _, p := range cfg.Paths {
+		p = fsutils.NormalizePathInRegex(p)
+
+		patternRe, err := regexp.Compile(p)
+		if err != nil {
+			return nil, fmt.Errorf("can't compile regexp %q: %w", p, err)
+		}
+
+		patternsRe = append(patternsRe, patternRe)
+		counter[patternRe] = 0
+	}
+
+	return &ExclusionPaths{
+		patterns:           patternsRe,
+		warnUnused:         cfg.WarnUnused,
+		skippedPathCounter: counter,
+		log:                log.Child(logutils.DebugKeyExclusionPaths),
+	}, nil
+}
+
+func (*ExclusionPaths) Name() string {
+	return "exclusion_paths"
+}
+
+func (p *ExclusionPaths) Process(issues []result.Issue) ([]result.Issue, error) {
+	if len(p.patterns) == 0 {
+		return issues, nil
+	}
+
+	return filterIssues(issues, p.shouldPassIssue), nil
+}
+
+func (p *ExclusionPaths) Finish() {
+	for pattern, count := range p.skippedPathCounter {
+		if p.warnUnused && count == 0 {
+			p.log.Warnf("Skipped %d issues by pattern %q", count, pattern)
+		} else {
+			p.log.Infof("Skipped %d issues by pattern %q", count, pattern)
+		}
+	}
+}
+
+func (p *ExclusionPaths) shouldPassIssue(issue *result.Issue) bool {
+	for _, pattern := range p.patterns {
+		if pattern.MatchString(issue.RelativePath) {
+			p.skippedPathCounter[pattern] += 1
+			return false
+		}
+	}
+
+	return true
+}

pkg/result/processors/exclusion_paths_test.go

@@ -0,0 +1,105 @@
+package processors
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/golangci/golangci-lint/pkg/config"
+	"github.com/golangci/golangci-lint/pkg/logutils"
+	"github.com/golangci/golangci-lint/pkg/result"
+)
+
+func TestExclusionPaths_Process(t *testing.T) {
+	logger := logutils.NewStderrLog(logutils.DebugKeyEmpty)
+	logger.SetLevel(logutils.LogLevelDebug)
+
+	testCases := []struct {
+		desc     string
+		patterns []string
+		issues   []result.Issue
+		expected []result.Issue
+	}{
+		{
+			desc:     "word",
+			patterns: []string{"foo"},
+			issues: []result.Issue{
+				{RelativePath: "foo.go"},
+				{RelativePath: "foo/foo.go"},
+				{RelativePath: "foo/bar.go"},
+				{RelativePath: "bar/foo.go"},
+				{RelativePath: "bar/bar.go"},
+			},
+			expected: []result.Issue{
+				{RelativePath: "bar/bar.go"},
+			},
+		},
+		{
+			desc:     "begin with word",
+			patterns: []string{"^foo"},
+			issues: []result.Issue{
+				{RelativePath: "foo.go"},
+				{RelativePath: "foo/foo.go"},
+				{RelativePath: "foo/bar.go"},
+				{RelativePath: "bar/foo.go"},
+				{RelativePath: "bar/bar.go"},
+			},
+			expected: []result.Issue{
+				{RelativePath: "bar/foo.go"},
+				{RelativePath: "bar/bar.go"},
+			},
+		},
+		{
+			desc:     "directory begin with word",
+			patterns: []string{"^foo/"},
+			issues: []result.Issue{
+				{RelativePath: "foo.go"},
+				{RelativePath: "foo/foo.go"},
+				{RelativePath: "foo/bar.go"},
+				{RelativePath: "bar/foo.go"},
+				{RelativePath: "bar/bar.go"},
+			},
+			expected: []result.Issue{
+				{RelativePath: "foo.go"},
+				{RelativePath: "bar/foo.go"},
+				{RelativePath: "bar/bar.go"},
+			},
+		},
+		{
+			desc:     "same suffix with unconstrained expression",
+			patterns: []string{"c/d.go"},
+			issues: []result.Issue{
+				{RelativePath: "a/b/c/d.go"},
+				{RelativePath: "c/d.go"},
+			},
+			expected: []result.Issue{},
+		},
+		{
+			desc:     "same suffix with constrained expression",
+			patterns: []string{"^c/d.go"},
+			issues: []result.Issue{
+				{RelativePath: "a/b/c/d.go"},
+				{RelativePath: "c/d.go"},
+			},
+			expected: []result.Issue{
+				{RelativePath: "a/b/c/d.go"},
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			p, err := NewExclusionPaths(logger, &config.LinterExclusions{Paths: test.patterns})
+			require.NoError(t, err)
+
+			processedIssues := process(t, p, test.issues...)
+
+			assert.Equal(t, test.expected, processedIssues)
+
+			p.Finish()
+		})
+	}
+}