dev: simplify severity processor

pkg/lint/runner.go

@@ -328,22 +328,11 @@ func getSeverityRulesProcessor(cfg *config.Severity, log logutils.Log, files *fs
 		})
 	}
 
-	var severityRulesProcessor processors.Processor
-	if cfg.CaseSensitive {
-		severityRulesProcessor = processors.NewSeverityRulesCaseSensitive(
-			cfg.Default,
-			severityRules,
-			files,
-			log.Child(logutils.DebugKeySeverityRules),
-		)
-	} else {
-		severityRulesProcessor = processors.NewSeverityRules(
-			cfg.Default,
-			severityRules,
-			files,
-			log.Child(logutils.DebugKeySeverityRules),
-		)
+	severityOpts := processors.SeverityOptions{
+		Default:       cfg.Default,
+		Rules:         severityRules,
+		CaseSensitive: cfg.CaseSensitive,
 	}
 
-	return severityRulesProcessor
+	return processors.NewSeverity(log.Child(logutils.DebugKeySeverityRules), files, severityOpts)
 }

pkg/result/processors/severity_rules.go → pkg/result/processors/severity.go

@@ -8,6 +8,8 @@ import (
 	"github.com/golangci/golangci-lint/pkg/result"
 )
 
+var _ Processor = &Severity{}
+
 type severityRule struct {
 	baseRule
 	severity string
@@ -18,53 +20,47 @@ type SeverityRule struct {
 	Severity string
 }
 
-type SeverityRules struct {
+type SeverityOptions struct {
+	Default       string
+	Rules         []SeverityRule
+	CaseSensitive bool
+}
+
+type Severity struct {
+	name string
+
+	log logutils.Log
+
+	files *fsutils.Files
+
 	defaultSeverity string
 	rules           []severityRule
-	files           *fsutils.Files
-	log             logutils.Log
 }
 
-func NewSeverityRules(defaultSeverity string, rules []SeverityRule, files *fsutils.Files, log logutils.Log) *SeverityRules {
-	r := &SeverityRules{
+func NewSeverity(log logutils.Log, files *fsutils.Files, opts SeverityOptions) *Severity {
+	p := &Severity{
+		name:            "severity-rules",
 		files:           files,
 		log:             log,
-		defaultSeverity: defaultSeverity,
+		defaultSeverity: opts.Default,
 	}
-	r.rules = createSeverityRules(rules, "(?i)")
-
-	return r
-}
 
-func createSeverityRules(rules []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)
-		}
-		parsedRules = append(parsedRules, parsedRule)
+	prefix := "(?i)"
+	if opts.CaseSensitive {
+		prefix = ""
+		p.name = "severity-rules-case-sensitive"
 	}
-	return parsedRules
+
+	p.rules = createSeverityRules(opts.Rules, prefix)
+
+	return p
 }
 
-func (p SeverityRules) Process(issues []result.Issue) ([]result.Issue, error) {
+func (p *Severity) Process(issues []result.Issue) ([]result.Issue, error) {
 	if len(p.rules) == 0 && p.defaultSeverity == "" {
 		return issues, nil
 	}
+
 	return transformIssues(issues, func(i *result.Issue) *result.Issue {
 		for _, rule := range p.rules {
 			rule := rule
@@ -79,30 +75,45 @@ func (p SeverityRules) Process(issues []result.Issue) ([]result.Issue, error) {
 				return i
 			}
 		}
+
 		i.Severity = p.defaultSeverity
+
 		return i
 	}), nil
 }
 
-func (SeverityRules) Name() string { return "severity-rules" }
-func (SeverityRules) Finish()      {}
+func (p *Severity) Name() string { return p.name }
 
-var _ Processor = SeverityRules{}
+func (*Severity) Finish() {}
 
-type SeverityRulesCaseSensitive struct {
-	*SeverityRules
-}
+func createSeverityRules(rules []SeverityRule, prefix string) []severityRule {
+	parsedRules := make([]severityRule, 0, len(rules))
 
-func NewSeverityRulesCaseSensitive(defaultSeverity string, rules []SeverityRule,
-	files *fsutils.Files, log logutils.Log) *SeverityRulesCaseSensitive {
-	r := &SeverityRules{
-		files:           files,
-		log:             log,
-		defaultSeverity: defaultSeverity,
+	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)
+		}
+
+		parsedRules = append(parsedRules, parsedRule)
 	}
-	r.rules = createSeverityRules(rules, "")
 
-	return &SeverityRulesCaseSensitive{r}
+	return parsedRules
 }
-
-func (SeverityRulesCaseSensitive) Name() string { return "severity-rules-case-sensitive" }