From 9f3185c486581dab46e4ce12b0ef4190a1845bef Mon Sep 17 00:00:00 2001 From: Fernandez Ludovic Date: Mon, 3 Mar 2025 02:04:53 +0100 Subject: [PATCH] chore: remove filecache --- pkg/fsutils/files.go | 33 --------- pkg/lint/runner.go | 9 +-- pkg/result/processors/base_rule.go | 6 +- pkg/result/processors/exclusion_rules.go | 12 ++-- pkg/result/processors/exclusion_rules_test.go | 69 ++++--------------- pkg/result/processors/path_prettifier.go | 9 ++- pkg/result/processors/severity.go | 8 +-- pkg/result/processors/severity_test.go | 65 ++--------------- 8 files changed, 38 insertions(+), 173 deletions(-) delete mode 100644 pkg/fsutils/files.go diff --git a/pkg/fsutils/files.go b/pkg/fsutils/files.go deleted file mode 100644 index 4398ab9fc1e6..000000000000 --- a/pkg/fsutils/files.go +++ /dev/null @@ -1,33 +0,0 @@ -package fsutils - -import "path/filepath" - -// Files combines different operations related to handling file paths and content. -type Files struct { - *LineCache - pathPrefix string -} - -func NewFiles(lc *LineCache, pathPrefix string) *Files { - return &Files{ - LineCache: lc, - pathPrefix: pathPrefix, - } -} - -// WithPathPrefix takes a path that is relative to the current directory (as used in issues) -// and adds the configured path prefix, if there is one. -// The resulting path then can be shown to the user or compared against paths specified in the configuration. -func (f *Files) WithPathPrefix(relativePath string) string { - return WithPathPrefix(f.pathPrefix, relativePath) -} - -// WithPathPrefix takes a path that is relative to the current directory (as used in issues) -// and adds the configured path prefix, if there is one. -// The resulting path then can be shown to the user or compared against paths specified in the configuration. -func WithPathPrefix(pathPrefix, relativePath string) string { - if pathPrefix == "" { - return relativePath - } - return filepath.Join(pathPrefix, relativePath) -} diff --git a/pkg/lint/runner.go b/pkg/lint/runner.go index 0795a35ef4a5..a0928a41ae9d 100644 --- a/pkg/lint/runner.go +++ b/pkg/lint/runner.go @@ -37,11 +37,6 @@ func NewRunner(log logutils.Log, cfg *config.Config, goenv *goutil.Env, lineCache *fsutils.LineCache, fileCache *fsutils.FileCache, dbManager *lintersdb.Manager, lintCtx *linter.Context, ) (*Runner, error) { - // Beware that some processors need to add the path prefix when working with paths - // because they get invoked before the path prefixer (exclude and severity rules) - // or process other paths (skip files). - files := fsutils.NewFiles(lineCache, cfg.Output.PathPrefix) - pathRelativity, err := processors.NewPathRelativity(log, cfg.GetBasePath()) if err != nil { return nil, fmt.Errorf("error creating path relativity processor: %w", err) @@ -98,7 +93,7 @@ func NewRunner(log logutils.Log, cfg *config.Config, goenv *goutil.Env, // Must be before exclude because users see already marked output and configure excluding by it. processors.NewIdentifierMarker(), - processors.NewExclusionRules(log.Child(logutils.DebugKeyExclusionRules), files, + processors.NewExclusionRules(log.Child(logutils.DebugKeyExclusionRules), lineCache, &cfg.Linters.Exclusions), processors.NewNolintFilter(log.Child(logutils.DebugKeyNolintFilter), dbManager, enabledLinters), @@ -117,7 +112,7 @@ func NewRunner(log logutils.Log, cfg *config.Config, goenv *goutil.Env, // Now we can modify the issues for output. processors.NewSourceCode(lineCache, log.Child(logutils.DebugKeySourceCode)), processors.NewPathShortener(), - processors.NewSeverity(log.Child(logutils.DebugKeySeverityRules), files, &cfg.Severity), + processors.NewSeverity(log.Child(logutils.DebugKeySeverityRules), lineCache, &cfg.Severity), processors.NewPathPrettifier(log, cfg.Output.PathPrefix), processors.NewSortResults(&cfg.Output), }, diff --git a/pkg/result/processors/base_rule.go b/pkg/result/processors/base_rule.go index 6fb15597096b..6a6f112a087a 100644 --- a/pkg/result/processors/base_rule.go +++ b/pkg/result/processors/base_rule.go @@ -47,14 +47,14 @@ func (r *baseRule) isEmpty() bool { return r.text == nil && r.source == nil && r.path == nil && r.pathExcept == nil && len(r.linters) == 0 } -func (r *baseRule) match(issue *result.Issue, files *fsutils.Files, log logutils.Log) bool { +func (r *baseRule) match(issue *result.Issue, lines *fsutils.LineCache, log logutils.Log) bool { if r.isEmpty() { return false } if r.text != nil && !r.text.MatchString(issue.Text) { return false } - if r.path != nil && !r.path.MatchString(files.WithPathPrefix(issue.RelativePath)) { + if r.path != nil && !r.path.MatchString(issue.RelativePath) { return false } if r.pathExcept != nil && r.pathExcept.MatchString(issue.RelativePath) { @@ -65,7 +65,7 @@ func (r *baseRule) match(issue *result.Issue, files *fsutils.Files, log logutils } // the most heavyweight checking last - if r.source != nil && !r.matchSource(issue, files.LineCache, log) { + if r.source != nil && !r.matchSource(issue, lines, log) { return false } diff --git a/pkg/result/processors/exclusion_rules.go b/pkg/result/processors/exclusion_rules.go index 098b34a0cb44..7a9673ac459c 100644 --- a/pkg/result/processors/exclusion_rules.go +++ b/pkg/result/processors/exclusion_rules.go @@ -14,8 +14,9 @@ import ( var _ Processor = (*ExclusionRules)(nil) type ExclusionRules struct { - log logutils.Log - files *fsutils.Files + log logutils.Log + + lines *fsutils.LineCache warnUnused bool skippedCounter map[string]int @@ -23,11 +24,10 @@ type ExclusionRules struct { rules []excludeRule } -func NewExclusionRules(log logutils.Log, files *fsutils.Files, - cfg *config.LinterExclusions) *ExclusionRules { +func NewExclusionRules(log logutils.Log, lines *fsutils.LineCache, cfg *config.LinterExclusions) *ExclusionRules { p := &ExclusionRules{ log: log, - files: files, + lines: lines, warnUnused: cfg.WarnUnused, skippedCounter: map[string]int{}, } @@ -56,7 +56,7 @@ func (p *ExclusionRules) Process(issues []result.Issue) ([]result.Issue, error) return filterIssues(issues, func(issue *result.Issue) bool { for _, rule := range p.rules { - if !rule.match(issue, p.files, p.log) { + if !rule.match(issue, p.lines, p.log) { continue } diff --git a/pkg/result/processors/exclusion_rules_test.go b/pkg/result/processors/exclusion_rules_test.go index 512246c3fc81..9e110536db6a 100644 --- a/pkg/result/processors/exclusion_rules_test.go +++ b/pkg/result/processors/exclusion_rules_test.go @@ -1,7 +1,6 @@ package processors import ( - "path" "path/filepath" "testing" @@ -13,7 +12,7 @@ import ( ) func TestExclusionRules_Process_multiple(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "") + lines := fsutils.NewLineCache(fsutils.NewFileCache()) cfg := &config.LinterExclusions{ Rules: []config.ExcludeRule{ @@ -50,7 +49,7 @@ func TestExclusionRules_Process_multiple(t *testing.T) { }, } - p := NewExclusionRules(nil, files, cfg) + p := NewExclusionRules(nil, lines, cfg) cases := []issueTestCase{ {Path: "e.go", Text: "exclude", Linter: "linter"}, @@ -91,52 +90,8 @@ func TestExclusionRules_Process_multiple(t *testing.T) { assert.Equal(t, expectedCases, resultingCases) } -func TestExclusionRules_Process_pathPrefix(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), path.Join("some", "dir")) - - cfg := &config.LinterExclusions{ - Rules: []config.ExcludeRule{ - { - BaseRule: config.BaseRule{ - Path: `some/dir/e\.go`, - }, - }, - }, - } - - p := NewExclusionRules(nil, files, cfg) - - cases := []issueTestCase{ - {Path: "e.go"}, - {Path: "other.go"}, - } - - var issues []result.Issue - for _, c := range cases { - issues = append(issues, newIssueFromIssueTestCase(c)) - } - - processedIssues := process(t, p, issues...) - - var resultingCases []issueTestCase - for _, i := range processedIssues { - resultingCases = append(resultingCases, issueTestCase{ - Path: i.FilePath(), - Linter: i.FromLinter, - Text: i.Text, - Line: i.Line(), - }) - } - - expectedCases := []issueTestCase{ - {Path: "other.go"}, - } - - assert.Equal(t, expectedCases, resultingCases) -} - func TestExclusionRules_Process_text(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "") + lines := fsutils.NewLineCache(fsutils.NewFileCache()) cfg := &config.LinterExclusions{ Rules: []config.ExcludeRule{{ @@ -147,7 +102,7 @@ func TestExclusionRules_Process_text(t *testing.T) { }}, } - p := NewExclusionRules(nil, files, cfg) + p := NewExclusionRules(nil, lines, cfg) texts := []string{"exclude", "1", "", "exclud", "notexclude"} var issues []result.Issue @@ -170,15 +125,15 @@ func TestExclusionRules_Process_text(t *testing.T) { } func TestExclusionRules_Process_empty(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "") + lines := fsutils.NewLineCache(fsutils.NewFileCache()) - p := NewExclusionRules(nil, files, &config.LinterExclusions{}) + p := NewExclusionRules(nil, lines, &config.LinterExclusions{}) processAssertSame(t, p, newIssueFromTextTestCase("test")) } func TestExclusionRules_Process_caseSensitive_multiple(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "") + lines := fsutils.NewLineCache(fsutils.NewFileCache()) cfg := &config.LinterExclusions{ Rules: []config.ExcludeRule{ @@ -209,7 +164,7 @@ func TestExclusionRules_Process_caseSensitive_multiple(t *testing.T) { }, } - p := NewExclusionRules(nil, files, cfg) + p := NewExclusionRules(nil, lines, cfg) cases := []issueTestCase{ {Path: "e.go", Text: "exclude", Linter: "linter"}, @@ -253,7 +208,7 @@ func TestExclusionRules_Process_caseSensitive_multiple(t *testing.T) { } func TestExclusionRules_Process_caseSensitive_text(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "") + lines := fsutils.NewLineCache(fsutils.NewFileCache()) cfg := &config.LinterExclusions{ Rules: []config.ExcludeRule{ @@ -266,7 +221,7 @@ func TestExclusionRules_Process_caseSensitive_text(t *testing.T) { }, } - p := NewExclusionRules(nil, files, cfg) + p := NewExclusionRules(nil, lines, cfg) texts := []string{"exclude", "excLude", "1", "", "exclud", "notexclude"} @@ -290,9 +245,9 @@ func TestExclusionRules_Process_caseSensitive_text(t *testing.T) { } func TestExclusionRules_Process_caseSensitive_empty(t *testing.T) { - files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "") + lines := fsutils.NewLineCache(fsutils.NewFileCache()) - p := NewExclusionRules(nil, files, &config.LinterExclusions{}) + p := NewExclusionRules(nil, lines, &config.LinterExclusions{}) processAssertSame(t, p, newIssueFromTextTestCase("test")) } diff --git a/pkg/result/processors/path_prettifier.go b/pkg/result/processors/path_prettifier.go index 6a04b1c35989..ad9a5663c3c9 100644 --- a/pkg/result/processors/path_prettifier.go +++ b/pkg/result/processors/path_prettifier.go @@ -1,7 +1,8 @@ package processors import ( - "github.com/golangci/golangci-lint/pkg/fsutils" + "path/filepath" + "github.com/golangci/golangci-lint/pkg/logutils" "github.com/golangci/golangci-lint/pkg/result" ) @@ -30,7 +31,11 @@ func (p *PathPrettifier) Process(issues []result.Issue) ([]result.Issue, error) return transformIssues(issues, func(issue *result.Issue) *result.Issue { newIssue := issue - newIssue.Pos.Filename = fsutils.WithPathPrefix(p.prefix, issue.RelativePath) + if p.prefix == "" { + newIssue.Pos.Filename = issue.RelativePath + } else { + newIssue.Pos.Filename = filepath.Join(p.prefix, issue.RelativePath) + } return newIssue }), nil diff --git a/pkg/result/processors/severity.go b/pkg/result/processors/severity.go index 4c9a978b055b..c0514110acd6 100644 --- a/pkg/result/processors/severity.go +++ b/pkg/result/processors/severity.go @@ -22,16 +22,16 @@ type Severity struct { log logutils.Log - files *fsutils.Files + lines *fsutils.LineCache defaultSeverity string rules []severityRule } -func NewSeverity(log logutils.Log, files *fsutils.Files, cfg *config.Severity) *Severity { +func NewSeverity(log logutils.Log, lines *fsutils.LineCache, cfg *config.Severity) *Severity { p := &Severity{ name: "severity-rules", - files: files, + lines: lines, log: log, defaultSeverity: cfg.Default, } @@ -55,7 +55,7 @@ func (*Severity) Finish() {} func (p *Severity) transform(issue *result.Issue) *result.Issue { for _, rule := range p.rules { - if rule.match(issue, p.files, p.log) { + if rule.match(issue, p.lines, p.log) { if rule.severity == severityFromLinter || (rule.severity == "" && p.defaultSeverity == severityFromLinter) { return issue } diff --git a/pkg/result/processors/severity_test.go b/pkg/result/processors/severity_test.go index b5c36700c76e..dcd3974fb2f7 100644 --- a/pkg/result/processors/severity_test.go +++ b/pkg/result/processors/severity_test.go @@ -1,7 +1,6 @@ package processors import ( - "path" "path/filepath" "testing" @@ -15,7 +14,6 @@ import ( func TestSeverity_multiple(t *testing.T) { lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) - files := fsutils.NewFiles(lineCache, "") log := logutils.NewStderrLog(logutils.DebugKeyEmpty) opts := &config.Severity{ @@ -79,7 +77,7 @@ func TestSeverity_multiple(t *testing.T) { }, } - p := NewSeverity(log, files, opts) + p := NewSeverity(log, lineCache, opts) cases := []issueTestCase{ {Path: "ssl.go", Text: "ssl", Linter: "gosec"}, @@ -128,58 +126,6 @@ func TestSeverity_multiple(t *testing.T) { assert.Equal(t, expectedCases, resultingCases) } -func TestSeverity_pathPrefix(t *testing.T) { - lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) - pathPrefix := path.Join("some", "dir") - files := fsutils.NewFiles(lineCache, pathPrefix) - log := logutils.NewStderrLog(logutils.DebugKeyEmpty) - - opts := &config.Severity{ - Default: "error", - Rules: []config.SeverityRule{ - { - Severity: "info", - BaseRule: config.BaseRule{ - Text: "some", - Path: `some/dir/e\.go`, - }, - }, - }, - } - - p := NewSeverity(log, files, opts) - - cases := []issueTestCase{ - {Path: "e.go", Text: "some", Linter: "linter"}, - {Path: "other.go", Text: "some", Linter: "linter"}, - } - - var issues []result.Issue - for _, c := range cases { - issues = append(issues, newIssueFromIssueTestCase(c)) - } - - processedIssues := process(t, p, issues...) - - var resultingCases []issueTestCase - for _, i := range processedIssues { - resultingCases = append(resultingCases, issueTestCase{ - Path: i.FilePath(), - Linter: i.FromLinter, - Text: i.Text, - Line: i.Line(), - Severity: i.Severity, - }) - } - - expectedCases := []issueTestCase{ - {Path: "e.go", Text: "some", Linter: "linter", Severity: "info"}, - {Path: "other.go", Text: "some", Linter: "linter", Severity: "error"}, - } - - assert.Equal(t, expectedCases, resultingCases) -} - func TestSeverity_text(t *testing.T) { opts := &config.Severity{ Rules: []config.SeverityRule{ @@ -216,7 +162,6 @@ func TestSeverity_text(t *testing.T) { func TestSeverity_onlyDefault(t *testing.T) { lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) - files := fsutils.NewFiles(lineCache, "") log := logutils.NewStderrLog(logutils.DebugKeyEmpty) opts := config.Severity{ @@ -224,7 +169,7 @@ func TestSeverity_onlyDefault(t *testing.T) { Rules: []config.SeverityRule{}, } - p := NewSeverity(log, files, &opts) + p := NewSeverity(log, lineCache, &opts) cases := []issueTestCase{ {Path: "ssl.go", Text: "ssl", Linter: "gosec"}, @@ -265,7 +210,6 @@ func TestSeverity_empty(t *testing.T) { func TestSeverity_caseSensitive(t *testing.T) { lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) - files := fsutils.NewFiles(lineCache, "") opts := &config.Severity{ Default: "error", @@ -280,7 +224,7 @@ func TestSeverity_caseSensitive(t *testing.T) { }, } - p := NewSeverity(nil, files, opts) + p := NewSeverity(nil, lineCache, opts) cases := []issueTestCase{ {Path: "e.go", Text: "ssL", Linter: "gosec"}, @@ -313,7 +257,6 @@ func TestSeverity_caseSensitive(t *testing.T) { func TestSeverity_transform(t *testing.T) { lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) - files := fsutils.NewFiles(lineCache, "") testCases := []struct { desc string @@ -485,7 +428,7 @@ func TestSeverity_transform(t *testing.T) { t.Run(test.desc, func(t *testing.T) { t.Parallel() - p := NewSeverity(nil, files, test.opts) + p := NewSeverity(nil, lineCache, test.opts) newIssue := p.transform(test.issue)