Merge pull request #383 from PDOK/cql-text-implementation

feat: setup listener to parse CQL to SQLite.

Author: rkettelerij

internal/engine/types/stack.go

@@ -0,0 +1,48 @@
+package types
+
+// Stack of strings. See https://en.wikipedia.org/wiki/Stack_(abstract_data_type)
+type Stack struct {
+	stack []string
+}
+
+func NewStack() *Stack {
+	return &Stack{make([]string, 0)}
+}
+
+func (s *Stack) Push(value string) {
+	s.stack = append(s.stack, value)
+}
+
+func (s *Stack) Pop() string {
+	length := len(s.stack)
+	if length == 0 {
+		return ""
+	}
+	value := s.stack[length-1]
+	s.stack = s.stack[:length-1]
+	return value
+}
+
+func (s *Stack) PopMany(count int) []string {
+	if count <= 1 {
+		return nil
+	}
+	if count > len(s.stack) {
+		count = len(s.stack)
+	}
+	items := make([]string, count)
+
+	// Pop in reverse to maintain the correct ordering
+	for i := count - 1; i >= 0; i-- {
+		items[i] = s.Pop()
+	}
+	return items
+}
+
+func (s *Stack) Peek() string {
+	length := len(s.stack)
+	if length == 0 {
+		return ""
+	}
+	return s.stack[length-1]
+}

internal/engine/types/stack_test.go

@@ -0,0 +1,105 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestStack_Push(t *testing.T) {
+	tests := []struct {
+		name     string
+		values   []string
+		expected []string
+	}{
+		{name: "single item", values: []string{"a"}, expected: []string{"a"}},
+		{name: "multiple items", values: []string{"a", "b", "c"}, expected: []string{"a", "b", "c"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			stack := NewStack()
+			for _, v := range tt.values {
+				stack.Push(v)
+			}
+
+			require.Equal(t, tt.expected, stack.stack)
+		})
+	}
+}
+
+func TestStack_Pop(t *testing.T) {
+	tests := []struct {
+		name         string
+		initialStack []string
+		popResult    string
+		finalStack   []string
+	}{
+		{name: "pop from empty stack", initialStack: []string{}, popResult: "", finalStack: []string{}},
+		{name: "pop last item", initialStack: []string{"a"}, popResult: "a", finalStack: []string{}},
+		{name: "pop multiple items", initialStack: []string{"a", "b", "c"}, popResult: "c", finalStack: []string{"a", "b"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			stack := &Stack{stack: tt.initialStack}
+			result := stack.Pop()
+
+			require.Equal(t, tt.popResult, result)
+			require.Equal(t, tt.finalStack, stack.stack)
+		})
+	}
+}
+
+func TestStack_PopMany(t *testing.T) {
+	tests := []struct {
+		name         string
+		initialStack []string
+		count        int
+		popResult    []string
+		finalStack   []string
+	}{
+		{name: "pop many on empty stack", initialStack: []string{}, count: 3, popResult: []string{}, finalStack: []string{}},
+		{name: "pop 0 items", initialStack: []string{"a", "b", "c"}, count: 0, popResult: nil, finalStack: []string{"a", "b", "c"}},
+		{name: "pop less than stack size", initialStack: []string{"a", "b", "c"}, count: 2, popResult: []string{"b", "c"}, finalStack: []string{"a"}},
+		{name: "pop all items", initialStack: []string{"a", "b", "c"}, count: 3, popResult: []string{"a", "b", "c"}, finalStack: []string{}},
+		{name: "pop more than available", initialStack: []string{"a", "b"}, count: 5, popResult: []string{"a", "b"}, finalStack: []string{}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			stack := &Stack{stack: tt.initialStack}
+			result := stack.PopMany(tt.count)
+
+			if tt.popResult == nil {
+				require.Nil(t, result)
+			} else {
+				require.Equal(t, tt.popResult, result)
+			}
+			require.Equal(t, tt.finalStack, stack.stack)
+		})
+	}
+}
+
+func TestStack_Peek(t *testing.T) {
+	tests := []struct {
+		name         string
+		initialStack []string
+		expected     string
+		finalStack   []string
+	}{
+		{name: "peek on empty stack", initialStack: []string{}, expected: "", finalStack: []string{}},
+		{name: "peek single item", initialStack: []string{"a"}, expected: "a", finalStack: []string{"a"}},
+		{name: "peek multiple items", initialStack: []string{"a", "b", "c"}, expected: "c", finalStack: []string{"a", "b", "c"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			stack := &Stack{stack: tt.initialStack}
+			result := stack.Peek()
+
+			require.Equal(t, tt.expected, result)
+			require.Equal(t, tt.finalStack, stack.stack)
+		})
+	}
+}

internal/engine/types/text.go

@@ -0,0 +1,21 @@
+package types
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// IsValidString returns true if the given string is valid UTF-8
+func IsValidString(s string) bool {
+	if !utf8.ValidString(s) {
+		return false
+	}
+
+	for _, r := range s {
+		// check for non-printable control characters
+		if unicode.IsControl(r) {
+			return false
+		}
+	}
+	return true
+}

internal/engine/types/text_test.go

@@ -0,0 +1,58 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsValidString(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{
+			name:     "valid UTF-8 string",
+			input:    "Hello, World!",
+			expected: true,
+		},
+		{
+			name:     "string with control character",
+			input:    "Hello\x00World",
+			expected: false,
+		},
+		{
+			name:     "valid empty string",
+			input:    "",
+			expected: true,
+		},
+		{
+			name:     "invalid UTF-8 string",
+			input:    string([]byte{0xff, 0xfe, 0xfd}),
+			expected: false,
+		},
+		{
+			name:     "string with only printable characters",
+			input:    "Hello, World!",
+			expected: true,
+		},
+		{
+			name:     "string with newline character",
+			input:    "Hello\nWorld",
+			expected: false,
+		},
+		{
+			name:     "string with tab character",
+			input:    "Hello\tWorld",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsValidString(tt.input)
+			assert.Equal(t, tt.expected, result, "IsValidString(%q)", tt.input)
+		})
+	}
+}

internal/engine/util/area.go

@@ -6,7 +6,6 @@ import (
 	"github.com/twpayne/go-geom"
 )
 
-// Copied from https://github.com/PDOK/gokoala/blob/070ec77b2249553959330ff8029bfdf48d7e5d86/internal/ogc/features/url.go#L264
 func SurfaceArea(bbox *geom.Bounds) float64 {
 	// Use the same logic as bbox.Area() in https://github.com/go-spatial/geom to calculate surface area.
 	// The bounds.Area() in github.com/twpayne/go-geom behaves differently and is not what we're looking for.

internal/engine/util/random.go

@@ -0,0 +1,28 @@
+package util
+
+import "math/rand/v2"
+
+// Randomizer is used to generate random numbers
+type Randomizer interface {
+	IntN(n int) int
+}
+
+// DefaultRandomizer is used for production and wraps the stdlib math/rand/v2 package
+var DefaultRandomizer = defaultRandomizer{}
+
+type defaultRandomizer struct{}
+
+func (defaultRandomizer) IntN(n int) int { return rand.IntN(n) } //nolint:gosec
+
+// MockRandomizer is used for testing and provides predictable results
+type MockRandomizer struct {
+	counter int
+}
+
+func (m *MockRandomizer) IntN(n int) int {
+	if n <= 0 {
+		return 0
+	}
+	m.counter++ // not so random, instead it's predictable for testing
+	return m.counter % n
+}

internal/engine/util/random_test.go

@@ -0,0 +1,67 @@
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDefaultRandomizer(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       int
+		expectPanic bool
+	}{
+		{name: "positive input", input: 10, expectPanic: false},
+		{name: "zero input", input: 0, expectPanic: true},
+		{name: "negative input", input: -5, expectPanic: true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// given
+			randomizer := DefaultRandomizer
+
+			if tt.expectPanic {
+				require.Panics(t, func() {
+					randomizer.IntN(tt.input)
+				})
+				return
+			}
+
+			require.NotPanics(t, func() {
+				_ = randomizer.IntN(tt.input)
+			})
+
+			// when
+			result := randomizer.IntN(tt.input)
+
+			// then
+			assert.GreaterOrEqual(t, result, 0)
+			assert.Less(t, result, tt.input)
+		})
+	}
+}
+
+func TestMockRandomizer(t *testing.T) {
+	tests := []struct {
+		name    string
+		counter int
+	}{
+		{name: "initial state", counter: 0},
+		{name: "incremented once", counter: 1},
+		{name: "incremented twice", counter: 2},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// given
+			mock := MockRandomizer{counter: tt.counter}
+
+			// when
+			result := mock.IntN(100)
+
+			// then
+			assert.Equal(t, tt.counter+1, result)
+		})
+	}
+}