init

Signed-off-by: Hunan Rostomyan <[email protected]>

Author: cppforlife

README.md

@@ -0,0 +1,18 @@
+## go-patch
+
+More or less based on https://tools.ietf.org/html/rfc6902.
+
+## Pointer (aka path)
+
+More or less based on https://tools.ietf.org/html/rfc6901.
+
+- Root
+- Index (ex: `/0`, `/-1`)
+- AfterLastIndex (ex: `/-`)
+- MatchingIndex (ex: `/key=val`)
+- Key: `/key`
+
+## Operations
+
+- Remove
+- Replace

err_op.go

@@ -0,0 +1,9 @@
+package patch
+
+type ErrOp struct {
+	Err error
+}
+
+func (op ErrOp) Apply(_ interface{}) (interface{}, error) {
+	return nil, op.Err
+}

errs.go

@@ -0,0 +1,24 @@
+package patch
+
+import (
+	"fmt"
+)
+
+type opMismatchTypeErr struct {
+	type_ string
+	path  Pointer
+	obj   interface{}
+}
+
+func newOpArrayMismatchTypeErr(tokens []Token, obj interface{}) opMismatchTypeErr {
+	return opMismatchTypeErr{"an array", NewPointer(tokens), obj}
+}
+
+func newOpMapMismatchTypeErr(tokens []Token, obj interface{}) opMismatchTypeErr {
+	return opMismatchTypeErr{"a map", NewPointer(tokens), obj}
+}
+
+func (e opMismatchTypeErr) Error() string {
+	errMsg := "Expected to find %s at path '%s' but found '%T'"
+	return fmt.Sprintf(errMsg, e.type_, e.path, e.obj)
+}

integration_test.go

@@ -0,0 +1,119 @@
+package patch_test
+
+import (
+  . "github.com/onsi/ginkgo"
+  . "github.com/onsi/gomega"
+  "gopkg.in/yaml.v2"
+
+  . "github.com/cppforlife/go-patch"
+)
+
+var _ = Describe("Integration", func() {
+  It("works in a basic way", func() {
+    inStr := `
+releases:
+- name: capi
+  version: 0.1
+
+instance_groups:
+- name: cloud_controller
+  instances: 0
+  jobs:
+  - name: cloud_controller
+    release: capi
+
+- name: uaa
+  instances: 0
+`
+
+    var in interface{}
+
+    err := yaml.Unmarshal([]byte(inStr), &in)
+    Expect(err).ToNot(HaveOccurred())
+
+    ops1Str := `
+- type: replace
+  path: /instance_groups/name=cloud_controller/instances
+  value: 1
+
+- type: replace
+  path: /instance_groups/name=cloud_controller/jobs/name=cloud_controller/consumes?/db
+  value:
+    instances:
+    - address: some-db.local
+    properties:
+      username: user
+      password: pass
+
+- type: replace
+  path: /instance_groups/name=uaa/instances
+  value: 1
+
+- type: replace
+  path: /instance_groups/-
+  value:
+    name: uaadb
+    instances: 2
+`
+
+    var opDefs1 []OpDefinition
+
+    err = yaml.Unmarshal([]byte(ops1Str), &opDefs1)
+    Expect(err).ToNot(HaveOccurred())
+
+    ops1, err := NewOpsFromDefinitions(opDefs1)
+    Expect(err).ToNot(HaveOccurred())
+
+    ops2Str := `
+- type: replace
+  path: /releases/name=capi/version
+  value: latest
+`
+
+    var opDefs2 []OpDefinition
+
+    err = yaml.Unmarshal([]byte(ops2Str), &opDefs2)
+    Expect(err).ToNot(HaveOccurred())
+
+    ops2, err := NewOpsFromDefinitions(opDefs2)
+    Expect(err).ToNot(HaveOccurred())
+
+    ops := append(ops1, ops2...)
+
+    res, err := ops.Apply(in)
+    Expect(err).ToNot(HaveOccurred())
+
+    outStr := `
+releases:
+- name: capi
+  version: latest
+
+instance_groups:
+- name: cloud_controller
+  instances: 1
+  jobs:
+  - name: cloud_controller
+    release: capi
+    consumes:
+      db:
+        instances:
+        - address: some-db.local
+        properties:
+          username: user
+          password: pass
+
+- name: uaa
+  instances: 1
+
+- name: uaadb
+  instances: 2
+`
+
+    var out interface{}
+
+    err = yaml.Unmarshal([]byte(outStr), &out)
+    Expect(err).ToNot(HaveOccurred())
+
+    Expect(res).To(Equal(out))
+  })
+})

op_definition.go

@@ -0,0 +1,75 @@
+package patch
+
+import (
+	"fmt"
+)
+
+// OpDefinition struct is useful for JSON and YAML unmarshaling
+type OpDefinition struct {
+	Type  string
+	Path  *string
+	Value *interface{}
+}
+
+func NewOpsFromDefinitions(opDefs []OpDefinition) (Ops, error) {
+	var ops []Op
+	var op Op
+	var err error
+
+	for i, opDef := range opDefs {
+		switch opDef.Type {
+		case "replace":
+			op, err = newReplaceOp(opDef)
+			if err != nil {
+				return nil, fmt.Errorf("Replace operation [%d]: %s", i, err)
+			}
+
+		case "remove":
+			op, err = newRemoveOp(opDef)
+			if err != nil {
+				return nil, fmt.Errorf("Remove operation [%d]: %s", i, err)
+			}
+
+		default:
+			return nil, fmt.Errorf("Unknown operation [%d] with type '%s'", i, opDef.Type)
+		}
+
+		ops = append(ops, op)
+	}
+
+	return Ops(ops), nil
+}
+
+func newReplaceOp(opDef OpDefinition) (ReplaceOp, error) {
+	if opDef.Path == nil {
+		return ReplaceOp{}, fmt.Errorf("Missing path")
+	}
+
+	if opDef.Value == nil {
+		return ReplaceOp{}, fmt.Errorf("Missing value")
+	}
+
+	ptr, err := NewPointerFromString(*opDef.Path)
+	if err != nil {
+		return ReplaceOp{}, fmt.Errorf("Invalid path: %s", err)
+	}
+
+	return ReplaceOp{Path: ptr, Value: *opDef.Value}, nil
+}
+
+func newRemoveOp(opDef OpDefinition) (RemoveOp, error) {
+	if opDef.Path == nil {
+		return RemoveOp{}, fmt.Errorf("Missing path")
+	}
+
+	if opDef.Value != nil {
+		return RemoveOp{}, fmt.Errorf("Cannot specify value")
+	}
+
+	ptr, err := NewPointerFromString(*opDef.Path)
+	if err != nil {
+		return RemoveOp{}, fmt.Errorf("Invalid path: %s", err)
+	}
+
+	return RemoveOp{Path: ptr}, nil
+}

op_definition_test.go

@@ -0,0 +1,77 @@
+package patch_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "github.com/cppforlife/go-patch"
+)
+
+var _ = Describe("NewOpsFromDefinitions", func() {
+	var (
+		path                    = "/abc"
+		invalidPath             = "abc"
+		val         interface{} = 123
+	)
+
+	It("supports 'replace' and 'remove' operations", func() {
+		opDefs := []OpDefinition{
+			{Type: "replace", Path: &path, Value: &val},
+			{Type: "remove", Path: &path},
+		}
+
+		ops, err := NewOpsFromDefinitions(opDefs)
+		Expect(err).ToNot(HaveOccurred())
+
+		Expect(ops).To(Equal(Ops([]Op{
+			ReplaceOp{Path: MustNewPointerFromString("/abc"), Value: 123},
+			RemoveOp{Path: MustNewPointerFromString("/abc")},
+		})))
+	})
+
+	It("returns error if operation type is unknown", func() {
+		_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "test"}})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(Equal("Unknown operation [0] with type 'test'"))
+	})
+
+	Describe("replace", func() {
+		It("requires path", func() {
+			_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "replace"}})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("Replace operation [0]: Missing path"))
+		})
+
+		It("requires value", func() {
+			_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "replace", Path: &path}})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("Replace operation [0]: Missing value"))
+		})
+
+		It("requires valid path", func() {
+			_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "replace", Path: &invalidPath, Value: &val}})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("Replace operation [0]: Invalid path: Expected to start with '/'"))
+		})
+	})
+
+	Describe("remove", func() {
+		It("requires path", func() {
+			_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "remove"}})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("Remove operation [0]: Missing path"))
+		})
+
+		It("does not allow value", func() {
+			_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "remove", Path: &path, Value: &val}})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("Remove operation [0]: Cannot specify value"))
+		})
+
+		It("requires valid path", func() {
+			_, err := NewOpsFromDefinitions([]OpDefinition{{Type: "remove", Path: &invalidPath}})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("Remove operation [0]: Invalid path: Expected to start with '/'"))
+		})
+	})
+})

ops.go

@@ -0,0 +1,25 @@
+package patch
+
+type Ops []Op
+
+type Op interface {
+	Apply(interface{}) (interface{}, error)
+}
+
+// Ensure basic operations implement Op
+var _ Op = ReplaceOp{}
+var _ Op = RemoveOp{}
+var _ Op = ErrOp{}
+
+func (ops Ops) Apply(doc interface{}) (interface{}, error) {
+	var err error
+
+	for _, op := range ops {
+		doc, err = op.Apply(doc)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return doc, nil
+}

ops_test.go

@@ -0,0 +1,40 @@
+package patch_test
+
+import (
+	"errors"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "github.com/cppforlife/go-patch"
+)
+
+var _ = Describe("Ops.Apply", func() {
+	It("runs through all operations", func() {
+		ops := Ops([]Op{
+			RemoveOp{Path: MustNewPointerFromString("/0")},
+			RemoveOp{Path: MustNewPointerFromString("/0")},
+		})
+
+		res, err := ops.Apply([]interface{}{1, 2, 3})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(res).To(Equal([]interface{}{3}))
+	})
+
+	It("returns original input if there are no operations", func() {
+		res, err := Ops([]Op{}).Apply([]interface{}{1, 2, 3})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(res).To(Equal([]interface{}{1, 2, 3}))
+	})
+
+	It("returns error if any operation errors", func() {
+		ops := Ops([]Op{
+			RemoveOp{Path: MustNewPointerFromString("/0")},
+			ErrOp{errors.New("fake-err")},
+		})
+
+		_, err := ops.Apply([]interface{}{1, 2, 3})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("fake-err"))
+	})
+})