feat: support ignore patterns

Fixes: #8, #10

Author: muthukrishnan24

config/config.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
 
 	"golang.org/x/mod/semver"
 	yaml "gopkg.in/yaml.v2"
@@ -48,6 +49,9 @@ func Parse(confPath string) (*lint.Config, error) {
 		conf.MinVersion = internal.Version()
 	}
 
+	// Always set the built-in default patterns
+	conf.DefaultIgnorePatterns = DefaultIgnorePatterns()
+
 	if conf.Formatter == "" {
 		return nil, errors.New("config error: formatter is empty")
 	}
@@ -124,6 +128,15 @@ func Validate(conf *lint.Config) []error {
 			errs = append(errs, err)
 		}
 	}
+
+	// Validate ignore patterns (both default and user-defined)
+	for _, pattern := range conf.EffectiveIgnorePatterns() {
+		_, err := regexp.Compile(pattern)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("invalid ignore pattern %q: %w", pattern, err))
+		}
+	}
+
 	return errs
 }
 

config/default.go

@@ -7,6 +7,51 @@ import (
 	"github.com/conventionalcommit/commitlint/rule"
 )
 
+const (
+	DefaultTypeCharset  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	DefaultScopeCharset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/,"
+)
+
+// DefaultIgnorePatterns returns the default list of ignore patterns
+// These patterns match commit messages auto-generated by git commands
+// like merge, revert, fixup, squash, etc.
+func DefaultIgnorePatterns() []string {
+	return []string{
+		// GitHub / GitLab merge
+		`^Merge pull request #\d+`,
+		`^Merge .+ into .+`,
+		`^Merge branch '.+'`,
+		`^Merge tag '.+'`,
+		`^Merge remote-tracking branch '.+'`,
+
+		// Azure DevOps / Bitbucket merge
+		`^Merged .+ (in|into) .+`,
+		`^Merged PR #?\d+`,
+
+		// Revert and Reapply
+		`^(R|r)evert `,
+		`^(R|r)eapply `,
+
+		// Fixup, Amend, Squash (git commit --fixup/--squash)
+		`^(amend|fixup|squash)! `,
+
+		// Automatic merges
+		`^Automatic merge`,
+		`^Auto-merged .+ into .+`,
+
+		// Initial commit
+		`^Initial commit$`,
+	}
+}
+
+// DefaultTypeEnums returns the default list of type enums
+func DefaultTypeEnums() []interface{} {
+	return []interface{}{
+		"feat", "fix", "docs", "style", "refactor", "perf",
+		"test", "build", "ci", "chore", "revert",
+	}
+}
+
 // NewDefault returns default config
 func NewDefault() *lint.Config {
 	// Enabled Rules
@@ -47,10 +92,7 @@ func NewDefault() *lint.Config {
 
 		// Types Enum Rule
 		(&rule.TypeEnumRule{}).Name(): {
-			Argument: []interface{}{
-				"feat", "fix", "docs", "style", "refactor", "perf",
-				"test", "build", "ci", "chore", "revert",
-			},
+			Argument: DefaultTypeEnums(),
 		},
 
 		// Scope Enum Rule
@@ -113,12 +155,12 @@ func NewDefault() *lint.Config {
 
 		// Type Charset Rule
 		(&rule.TypeCharsetRule{}).Name(): {
-			Argument: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+			Argument: DefaultTypeCharset,
 		},
 
 		// Scope Charset Rule
 		(&rule.ScopeCharsetRule{}).Name(): {
-			Argument: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/,",
+			Argument: DefaultScopeCharset,
 		},
 
 		// Footer Enum Rule
@@ -128,16 +170,17 @@ func NewDefault() *lint.Config {
 
 		// Footer Type Enum Rule
 		(&rule.FooterTypeEnumRule{}).Name(): {
-			Argument: []map[interface{}]interface{}{},
+			Argument: []interface{}{},
 		},
 	}
 
 	def := &lint.Config{
-		MinVersion: internal.Version(),
-		Formatter:  (&formatter.DefaultFormatter{}).Name(),
-		Rules:      rules,
-		Severity:   severity,
-		Settings:   settings,
+		MinVersion:            internal.Version(),
+		Formatter:             (&formatter.DefaultFormatter{}).Name(),
+		Rules:                 rules,
+		Severity:              severity,
+		Settings:              settings,
+		DefaultIgnorePatterns: DefaultIgnorePatterns(),
 	}
 	return def
 }

lint/config.go

@@ -33,6 +33,32 @@ type Config struct {
 
 	// Settings is rule name to rule settings
 	Settings map[string]RuleSetting `yaml:"settings"`
+
+	// DisableDefaultIgnores disables the built-in ignore patterns
+	// (merge, revert, fixup, squash, etc.) when set to true.
+	DisableDefaultIgnores bool `yaml:"disable-default-ignores,omitempty"`
+
+	// IgnorePatterns is a list of user-defined regex patterns.
+	// If the first line of the commit message matches any pattern,
+	// linting is skipped. These are added on top of the default
+	// patterns (unless DisableDefaultIgnores is true).
+	IgnorePatterns []string `yaml:"ignores,omitempty"`
+
+	// DefaultIgnorePatterns holds the built-in patterns (set by config package).
+	// Not serialized to YAML - users never set this directly.
+	DefaultIgnorePatterns []string `yaml:"-"`
+}
+
+// EffectiveIgnorePatterns returns the combined list of patterns the linter should use.
+// If DisableDefaultIgnores is true, only user-defined patterns are returned.
+func (c *Config) EffectiveIgnorePatterns() []string {
+	if c.DisableDefaultIgnores {
+		return c.IgnorePatterns
+	}
+	combined := make([]string, 0, len(c.DefaultIgnorePatterns)+len(c.IgnorePatterns))
+	combined = append(combined, c.DefaultIgnorePatterns...)
+	combined = append(combined, c.IgnorePatterns...)
+	return combined
 }
 
 // GetRule returns RuleConfig for given rule name

lint/linter.go

@@ -1,26 +1,43 @@
 // Package lint provides a simple linter for conventional commits
 package lint
 
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
 // Linter is linter for commit message
 type Linter struct {
 	conf  *Config
 	rules []Rule
 
-	parser Parser
+	parser         Parser
+	ignorePatterns []*regexp.Regexp
 }
 
 // New returns a new Linter instance with given config and rules
 func New(conf *Config, rules []Rule) (*Linter, error) {
+	compiled, err := compilePatterns(conf.EffectiveIgnorePatterns())
+	if err != nil {
+		return nil, err
+	}
+
 	l := &Linter{
-		conf:   conf,
-		rules:  rules,
-		parser: newParser(),
+		conf:           conf,
+		rules:          rules,
+		parser:         newParser(),
+		ignorePatterns: compiled,
 	}
 	return l, nil
 }
 
 // ParseAndLint checks the given commitMsg string against rules
 func (l *Linter) ParseAndLint(commitMsg string) (*Result, error) {
+	if l.isIgnored(commitMsg) {
+		return newResult(commitMsg), nil
+	}
+
 	msg, err := l.parser.Parse(commitMsg)
 	if err != nil {
 		issues := l.parserErrorRule(commitMsg, err)
@@ -29,6 +46,34 @@ func (l *Linter) ParseAndLint(commitMsg string) (*Result, error) {
 	return l.Lint(msg)
 }
 
+// isIgnored checks if the first line of the commit message
+// matches any of the configured ignore patterns
+func (l *Linter) isIgnored(commitMsg string) bool {
+	if len(l.ignorePatterns) == 0 {
+		return false
+	}
+
+	firstLine := strings.Split(commitMsg, "\n")[0]
+	for _, re := range l.ignorePatterns {
+		if re.MatchString(firstLine) {
+			return true
+		}
+	}
+	return false
+}
+
+func compilePatterns(patterns []string) ([]*regexp.Regexp, error) {
+	compiled := make([]*regexp.Regexp, 0, len(patterns))
+	for _, p := range patterns {
+		re, err := regexp.Compile(p)
+		if err != nil {
+			return nil, fmt.Errorf("invalid ignore pattern %q: %w", p, err)
+		}
+		compiled = append(compiled, re)
+	}
+	return compiled, nil
+}
+
 // Lint checks the given Commit against rules
 func (l *Linter) Lint(msg Commit) (*Result, error) {
 	issues := make([]*Issue, 0, len(l.rules))