Add prepend operator

Author: aeijdenberg

patch/pointer.go

@@ -52,6 +52,12 @@ func NewPointerFromString(str string) (Pointer, error) {
 			continue
 		}
 
+		// parse as before first index
+		if isLast && tok == "+" {
+			tokens = append(tokens, BeforeFirstIndexToken{})
+			continue
+		}
+
 		// parse wildcard
 		if tok == "*" {
 			tokens = append(tokens, WildcardToken{})

patch/replace_op_test.go

@@ -132,6 +132,16 @@ var _ = Describe("ReplaceOp.Apply", func() {
 			Expect(res).To(Equal([]interface{}{1, 2, 3, 10}))
 		})
 
+		It("prepends new item", func() {
+			res, err := ReplaceOp{Path: MustNewPointerFromString("/+"), Value: 10}.Apply([]interface{}{})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res).To(Equal([]interface{}{10}))
+
+			res, err = ReplaceOp{Path: MustNewPointerFromString("/+"), Value: 10}.Apply([]interface{}{1, 2, 3})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res).To(Equal([]interface{}{10, 1, 2, 3}))
+		})
+
 		It("appends nested array item", func() {
 			doc := []interface{}{[]interface{}{10, 11, 12}, 2, 3}
 
@@ -140,6 +150,14 @@ var _ = Describe("ReplaceOp.Apply", func() {
 			Expect(res).To(Equal([]interface{}{[]interface{}{10, 11, 12, 100}, 2, 3}))
 		})
 
+		It("prepends nested array item", func() {
+			doc := []interface{}{[]interface{}{10, 11, 12}, 2, 3}
+
+			res, err := ReplaceOp{Path: MustNewPointerFromString("/0/+"), Value: 100}.Apply(doc)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res).To(Equal([]interface{}{[]interface{}{100, 10, 11, 12}, 2, 3}))
+		})
+
 		It("appends array item from an array that is inside a map", func() {
 			doc := map[interface{}]interface{}{
 				"abc": []interface{}{1, 2, 3},
@@ -153,6 +171,19 @@ var _ = Describe("ReplaceOp.Apply", func() {
 			}))
 		})
 
+		It("prepends array item from an array that is inside a map", func() {
+			doc := map[interface{}]interface{}{
+				"abc": []interface{}{1, 2, 3},
+			}
+
+			res, err := ReplaceOp{Path: MustNewPointerFromString("/abc/+"), Value: 10}.Apply(doc)
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(res).To(Equal(map[interface{}]interface{}{
+				"abc": []interface{}{10, 1, 2, 3},
+			}))
+		})
+
 		It("returns an error if after last index token is not last", func() {
 			ptr := NewPointer([]Token{RootToken{}, AfterLastIndexToken{}, KeyToken{}})
 
@@ -162,6 +193,15 @@ var _ = Describe("ReplaceOp.Apply", func() {
 				"Expected after last index token to be last in path '/-/'"))
 		})
 
+		It("returns an error if before first index token is not last", func() {
+			ptr := NewPointer([]Token{RootToken{}, BeforeFirstIndexToken{}, KeyToken{}})
+
+			_, err := ReplaceOp{Path: ptr}.Apply([]interface{}{})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal(
+				"Expected before first index token to be last in path '/+/'"))
+		})
+
 		It("returns an error if it's not an array being accessed", func() {
 			_, err := ReplaceOp{Path: MustNewPointerFromString("/-")}.Apply(map[interface{}]interface{}{})
 			Expect(err).To(HaveOccurred())
@@ -175,6 +215,20 @@ var _ = Describe("ReplaceOp.Apply", func() {
 			Expect(err.Error()).To(Equal(
 				"Expected to find an array at path '/key/-' but found 'map[interface {}]interface {}'"))
 		})
+
+		It("returns an error if it's not an array being accessed", func() {
+			_, err := ReplaceOp{Path: MustNewPointerFromString("/+")}.Apply(map[interface{}]interface{}{})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal(
+				"Expected to find an array at path '/+' but found 'map[interface {}]interface {}'"))
+
+			doc := map[interface{}]interface{}{"key": map[interface{}]interface{}{}}
+
+			_, err = ReplaceOp{Path: MustNewPointerFromString("/key/+")}.Apply(doc)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal(
+				"Expected to find an array at path '/key/+' but found 'map[interface {}]interface {}'"))
+		})
 	})
 
 	Describe("array item with matching key and value", func() {
@@ -429,6 +483,18 @@ var _ = Describe("ReplaceOp.Apply", func() {
 			}))
 		})
 
+		It("creates missing key with array value for index access if key is not expected to exist", func() {
+			doc := map[interface{}]interface{}{"xyz": "xyz"}
+
+			res, err := ReplaceOp{Path: MustNewPointerFromString("/abc?/+"), Value: 1}.Apply(doc)
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(res).To(Equal(map[interface{}]interface{}{
+				"abc": []interface{}{1},
+				"xyz": "xyz",
+			}))
+		})
+
 		It("returns an error if missing key needs to be created but next access does not make sense", func() {
 			doc := map[interface{}]interface{}{"xyz": "xyz"}
 

patch/token_prepend.go

@@ -0,0 +1,42 @@
+package patch
+
+import "fmt"
+
+type BeforeFirstIndexToken struct{}
+
+func (t BeforeFirstIndexToken) String() string {
+	return "+"
+}
+
+func (t BeforeFirstIndexToken) processDescent(ctx *tokenContext) (interface{}, error) {
+	if ctx.Node == nil {
+		ctx.Node = make([]interface{}, 0)
+		if ctx.Method == methodReplace {
+			ctx.Setter(ctx.Node)
+		}
+	}
+
+	if ctx.Method != methodReplace {
+		if ctx.Method == methodFind {
+			errMsg := "Expected after last index token to be last in path '%s' (not supported in find operations)"
+			return nil, fmt.Errorf(errMsg, NewPointer(ctx.Tokens))
+		}
+		return nil, opUnexpectedTokenErr{t, NewPointer(ctx.Tokens[:ctx.TokenIndex+1])}
+	}
+
+	typedObj, ok := ctx.Node.([]interface{})
+	if !ok {
+		return nil, newOpArrayMismatchTypeErr(ctx.Tokens[:ctx.TokenIndex+1], ctx.Node)
+	}
+
+	if !ctx.IsLast() {
+		return nil, fmt.Errorf("Expected before first index token to be last in path '%s'", Pointer{tokens: ctx.Tokens})
+	}
+
+	v, err := ctx.Value()
+	if err != nil {
+		return nil, err
+	}
+	ctx.Setter(append([]interface{}{v}, typedObj...))
+	return nil, nil
+}