Refactor: Extract examples.Generate function

cmd/extract-pattern/main.go

@@ -2,19 +2,16 @@ package main
 
 import (
 	"fmt"
-	"math/rand"
 	"os"
-	"strings"
 
+	"github.com/carloscasalar/fantasyname-pattern-extractor/internal/examples"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/lipgloss/table"
 
 	"github.com/carloscasalar/fantasyname-pattern-extractor/internal/tokenizer"
 	"github.com/carloscasalar/fantasyname-pattern-extractor/internal/transformer"
 
 	"github.com/jessevdk/go-flags"
-
-	"github.com/s0rg/fantasyname"
 )
 
 func main() {
@@ -40,19 +37,15 @@ func main() {
 		fmt.Println(lipgloss.JoinHorizontal(lipgloss.Left, titleBox.Render("PATTERN:"), patternBox.Render(capitalizedPattern)))
 		return
 	}
-	examples := make([]string, opts.NumberOfOutputsToGenerate)
 
-	for i := 0; i < int(opts.NumberOfOutputsToGenerate); i++ {
-		gen, err := fantasyname.Compile(capitalizedPattern, fantasyname.Collapse(true), fantasyname.RandFn(rand.Intn))
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		examples[i] = gen.String()
+	nameExamples, err := examples.Generate(capitalizedPattern, opts.NumberOfOutputsToGenerate)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
 	}
 
 	rows := [][]string{
-		{capitalizedPattern, commaSeparated(examples)},
+		{capitalizedPattern, nameExamples},
 	}
 
 	re := lipgloss.NewRenderer(os.Stdout)
@@ -77,22 +70,6 @@ func main() {
 	fmt.Println(t)
 }
 
-func commaSeparated(examples []string) string {
-	if len(examples) == 0 {
-		return ""
-	}
-
-	joinedString := new(strings.Builder)
-	for i, example := range examples {
-		joinedString.WriteString(example)
-		if i < len(examples)-1 {
-			joinedString.WriteString(", ")
-		}
-	}
-
-	return joinedString.String()
-}
-
 func readOptionsOrFail() Ops {
 	var opts Ops
 	parser := flags.NewParser(&opts, flags.Default)

internal/examples/generate.go

@@ -0,0 +1,42 @@
+package examples
+
+import (
+	"math/rand"
+	"strings"
+
+	"github.com/s0rg/fantasyname"
+)
+
+const emptyNames = ""
+
+// Generate as many examples as numberOfExamples from the given pattern as a comma-separated string
+func Generate(pattern string, numberOfExamples uint) (string, error) {
+	if pattern == "" || numberOfExamples == 0 {
+		return emptyNames, nil
+	}
+	examples := make([]string, numberOfExamples)
+	for i := 0; i < int(numberOfExamples); i++ {
+		gen, err := fantasyname.Compile(pattern, fantasyname.Collapse(true), fantasyname.RandFn(rand.Intn))
+		if err != nil {
+			return emptyNames, err
+		}
+		examples[i] = gen.String()
+	}
+	return commaSeparated(examples), nil
+}
+
+func commaSeparated(examples []string) string {
+	if len(examples) == 0 {
+		return ""
+	}
+
+	joinedString := new(strings.Builder)
+	for i, example := range examples {
+		joinedString.WriteString(example)
+		if i < len(examples)-1 {
+			joinedString.WriteString(", ")
+		}
+	}
+
+	return joinedString.String()
+}

internal/examples/generate_test.go

@@ -0,0 +1,61 @@
+package examples_test
+
+import (
+	"testing"
+
+	"github.com/carloscasalar/fantasyname-pattern-extractor/internal/examples"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGenerateExamples_(t *testing.T) {
+	tests := map[string]struct {
+		pattern          string
+		numberOfExamples uint
+		expected         string
+	}{
+		"Empty pattern should return no examples": {
+			pattern:          "",
+			numberOfExamples: 100,
+			expected:         "",
+		},
+		"Zero examples should return no examples": {
+			pattern:          "vcv",
+			numberOfExamples: 0,
+			expected:         "",
+		},
+		"Valid pattern and non-zero number should generate the expected number of examples": {
+			pattern:          "(some pattern)",
+			numberOfExamples: 3,
+			expected:         "some pattern, some pattern, some pattern",
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			got, err := examples.Generate(tt.pattern, tt.numberOfExamples)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, got)
+		})
+	}
+}
+
+func TestGenerateExamples_ErrorCases(t *testing.T) {
+	tests := map[string]struct {
+		pattern          string
+		numberOfExamples uint
+	}{
+		"Invalid pattern should result in error": {
+			pattern:          "a>",
+			numberOfExamples: 1,
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			got, err := examples.Generate(tt.pattern, tt.numberOfExamples)
+			assert.Error(t, err)
+			assert.Equal(t, "", got)
+		})
+	}
+}