From d5963f63eee44c2f883359112ae7c160d9c0a8ff Mon Sep 17 00:00:00 2001
From: muthukrishnan24 <muthukrishnanofficial@gmail.com>
Date: Wed, 22 Sep 2021 08:47:44 +0530
Subject: [PATCH] feat: add registry for custom rule and formatters

---
 config/lint.go     | 50 +++++++++++++++-----------
 config/registry.go | 90 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+), 20 deletions(-)
 create mode 100644 config/registry.go

diff --git a/config/lint.go b/config/lint.go
index 77dcc3c..fa9226d 100644
--- a/config/lint.go
+++ b/config/lint.go
@@ -6,6 +6,18 @@ import (
 	"github.com/conventionalcommit/commitlint/lint"
 )
 
+// RegisterRule registers a custom rule
+// if rule already exists, returns error
+func RegisterRule(rule lint.Rule) error {
+	return globalRegistry.RegisterRule(rule)
+}
+
+// RegisterFormatter registers a custom formatter
+// if formatter already exists, returns error
+func RegisterFormatter(format lint.Formatter) error {
+	return globalRegistry.RegisterFormatter(format)
+}
+
 // GetLinter returns Linter for given confFilePath
 func GetLinter(conf *lint.Config) (*lint.Linter, error) {
 	rules, err := GetEnabledRules(conf)
@@ -16,37 +28,35 @@ func GetLinter(conf *lint.Config) (*lint.Linter, error) {
 }
 
 // GetFormatter returns the formatter as defined in conf
-func GetFormatter(c *lint.Config) (lint.Formatter, error) {
-	for _, f := range defaultFormatters {
-		if f.Name() == c.Formatter {
-			return f, nil
-		}
+func GetFormatter(conf *lint.Config) (lint.Formatter, error) {
+	format, ok := globalRegistry.GetFormatter(conf.Formatter)
+	if !ok {
+		return nil, fmt.Errorf("'%s' formatter not found", conf.Formatter)
 	}
-	return nil, fmt.Errorf("%s formatter not found", c.Formatter)
+	return format, nil
 }
 
 // GetEnabledRules forms Rule object for rules which are enabled in config
 func GetEnabledRules(conf *lint.Config) ([]lint.Rule, error) {
-	// rules lookup map
-	rulesMap := map[string]lint.Rule{}
-	for _, r := range defaultRules {
-		rulesMap[r.Name()] = r
-	}
-
 	enabledRules := make([]lint.Rule, 0, len(conf.Rules))
 
 	for ruleName, ruleConfig := range conf.Rules {
-		r, ok := rulesMap[ruleName]
+		// Checking if rule is registered
+		// before checking if rule is enabled
+		r, ok := globalRegistry.GetRule(ruleName)
 		if !ok {
-			return nil, fmt.Errorf("unknown rule: %s", ruleName)
+			return nil, fmt.Errorf("'%s' rule not found", ruleName)
 		}
-		if ruleConfig.Enabled {
-			err := r.Apply(ruleConfig.Argument, ruleConfig.Flags)
-			if err != nil {
-				return nil, err
-			}
-			enabledRules = append(enabledRules, r)
+
+		if !ruleConfig.Enabled {
+			continue
+		}
+
+		err := r.Apply(ruleConfig.Argument, ruleConfig.Flags)
+		if err != nil {
+			return nil, err
 		}
+		enabledRules = append(enabledRules, r)
 	}
 
 	return enabledRules, nil
diff --git a/config/registry.go b/config/registry.go
new file mode 100644
index 0000000..9791482
--- /dev/null
+++ b/config/registry.go
@@ -0,0 +1,90 @@
+package config
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/conventionalcommit/commitlint/lint"
+)
+
+var globalRegistry = newRegistry()
+
+type registry struct {
+	mut *sync.Mutex
+
+	allRules      map[string]lint.Rule
+	allFormatters map[string]lint.Formatter
+}
+
+func newRegistry() *registry {
+	reg := &registry{
+		mut: &sync.Mutex{},
+
+		allRules:      make(map[string]lint.Rule),
+		allFormatters: make(map[string]lint.Formatter),
+	}
+
+	// Register Default Rules
+	for _, rule := range defaultRules {
+		err := reg.RegisterRule(rule)
+		if err != nil {
+			// default rules should not throw error
+			panic(err)
+		}
+	}
+
+	// Register Default Formatters
+	for _, format := range defaultFormatters {
+		err := reg.RegisterFormatter(format)
+		if err != nil {
+			// default formatters should not throw error
+			panic(err)
+		}
+	}
+
+	return reg
+}
+
+func (r *registry) RegisterRule(rule lint.Rule) error {
+	r.mut.Lock()
+	defer r.mut.Unlock()
+
+	_, ok := r.allRules[rule.Name()]
+	if ok {
+		return fmt.Errorf("'%s' rule already registered", rule.Name())
+	}
+
+	r.allRules[rule.Name()] = rule
+
+	return nil
+}
+
+func (r *registry) RegisterFormatter(format lint.Formatter) error {
+	r.mut.Lock()
+	defer r.mut.Unlock()
+
+	_, ok := r.allFormatters[format.Name()]
+	if ok {
+		return fmt.Errorf("'%s' formatter already registered", format.Name())
+	}
+
+	r.allFormatters[format.Name()] = format
+
+	return nil
+}
+
+func (r *registry) GetRule(name string) (lint.Rule, bool) {
+	r.mut.Lock()
+	defer r.mut.Unlock()
+
+	rule, ok := r.allRules[name]
+	return rule, ok
+}
+
+func (r *registry) GetFormatter(name string) (lint.Formatter, bool) {
+	r.mut.Lock()
+	defer r.mut.Unlock()
+
+	format, ok := r.allFormatters[name]
+	return format, ok
+}