Changed string template

Author: yel0k

CHANGELOG.md

@@ -38,3 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Data partitioning
 - Ability to continue generation
 - Availability to ignore some models for generation
+
+### Changed
+
+- String templates replaced with jinja like

doc/ru/usage.md

@@ -160,8 +160,10 @@ open_ai:
 - `min_length`: Минимальная длина строки. По умолчанию 1.
 - `max_length`: Максимальная длина строки. По умолчанию 32.
 - `logical_type`: Логический тип строки. Поддерживаемые значения: `first_name`, `last_name`, `phone`, `text`.
-- `template`: Шаблон для генерации строки. Символ `A` - любая большая буква, символ `a` - любая маленькая буква,
-  символ `0` - любая цифра, символ `#` - любой символ. Остальные символы остаются как есть.
+- `template`: Jinja-подобный шаблон для генерации строки. Позволяет использовать любые поля генерируемой модели и
+  задавать паттерн строки с помощью функции `pattern`, где символ `A` - любая большая буква, символ `a` - любая маленькая буква,
+  символ `0` - любая цифра, символ `#` - любой символ, а остальные символы остаются как есть.
+  Также поддерживается использование фильтров, таких как `upper` и `lower`.
 - `locale`: Локаль для генерации строк. Поддерживаемые значения: `ru`, `en`. По умолчанию `en`.
 - `without_large_letters`: Флаг, указывающий, исключать ли большие буквы из строки.
 - `without_small_letters`: Флаг, указывающий, исключать ли маленькие буквы из строки.
@@ -307,9 +309,13 @@ models:
       - name: passport
         type: string
         type_params:
-          template: AA 00 000 000
+          template: "{{ pattern('AA 00 000 000') }}"
         distinct_percentage: 1
         ordered: true
+      - name: email  
+        type: string
+        type_params:
+          template: "{{ first_name_en | lower }}.{{ id }}@example.com"
       - name: rating
         type: float
         type_params:

go.mod

@@ -36,7 +36,9 @@ require (
 	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/flosch/pongo2 v0.0.0-20200913210552-0d938eb266f3 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/flatbuffers v25.2.10+incompatible // indirect
@@ -58,6 +60,7 @@ require (
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a // indirect
+	github.com/otaviokr/topological-sort v1.1.0 // indirect
 	github.com/pierrec/lz4/v4 v4.1.22 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect

go.sum

@@ -2,10 +2,12 @@ package models
 
 import (
 	"encoding/json"
+	"github.com/otaviokr/topological-sort/toposort"
 	"io"
 	"os"
 	"path/filepath"
 	"reflect"
+	"regexp"
 	"strings"
 
 	"github.com/ilyakaznacheev/cleanenv"
@@ -119,3 +121,46 @@ func parseErrsToString(errs []error) string {
 
 	return sb.String()
 }
+
+func TopologicalSort(columns []*Column) ([]string, error) {
+	graph := make(map[string][]string)
+	for _, c := range columns {
+		graph[c.Name] = make([]string, 0)
+
+		if c.Type != "string" {
+			continue
+		}
+
+		for _, r := range c.Ranges {
+			if r.StringParams.Template == "" {
+				continue
+			}
+
+			graph[c.Name] = extractValuesFromTemplate(r.StringParams.Template)
+		}
+	}
+
+	sortedVertexes, err := toposort.ReverseTarjan(graph)
+	if err != nil {
+		return nil, err
+	}
+
+	return sortedVertexes, nil
+}
+
+func extractValuesFromTemplate(template string) []string {
+	re := regexp.MustCompile(`{{\s*([^}]+)\s*}}`)
+	matches := re.FindAllStringSubmatch(template, -1)
+
+	var values []string
+	for _, match := range matches {
+		expr := match[1]
+
+		parts := regexp.MustCompile(`\s*\|\s*|\s+`).Split(expr, -1)
+		if len(parts) > 0 && parts[0] != "" && !strings.Contains(parts[0], "(") {
+			values = append(values, parts[0])
+		}
+	}
+
+	return values
+}

internal/generator/models/common.go

@@ -0,0 +1,163 @@
+package models
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestExtractValuesFromTemplate(t *testing.T) {
+	type testCase struct {
+		name     string
+		template string
+		expected []string
+	}
+
+	testCases := []testCase{
+		{
+			name:     "Empty template",
+			template: "",
+			expected: nil,
+		},
+		{
+			name:     "Valid template",
+			template: "{{ foo }}.{{boo}}",
+			expected: []string{"foo", "boo"},
+		},
+		{
+			name:     "Template with filters",
+			template: "{{ foo | upper | lower }}",
+			expected: []string{"foo"},
+		},
+		{
+			name:     "Template with functions",
+			template: "{{ upper('foo') | lower }}@{{ boo }}",
+			expected: []string{"boo"},
+		},
+		{
+			name:     "Invalid template",
+			template: "{_{ foo }}",
+			expected: nil,
+		},
+	}
+
+	testFunc := func(t *testing.T, tc testCase) {
+		t.Helper()
+
+		actual := extractValuesFromTemplate(tc.template)
+		require.Equal(t, tc.expected, actual)
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) { testFunc(t, tc) })
+	}
+}
+
+func TestTopologicalSort(t *testing.T) {
+	type testCase struct {
+		name     string
+		columns  []*Column
+		wantErr  bool
+		expected []string
+	}
+
+	testCases := []testCase{
+		{
+			name:     "Empty columns",
+			columns:  []*Column{},
+			wantErr:  false,
+			expected: []string{},
+		},
+		{
+			name: "Columns with dependencies",
+			columns: []*Column{
+				{
+					Name: "1",
+					Type: "string",
+					Ranges: []*Params{
+						{
+							StringParams: &ColumnStringParams{
+								Template: "{{ 3 }}",
+							},
+						},
+					},
+				},
+				{
+					Name: "2",
+					Type: "string",
+					Ranges: []*Params{
+						{
+							StringParams: &ColumnStringParams{
+								Template: "{{ 4 }}",
+							},
+						},
+					},
+				},
+				{
+					Name: "3",
+					Type: "string",
+					Ranges: []*Params{
+						{
+							StringParams: &ColumnStringParams{
+								Template: "{{ 2 }}",
+							},
+						},
+					},
+				},
+				{
+					Name: "4",
+					Type: "string",
+					Ranges: []*Params{
+						{
+							StringParams: &ColumnStringParams{
+								Template: "",
+							},
+						},
+					},
+				},
+			},
+			wantErr:  false,
+			expected: []string{"4", "2", "3", "1"},
+		},
+		{
+			name: "Columns with cycle dependencies",
+			columns: []*Column{
+				{
+					Name: "1",
+					Type: "string",
+					Ranges: []*Params{
+						{
+							StringParams: &ColumnStringParams{
+								Template: "{{ 2 }}",
+							},
+						},
+					},
+				},
+				{
+					Name: "2",
+					Type: "string",
+					Ranges: []*Params{
+						{
+							StringParams: &ColumnStringParams{
+								Template: "{{ 1 }}",
+							},
+						},
+					},
+				},
+			},
+			wantErr:  true,
+			expected: nil,
+		},
+	}
+
+	testFunc := func(t *testing.T, tc testCase) {
+		t.Helper()
+
+		actual, err := TopologicalSort(tc.columns)
+		require.Equal(t, tc.wantErr, err != nil)
+		require.Equal(t, tc.expected, actual)
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) { testFunc(t, tc) })
+	}
+}

internal/generator/models/common_test.go

@@ -200,7 +200,7 @@ type valueID struct {
 type BatchGenerator struct {
 	numbers    []valueID
 	nextNumber int
-	valuer     func(number valueID) (any, error)
+	valuer     func(number valueID, generatedValues map[string]any) (any, error)
 }
 
 func (cg *ColumnGenerator) NewBatchGenerator(batchSize uint64) *BatchGenerator {
@@ -226,14 +226,14 @@ func (cg *ColumnGenerator) NewBatchGenerator(batchSize uint64) *BatchGenerator {
 		}
 	}
 
-	valuer := func(id valueID) (any, error) {
+	valuer := func(id valueID, generatedValues map[string]any) (any, error) {
 		vg := cg.rangeGenerators[id.generatorIndex]
 
 		if vg.nullPercentage > 0 && fastRandomFloat(cg.dataColumnSeed+uint64(id.number)) < vg.nullPercentage {
 			return nil, nil //nolint:nilnil
 		}
 
-		return vg.generator.Value(id.number)
+		return vg.generator.Value(id.number, generatedValues)
 	}
 
 	return &BatchGenerator{
@@ -243,8 +243,8 @@ func (cg *ColumnGenerator) NewBatchGenerator(batchSize uint64) *BatchGenerator {
 }
 
 // Value returns random value for described column.
-func (g *BatchGenerator) Value() (any, error) {
-	res, err := g.valuer(g.numbers[g.nextNumber])
+func (g *BatchGenerator) Value(generatedValues map[string]any) (any, error) {
+	res, err := g.valuer(g.numbers[g.nextNumber], generatedValues)
 	g.nextNumber++
 	g.nextNumber %= len(g.numbers)
 

internal/generator/usecase/general/generator/generator.go

@@ -26,7 +26,7 @@ func (g *DateTimeGenerator) SetTotalCount(totalValuesCount uint64) error {
 }
 
 // Value returns n-th date from range.
-func (g *DateTimeGenerator) Value(number float64) (any, error) {
+func (g *DateTimeGenerator) Value(number float64, _ map[string]any) (any, error) {
 	fromSec := g.From.Unix()
 	toSec := g.To.Unix()
 

internal/generator/usecase/general/generator/value/datetime.go

@@ -31,7 +31,7 @@ func (g *EnumGenerator) SetTotalCount(totalValuesCount uint64) error {
 	return nil
 }
 
-func (g *EnumGenerator) Value(number float64) (any, error) {
+func (g *EnumGenerator) Value(number float64, _ map[string]any) (any, error) {
 	idx := int(math.Floor(number)) / g.rowsPerValue
 
 	return g.Values[idx], nil

internal/generator/usecase/general/generator/value/enum.go

@@ -26,7 +26,7 @@ func (g *FloatGenerator) SetTotalCount(totalValuesCount uint64) error {
 }
 
 // Value returns n-th float number from range.
-func (g *FloatGenerator) Value(number float64) (any, error) {
+func (g *FloatGenerator) Value(number float64, _ map[string]any) (any, error) {
 	value := orderedFloat64(g.From, g.To, number, g.totalValuesCount)
 
 	if g.BitWidth == 32 { //nolint:mnd