Updated code after PR review

Author: addvanced

go.mod

@@ -7,6 +7,7 @@ toolchain go1.24.6
 require (
 	github.com/forPelevin/gomoji v1.3.1
 	golang.org/x/net v0.43.0
+	golang.org/x/sync v0.16.0
 	golang.org/x/text v0.28.0
 )
 

go.sum

@@ -4,5 +4,7 @@ github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=

slugger/slugger.go

@@ -20,14 +20,14 @@ type Slugger struct {
 	Substitutions map[string]string // A map of string replacements to apply before generating the slug
 	WithEmoji     bool              // If true, emojis will be included in a slug-friendly format
 
-	init     sync.Once         // Controls initialization of the replacer
+	mu       sync.RWMutex      // Guards substitutions and replacer; safe for concurrent Slug and updates
 	replacer *strings.Replacer // Replacer used to handle substitutions in the input string
 }
 
 // New creates and returns a new Slugger instance with optional substitutions and emoji handling.
 func New(substitutions map[string]string, withEmoji bool) *Slugger {
 	return &Slugger{
-		Substitutions: substitutions,
+		Substitutions: copyMap(substitutions),
 		WithEmoji:     withEmoji,
 		Separator:     defaultSeparator,
 	}
@@ -50,9 +50,17 @@ func (sl *Slugger) Slug(s, separator string) string {
 
 	s = strings.ToLower(s)
 
-	sl.init.Do(sl.initReplacer)
-	if sl.replacer != nil {
-		s = sl.replacer.Replace(s)
+	sl.mu.RLock()
+	r := sl.replacer
+	sl.mu.RUnlock()
+	if r == nil {
+		sl.initReplacer()
+		sl.mu.RLock()
+		r = sl.replacer
+		sl.mu.RUnlock()
+	}
+	if r != nil {
+		s = r.Replace(s)
 	}
 
 	words := normalizeWordsToSafeASCII(s)
@@ -65,42 +73,67 @@ func (sl *Slugger) Slug(s, separator string) string {
 
 // AddSubstitution adds a new substitution to the Slugger and resets the replacer cache.
 func (sl *Slugger) AddSubstitution(key, value string) {
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
 	if sl.Substitutions == nil {
 		sl.Substitutions = make(map[string]string)
 	}
 
 	sl.Substitutions[key] = value
-	sl.init = sync.Once{}
+	sl.replacer = nil
 }
 
 // RemoveSubstitution deletes a substitution by key and resets the replacer cache.
 func (sl *Slugger) RemoveSubstitution(key string) {
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
 	if len(sl.Substitutions) == 0 {
 		return
 	}
 
 	if _, exists := sl.Substitutions[key]; exists {
 		delete(sl.Substitutions, key)
-		sl.init = sync.Once{}
+		sl.replacer = nil
 	}
 }
 
 // ReplaceSubstitution updates the value of an existing substitution and resets the replacer cache.
 func (sl *Slugger) ReplaceSubstitution(key, newValue string) {
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
 	if len(sl.Substitutions) == 0 {
 		return
 	}
 
 	if _, exists := sl.Substitutions[key]; exists {
 		sl.Substitutions[key] = newValue
-		sl.init = sync.Once{}
+		sl.replacer = nil
 	}
 }
 
 // SetSubstitutions replaces all current substitutions with the provided map and resets the replacer cache.
 func (sl *Slugger) SetSubstitutions(substitutions map[string]string) {
-	sl.Substitutions = substitutions
-	sl.init = sync.Once{} // Reset the initialization to rebuild the replacer
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
+	sl.Substitutions = copyMap(substitutions)
+	sl.replacer = nil
+}
+
+func copyMap(m map[string]string) map[string]string {
+	if m == nil {
+		return make(map[string]string)
+	}
+
+	cp := make(map[string]string, len(m))
+	for k, v := range m {
+		cp[k] = v
+	}
+
+	return cp
 }
 
 // ligatureReplacer is used to replace common ligatures with their ASCII equivalents.
@@ -140,6 +173,9 @@ func normalizeWordsToSafeASCII(s string) []string {
 // initReplacer builds and caches a strings.Replacer from the current substitutions.
 // Substitution keys are sorted by length (descending) to ensure longer matches are replaced first.
 func (sl *Slugger) initReplacer() {
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
 	// Reset the replacer to nil so that it can be rebuilt with the latest substitutions
 	sl.replacer = nil
 
@@ -165,7 +201,7 @@ func (sl *Slugger) initReplacer() {
 	}
 
 	slices.SortFunc(subsPairs, func(a, b subsKV) int {
-		if la, lb := len(a.k), len(b.k); la != lb {
+		if la, lb := len([]rune(a.k)), len([]rune(b.k)); la != lb {
 			return cmp.Compare(lb, la) // sort by key length DESC
 		}
 

slugger/slugger_test.go

@@ -1,7 +1,14 @@
 package slugger
 
 import (
+	"context"
+	"fmt"
 	"testing"
+	"time"
+	"unicode"
+
+	"github.com/kashifkhan0771/utils/rand"
+	"golang.org/x/sync/errgroup"
 )
 
 func TestSlugger_Slug(t *testing.T) {
@@ -83,6 +90,14 @@ func TestSlugger_Slug(t *testing.T) {
 			removeSubstitutionsChange: true,
 			expected:                  "hello-and-world-helloworld",
 		},
+		{
+			name:                "ReplaceSubstitution updates value only",
+			input:               "Price is 10 %",
+			separator:           "-",
+			substitutions:       map[string]string{"%": "percent"},
+			substitutionsChange: map[string]string{"%": "pct"},
+			expected:            "price-is-10-pct",
+		},
 		{
 			name:               "Clear all substitutions",
 			input:              "Hello & World #HelloWorld",
@@ -204,6 +219,119 @@ func TestSlugger_Slug_EdgeCases(t *testing.T) {
 	}
 }
 
+func TestSluggerConcurrentSubstitutions(t *testing.T) {
+	t.Parallel()
+
+	pick := func(slice []string) string {
+		if len(slice) == 0 {
+			return ""
+		}
+		p, err := rand.Pick(slice)
+		if err != nil {
+			return ""
+		}
+		return p
+	}
+
+	intN := func(max int) int {
+		n, err := rand.NumberInRange(0, int64(max-1))
+		if err != nil {
+			return 0
+		}
+		return int(n)
+	}
+
+	sl := New(map[string]string{
+		"hello": "hi",
+		"😀":     "smile",
+		"æ":     "ae",
+		"foo":   "bar",
+	}, true)
+
+	// Random inputs to stress both emoji path and substitutions.
+	inputs := []string{
+		"Hello World!",
+		"  multiple    spaces   ",
+		"Æblegrød med fløde",
+		"foo/bar_baz.qux",
+		"Mixed—dash–types… and punctuation!!!",
+		"Edge😀Case🚀❤️",
+		"____ leading and trailing ____",
+		"",
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	eg, ctx := errgroup.WithContext(ctx)
+
+	// Spin up 8 readers.
+	for range 8 {
+		eg.Go(func() error {
+			for {
+				select {
+				case <-ctx.Done():
+					return nil
+				default:
+				}
+
+				in := pick(inputs)
+				sep := pick([]string{"", "-", "_", ".", "--"})
+				out := sl.Slug(in, sep)
+
+				// Basic sanity: only ASCII letters/digits and -_. separators, no spaces.
+				for _, rr := range out {
+					if rr > unicode.MaxASCII {
+						return fmt.Errorf("non-ascii rune in slug: %q -> %q", in, out)
+					}
+					if unicode.IsSpace(rr) {
+						return fmt.Errorf("space in slug: %q -> %q", in, out)
+					}
+				}
+			}
+		})
+	}
+
+	// Spin up 4 writers.
+	for range 4 {
+		eg.Go(func() error {
+			keys := []string{"hello", "😀", "æ", "foo", "bar", "baz", "qux", "quux"}
+
+			for {
+				select {
+				case <-ctx.Done():
+					return nil
+				default:
+				}
+
+				switch intN(4) {
+				case 0: // Add
+					k := pick(keys) + time.Now().Format("150405.000")
+					sl.AddSubstitution(k, pick(keys))
+				case 1: // Remove
+					sl.RemoveSubstitution(pick(keys))
+				case 2: // Replace
+					sl.ReplaceSubstitution(pick(keys), pick(keys))
+				case 3: // Replace all
+					n := 1 + intN(4)
+					m := make(map[string]string, n)
+					for range n {
+						m[pick(keys)] = keys[intN(len(keys))]
+					}
+					sl.SetSubstitutions(m)
+				}
+
+				// Random sleep to avoid contention.
+				time.Sleep(time.Duration(intN(3)) * time.Millisecond)
+			}
+		})
+	}
+
+	// Wait for completion (either timeout or earlier failure).
+	if err := eg.Wait(); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func BenchmarkSlugger_Slug(b *testing.B) {
 	sl := New(map[string]string{"&": "and"}, false)