Refactor ctyToGo-related code

mumoshu · Apr 17, 2020 · e62ed03 · e62ed03
1 parent 5f09f29
commit e62ed03
Show file tree

Hide file tree

Showing 2 changed files with 86 additions and 70 deletions.
diff --git a/pkg/app/cty2go.go b/pkg/app/cty2go.go
@@ -2,6 +2,7 @@ package app
 
 import (
 	"fmt"
+
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/zclconf/go-cty/cty"
@@ -117,103 +118,119 @@ func ctyToGo(v cty.Value) (interface{}, error) {
 			if err != nil {
 				return nil, err
 			}
+
 			m[k] = v
 		}
 
 		vv = m
 	default:
 		if tpe.IsTupleType() {
-			elemTypes := tpe.TupleElementTypes()
-
-			if len(elemTypes) == 0 {
-				vv = []interface{}{}
-			} else {
-				var lastElemType *cty.Type
+			a, err := ctyTupleToGo(v)
+			if err != nil {
+				return nil, err
+			}
 
-				var typeVaries bool
+			vv = a
+		} else if tpe.IsObjectType() {
+			m := map[string]interface{}{}
 
-				for i := range elemTypes {
-					t := &elemTypes[i]
+			for name := range tpe.AttributeTypes() {
+				attr := v.GetAttr(name)
 
-					if lastElemType == nil {
-						lastElemType = t
-					} else if !lastElemType.Equals(*t) {
-						//return nil, fmt.Errorf("handler for tuple with varying element types is not implemented yet: %v", v)
-						typeVaries = true
-						break
-					}
+				v, err := ctyToGo(attr)
+				if err != nil {
+					return nil, fmt.Errorf("unable to decoode attribute %q of object: %w", name, err)
 				}
+				m[name] = v
+			}
 
-				if typeVaries {
-					var elems []interface{}
+			vv = m
+		} else {
+			return nil, fmt.Errorf("handler for type %s not implemented yet", v.Type().FriendlyName())
+		}
+	}
 
-					iter := v.ElementIterator()
+	return vv, nil
+}
 
-					for iter.Next() {
-						_, elemValue := iter.Element()
-						elemGo, err := ctyToGo(elemValue)
-						if err != nil {
-							return nil, err
-						}
+func ctyTupleToGo(tuple cty.Value) (interface{}, error) {
+	tpe := tuple.Type()
 
-						elems = append(elems, elemGo)
-					}
+	elemTypes := tpe.TupleElementTypes()
 
-					vv = elems
-				} else {
-					switch *lastElemType {
-					case cty.String:
-						var vvv []string
+	if len(elemTypes) == 0 {
+		return []interface{}{}, nil
+	}
 
-						for i := range elemTypes {
-							var s string
+	var lastElemType *cty.Type
 
-							if err := gocty.FromCtyValue(v.Index(cty.NumberIntVal(int64(i))), &s); err != nil {
-								return nil, err
-							}
+	var typeVaries bool
 
-							vvv = append(vvv, s)
-						}
+	for i := range elemTypes {
+		t := &elemTypes[i]
 
-						vv = vvv
-					case cty.Number:
-						var vvv []int
+		if lastElemType == nil {
+			lastElemType = t
+		} else if !lastElemType.Equals(*t) {
+			//return nil, fmt.Errorf("handler for tuple with varying element types is not implemented yet: %v", v)
+			typeVaries = true
+			break
+		}
+	}
 
-						for i := range elemTypes {
-							var s int
+	if typeVaries {
+		var elems []interface{}
 
-							if err := gocty.FromCtyValue(v.Index(cty.NumberIntVal(int64(i))), &s); err != nil {
-								return nil, err
-							}
+		iter := tuple.ElementIterator()
 
-							vvv = append(vvv, s)
-						}
+		for iter.Next() {
+			_, elemValue := iter.Element()
 
-						vv = vvv
-					default:
-						return nil, fmt.Errorf("handler for tuple with element type of %s is not implemented yet: %v", *lastElemType, v)
-					}
-				}
+			elemGo, err := ctyToGo(elemValue)
+			if err != nil {
+				return nil, err
 			}
-		} else if tpe.IsObjectType() {
-			m := map[string]interface{}{}
 
-			for name := range tpe.AttributeTypes() {
-				attr := v.GetAttr(name)
+			elems = append(elems, elemGo)
+		}
 
-				v, err := ctyToGo(attr)
-				if err != nil {
-					return nil, fmt.Errorf("unable to decoode attribute %q of object: %w", name, err)
-				}
-				m[name] = v
+		return elems, nil
+	}
+
+	var nonEmptyGoSlice interface{}
+
+	switch *lastElemType {
+	case cty.String:
+		var strSlice []string
+
+		for i := range elemTypes {
+			var elem string
+
+			if err := gocty.FromCtyValue(tuple.Index(cty.NumberIntVal(int64(i))), &elem); err != nil {
+				return nil, err
 			}
 
-			vv = m
-		} else {
-			return nil, fmt.Errorf("handler for type %s not implemented yet", v.Type().FriendlyName())
+			strSlice = append(strSlice, elem)
 		}
+
+		nonEmptyGoSlice = strSlice
+	case cty.Number:
+		var intSlice []int
+
+		for i := range elemTypes {
+			var elem int
+
+			if err := gocty.FromCtyValue(tuple.Index(cty.NumberIntVal(int64(i))), &elem); err != nil {
+				return nil, err
+			}
+
+			intSlice = append(intSlice, elem)
+		}
+
+		nonEmptyGoSlice = intSlice
+	default:
+		return nil, fmt.Errorf("handler for tuple with element type of %s is not implemented yet: %v", *lastElemType, tuple)
 	}
 
-	return vv, nil
+	return nonEmptyGoSlice, nil
 }
-
diff --git a/pkg/app/values.go b/pkg/app/values.go
@@ -2,6 +2,7 @@ package app
 
 import (
 	"fmt"
+
 	"github.com/hashicorp/hcl/v2"
 	"github.com/zclconf/go-cty/cty"
 )
@@ -70,7 +71,6 @@ func setParameterValues(subject string, ctx cty.Value, specs []Parameter, overri
 	return values, nil
 }
 
-
 func setOptionValues(subject string, ctx cty.Value, specs []OptionSpec, overrides map[string]interface{}, f SetOptsFunc) (map[string]cty.Value, error) {
 	values := map[string]cty.Value{}
 
@@ -93,4 +93,3 @@ func setOptionValues(subject string, ctx cty.Value, specs []OptionSpec, override
 
 	return values, nil
 }
-