From 4e3f7e0dd2f9bab03249052761a12d0bc147dbfc Mon Sep 17 00:00:00 2001 From: Fernandez Ludovic Date: Wed, 29 Jan 2025 17:24:02 +0100 Subject: [PATCH 1/2] refactor: factorize base rule parsing --- pkg/result/processors/base_rule.go | 42 ++++++++++++++++++++ pkg/result/processors/exclusion_rules.go | 50 +++++------------------- pkg/result/processors/severity.go | 44 +++++---------------- 3 files changed, 60 insertions(+), 76 deletions(-) diff --git a/pkg/result/processors/base_rule.go b/pkg/result/processors/base_rule.go index c54cd082f271..9148ae0c0835 100644 --- a/pkg/result/processors/base_rule.go +++ b/pkg/result/processors/base_rule.go @@ -3,6 +3,7 @@ package processors import ( "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" @@ -21,6 +22,33 @@ type baseRule struct { internalReference string `mapstructure:"-"` } +// The usage of `regexp.MustCompile()` is safe here, +// because the regular expressions are checked before inside [config.BaseRule.Validate]. +func newBaseRule(rule *config.BaseRule, prefix string) baseRule { + base := baseRule{ + linters: rule.Linters, + internalReference: rule.InternalReference, + } + + if rule.Text != "" { + base.text = regexp.MustCompile(prefix + rule.Text) + } + + if rule.Source != "" { + base.source = regexp.MustCompile(prefix + rule.Source) + } + + if rule.Path != "" { + base.path = regexp.MustCompile(fsutils.NormalizePathInRegex(rule.Path)) + } + + if rule.PathExcept != "" { + base.pathExcept = regexp.MustCompile(fsutils.NormalizePathInRegex(rule.PathExcept)) + } + + return base +} + func (r *baseRule) isEmpty() bool { return r.text == nil && r.source == nil && r.path == nil && r.pathExcept == nil && len(r.linters) == 0 } @@ -69,3 +97,17 @@ func (r *baseRule) matchSource(issue *result.Issue, lineCache *fsutils.LineCache return r.source.MatchString(sourceLine) } + +func parseRules[T, V any](rules []T, prefix string, newFn func(*T, string) V) []V { + if len(rules) == 0 { + return nil + } + + parsedRules := make([]V, 0, len(rules)) + + for _, r := range rules { + parsedRules = append(parsedRules, newFn(&r, prefix)) + } + + return parsedRules +} diff --git a/pkg/result/processors/exclusion_rules.go b/pkg/result/processors/exclusion_rules.go index 84e10e06e31d..bd7924cb3cf0 100644 --- a/pkg/result/processors/exclusion_rules.go +++ b/pkg/result/processors/exclusion_rules.go @@ -2,7 +2,6 @@ package processors import ( "fmt" - "regexp" "slices" "strings" @@ -24,7 +23,8 @@ type ExclusionRules struct { rules []excludeRule } -func NewExclusionRules(log logutils.Log, files *fsutils.Files, cfg *config.LinterExclusions, oldCfg *config.Issues) *ExclusionRules { +func NewExclusionRules(log logutils.Log, files *fsutils.Files, + cfg *config.LinterExclusions, oldCfg *config.Issues) *ExclusionRules { p := &ExclusionRules{ log: log, files: files, @@ -41,7 +41,7 @@ func NewExclusionRules(log logutils.Log, files *fsutils.Files, cfg *config.Linte excludeRules := slices.Concat(slices.Clone(cfg.Rules), filterInclude(getLinterExclusionPresets(cfg.Presets), oldCfg.IncludeDefaultExcludes)) - p.rules = createExcludeRules(excludeRules, prefix) + p.rules = parseRules(excludeRules, prefix, newExcludeRule) // TODO(ldez): should be removed in v2. for _, pattern := range oldCfg.ExcludePatterns { @@ -49,12 +49,14 @@ func NewExclusionRules(log logutils.Log, files *fsutils.Files, cfg *config.Linte continue } - rule := newRule(&config.ExcludeRule{ + r := &config.ExcludeRule{ BaseRule: config.BaseRule{ Path: `.+\.go`, Text: pattern, }, - }, prefix) + } + + rule := newExcludeRule(r, prefix) p.rules = append(p.rules, rule) } @@ -109,28 +111,8 @@ type excludeRule struct { baseRule } -func newRule(rule *config.ExcludeRule, prefix string) excludeRule { - parsedRule := excludeRule{} - parsedRule.linters = rule.Linters - parsedRule.internalReference = rule.InternalReference - - if rule.Text != "" { - parsedRule.text = regexp.MustCompile(prefix + rule.Text) - } - - if rule.Source != "" { - parsedRule.source = regexp.MustCompile(prefix + rule.Source) - } - - if rule.Path != "" { - parsedRule.path = regexp.MustCompile(fsutils.NormalizePathInRegex(rule.Path)) - } - - if rule.PathExcept != "" { - parsedRule.pathExcept = regexp.MustCompile(fsutils.NormalizePathInRegex(rule.PathExcept)) - } - - return parsedRule +func newExcludeRule(rule *config.ExcludeRule, prefix string) excludeRule { + return excludeRule{baseRule: newBaseRule(&rule.BaseRule, prefix)} } func (e excludeRule) String() string { @@ -159,20 +141,6 @@ func (e excludeRule) String() string { return strings.Join(msg, ", ") } -func createExcludeRules(rules []config.ExcludeRule, prefix string) []excludeRule { - if len(rules) == 0 { - return nil - } - - parsedRules := make([]excludeRule, 0, len(rules)) - - for _, rule := range rules { - parsedRules = append(parsedRules, newRule(&rule, prefix)) - } - - return parsedRules -} - // TODO(ldez): must be removed in v2, only for compatibility with exclude-use-default/include. func filterInclude(rules []config.ExcludeRule, refs []string) []config.ExcludeRule { if len(refs) == 0 { diff --git a/pkg/result/processors/severity.go b/pkg/result/processors/severity.go index fa853527a759..2dacf663874d 100644 --- a/pkg/result/processors/severity.go +++ b/pkg/result/processors/severity.go @@ -2,7 +2,6 @@ package processors import ( "cmp" - "regexp" "github.com/golangci/golangci-lint/pkg/config" "github.com/golangci/golangci-lint/pkg/fsutils" @@ -14,11 +13,6 @@ const severityFromLinter = "@linter" var _ Processor = (*Severity)(nil) -type severityRule struct { - baseRule - severity string -} - // Severity modifies report severity. // It uses the same `baseRule` structure as [ExcludeRules] processor. // @@ -48,7 +42,7 @@ func NewSeverity(log logutils.Log, files *fsutils.Files, cfg *config.Severity) * p.name = "severity-rules-case-sensitive" } - p.rules = createSeverityRules(cfg.Rules, prefix) + p.rules = parseRules(cfg.Rules, prefix, newSeverityRule) return p } @@ -85,34 +79,14 @@ func (p *Severity) transform(issue *result.Issue) *result.Issue { return issue } -func createSeverityRules(rules []config.SeverityRule, prefix string) []severityRule { - parsedRules := make([]severityRule, 0, len(rules)) - - for _, rule := range rules { - parsedRule := severityRule{} - parsedRule.linters = rule.Linters - parsedRule.severity = rule.Severity - - if rule.Text != "" { - parsedRule.text = regexp.MustCompile(prefix + rule.Text) - } - - if rule.Source != "" { - parsedRule.source = regexp.MustCompile(prefix + rule.Source) - } - - if rule.Path != "" { - path := fsutils.NormalizePathInRegex(rule.Path) - parsedRule.path = regexp.MustCompile(path) - } - - if rule.PathExcept != "" { - pathExcept := fsutils.NormalizePathInRegex(rule.PathExcept) - parsedRule.pathExcept = regexp.MustCompile(pathExcept) - } +type severityRule struct { + baseRule + severity string +} - parsedRules = append(parsedRules, parsedRule) +func newSeverityRule(rule *config.SeverityRule, prefix string) severityRule { + return severityRule{ + baseRule: newBaseRule(&rule.BaseRule, prefix), + severity: rule.Severity, } - - return parsedRules } From 90779315309b00670674c118b7049b9e54e2195f Mon Sep 17 00:00:00 2001 From: Fernandez Ludovic Date: Thu, 30 Jan 2025 20:19:40 +0100 Subject: [PATCH 2/2] refactor: move internalReference into excludeRule --- pkg/result/processors/base_rule.go | 6 +----- pkg/result/processors/exclusion_rules.go | 8 +++++++- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/pkg/result/processors/base_rule.go b/pkg/result/processors/base_rule.go index 9148ae0c0835..72dc202847d4 100644 --- a/pkg/result/processors/base_rule.go +++ b/pkg/result/processors/base_rule.go @@ -17,17 +17,13 @@ type baseRule struct { path *regexp.Regexp pathExcept *regexp.Regexp linters []string - - // For compatibility with exclude-use-default/include. - internalReference string `mapstructure:"-"` } // The usage of `regexp.MustCompile()` is safe here, // because the regular expressions are checked before inside [config.BaseRule.Validate]. func newBaseRule(rule *config.BaseRule, prefix string) baseRule { base := baseRule{ - linters: rule.Linters, - internalReference: rule.InternalReference, + linters: rule.Linters, } if rule.Text != "" { diff --git a/pkg/result/processors/exclusion_rules.go b/pkg/result/processors/exclusion_rules.go index bd7924cb3cf0..7730a53dd04c 100644 --- a/pkg/result/processors/exclusion_rules.go +++ b/pkg/result/processors/exclusion_rules.go @@ -109,10 +109,16 @@ func (p *ExclusionRules) Finish() { type excludeRule struct { baseRule + + // For compatibility with exclude-use-default/include. + internalReference string `mapstructure:"-"` } func newExcludeRule(rule *config.ExcludeRule, prefix string) excludeRule { - return excludeRule{baseRule: newBaseRule(&rule.BaseRule, prefix)} + return excludeRule{ + baseRule: newBaseRule(&rule.BaseRule, prefix), + internalReference: rule.InternalReference, + } } func (e excludeRule) String() string {