Update go dependencies

vendor/github.com/yudai/gojsondiff/unmarshaler.go

@@ -0,0 +1,131 @@
+package gojsondiff
+
+import (
+	"encoding/json"
+	"errors"
+	dmp "github.com/sergi/go-diff/diffmatchpatch"
+	"io"
+	"strconv"
+)
+
+type Unmarshaller struct {
+}
+
+func NewUnmarshaller() *Unmarshaller {
+	return &Unmarshaller{}
+}
+
+func (um *Unmarshaller) UnmarshalBytes(diffBytes []byte) (Diff, error) {
+	var diffObj map[string]interface{}
+	json.Unmarshal(diffBytes, &diffObj)
+	return um.UnmarshalObject(diffObj)
+}
+
+func (um *Unmarshaller) UnmarshalString(diffString string) (Diff, error) {
+	return um.UnmarshalBytes([]byte(diffString))
+}
+
+func (um *Unmarshaller) UnmarshalReader(diffReader io.Reader) (Diff, error) {
+	var diffBytes []byte
+	io.ReadFull(diffReader, diffBytes)
+	return um.UnmarshalBytes(diffBytes)
+}
+
+func (um *Unmarshaller) UnmarshalObject(diffObj map[string]interface{}) (Diff, error) {
+	result, err := process(Name(""), diffObj)
+	if err != nil {
+		return nil, err
+	}
+	return &diff{deltas: result.(*Object).Deltas}, nil
+}
+
+func process(position Position, object interface{}) (Delta, error) {
+	var delta Delta
+	switch object.(type) {
+	case map[string]interface{}:
+		o := object.(map[string]interface{})
+		if isArray, typed := o["_t"]; typed && isArray == "a" {
+			deltas := make([]Delta, 0, len(o))
+			for name, value := range o {
+				if name == "_t" {
+					continue
+				}
+
+				normalizedName := name
+				if normalizedName[0] == '_' {
+					normalizedName = name[1:]
+				}
+				index, err := strconv.Atoi(normalizedName)
+				if err != nil {
+					return nil, err
+				}
+
+				childDelta, err := process(Index(index), value)
+				if err != nil {
+					return nil, err
+				}
+
+				deltas = append(deltas, childDelta)
+			}
+
+			for _, d := range deltas {
+				switch d.(type) {
+				case *Moved:
+					moved := d.(*Moved)
+
+					var dd interface{}
+					var i int
+					for i, dd = range deltas {
+						switch dd.(type) {
+						case *Moved:
+						case PostDelta:
+							pd := dd.(PostDelta)
+							if moved.PostPosition() == pd.PostPosition() {
+								moved.Delta = pd
+								deltas = append(deltas[:i], deltas[i+1:]...)
+							}
+						}
+					}
+				}
+			}
+
+			delta = NewArray(position, deltas)
+		} else {
+			deltas := make([]Delta, 0, len(o))
+			for name, value := range o {
+				childDelta, err := process(Name(name), value)
+				if err != nil {
+					return nil, err
+				}
+				deltas = append(deltas, childDelta)
+			}
+			delta = NewObject(position, deltas)
+		}
+	case []interface{}:
+		o := object.([]interface{})
+		switch len(o) {
+		case 1:
+			delta = NewAdded(position, o[0])
+		case 2:
+			delta = NewModified(position, o[0], o[1])
+		case 3:
+			switch o[2] {
+			case float64(0):
+				delta = NewDeleted(position, o[0])
+			case float64(2):
+				dmp := dmp.New()
+				patches, err := dmp.PatchFromText(o[0].(string))
+				if err != nil {
+					return nil, err
+				}
+				delta = NewTextDiff(position, patches, nil, nil)
+			case float64(3):
+				delta = NewMoved(position, Index(int(o[1].(float64))), nil, nil)
+			default:
+				return nil, errors.New("Unknown delta type")
+			}
+		}
+	}
+
+	return delta, nil
+}