basic support for custom datatypes when traversing path expressions

Author: xrstf

pkg/eval/test/symbol_test.go

@@ -4,10 +4,12 @@
 package test
 
 import (
+	"fmt"
 	"testing"
 
 	"go.xrstf.de/rudi/pkg/eval/types"
 	"go.xrstf.de/rudi/pkg/lang/ast"
+	"go.xrstf.de/rudi/pkg/pathexpr"
 	"go.xrstf.de/rudi/pkg/testutil"
 )
 
@@ -24,6 +26,39 @@ func makeSymbol(name string, path *ast.PathExpression) ast.Symbol {
 	return sym
 }
 
+type customType struct {
+	Data string
+}
+
+type customObjGetter struct {
+	value any
+}
+
+var _ pathexpr.ObjectReader = customObjGetter{}
+
+func (g customObjGetter) GetObjectKey(name string) (any, error) {
+	if name == "value" {
+		return g.value, nil
+	}
+
+	return nil, fmt.Errorf("cannot get property %q", name)
+}
+
+type customVecGetter struct {
+	magic int
+	value any
+}
+
+var _ pathexpr.VectorReader = customVecGetter{}
+
+func (g customVecGetter) GetVectorItem(index int) (any, error) {
+	if index == g.magic {
+		return g.value, nil
+	}
+
+	return nil, fmt.Errorf("cannot get index %d", index)
+}
+
 func TestEvalSymbol(t *testing.T) {
 	testcases := []testutil.Testcase{
 		// <utterly invalid Symbol>
@@ -44,6 +79,14 @@ func TestEvalSymbol(t *testing.T) {
 			},
 			Expected: "foo",
 		},
+		// $var with custom data type
+		{
+			AST: makeSymbol("var", nil),
+			Variables: types.Variables{
+				"var": customType{Data: "foo"},
+			},
+			Expected: customType{Data: "foo"},
+		},
 		// $var.foo
 		{
 			AST: makeSymbol("var", &ast.PathExpression{Steps: []ast.Expression{ast.Identifier{Name: "foo"}}}),
@@ -86,6 +129,22 @@ func TestEvalSymbol(t *testing.T) {
 			AST:      makeSymbol("", &ast.PathExpression{}),
 			Expected: nil,
 		},
+		// $custom.value
+		{
+			AST: makeSymbol("custom", &ast.PathExpression{Steps: []ast.Expression{ast.Identifier{Name: "value"}}}),
+			Variables: types.Variables{
+				"custom": customObjGetter{value: "foo"},
+			},
+			Expected: "foo",
+		},
+		// $custom[7]
+		{
+			AST: makeSymbol("custom", &ast.PathExpression{Steps: []ast.Expression{ast.Number{Value: 7}}}),
+			Variables: types.Variables{
+				"custom": customVecGetter{magic: 7, value: "foo"},
+			},
+			Expected: "foo",
+		},
 	}
 
 	for _, testcase := range testcases {

pkg/pathexpr/delete.go

@@ -8,6 +8,14 @@ import (
 	"fmt"
 )
 
+type ObjectKeyDeleter interface {
+	DeleteObjectKey(name string) (any, error)
+}
+
+type VectorItemDeleter interface {
+	DeleteVectorItem(index int) (any, error)
+}
+
 func removeSliceItem(slice []any, index int) []any {
 	return append(slice[:index], slice[index+1:]...)
 }
@@ -24,18 +32,18 @@ func Delete(dest any, path Path) (any, error) {
 	if len(remainingSteps) == 0 {
 		// [index]
 		if index, ok := toIntegerStep(thisStep); ok {
-			if index < 0 {
-				return nil, fmt.Errorf("index %d out of bounds", index)
-			}
-
 			if slice, ok := dest.([]any); ok {
-				if index >= len(slice) {
+				if index < 0 || index >= len(slice) {
 					return nil, fmt.Errorf("index %d out of bounds", index)
 				}
 
 				return removeSliceItem(slice, index), nil
 			}
 
+			if deleter, ok := dest.(VectorItemDeleter); ok {
+				return deleter.DeleteVectorItem(index)
+			}
+
 			return nil, fmt.Errorf("cannot delete index from %T", dest)
 		}
 
@@ -46,6 +54,10 @@ func Delete(dest any, path Path) (any, error) {
 				return object, nil
 			}
 
+			if deleter, ok := dest.(ObjectKeyDeleter); ok {
+				return deleter.DeleteObjectKey(key)
+			}
+
 			return nil, fmt.Errorf("cannot delete key from %T", dest)
 		}
 
@@ -54,12 +66,8 @@ func Delete(dest any, path Path) (any, error) {
 
 	// [index]...
 	if index, ok := toIntegerStep(thisStep); ok {
-		if index < 0 {
-			return nil, fmt.Errorf("index %d out of bounds", index)
-		}
-
 		if slice, ok := dest.([]any); ok {
-			if index >= len(slice) {
+			if index < 0 || index >= len(slice) {
 				return nil, fmt.Errorf("index %d out of bounds", index)
 			}
 
@@ -75,6 +83,20 @@ func Delete(dest any, path Path) (any, error) {
 			return slice, nil
 		}
 
+		if writer, ok := dest.(VectorWriter); ok {
+			existingValue, err := writer.GetVectorItem(index)
+			if err != nil {
+				return nil, fmt.Errorf("cannot descend with [%d] into %T", index, dest)
+			}
+
+			updatedValue, err := Delete(existingValue, remainingSteps)
+			if err != nil {
+				return nil, err
+			}
+
+			return writer.SetVectorItem(index, updatedValue)
+		}
+
 		return nil, fmt.Errorf("cannot descend with [%d] into %T", index, dest)
 	}
 
@@ -94,6 +116,20 @@ func Delete(dest any, path Path) (any, error) {
 			return object, nil
 		}
 
+		if writer, ok := dest.(ObjectWriter); ok {
+			existingValue, err := writer.GetObjectKey(key)
+			if err != nil {
+				return nil, fmt.Errorf("cannot descend with [%s] into %T", key, dest)
+			}
+
+			updatedValue, err := Delete(existingValue, remainingSteps)
+			if err != nil {
+				return nil, err
+			}
+
+			return writer.SetObjectKey(key, updatedValue)
+		}
+
 		return nil, fmt.Errorf("cannot descend with [%s] into %T", key, dest)
 	}
 

pkg/pathexpr/delete_test.go

@@ -4,11 +4,77 @@
 package pathexpr
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 )
 
+type customObjDeleter struct {
+	Value any
+}
+
+var _ ObjectKeyDeleter = &customObjDeleter{}
+
+func (w customObjDeleter) GetObjectKey(name string) (any, error) {
+	if name == "value" {
+		return w.Value, nil
+	}
+
+	return nil, fmt.Errorf("cannot get property %q", name)
+}
+
+func (w *customObjDeleter) SetObjectKey(name string, value any) (any, error) {
+	if name == "value" {
+		w.Value = value
+		return w, nil
+	}
+
+	return nil, fmt.Errorf("cannot set property %q", name)
+}
+
+func (w *customObjDeleter) DeleteObjectKey(name string) (any, error) {
+	if name == "value" {
+		w.Value = nil
+		return w, nil
+	}
+
+	return nil, fmt.Errorf("cannot delete property %q", name)
+}
+
+type customVecDeleter struct {
+	Magic int
+	Value any
+}
+
+var _ VectorItemDeleter = &customVecDeleter{}
+
+func (w customVecDeleter) GetVectorItem(index int) (any, error) {
+	if index == w.Magic {
+		return w.Value, nil
+	}
+
+	return nil, fmt.Errorf("cannot get index %d", index)
+}
+
+func (w *customVecDeleter) SetVectorItem(index int, value any) (any, error) {
+	if index == w.Magic {
+		w.Value = value
+		return w, nil
+	}
+
+	return nil, fmt.Errorf("index %d out of bounds", index)
+}
+
+func (w *customVecDeleter) DeleteVectorItem(index int) (any, error) {
+	if index == w.Magic {
+		w.Value = nil
+		return w, nil
+	}
+
+	return nil, fmt.Errorf("index %d out of bounds", index)
+}
+
 func TestDelete(t *testing.T) {
 	testcases := []struct {
 		name     string
@@ -125,6 +191,70 @@ func TestDelete(t *testing.T) {
 			path:    Path{3, "list"},
 			invalid: true,
 		},
+
+		// custom types
+
+		{
+			name: "can delete in custom objects",
+			dest: &customObjDeleter{
+				Value: "old",
+			},
+			path: Path{"value"},
+			expected: &customObjDeleter{
+				Value: nil,
+			},
+		},
+		{
+			name: "can delete in custom objects",
+			dest: &customObjDeleter{
+				Value: map[string]any{
+					"foo":   "bar",
+					"hello": "world",
+					"list":  []any{1, 2, 3},
+				},
+			},
+			path: Path{"value", "list", 1},
+			expected: &customObjDeleter{
+				Value: map[string]any{
+					"foo":   "bar",
+					"hello": "world",
+					"list":  []any{1, 3},
+				},
+			},
+		},
+
+		{
+			name: "can delete in custom vectors",
+			dest: &customVecDeleter{
+				Magic: 7,
+				Value: "old",
+			},
+			path: Path{7},
+			expected: &customVecDeleter{
+				Magic: 7,
+				Value: nil,
+			},
+		},
+		{
+			name: "can delete in custom vectors",
+			dest: &customVecDeleter{
+				Magic: 7,
+				Value: map[string]any{
+					"foo":   "bar",
+					"hello": "world",
+					"list":  []any{1, 2, 3},
+				},
+			},
+			path: Path{7, "list", 1},
+			expected: &customVecDeleter{
+				Magic: 7,
+				Value: map[string]any{
+					"foo":   "bar",
+					"hello": "world",
+					"list":  []any{1, 3},
+				},
+			},
+		},
 	}
 
 	for _, tc := range testcases {