Add map var case, and ignore empty object(map/slice/struct), which mi…

…ght cause cty return error.

gohcl/eval_context.go

@@ -43,7 +43,10 @@ func structMapVal(v interface{}) map[string]cty.Value {
 
  if !value.IsZero() {
  k := marshalKey(key.Name)
- variables[k] = reflectVal(value)
+ refVal, err := reflectVal(value)
+ if err == nil {
+ variables[k] = refVal
+ }
  }
 
  }
@@ -54,48 +57,81 @@ func structMapVal(v interface{}) map[string]cty.Value {
 // reflectVal receive a reflect.Value and according to the kind implemented,
 // return a cty.Value. The value kind that have been implemented so far are
 // Int/Uint, Float, String, and nest Struct and Slice
-func reflectVal(v reflect.Value) cty.Value {
+func reflectVal(v reflect.Value) (cty.Value, error) {
  switch v.Kind() {
  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return cty.NumberIntVal(v.Int())
+ return cty.NumberIntVal(v.Int()), nil
  case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
- return cty.NumberUIntVal(v.Uint())
+ return cty.NumberUIntVal(v.Uint()), nil
  case reflect.Float32, reflect.Float64:
- return cty.NumberFloatVal(v.Float())
+ return cty.NumberFloatVal(v.Float()), nil
  case reflect.String:
- return cty.StringVal(v.String())
+ return cty.StringVal(v.String()), nil
  case reflect.Struct:
  return structVal(v)
  case reflect.Slice:
- return sliceVal(v)
+ return listVal(v)
+ case reflect.Map:
+ return mapVal(v)
  default:
- panic(fmt.Sprintf("target value must be pointer to int, string, slice, struct or map, not %s", v.String()))
+ return cty.EmptyObjectVal, fmt.Errorf("target value must be pointer to number, string, slice, struct or map, not %s", v.String())
  }
 }
 
-// sliceVal receive a reflect.Value which should be asserted as Slice type.
+func mapVal(v reflect.Value) (cty.Value, error) {
+ var mapVar = make(map[string]cty.Value)
+ kind := v.Type().Key().Kind()
+ if kind == reflect.String {
+ iter := v.MapRange()
+ for iter.Next() {
+ refVal, err := reflectVal(iter.Value())
+ if err == nil {
+ mapVar[marshalKey(iter.Key().String())] = refVal
+ }
+ }
+ if len(mapVar) > 0 {
+ return cty.MapVal(mapVar), nil
+ }
+ return cty.EmptyObjectVal, fmt.Errorf("target map error or is empty")
+ }
+ return cty.EmptyObjectVal, fmt.Errorf("target key should be string, %s is not support", kind.String())
+}
+
+// listVal receive a reflect.Value which should be asserted as Slice type.
 // In the for loop, each var would be called by func reflectVal to return
 // a cty.Value and add into a slice.Finally return cty.ListVal
-func sliceVal(v reflect.Value) cty.Value {
+func listVal(v reflect.Value) (cty.Value, error) {
  elems := []cty.Value{}
  for i := 0; i < v.Len(); i++ {
- elems = append(elems, reflectVal(v.Index(i)))
+ refVal, err := reflectVal(v.Index(i))
+ if err == nil {
+ elems = append(elems, refVal)
+ }
+ }
+ if len(elems) > 0 {
+ return cty.ListVal(elems), nil
  }
- return cty.ListVal(elems)
+ return cty.EmptyTupleVal, fmt.Errorf(" slice is empty, cty.ListVal must not call ListVal with empty slice")
 }
 
 // structVal received a reflect.Value which should be asserted as Struct type.
 // It uses the NumFiled() of reflect type to loop all struct fields,
 // and return cty.MapVal
 
-func structVal(v reflect.Value) cty.Value {
+func structVal(v reflect.Value) (cty.Value, error) {
  var ctyVals = make(map[string]cty.Value)
  for index := 0; index < v.Type().NumField(); index++ {
  key := v.Type().Field(index)
  value := v.Field(index)
- ctyVals[marshalKey(key.Name)] = reflectVal(value)
+ refVal, err := reflectVal(value)
+ if err == nil {
+ ctyVals[marshalKey(key.Name)] = refVal
+ }
+ }
+ if len(ctyVals) > 0 {
+ return cty.MapVal(ctyVals), nil
  }
- return cty.MapVal(ctyVals)
+ return cty.EmptyObjectVal, fmt.Errorf(" slice is empty, cty.ListVal must not call ListVal with empty map")
 }
 
 // marshalKey trans camelcase to lowercase with separated by underscores

gohcl/eval_context_test.go

@@ -67,6 +67,52 @@ func TestEvalContext(t *testing.T) {
  },
  },
  },
+ {
+ Input: struct {
+ HashMap map[string]string
+ }{
+ HashMap: map[string]string{
+ "a": "b",
+ "c": "d",
+ },
+ },
+ Output: hcl.EvalContext{Variables: map[string]cty.Value{
+ "hash_map": cty.MapVal(map[string]cty.Value{
+ "a": cty.StringVal("b"),
+ "c": cty.StringVal("d"),
+ }),
+ }},
+ },
+ {
+ Input: struct {
+ HashMap map[string]string
+ }{
+ HashMap: map[string]string{},
+ },
+ Output: hcl.EvalContext{Variables: map[string]cty.Value{}},
+ },
+ {
+ Input: struct {
+ Array []string
+ }{
+ Array: []string{"elem-1", "elem-2"},
+ },
+ Output: hcl.EvalContext{Variables: map[string]cty.Value{
+ "array": cty.ListVal(
+ []cty.Value{
+ cty.StringVal("elem-1"),
+ cty.StringVal("elem-2"),
+ }),
+ }},
+ },
+ {
+ Input: struct {
+ Array []string
+ }{
+ Array: []string{},
+ },
+ Output: hcl.EvalContext{Variables: map[string]cty.Value{}},
+ },
  }
 
  for index, test := range tests {