feat(config)!: new config format

new config format makes it easy to control enabled rules
and severity levels for each rule

* rename RuleConfig to RuleSettings

config/config.go

@@ -62,14 +62,28 @@ func Validate(conf *lint.Config) []error {
 		}
 	}
 
-	for ruleName, r := range conf.Rules {
+	// Check Severity Level
+	if !isSeverityValid(conf.Severity.Default) {
+		errs = append(errs, fmt.Errorf("unknown default severity level '%s'", conf.Severity.Default))
+	}
+
+	for ruleName, sev := range conf.Severity.Rules {
 		// Check Severity Level of rule config
-		switch r.Severity {
-		case lint.SeverityError, lint.SeverityWarn:
-		default:
-			errs = append(errs, fmt.Errorf("unknown severity level '%s' for rule '%s'", r.Severity, ruleName))
+		if !isSeverityValid(sev) {
+			errs = append(errs, fmt.Errorf("unknown default severity level '%s' for rule '%s'", ruleName, sev))
+		}
+	}
+
+	for _, ruleName := range conf.Rules {
+		// Check if rule is registered
+		_, ok := registry.GetRule(ruleName)
+		if !ok {
+			errs = append(errs, fmt.Errorf("unknown rule '%s'", ruleName))
+			continue
 		}
+	}
 
+	for ruleName, r := range conf.Settings {
 		// Check if rule is registered
 		ruleData, ok := registry.GetRule(ruleName)
 		if !ok {
@@ -133,3 +147,7 @@ func checkIfMinVersion(versionNo string) error {
 	}
 	return fmt.Errorf("min version required is %s. you have %s.\nupgrade commitlint", versionNo, internal.Version())
 }
+
+func isSeverityValid(s lint.Severity) bool {
+	return s == lint.SeverityError || s == lint.SeverityWarn
+}

config/default.go

@@ -9,151 +9,130 @@ import (
 
 // Default returns default config
 func Default() *lint.Config {
-	def := &lint.Config{
-		MinVersion: internal.Version(),
+	// Enabled Rules
+	rules := []string{
+		(&rule.HeadMinLenRule{}).Name(),
+		(&rule.HeadMaxLenRule{}).Name(),
+		(&rule.BodyMaxLineLenRule{}).Name(),
+		(&rule.FooterMaxLineLenRule{}).Name(),
+		(&rule.TypeEnumRule{}).Name(),
+	}
 
-		Formatter: (&formatter.DefaultFormatter{}).Name(),
+	// Severity Levels
+	severity := lint.SeverityConfig{
+		Default: lint.SeverityError,
+	}
 
-		Rules: map[string]lint.RuleConfig{
-			// Header Min Len Rule
-			(&rule.HeadMinLenRule{}).Name(): {
-				Enabled:  true,
-				Severity: lint.SeverityError,
-				Argument: 10,
-			},
+	// Default Rule Settings
+	settings := map[string]lint.RuleSetting{
+		// Header Min Len Rule
+		(&rule.HeadMinLenRule{}).Name(): {
+			Argument: 10,
+		},
 
-			// Header Max Len Rule
-			(&rule.HeadMaxLenRule{}).Name(): {
-				Enabled:  true,
-				Severity: lint.SeverityError,
-				Argument: 50,
-			},
+		// Header Max Len Rule
+		(&rule.HeadMaxLenRule{}).Name(): {
+			Argument: 50,
+		},
 
-			// Body Max Line Rule
-			(&rule.BodyMaxLineLenRule{}).Name(): {
-				Enabled:  true,
-				Severity: lint.SeverityError,
-				Argument: 72,
-			},
+		// Body Max Line Rule
+		(&rule.BodyMaxLineLenRule{}).Name(): {
+			Argument: 72,
+		},
 
-			// Footer Max Line Rule
-			(&rule.FooterMaxLineLenRule{}).Name(): {
-				Enabled:  true,
-				Severity: lint.SeverityError,
-				Argument: 72,
-			},
+		// Footer Max Line Rule
+		(&rule.FooterMaxLineLenRule{}).Name(): {
+			Argument: 72,
+		},
 
-			// Types Enum Rule
-			(&rule.TypeEnumRule{}).Name(): {
-				Enabled:  true,
-				Severity: lint.SeverityError,
-				Argument: []interface{}{
-					"feat", "fix", "docs", "style", "refactor", "perf",
-					"test", "build", "ci", "chore", "revert",
-				},
+		// Types Enum Rule
+		(&rule.TypeEnumRule{}).Name(): {
+			Argument: []interface{}{
+				"feat", "fix", "docs", "style", "refactor", "perf",
+				"test", "build", "ci", "chore", "revert",
 			},
+		},
 
-			// Scope Enum Rule
-			(&rule.ScopeEnumRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: []interface{}{},
-				Flags: map[string]interface{}{
-					"allow-empty": true,
-				},
+		// Scope Enum Rule
+		(&rule.ScopeEnumRule{}).Name(): {
+			Argument: []interface{}{},
+			Flags: map[string]interface{}{
+				"allow-empty": true,
 			},
+		},
 
-			// Body Min Len Rule
-			(&rule.BodyMinLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: 0,
-			},
+		// Body Min Len Rule
+		(&rule.BodyMinLenRule{}).Name(): {
+			Argument: 0,
+		},
 
-			// Body Max Len Rule
-			(&rule.BodyMaxLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: -1,
-			},
+		// Body Max Len Rule
+		(&rule.BodyMaxLenRule{}).Name(): {
+			Argument: -1,
+		},
 
-			// Footer Min Len Rule
-			(&rule.FooterMinLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: 0,
-			},
+		// Footer Min Len Rule
+		(&rule.FooterMinLenRule{}).Name(): {
+			Argument: 0,
+		},
 
-			// Footer Max Len Rule
-			(&rule.FooterMaxLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: -1,
-			},
+		// Footer Max Len Rule
+		(&rule.FooterMaxLenRule{}).Name(): {
+			Argument: -1,
+		},
 
-			// Type Min Len Rule
-			(&rule.TypeMinLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: 0,
-			},
+		// Type Min Len Rule
+		(&rule.TypeMinLenRule{}).Name(): {
+			Argument: 0,
+		},
 
-			// Type Max Len Rule
-			(&rule.TypeMaxLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: -1,
-			},
+		// Type Max Len Rule
+		(&rule.TypeMaxLenRule{}).Name(): {
+			Argument: -1,
+		},
 
-			// Scope Min Len Rule
-			(&rule.ScopeMinLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: 0,
-			},
+		// Scope Min Len Rule
+		(&rule.ScopeMinLenRule{}).Name(): {
+			Argument: 0,
+		},
 
-			// Scope Max Len Rule
-			(&rule.ScopeMaxLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: -1,
-			},
+		// Scope Max Len Rule
+		(&rule.ScopeMaxLenRule{}).Name(): {
+			Argument: -1,
+		},
 
-			// Description Min Len Rule
-			(&rule.DescriptionMinLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: 0,
-			},
+		// Description Min Len Rule
+		(&rule.DescriptionMinLenRule{}).Name(): {
+			Argument: 0,
+		},
 
-			// Description Max Len Rule
-			(&rule.DescriptionMaxLenRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: -1,
-			},
+		// Description Max Len Rule
+		(&rule.DescriptionMaxLenRule{}).Name(): {
+			Argument: -1,
+		},
 
-			// Type Charset Rule
-			(&rule.TypeCharsetRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-			},
+		// Type Charset Rule
+		(&rule.TypeCharsetRule{}).Name(): {
+			Argument: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		},
 
-			// Scope Charset Rule
-			(&rule.ScopeCharsetRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/,",
-			},
+		// Scope Charset Rule
+		(&rule.ScopeCharsetRule{}).Name(): {
+			Argument: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/,",
+		},
 
-			// Footer Enum Rule
-			(&rule.FooterEnumRule{}).Name(): {
-				Enabled:  false,
-				Severity: lint.SeverityError,
-				Argument: []interface{}{},
-			},
+		// Footer Enum Rule
+		(&rule.FooterEnumRule{}).Name(): {
+			Argument: []interface{}{},
 		},
 	}
+
+	def := &lint.Config{
+		MinVersion: internal.Version(),
+		Formatter:  (&formatter.DefaultFormatter{}).Name(),
+		Rules:      rules,
+		Severity:   severity,
+		Settings:   settings,
+	}
 	return def
 }

config/lint.go

@@ -18,6 +18,7 @@ func NewLinter(conf *lint.Config) (*lint.Linter, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	return lint.New(conf, rules)
 }
 
@@ -39,19 +40,20 @@ func GetFormatter(conf *lint.Config) (lint.Formatter, error) {
 func GetEnabledRules(conf *lint.Config) ([]lint.Rule, error) {
 	enabledRules := make([]lint.Rule, 0, len(conf.Rules))
 
-	for ruleName, ruleConfig := range conf.Rules {
+	for _, ruleName := range conf.Rules {
 		// Checking if rule is registered
 		// before checking if rule is enabled
 		r, ok := registry.GetRule(ruleName)
 		if !ok {
 			return nil, fmt.Errorf("config error: '%s' rule not found", ruleName)
 		}
 
-		if !ruleConfig.Enabled {
-			continue
+		rConf, ok := conf.Settings[ruleName]
+		if !ok {
+			return nil, fmt.Errorf("config error: '%s' rule settings not found", ruleName)
 		}
 
-		err := r.Apply(ruleConfig.Argument, ruleConfig.Flags)
+		err := r.Apply(rConf.Argument, rConf.Flags)
 		if err != nil {
 			return nil, fmt.Errorf("config error: %v", err)
 		}

lint/config.go

@@ -1,15 +1,15 @@
 package lint
 
-// RuleConfig represent config for a rule
-type RuleConfig struct {
-	Enabled bool `yaml:"enabled"`
-
-	Severity Severity `yaml:"severity"`
-
-	Argument interface{} `yaml:"argument"`
+// RuleSetting represent config for a rule
+type RuleSetting struct {
+	Argument interface{}            `yaml:"argument"`
+	Flags    map[string]interface{} `yaml:"flags,omitempty"`
+}
 
-	// Flags are optional key value pairs
-	Flags map[string]interface{} `yaml:"flags"`
+// SeverityConfig represent severity levels for rules
+type SeverityConfig struct {
+	Default Severity            `yaml:"default"`
+	Rules   map[string]Severity `yaml:"rules,omitempty"`
 }
 
 // Config represent linter config
@@ -21,11 +21,26 @@ type Config struct {
 	// Formatter of the lint result
 	Formatter string `yaml:"formatter"`
 
-	// Rules is rule name to rule config map
-	Rules map[string]RuleConfig `yaml:"rules"`
+	// Enabled Rules
+	Rules []string `yaml:"rules"`
+
+	// Severity
+	Severity SeverityConfig `yaml:"severity"`
+
+	// Settings is rule name to rule settings
+	Settings map[string]RuleSetting `yaml:"settings"`
 }
 
 // GetRule returns RuleConfig for given rule name
-func (c *Config) GetRule(ruleName string) RuleConfig {
-	return c.Rules[ruleName]
+func (c *Config) GetRule(ruleName string) RuleSetting {
+	return c.Settings[ruleName]
+}
+
+// GetSeverity returns Severity for given ruleName
+func (c *Config) GetSeverity(ruleName string) Severity {
+	s, ok := c.Severity.Rules[ruleName]
+	if ok {
+		return s
+	}
+	return c.Severity.Default
 }

lint/linter.go

@@ -38,8 +38,8 @@ func (l *Linter) LintCommit(msg *Commit) (*Failure, error) {
 
 	for _, rule := range l.rules {
 		currentRule := rule
-		ruleConf := l.conf.GetRule(currentRule.Name())
-		ruleRes, isValid := l.runRule(currentRule, ruleConf.Severity, msg)
+		severity := l.conf.GetSeverity(currentRule.Name())
+		ruleRes, isValid := l.runRule(currentRule, severity, msg)
 		if !isValid {
 			res.add(ruleRes)
 		}