1 files changed, 176 insertions, 0 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/json.go b/vendor/github.com/zclconf/go-cty/cty/json.go
new file mode 100644
index 0000000..c421a62
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json.go
@@ -0,0 +1,176 @@
+package cty
+
+import (
+        "bytes"
+        "encoding/json"
+        "fmt"
+)
+
+// MarshalJSON is an implementation of json.Marshaler that allows Type
+// instances to be serialized as JSON.
+//
+// All standard types can be serialized, but capsule types cannot since there
+// is no way to automatically recover the original pointer and capsule types
+// compare by equality.
+func (t Type) MarshalJSON() ([]byte, error) {
+        switch impl := t.typeImpl.(type) {
+        case primitiveType:
+                switch impl.Kind {
+                case primitiveTypeBool:
+                        return []byte{'"', 'b', 'o', 'o', 'l', '"'}, nil
+                case primitiveTypeNumber:
+                        return []byte{'"', 'n', 'u', 'm', 'b', 'e', 'r', '"'}, nil
+                case primitiveTypeString:
+                        return []byte{'"', 's', 't', 'r', 'i', 'n', 'g', '"'}, nil
+                default:
+                        panic("unknown primitive type kind")
+                }
+        case typeList, typeMap, typeSet:
+                buf := &bytes.Buffer{}
+                etyJSON, err := t.ElementType().MarshalJSON()
+                if err != nil {
+                        return nil, err
+                }
+                buf.WriteRune('[')
+                switch impl.(type) {
+                case typeList:
+                        buf.WriteString(`"list"`)
+                case typeMap:
+                        buf.WriteString(`"map"`)
+                case typeSet:
+                        buf.WriteString(`"set"`)
+                }
+                buf.WriteRune(',')
+                buf.Write(etyJSON)
+                buf.WriteRune(']')
+                return buf.Bytes(), nil
+        case typeObject:
+                buf := &bytes.Buffer{}
+                atysJSON, err := json.Marshal(t.AttributeTypes())
+                if err != nil {
+                        return nil, err
+                }
+                buf.WriteString(`["object",`)
+                buf.Write(atysJSON)
+                buf.WriteRune(']')
+                return buf.Bytes(), nil
+        case typeTuple:
+                buf := &bytes.Buffer{}
+                etysJSON, err := json.Marshal(t.TupleElementTypes())
+                if err != nil {
+                        return nil, err
+                }
+                buf.WriteString(`["tuple",`)
+                buf.Write(etysJSON)
+                buf.WriteRune(']')
+                return buf.Bytes(), nil
+        case pseudoTypeDynamic:
+                return []byte{'"', 'd', 'y', 'n', 'a', 'm', 'i', 'c', '"'}, nil
+        case *capsuleType:
+                return nil, fmt.Errorf("type not allowed: %s", t.FriendlyName())
+        default:
+                // should never happen
+                panic("unknown type implementation")
+        }
+}
+
+// UnmarshalJSON is the opposite of MarshalJSON. See the documentation of
+// MarshalJSON for information on the limitations of JSON serialization of
+// types.
+func (t *Type) UnmarshalJSON(buf []byte) error {
+        r := bytes.NewReader(buf)
+        dec := json.NewDecoder(r)
+
+        tok, err := dec.Token()
+        if err != nil {
+                return err
+        }
+
+        switch v := tok.(type) {
+        case string:
+                switch v {
+                case "bool":
+                        *t = Bool
+                case "number":
+                        *t = Number
+                case "string":
+                        *t = String
+                case "dynamic":
+                        *t = DynamicPseudoType
+                default:
+                        return fmt.Errorf("invalid primitive type name %q", v)
+                }
+
+                if dec.More() {
+                        return fmt.Errorf("extraneous data after type description")
+                }
+                return nil
+        case json.Delim:
+                if rune(v) != '[' {
+                        return fmt.Errorf("invalid complex type description")
+                }
+
+                tok, err = dec.Token()
+                if err != nil {
+                        return err
+                }
+
+                kind, ok := tok.(string)
+                if !ok {
+                        return fmt.Errorf("invalid complex type kind name")
+                }
+
+                switch kind {
+                case "list":
+                        var ety Type
+                        err = dec.Decode(&ety)
+                        if err != nil {
+                                return err
+                        }
+                        *t = List(ety)
+                case "map":
+                        var ety Type
+                        err = dec.Decode(&ety)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Map(ety)
+                case "set":
+                        var ety Type
+                        err = dec.Decode(&ety)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Set(ety)
+                case "object":
+                        var atys map[string]Type
+                        err = dec.Decode(&atys)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Object(atys)
+                case "tuple":
+                        var etys []Type
+                        err = dec.Decode(&etys)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Tuple(etys)
+                default:
+                        return fmt.Errorf("invalid complex type kind name")
+                }
+
+                tok, err = dec.Token()
+                if err != nil {
+                        return err
+                }
+                if delim, ok := tok.(json.Delim); !ok || rune(delim) != ']' || dec.More() {
+                        return fmt.Errorf("unexpected extra data in type description")
+                }
+
+                return nil
+
+        default:
+                return fmt.Errorf("invalid type description")
+        }
+}