✨ multilang support

Author: stefanitsky

README.md

@@ -18,17 +18,17 @@ import "stefanitsky.me/gachinator"
 func main() {
     // ...
     input := "some input message text"
-    result := gachinator.Gachinate([]byte(input))
+    result := gachinator.GachinateEN([]byte(input))
     fmt.Println(string(result))
     // ...
 }
 ```
 
 ## Examples
 
-### EN (no yet implemented)
+### EN
 
-* `message` -> `mASSage`
+* `manufacturable` -> `manuFUCKturable`
 * `cool` -> `c♂♂l`
 
 ### RU
@@ -38,5 +38,4 @@ func main() {
 
 ## TODO
 
-* Multilingual regexp (EN/RU etc.)
 * CLI auto ci build

cmd/gachinator/gachinator.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bufio"
+	"flag"
 	"fmt"
 	"os"
 
@@ -14,11 +15,20 @@ var (
 )
 
 func main() {
+	lang := flag.String("lang", "ru", "select language config")
+	flag.Parse()
+
+	lc, err := gachinator.FindLangConfig(*lang)
+	if err != nil {
+		fmt.Fprint(os.Stdout, err)
+		os.Exit(1)
+	}
+
 	sc := bufio.NewScanner(os.Stdin)
 
 	for sc.Scan() {
 		currentLine = sc.Bytes()
-		gachinatedLine = gachinator.Gachinate(currentLine)
+		gachinatedLine = gachinator.Gachinate(currentLine, *lc)
 		fmt.Fprint(os.Stdout, string(gachinatedLine))
 	}
 

gachinate.go

@@ -2,6 +2,7 @@
 package gachinator
 
 import (
+	"fmt"
 	"regexp"
 )
 
@@ -12,22 +13,52 @@ type match struct {
 	found    bool
 }
 
+type langConfig struct {
+	re        *regexp.Regexp
+	replacers map[int][]byte
+}
+
 var (
-	re        = regexp.MustCompile(`([эЭ]с)|(о)|([кК][ао]м)|([фФ]ак)|(т[её]мн(ый|ое|ая|о|ые|ых))|(гей)|(глубок(ий|ое|ая|о|и|ие|ого))|(доллар(ов|ы))`)
-	replacers = map[int][]byte{
-		0: []byte("ASS"),
-		1: []byte("♂"),
-		2: []byte("CUM"),
-		3: []byte("FUCK"),
-		4: []byte("DARK"),
-		// 5: useless suffixes group
-		6: []byte("GAY"),
-		7: []byte("DEEP"),
-		// 8: useless suffixes group
-		9: []byte("BUCKS"),
+	RussianConfig = langConfig{
+		re: regexp.MustCompile(`([эЭ]с)|(о)|([кК][ао]м)|([фФ]ак)|(т[её]мн(ый|ое|ая|о|ые|ых))|(гей)|(глубок(ий|ое|ая|о|и|ие|ого))|(доллар(ов|ы))`),
+		replacers: map[int][]byte{
+			0: []byte("ASS"),
+			1: []byte("♂"),
+			2: []byte("CUM"),
+			3: []byte("FUCK"),
+			4: []byte("DARK"),
+			// 5: useless suffixes group
+			6: []byte("GAY"),
+			7: []byte("DEEP"),
+			// 8: useless suffixes group
+			9: []byte("BUCKS"),
+		},
+	}
+	EnglishConfig = langConfig{
+		re: regexp.MustCompile(`([eE]ss)|(o)|([cC][ou]m(e))|([fF]ac)|([dD]ark)`),
+		replacers: map[int][]byte{
+			0: []byte("ASS"),
+			1: []byte("♂"),
+			2: []byte("CUM"),
+			// 3: useless suffix group
+			4: []byte("FUCK"),
+			5: []byte("DARK"),
+		},
+	}
+	langCodeToLangConfig = map[string]langConfig{
+		"ru": RussianConfig,
+		"en": EnglishConfig,
 	}
 )
 
+type LangConfigNotFoundError struct {
+	lang string
+}
+
+func (e *LangConfigNotFoundError) Error() string {
+	return fmt.Sprintf("language config for \"%v\" is not found (available configs are: ru, en).", e.lang)
+}
+
 var (
 	offset int
 	m      match
@@ -42,16 +73,42 @@ var (
 	found    bool
 )
 
-// Gachinates your input text and returns gachinated variant.
-func Gachinate(b []byte) []byte {
-	allSubmatchIndexes := re.FindAllSubmatchIndex(b, -1)
+// Gachinates your input text with specified language config and returns gachinated variant.
+func Gachinate(b []byte, lc langConfig) []byte {
+	return *gachinate(&b, lc)
+}
+
+// Gachinate russian input
+func GachinateRU(b []byte) []byte {
+	return *gachinate(&b, RussianConfig)
+}
+
+// Gachinate english input
+func GachinateEN(b []byte) []byte {
+	return *gachinate(&b, EnglishConfig)
+}
+
+// Finds language config by lang code
+// Example:
+// lc, err := FindLangConfig("ru")
+func FindLangConfig(lang string) (*langConfig, error) {
+	lc, found := langCodeToLangConfig[lang]
+	if !found {
+		return nil, &LangConfigNotFoundError{lang}
+	}
+
+	return &lc, nil
+}
+
+func gachinate(b *[]byte, lc langConfig) *[]byte {
+	allSubmatchIndexes := lc.re.FindAllSubmatchIndex(*b, -1)
 
 	offset = 0
 	for _, loc := range allSubmatchIndexes {
-		m = findMatch(&loc, &b)
+		m = findMatch(&loc, b, &lc)
 		if m.found {
-			orig = b[m.start:m.end]
-			b = append(b[:m.start+offset], append(m.replacer, b[m.end+offset:]...)...)
+			orig = (*b)[m.start:m.end]
+			*b = append((*b)[:m.start+offset], append(m.replacer, (*b)[m.end+offset:]...)...)
 			offset += len(m.replacer) - len(orig)
 		}
 	}
@@ -60,13 +117,13 @@ func Gachinate(b []byte) []byte {
 }
 
 // Finds match by found regex submatch indexes and returns match struct.
-func findMatch(indexes *[]int, b *[]byte) (m match) {
+func findMatch(indexes *[]int, b *[]byte, lc *langConfig) (m match) {
 	subIndex = 0
 
 	for i := 2; i < len(*indexes); i += 2 {
 		start, end = (*indexes)[i], (*indexes)[i+1]
 		if start != -1 && end != -1 {
-			repl, found = replacers[subIndex]
+			repl, found = lc.replacers[subIndex]
 			if found {
 				m.start = start
 				m.end = end

gachinate_test.go

@@ -2,6 +2,7 @@ package gachinator
 
 import (
 	"bufio"
+	"bytes"
 	"io"
 	"os"
 	"testing"
@@ -12,7 +13,13 @@ type GachinateTestCase struct {
 	expectedOutput string
 }
 
-func TestGachinate(t *testing.T) {
+type GachinateSimpleTestCase struct {
+	input          string
+	expectedOutput string
+	langConfig     langConfig
+}
+
+func TestGachinateRu(t *testing.T) {
 	cases := []GachinateTestCase{
 		{
 			input:          "фактор",
@@ -77,14 +84,108 @@ func TestGachinate(t *testing.T) {
 	}
 
 	for _, c := range cases {
-		result := string(Gachinate([]byte(c.input)))
+		result := string(GachinateRU([]byte(c.input)))
+
+		if result != c.expectedOutput {
+			t.Errorf("\nExpected: %v\nGot:%v\nOriginal:%v\n", c.expectedOutput, result, c.input)
+		}
+	}
+}
+
+func TestGachinateEn(t *testing.T) {
+	cases := []GachinateTestCase{
+		{
+			input:          "cool",
+			expectedOutput: "c♂♂l",
+		},
+		{
+			input:          "manufacturable",
+			expectedOutput: "manuFUCKturable",
+		},
+		{
+			input:          "message",
+			expectedOutput: "mASSage",
+		},
+		{
+			input:          "come",
+			expectedOutput: "CUM",
+		},
+		{
+			input:          "become",
+			expectedOutput: "beCUM",
+		},
+		{
+			input:          "semidarkness",
+			expectedOutput: "semiDARKnASS",
+		},
+	}
+
+	for _, c := range cases {
+		result := string(GachinateEN([]byte(c.input)))
 
 		if result != c.expectedOutput {
 			t.Errorf("\nExpected: %v\nGot:%v\nOriginal:%v\n", c.expectedOutput, result, c.input)
 		}
 	}
 }
 
+// Just test that it executes with different configs (no need complex test duplication)
+func TestGachinate(t *testing.T) {
+	cases := []GachinateSimpleTestCase{
+		{
+			input:          "круто",
+			expectedOutput: "крут♂",
+			langConfig:     RussianConfig,
+		},
+		{
+			input:          "cool",
+			expectedOutput: "c♂♂l",
+			langConfig:     EnglishConfig,
+		},
+	}
+
+	for _, c := range cases {
+		result := string(Gachinate([]byte(c.input), c.langConfig))
+
+		if result != c.expectedOutput {
+			t.Errorf("\nExpected: %v\nGot: %v\nOriginal: %v\nConfig: %v", c.expectedOutput, result, c.input, c.langConfig)
+		}
+	}
+}
+
+func TestFindLangConfig(t *testing.T) {
+	for lang, expectedConfig := range langCodeToLangConfig {
+		lc, err := FindLangConfig(lang)
+		if err != nil {
+			t.Errorf("Expected no error, but got %v", err)
+		}
+
+		// reflect.DeepEqual will not work, that's why we need to test manually
+		if lc.re != expectedConfig.re {
+			t.Errorf("Regex missmatch, expected %v, got %v", expectedConfig.re, lc.re)
+		}
+
+		foundReplacersLen, expectedReplacersLen := len(lc.replacers), len(expectedConfig.replacers)
+		if foundReplacersLen != expectedReplacersLen {
+			t.Errorf("Replacers missmatch, expected %v, got %v", lc.replacers, expectedConfig.replacers)
+		}
+
+		for k, v := range lc.replacers {
+			if v2, ok := expectedConfig.replacers[k]; !ok || !bytes.Equal(v, v2) {
+				t.Errorf("Language configs are not match, expected %v, got %v", expectedConfig, lc)
+			}
+		}
+	}
+}
+
+func TestFindLangConfigNotFound(t *testing.T) {
+	expectedErr := `language config for "fake" is not found (available configs are: ru, en).`
+	lc, err := FindLangConfig("fake")
+	if lc != nil || err.Error() != expectedErr {
+		t.Errorf(`Expected error: "%v", got language config: %v and error: %v`, expectedErr, lc, err)
+	}
+}
+
 func BenchmarkGachinate(b *testing.B) {
 	b.StopTimer()
 	f, err := os.Open("testdata/benchmark.txt")
@@ -101,7 +202,7 @@ func BenchmarkGachinate(b *testing.B) {
 
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		Gachinate(input)
+		GachinateRU(input)
 	}
 	b.StopTimer()
 }