Merge pull request #2 from multycloud/cty_value_update_docs

Implement cty.value encoding and update docs.

Author: goncalo-rodrigues

_tests/cty-value.hcl

@@ -0,0 +1,4 @@
+String             = "test"
+Map                = { "outer" = { "inner" = 5 } }
+Slice              = [["foo"], "bar", null]
+TemplateExpression = "${func("str")}\n"

hclencoder.go

@@ -30,7 +30,7 @@ func Encode(in interface{}) ([]byte, error) {
 func addRootBlock(block *hclwrite.Block, f *hclwrite.File) {
 	// root blocks without types are squashed by default
 	if block.Type() == "" {
-		SquashBlock(block, f.Body())
+		squashBlock(block, f.Body())
 	} else {
 		f.Body().AppendBlock(block)
 	}

hclencoder_test.go

@@ -2,6 +2,7 @@ package hclencoder
 
 import (
 	"fmt"
+	"github.com/zclconf/go-cty/cty"
 	"io/ioutil"
 	"testing"
 
@@ -40,6 +41,29 @@ func TestEncoder(t *testing.T) {
 			},
 			Output: "basic",
 		},
+		{
+			ID: "cty value",
+			Input: struct {
+				String             cty.Value
+				Map                cty.Value
+				Slice              cty.Value
+				TemplateExpression cty.Value
+			}{
+				String: cty.StringVal("test"),
+				Map: cty.ObjectVal(map[string]cty.Value{
+					"outer": cty.MapVal(map[string]cty.Value{
+						"inner": cty.NumberIntVal(5),
+					}),
+				}),
+				Slice: cty.TupleVal([]cty.Value{
+					cty.ListVal([]cty.Value{cty.StringVal("foo")}),
+					cty.StringVal("bar"),
+					cty.NullVal(cty.String),
+				}),
+				TemplateExpression: cty.StringVal("${func(\"str\")}\n"),
+			},
+			Output: "cty-value",
+		},
 		{
 			ID: "escaped strings",
 			Input: struct {

nodes.go

@@ -3,12 +3,9 @@ package hclencoder
 import (
 	"errors"
 	"fmt"
-	"github.com/hashicorp/hcl/v2"
-	"github.com/hashicorp/hcl/v2/hclsyntax"
 	"github.com/hashicorp/hcl/v2/hclwrite"
 	"github.com/zclconf/go-cty/cty"
 	"reflect"
-	"sort"
 	"strings"
 )
 
@@ -70,12 +67,35 @@ type fieldMeta struct {
 	omitEmpty     bool
 }
 
-func encode(in reflect.Value) (node *Node, err error) {
+type node struct {
+	Block     *hclwrite.Block
+	BlockList []*hclwrite.Block
+	Value     *cty.Value
+	Tokens    hclwrite.Tokens
+}
+
+func (n node) isValue() bool {
+	return n.Value != nil
+}
+
+func (n node) isBlock() bool {
+	return n.Block != nil
+}
+
+func (n node) isBlockList() bool {
+	return n.BlockList != nil
+}
+
+func (n node) isTokens() bool {
+	return n.Tokens != nil
+}
+
+func encode(in reflect.Value) (node *node, err error) {
 	return encodeField(in, fieldMeta{})
 }
 
-// encode converts a reflected valued into an HCL ast.Node in a depth-first manner.
-func encodeField(in reflect.Value, meta fieldMeta) (node *Node, err error) {
+// encode converts a reflected valued into an HCL ast.node in a depth-first manner.
+func encodeField(in reflect.Value, meta fieldMeta) (node *node, err error) {
 	in, isNil := deref(in)
 	if isNil {
 		return nil, nil
@@ -95,29 +115,34 @@ func encodeField(in reflect.Value, meta fieldMeta) (node *Node, err error) {
 		return encodePrimitive(in, meta)
 
 	case reflect.Struct:
+		if in.Type().AssignableTo(reflect.TypeOf(cty.Value{})) {
+			meta.expression = true
+			str, _ := ValueToString(in.Interface().(cty.Value))
+			return encodePrimitive(reflect.ValueOf(str), meta)
+		}
 		return encodeStruct(in, meta)
 	default:
 		return nil, fmt.Errorf("cannot encode kind %s to HCL", in.Kind())
 	}
 }
 
-// encodePrimitive converts a primitive value into a Node contains its tokens
-func encodePrimitive(in reflect.Value, meta fieldMeta) (*Node, error) {
+// encodePrimitive converts a primitive value into a node contains its tokens
+func encodePrimitive(in reflect.Value, meta fieldMeta) (*node, error) {
 	// Keys must be literals, so we don't tokenize.
 	if meta.key {
 		k := cty.StringVal(in.String())
-		return &Node{Value: &k}, nil
+		return &node{Value: &k}, nil
 	}
 	tkn, err := tokenize(in, meta)
 	if err != nil {
 		return nil, err
 	}
 
-	return &Node{Tokens: tkn}, nil
+	return &node{Tokens: tkn}, nil
 }
 
 // encodeList converts a slice into either a block list or a primitive list depending on its element type
-func encodeList(in reflect.Value, meta fieldMeta) (*Node, error) {
+func encodeList(in reflect.Value, meta fieldMeta) (*node, error) {
 	childType := in.Type().Elem()
 
 childLoop:
@@ -140,13 +165,13 @@ childLoop:
 
 // encodePrimitiveList converts a slice of primitive values to an ast.ListType. An
 // ast.ObjectKey is never returned.
-func encodePrimitiveList(in reflect.Value, meta fieldMeta) (*Node, error) {
+func encodePrimitiveList(in reflect.Value, meta fieldMeta) (*node, error) {
 	return encodePrimitive(in, meta)
 }
 
 // encodeBlockList converts a slice of non-primitive types to an ast.ObjectList. An
 // ast.ObjectKey is never returned.
-func encodeBlockList(in reflect.Value, meta fieldMeta) (*Node, error) {
+func encodeBlockList(in reflect.Value, meta fieldMeta) (*node, error) {
 	var blocks []*hclwrite.Block
 
 	if !meta.repeatBlock {
@@ -164,34 +189,11 @@ func encodeBlockList(in reflect.Value, meta fieldMeta) (*Node, error) {
 		blocks = append(blocks, node.Block)
 	}
 
-	return &Node{BlockList: blocks}, nil
-}
-
-type Node struct {
-	Block     *hclwrite.Block
-	BlockList []*hclwrite.Block
-	Value     *cty.Value
-	Tokens    hclwrite.Tokens
-}
-
-func (n Node) isValue() bool {
-	return n.Value != nil
-}
-
-func (n Node) isBlock() bool {
-	return n.Block != nil
-}
-
-func (n Node) isBlockList() bool {
-	return n.BlockList != nil
-}
-
-func (n Node) isTokens() bool {
-	return n.Tokens != nil
+	return &node{BlockList: blocks}, nil
 }
 
 // encodeStruct converts a struct type into a block
-func encodeStruct(in reflect.Value, parentMeta fieldMeta) (*Node, error) {
+func encodeStruct(in reflect.Value, parentMeta fieldMeta) (*node, error) {
 	l := in.NumField()
 	block := hclwrite.NewBlock(parentMeta.name, nil)
 
@@ -238,7 +240,7 @@ func encodeStruct(in reflect.Value, parentMeta fieldMeta) (*Node, error) {
 
 		if val.isBlock() {
 			if meta.squash {
-				SquashBlock(val.Block, block.Body())
+				squashBlock(val.Block, block.Body())
 				for _, label := range val.Block.Labels() {
 					block.SetLabels(append(block.Labels(), label))
 				}
@@ -260,179 +262,15 @@ func encodeStruct(in reflect.Value, parentMeta fieldMeta) (*Node, error) {
 
 	}
 
-	return &Node{Block: block}, nil
+	return &node{Block: block}, nil
 }
 
-func SquashBlock(innerBlock *hclwrite.Block, block *hclwrite.Body) {
+func squashBlock(innerBlock *hclwrite.Block, block *hclwrite.Body) {
 	tkns := innerBlock.Body().BuildTokens(nil)
 	block.AppendUnstructuredTokens(tkns)
 
 }
 
-func convertTokens(tokens hclsyntax.Tokens) hclwrite.Tokens {
-	var result []*hclwrite.Token
-	for _, token := range tokens {
-		result = append(result, &hclwrite.Token{
-			Type:         token.Type,
-			Bytes:        token.Bytes,
-			SpacesBefore: 0,
-		})
-	}
-	return result
-}
-
-// tokenize converts a primitive type into tokens. structs and maps are converted into objects and slices are converted
-// into tuples.
-func tokenize(in reflect.Value, meta fieldMeta) (tkns hclwrite.Tokens, err error) {
-
-	tokenEqual := hclwrite.Token{
-		Type:         hclsyntax.TokenEqual,
-		Bytes:        []byte("="),
-		SpacesBefore: 0,
-	}
-	tokenComma := hclwrite.Token{
-		Type:         hclsyntax.TokenComma,
-		Bytes:        []byte(","),
-		SpacesBefore: 0,
-	}
-	tokenOCurlyBrace := hclwrite.Token{
-		Type:         hclsyntax.TokenOBrace,
-		Bytes:        []byte("{"),
-		SpacesBefore: 0,
-	}
-	tokenCCurlyBrace := hclwrite.Token{
-		Type:         hclsyntax.TokenCBrace,
-		Bytes:        []byte("}"),
-		SpacesBefore: 0,
-	}
-
-	switch in.Kind() {
-	case reflect.Bool:
-		return hclwrite.TokensForValue(cty.BoolVal(in.Bool())), nil
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return hclwrite.TokensForValue(cty.NumberUIntVal(in.Uint())), nil
-
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return hclwrite.TokensForValue(cty.NumberIntVal(in.Int())), nil
-
-	case reflect.Float64:
-		return hclwrite.TokensForValue(cty.NumberFloatVal(in.Float())), nil
-
-	case reflect.String:
-		val := in.String()
-		if !meta.expression {
-			val = fmt.Sprintf(`"%s"`, EscapeString(val))
-		}
-		// Unfortunately hcl escapes template expressions (${...}) when using hclwrite.TokensForValue. So we escape
-		// everything but template expressions and then parse the expression into tokens.
-		tokens, diags := hclsyntax.LexExpression([]byte(val), meta.name, hcl.Pos{
-			Line:   0,
-			Column: 0,
-			Byte:   0,
-		})
-
-		if diags != nil {
-			return nil, fmt.Errorf("error when parsing string %s: %v", val, diags.Error())
-		}
-		return convertTokens(tokens), nil
-	case reflect.Pointer, reflect.Interface:
-		val, isNil := deref(in)
-		if isNil {
-			return nil, nil
-		}
-		return tokenize(val, meta)
-	case reflect.Struct:
-		var tokens []*hclwrite.Token
-		tokens = append(tokens, &tokenOCurlyBrace)
-		for i := 0; i < in.NumField(); i++ {
-			field := in.Type().Field(i)
-			meta := extractFieldMeta(field)
-
-			rawVal := in.Field(i)
-			if meta.omitEmpty {
-				zeroVal := reflect.Zero(rawVal.Type()).Interface()
-				if reflect.DeepEqual(rawVal.Interface(), zeroVal) {
-					continue
-				}
-			}
-			val, err := tokenize(rawVal, meta)
-			if err != nil {
-				return nil, err
-			}
-			for _, tkn := range hclwrite.TokensForValue(cty.StringVal(meta.name)) {
-				tokens = append(tokens, tkn)
-			}
-			tokens = append(tokens, &tokenEqual)
-			for _, tkn := range val {
-				tokens = append(tokens, tkn)
-			}
-			if i < in.NumField()-1 {
-				tokens = append(tokens, &tokenComma)
-			}
-		}
-		tokens = append(tokens, &tokenCCurlyBrace)
-		return tokens, nil
-	case reflect.Slice:
-		var tokens []*hclwrite.Token
-		tokens = append(tokens, &hclwrite.Token{
-			Type:         hclsyntax.TokenOBrace,
-			Bytes:        []byte("["),
-			SpacesBefore: 0,
-		})
-		for i := 0; i < in.Len(); i++ {
-			value, err := tokenize(in.Index(i), meta)
-			if err != nil {
-				return nil, err
-			}
-			for _, tkn := range value {
-				tokens = append(tokens, tkn)
-			}
-			if i < in.Len()-1 {
-				tokens = append(tokens, &tokenComma)
-			}
-		}
-		tokens = append(tokens, &hclwrite.Token{
-			Type:         hclsyntax.TokenCBrace,
-			Bytes:        []byte("]"),
-			SpacesBefore: 0,
-		})
-		return tokens, nil
-	case reflect.Map:
-		if keyType := in.Type().Key().Kind(); keyType != reflect.String {
-			return nil, fmt.Errorf("map keys must be strings, %s given", keyType)
-		}
-		var tokens []*hclwrite.Token
-		tokens = append(tokens, &tokenOCurlyBrace)
-
-		var keys []string
-		for _, k := range in.MapKeys() {
-			keys = append(keys, k.String())
-		}
-		sort.Strings(keys)
-		for i, k := range keys {
-			val, err := tokenize(in.MapIndex(reflect.ValueOf(k)), meta)
-			if err != nil {
-				return nil, err
-			}
-			for _, tkn := range hclwrite.TokensForValue(cty.StringVal(k)) {
-				tokens = append(tokens, tkn)
-			}
-			tokens = append(tokens, &tokenEqual)
-			for _, tkn := range val {
-				tokens = append(tokens, tkn)
-			}
-			if i < len(keys)-1 {
-				tokens = append(tokens, &tokenComma)
-			}
-		}
-		tokens = append(tokens, &tokenCCurlyBrace)
-		return tokens, nil
-	}
-
-	return nil, fmt.Errorf("cannot encode primitive kind %s to token", in.Kind())
-}
-
 // extractFieldMeta pulls information about struct fields and the optional HCL tags
 func extractFieldMeta(f reflect.StructField) (meta fieldMeta) {
 	if f.Anonymous {