Broke up types.go into different files.

Same content, different files, easier to navigate.

Author: Paddy Carver

tfprotov5/tftypes/list.go

@@ -0,0 +1,16 @@
+package tftypes
+
+type List struct {
+	ElementType Type
+}
+
+func (l List) Is(t Type) bool {
+	_, ok := t.(List)
+	return ok
+}
+
+func (l List) String() string {
+	return "tftypes.List"
+}
+
+func (l List) private() {}

tfprotov5/tftypes/map.go

@@ -0,0 +1,16 @@
+package tftypes
+
+type Map struct {
+	AttributeType Type
+}
+
+func (m Map) Is(t Type) bool {
+	_, ok := t.(Map)
+	return ok
+}
+
+func (m Map) String() string {
+	return "tftypes.Map"
+}
+
+func (m Map) private() {}

tfprotov5/tftypes/object.go

@@ -0,0 +1,16 @@
+package tftypes
+
+type Object struct {
+	AttributeTypes map[string]Type
+}
+
+func (o Object) Is(t Type) bool {
+	_, ok := t.(Object)
+	return ok
+}
+
+func (o Object) String() string {
+	return "tftypes.Object"
+}
+
+func (o Object) private() {}

tfprotov5/tftypes/primitive.go

@@ -0,0 +1,29 @@
+package tftypes
+
+const (
+	UnknownType       = primitive("Unknown")
+	DynamicPseudoType = primitive("DynamicPseudoType")
+	String            = primitive("String")
+	Number            = primitive("Number")
+	Bool              = primitive("Bool")
+)
+
+var (
+	_ Type = primitive("test")
+)
+
+type primitive string
+
+func (p primitive) Is(t Type) bool {
+	v, ok := t.(primitive)
+	if !ok {
+		return false
+	}
+	return p == v
+}
+
+func (p primitive) String() string {
+	return "tftypes." + string(p)
+}
+
+func (p primitive) private() {}

tfprotov5/tftypes/types.go renamed to tfprotov5/tftypes/raw_value.go

@@ -7,118 +7,6 @@ import (
 	"math/big"
 )
 
-type unknown byte
-
-type Type interface {
-	Is(Type) bool
-	String() string
-	private()
-}
-
-type primitive string
-
-func (p primitive) Is(t Type) bool {
-	v, ok := t.(primitive)
-	if !ok {
-		return false
-	}
-	return p == v
-}
-
-func (p primitive) String() string {
-	return "tftypes." + string(p)
-}
-
-func (p primitive) private() {}
-
-const (
-	UnknownValue      = unknown(0)
-	UnknownType       = primitive("Unknown")
-	DynamicPseudoType = primitive("DynamicPseudoType")
-	String            = primitive("String")
-	Number            = primitive("Number")
-	Bool              = primitive("Bool")
-)
-
-var (
-	_ Type = primitive("test")
-)
-
-type List struct {
-	ElementType Type
-}
-
-func (l List) Is(t Type) bool {
-	_, ok := t.(List)
-	return ok
-}
-
-func (l List) String() string {
-	return "tftypes.List"
-}
-
-func (l List) private() {}
-
-type Set struct {
-	ElementType Type
-}
-
-func (s Set) Is(t Type) bool {
-	_, ok := t.(Set)
-	return ok
-}
-
-func (s Set) String() string {
-	return "tftypes.Set"
-}
-
-func (s Set) private() {}
-
-type Map struct {
-	AttributeType Type
-}
-
-func (m Map) Is(t Type) bool {
-	_, ok := t.(Map)
-	return ok
-}
-
-func (m Map) String() string {
-	return "tftypes.Map"
-}
-
-func (m Map) private() {}
-
-type Tuple struct {
-	ElementTypes []Type
-}
-
-func (tu Tuple) Is(t Type) bool {
-	_, ok := t.(Tuple)
-	return ok
-}
-
-func (t Tuple) String() string {
-	return "tftypes.Tuple"
-}
-
-func (t Tuple) private() {}
-
-type Object struct {
-	AttributeTypes map[string]Type
-}
-
-func (o Object) Is(t Type) bool {
-	_, ok := t.(Object)
-	return ok
-}
-
-func (o Object) String() string {
-	return "tftypes.Object"
-}
-
-func (o Object) private() {}
-
 type Unmarshaler interface {
 	UnmarshalTerraform5Type(RawValue) error
 }
@@ -428,99 +316,3 @@ func rawValueFromComplexType(typ Type, val interface{}) (RawValue, error) {
 	// TODO: return error
 	return RawValue{}, nil
 }
-
-func parseType(in interface{}) (Type, error) {
-	switch v := in.(type) {
-	// primitive types are represented just as strings,
-	// with the type name in the string itself
-	case string:
-		switch v {
-		case "string":
-			return String, nil
-		case "number":
-			return Number, nil
-		case "bool":
-			return Bool, nil
-		default:
-			// TODO: return an error
-		}
-	case []interface{}:
-		// sets, lists, tuples, maps, and objects are
-		// represented as slices, recursive iterations of this
-		// type/value syntax
-		if len(v) < 1 {
-			// TODO: return an error
-		}
-		switch v[0] {
-		case "set":
-			if len(v) != 2 {
-				// TODO: return an error
-			}
-			subType, err := parseType(v[1])
-			if err != nil {
-				// TODO: return an error
-			}
-			return Set{
-				ElementType: subType,
-			}, nil
-		case "list":
-			if len(v) != 2 {
-				// TODO: return an error
-			}
-			subType, err := parseType(v[1])
-			if err != nil {
-				// TODO: return an error
-			}
-			return List{
-				ElementType: subType,
-			}, nil
-		case "tuple":
-			if len(v) < 2 {
-				// TODO: return an error
-			}
-			var types []Type
-			for _, typ := range v {
-				subType, err := parseType(typ)
-				if err != nil {
-					// TODO: return an error
-				}
-				types = append(types, subType)
-			}
-			return Tuple{
-				ElementTypes: types,
-			}, nil
-		case "map":
-			if len(v) != 2 {
-				// TODO: return an error
-			}
-			subType, err := parseType(v[1])
-			if err != nil {
-				// TODO: return an error
-			}
-			return Map{
-				AttributeType: subType,
-			}, nil
-		case "object":
-			if len(v) < 2 {
-				// TODO: return an error
-			}
-			types := map[string]Type{}
-			valTypes := v[1].(map[string]interface{})
-			for key, typ := range valTypes {
-				subType, err := parseType(typ)
-				if err != nil {
-					// TODO: return an error
-				}
-				types[key] = subType
-			}
-			return Object{
-				AttributeTypes: types,
-			}, nil
-		default:
-			// TODO: return an error
-			return nil, nil
-		}
-	}
-	// TODO: return an error
-	return nil, nil
-}

tfprotov5/tftypes/set.go

@@ -0,0 +1,16 @@
+package tftypes
+
+type Set struct {
+	ElementType Type
+}
+
+func (s Set) Is(t Type) bool {
+	_, ok := t.(Set)
+	return ok
+}
+
+func (s Set) String() string {
+	return "tftypes.Set"
+}
+
+func (s Set) private() {}

tfprotov5/tftypes/tuple.go

@@ -0,0 +1,16 @@
+package tftypes
+
+type Tuple struct {
+	ElementTypes []Type
+}
+
+func (tu Tuple) Is(t Type) bool {
+	_, ok := t.(Tuple)
+	return ok
+}
+
+func (t Tuple) String() string {
+	return "tftypes.Tuple"
+}
+
+func (t Tuple) private() {}