Add append function and fix some issues

Author: TomWright

context.go

@@ -15,7 +15,6 @@ type Context struct {
 	data              Value
 	functions         *FunctionCollection
 	createWhenMissing bool
-	filters           []valueFilterFn
 }
 
 func newContextWithFunctions(value interface{}, selector string, functions *FunctionCollection) *Context {
@@ -31,15 +30,22 @@ func newContextWithFunctions(value interface{}, selector string, functions *Func
 		}
 
 		v = Value{
-			Value: reflectVal,
-			setFn: func(value Value) {
-				fmt.Println("root set")
-				reflectVal.Set(value.Value)
-			},
+			Value:    reflectVal,
 			metadata: map[string]interface{}{},
 		}
 	}
 
+	// Make sure we have an addressable root value.
+	if !v.CanAddr() {
+		pointerValue := reflect.New(v.Value.Type())
+		pointerValue.Elem().Set(v.Value)
+		v.Value = pointerValue
+	}
+
+	v.setFn = func(value Value) {
+		v.Unpack().Set(value.Value)
+	}
+
 	if v.metadata == nil {
 		v.metadata = map[string]interface{}{}
 	}
@@ -67,11 +73,6 @@ func newContextWithFunctions(value interface{}, selector string, functions *Func
 	}
 }
 
-// NewContext returns a new query context.
-func NewContext(value interface{}, selector string) *Context {
-	return newContextWithFunctions(value, selector, standardFunctions())
-}
-
 func newSelectContext(value interface{}, selector string) *Context {
 	return newContextWithFunctions(value, selector, standardFunctions())
 }
@@ -82,9 +83,7 @@ func newPutContext(value interface{}, selector string) *Context {
 }
 
 func newDeleteContext(value interface{}, selector string) *Context {
-	c := newContextWithFunctions(value, selector, standardFunctions())
-	c.filters = append(c.filters, withoutDeletePlaceholders)
-	return c
+	return newContextWithFunctions(value, selector, standardFunctions())
 }
 
 func Select(root interface{}, selector string) (Values, error) {
@@ -141,11 +140,7 @@ func (c *Context) CreateWhenMissing() bool {
 }
 
 func (c *Context) Data() Value {
-	if len(c.filters) == 0 {
-		return c.data
-	}
-	changed, _ := rebuildWithFilter(c.data, c.filters...)
-	return changed
+	return c.data
 }
 
 // Run calls Next repeatedly until no more steps are left.
@@ -199,73 +194,3 @@ func (c *Context) Step(i int) *Step {
 	}
 	return c.steps[i]
 }
-
-// valueFilterFn represents a filter that can be used to remove values
-// from the output data.
-// If the filter returns true, the value is removed.
-type valueFilterFn func(value Value) bool
-
-// withoutDeletePlaceholders implements valueFilterFn.
-func withoutDeletePlaceholders(value Value) bool {
-	return value.IsDeletePlaceholder()
-}
-
-func rebuildWithFilter(value Value, filters ...valueFilterFn) (Value, bool) {
-	changes := 0
-
-	remove := func(v Value) bool {
-		for _, f := range filters {
-			if f(v) {
-				return true
-			}
-		}
-		return false
-	}
-
-	var replacement reflect.Value
-	changed := false
-
-	switch value.Kind() {
-
-	case reflect.Map:
-		replacement = reflect.MakeMap(value.Type())
-
-		for _, key := range value.MapKeys() {
-			v := value.MapIndex(key)
-			if remove(v) {
-				changes++
-			} else {
-				newV, c := rebuildWithFilter(v, filters...)
-				if c {
-					changed = true
-				}
-				replacement.SetMapIndex(key.Value, newV.Value)
-			}
-		}
-
-	case reflect.Slice:
-		replacement = reflect.MakeSlice(value.Type(), 0, 0)
-		for i := 0; i < value.Len(); i++ {
-			v := value.Index(i)
-			if remove(v) {
-				changes++
-			} else {
-				newV, c := rebuildWithFilter(v, filters...)
-				if c {
-					changed = true
-				}
-				replacement = reflect.Append(replacement, newV.Value)
-			}
-		}
-	}
-
-	if changes > 0 {
-		changed = true
-	}
-
-	if changed {
-		return Value{Value: replacement}, true
-	}
-
-	return value, false
-}

context_test.go

@@ -33,7 +33,7 @@ func sameSlice(x, y []interface{}) bool {
 
 func selectTest(selector string, original interface{}, exp []interface{}) func(t *testing.T) {
 	return func(t *testing.T) {
-		c := NewContext(original, selector)
+		c := newSelectContext(original, selector)
 
 		values, err := c.Run()
 		if err != nil {
@@ -54,7 +54,7 @@ func TestNewContext(t *testing.T) {
 		orig := map[string]interface{}{
 			"name": "Tom",
 		}
-		ctx := NewContext(orig, "property(name)")
+		ctx := newPutContext(orig, "property(name)")
 		s, err := ctx.Run()
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
@@ -81,7 +81,7 @@ func TestNewContext(t *testing.T) {
 				"last":  "Wright",
 			},
 		}
-		ctx := NewContext(orig, "property(name).property(first)")
+		ctx := newPutContext(orig, "property(name).property(first)")
 		s, err := ctx.Run()
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
@@ -110,7 +110,7 @@ func TestNewContext(t *testing.T) {
 		}
 
 		orig := User{Name: "Tom"}
-		ctx := NewContext(&orig, "property(Name)")
+		ctx := newPutContext(&orig, "property(Name)")
 		s, err := ctx.Run()
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
@@ -138,7 +138,7 @@ func TestNewContext(t *testing.T) {
 		}
 
 		orig := User{Name: Name{First: "Tom", Last: "Wright"}}
-		ctx := NewContext(&orig, "property(Name).property(First)")
+		ctx := newPutContext(&orig, "property(Name).property(First)")
 		s, err := ctx.Run()
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
@@ -160,7 +160,7 @@ func TestNewContext(t *testing.T) {
 		orig := []interface{}{
 			"a", "b", "c",
 		}
-		ctx := NewContext(&orig, "index(0)")
+		ctx := newPutContext(&orig, "index(0)")
 		s, err := ctx.Run()
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)

func.go

@@ -47,6 +47,7 @@ func standardFunctions() *FunctionCollection {
 		FirstFunc,
 		LastFunc,
 		PropertyFunc,
+		AppendFunc,
 
 		// Filters
 		FilterFunc,

func_append.go

@@ -0,0 +1,46 @@
+package dasel
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var AppendFunc = BasicFunction{
+	name: "append",
+	runFn: func(c *Context, s *Step, args []string) (Values, error) {
+		if err := requireNoArgs("append", args); err != nil {
+			return nil, err
+		}
+
+		input := s.inputs()
+
+		if c.CreateWhenMissing() {
+			input = input.initEmptySlices()
+		}
+
+		res := make(Values, 0)
+
+		for _, val := range input {
+			switch val.Kind() {
+			case reflect.Slice, reflect.Array:
+				val = val.Append()
+
+				value := val.Index(val.Len() - 1)
+				res = append(res, value)
+			default:
+				return nil, fmt.Errorf("cannot use append selector on non slice/array types")
+			}
+		}
+
+		return res, nil
+	},
+	alternativeSelectorFn: func(part string) *Selector {
+		if part == "[]" {
+			return &Selector{
+				funcName: "append",
+				funcArgs: []string{},
+			}
+		}
+		return nil
+	},
+}

func_index.go

@@ -65,7 +65,7 @@ var IndexFunc = BasicFunction{
 		return res, nil
 	},
 	alternativeSelectorFn: func(part string) *Selector {
-		if strings.HasPrefix(part, "[") && strings.HasSuffix(part, "]") {
+		if part != "[]" && strings.HasPrefix(part, "[") && strings.HasSuffix(part, "]") {
 			return &Selector{
 				funcName: "index",
 				funcArgs: []string{

func_metadata_test.go

@@ -10,7 +10,7 @@ func TestMetadataFunc(t *testing.T) {
 		orig := []interface{}{
 			"abc", true, false, 1, 1.1, []interface{}{1},
 		}
-		ctx := NewContext(&orig, "all().metadata(type)")
+		ctx := newSelectContext(&orig, "all().metadata(type)")
 		s, err := ctx.Run()
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)

func_property.go

@@ -51,6 +51,7 @@ var PropertyFunc = BasicFunction{
 						if !c.CreateWhenMissing() {
 							return nil, fmt.Errorf("could not access map index: %w", &ErrPropertyNotFound{Property: property})
 						}
+						index = index.asUninitialised()
 					}
 					res = append(res, index)
 				case reflect.Struct:
@@ -63,7 +64,7 @@ var PropertyFunc = BasicFunction{
 					}
 					res = append(res, value)
 				default:
-					return nil, fmt.Errorf("cannot use property selector on non map/struct types")
+					return nil, fmt.Errorf("cannot use property selector on non map/struct types: %s", val.Kind().String())
 				}
 			}
 		}

internal/command/put_test.go

@@ -89,4 +89,44 @@ func TestPutCommand(t *testing.T) {
 		nil,
 		nil,
 	))
+
+	t.Run("SetStringOnExistingIndex", runTest(
+		[]string{"put", "-r", "json", "-t", "string", "--pretty=false", "-v", "z", "[1]"},
+		[]byte(`["a","b","c"]`),
+		newline([]byte(`["a","z","c"]`)),
+		nil,
+		nil,
+	))
+
+	t.Run("SetStringOnExistingNestedIndex", runTest(
+		[]string{"put", "-r", "json", "-t", "string", "--pretty=false", "-v", "z", "[0].[1]"},
+		[]byte(`[["a","b","c"],["d","e","f"]]`),
+		newline([]byte(`[["a","z","c"],["d","e","f"]]`)),
+		nil,
+		nil,
+	))
+
+	t.Run("AppendStringIndexToRoot", runTest(
+		[]string{"put", "-r", "json", "-t", "string", "--pretty=false", "-v", "z", "[]"},
+		[]byte(`[]`),
+		newline([]byte(`["z"]`)),
+		nil,
+		nil,
+	))
+
+	t.Run("AppendStringIndexToNestedSlice", runTest(
+		[]string{"put", "-r", "json", "-t", "string", "--pretty=false", "-v", "z", "[0].[]"},
+		[]byte(`[[]]`),
+		newline([]byte(`[["z"]]`)),
+		nil,
+		nil,
+	))
+
+	t.Run("AppendToChainOfMissingSlicesAndProperties", runTest(
+		[]string{"put", "-r", "json", "-t", "string", "--pretty=false", "-v", "Tom", "users.[].name.first"},
+		[]byte(`{}`),
+		newline([]byte(`{"users":[{"name":{"first":"Tom"}}]}`)),
+		nil,
+		nil,
+	))
 }