gozcl: decoding of bodies into structs and maps

gozcl/decode.go

@@ -2,6 +2,7 @@ package gozcl
 
 import (
 	"fmt"
+	"reflect"
 
 	"github.com/apparentlymart/go-cty/cty/convert"
 	"github.com/apparentlymart/go-cty/cty/gocty"
@@ -25,8 +26,217 @@ import (
 // may still be accessed by a careful caller for static analysis and editor
 // integration use-cases.
 func DecodeBody(body zcl.Body, ctx *zcl.EvalContext, val interface{}) zcl.Diagnostics {
-	// TODO: Implement
+	rv := reflect.ValueOf(val)
-	return nil
+	if rv.Kind() != reflect.Ptr {
+		panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+	}
+
+	return decodeBodyToValue(body, ctx, rv.Elem())
+}
+
+func decodeBodyToValue(body zcl.Body, ctx *zcl.EvalContext, val reflect.Value) zcl.Diagnostics {
+	et := val.Type()
+	switch et.Kind() {
+	case reflect.Struct:
+		return decodeBodyToStruct(body, ctx, val)
+	case reflect.Map:
+		return decodeBodyToMap(body, ctx, val)
+	default:
+		panic(fmt.Sprintf("target value must be pointer to struct or map, not %s", et.String()))
+	}
+}
+
+func decodeBodyToStruct(body zcl.Body, ctx *zcl.EvalContext, val reflect.Value) zcl.Diagnostics {
+	schema, partial := ImpliedBodySchema(val.Interface())
+
+	var content *zcl.BodyContent
+	var leftovers zcl.Body
+	var diags zcl.Diagnostics
+	if partial {
+		content, leftovers, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+	if content == nil {
+		return diags
+	}
+
+	tags := getFieldTags(val.Type())
+
+	if tags.Remain != nil {
+		fieldIdx := *tags.Remain
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+		switch {
+		case bodyType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(leftovers))
+		case attrsType.AssignableTo(field.Type):
+			attrs, attrsDiags := leftovers.JustAttributes()
+			if len(attrsDiags) > 0 {
+				diags = append(diags, attrsDiags...)
+			}
+			fieldV.Set(reflect.ValueOf(attrs))
+		default:
+			diags = append(diags, decodeBodyToValue(leftovers, ctx, fieldV)...)
+		}
+	}
+
+	for name, attr := range content.Attributes {
+		fieldIdx := tags.Attributes[name]
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+
+		switch {
+		case attrType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr))
+		case exprType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr.Expr))
+		default:
+			diags = append(diags, DecodeExpression(
+				attr.Expr, ctx, fieldV.Addr().Interface(),
+			)...)
+		}
+	}
+
+	blocksByType := content.Blocks.ByType()
+
+	for typeName, fieldIdx := range tags.Blocks {
+		blocks := blocksByType[typeName]
+		field := val.Type().Field(fieldIdx)
+
+		ty := field.Type
+		isSlice := false
+		isPtr := false
+		if ty.Kind() == reflect.Slice {
+			isSlice = true
+			ty = ty.Elem()
+		}
+		if ty.Kind() == reflect.Ptr {
+			isPtr = true
+			ty = ty.Elem()
+		}
+
+		if len(blocks) > 1 && !isSlice {
+			diags = append(diags, &zcl.Diagnostic{
+				Severity: zcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", typeName),
+				Detail: fmt.Sprintf(
+					"Only one %s block is allowed. Another was defined at %s.",
+					typeName, blocks[0].DefRange.String(),
+				),
+				Subject: &blocks[1].DefRange,
+			})
+			continue
+		}
+
+		if len(blocks) == 0 {
+			if isSlice || isPtr {
+				val.Field(fieldIdx).Set(reflect.Zero(field.Type))
+			} else {
+				diags = append(diags, &zcl.Diagnostic{
+					Severity: zcl.DiagError,
+					Summary:  fmt.Sprintf("Missing %s block", typeName),
+					Detail:   fmt.Sprintf("A %s block is required.", typeName),
+					Subject:  body.MissingItemRange().Ptr(),
+				})
+			}
+			continue
+		}
+
+		switch {
+
+		case isSlice:
+			elemType := ty
+			if isPtr {
+				elemType = reflect.PtrTo(ty)
+			}
+			sli := reflect.MakeSlice(reflect.SliceOf(elemType), len(blocks), len(blocks))
+
+			for i, block := range blocks {
+				if isPtr {
+					v := reflect.New(ty)
+					diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+					sli.Index(i).Set(v)
+				} else {
+					diags = append(diags, decodeBlockToValue(block, ctx, sli.Index(i))...)
+				}
+			}
+
+			val.Field(fieldIdx).Set(sli)
+
+		default:
+			block := blocks[0]
+			if isPtr {
+				v := reflect.New(ty)
+				diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+				val.Field(fieldIdx).Set(v)
+			} else {
+				diags = append(diags, decodeBlockToValue(block, ctx, val.Field(fieldIdx))...)
+			}
+
+		}
+
+	}
+
+	return diags
+}
+
+func decodeBodyToMap(body zcl.Body, ctx *zcl.EvalContext, v reflect.Value) zcl.Diagnostics {
+	attrs, diags := body.JustAttributes()
+	if attrs == nil {
+		return diags
+	}
+
+	mv := reflect.MakeMap(v.Type())
+
+	for k, attr := range attrs {
+		switch {
+		case attrType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr))
+		case exprType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr.Expr))
+		default:
+			ev := reflect.New(v.Type().Elem())
+			diags = append(diags, DecodeExpression(attr.Expr, ctx, ev.Interface())...)
+			mv.SetMapIndex(reflect.ValueOf(k), ev.Elem())
+		}
+	}
+
+	v.Set(mv)
+
+	return diags
+}
+
+func decodeBlockToValue(block *zcl.Block, ctx *zcl.EvalContext, v reflect.Value) zcl.Diagnostics {
+	var diags zcl.Diagnostics
+
+	ty := v.Type()
+
+	switch {
+	case blockType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block))
+	case bodyType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block.Body))
+	case attrsType.AssignableTo(ty):
+		attrs, attrsDiags := block.Body.JustAttributes()
+		if len(attrsDiags) > 0 {
+			diags = append(diags, attrsDiags...)
+		}
+		v.Elem().Set(reflect.ValueOf(attrs))
+	default:
+		diags = append(diags, decodeBodyToValue(block.Body, ctx, v)...)
+
+		if len(block.Labels) > 0 {
+			blockTags := getFieldTags(ty)
+			for li, lv := range block.Labels {
+				lfieldIdx := blockTags.Labels[li].FieldIndex
+				v.Field(lfieldIdx).Set(reflect.ValueOf(lv))
+			}
+		}
+
+	}
+
+	return diags
 }
 
 // DecodeExpression extracts the value of the given expression into the given

gozcl/decode_test.go

@@ -1,14 +1,490 @@
 package gozcl
 
 import (
+	"encoding/json"
 	"fmt"
 	"reflect"
 	"testing"
 
 	"github.com/apparentlymart/go-cty/cty"
 	"github.com/apparentlymart/go-zcl/zcl"
+	zclJSON "github.com/apparentlymart/go-zcl/zcl/json"
+	"github.com/davecgh/go-spew/spew"
 )
 
+func TestDecodeBody(t *testing.T) {
+	deepEquals := func(other interface{}) func(v interface{}) bool {
+		return func(v interface{}) bool {
+			return reflect.DeepEqual(v, other)
+		}
+	}
+
+	tests := []struct {
+		Body      map[string]interface{}
+		Target    interface{}
+		Check     func(v interface{}) bool
+		DiagCount int
+	}{
+		{
+			map[string]interface{}{},
+			struct{}{},
+			deepEquals(struct{}{}),
+			0,
+		},
+		{
+			map[string]interface{}{},
+			struct {
+				Name string `zcl:"name"`
+			}{},
+			deepEquals(struct {
+				Name string `zcl:"name"`
+			}{}),
+			1, // name is required
+		},
+		{
+			map[string]interface{}{},
+			struct {
+				Name *string `zcl:"name"`
+			}{},
+			deepEquals(struct {
+				Name *string `zcl:"name"`
+			}{}),
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+			},
+			struct {
+				Name string `zcl:"name"`
+			}{},
+			deepEquals(struct {
+				Name string `zcl:"name"`
+			}{"Ermintrude"}),
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  23,
+			},
+			struct {
+				Name string `zcl:"name"`
+			}{},
+			deepEquals(struct {
+				Name string `zcl:"name"`
+			}{"Ermintrude"}),
+			1, // Extraneous "age" property
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  50,
+			},
+			struct {
+				Name  string         `zcl:"name"`
+				Attrs zcl.Attributes `zcl:",remain"`
+			}{},
+			func(gotI interface{}) bool {
+				got := gotI.(struct {
+					Name  string         `zcl:"name"`
+					Attrs zcl.Attributes `zcl:",remain"`
+				})
+				return got.Name == "Ermintrude" && len(got.Attrs) == 1 && got.Attrs["age"] != nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  50,
+			},
+			struct {
+				Name   string   `zcl:"name"`
+				Remain zcl.Body `zcl:",remain"`
+			}{},
+			func(gotI interface{}) bool {
+				got := gotI.(struct {
+					Name   string   `zcl:"name"`
+					Remain zcl.Body `zcl:",remain"`
+				})
+
+				attrs, _ := got.Remain.JustAttributes()
+
+				return got.Name == "Ermintrude" && len(attrs) == 1 && attrs["age"] != nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  51,
+			},
+			struct {
+				Name   string               `zcl:"name"`
+				Remain map[string]cty.Value `zcl:",remain"`
+			}{},
+			deepEquals(struct {
+				Name   string               `zcl:"name"`
+				Remain map[string]cty.Value `zcl:",remain"`
+			}{
+				Name: "Ermintrude",
+				Remain: map[string]cty.Value{
+					"age": cty.NumberIntVal(51),
+				},
+			}),
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{},
+			},
+			struct {
+				Noodle struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating no diagnostics is good enough for this one.
+				return true
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{{}},
+			},
+			struct {
+				Noodle struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating no diagnostics is good enough for this one.
+				return true
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{{}, {}},
+			},
+			struct {
+				Noodle struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating one diagnostic is good enough for this one.
+				return true
+			},
+			1,
+		},
+		{
+			map[string]interface{}{},
+			struct {
+				Noodle struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating one diagnostic is good enough for this one.
+				return true
+			},
+			1,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{},
+			},
+			struct {
+				Noodle struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating one diagnostic is good enough for this one.
+				return true
+			},
+			1,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{},
+			},
+			struct {
+				Noodle *struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				return gotI.(struct {
+					Noodle *struct{} `zcl:"noodle,block"`
+				}).Noodle != nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{{}},
+			},
+			struct {
+				Noodle *struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				return gotI.(struct {
+					Noodle *struct{} `zcl:"noodle,block"`
+				}).Noodle != nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{},
+			},
+			struct {
+				Noodle *struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				return gotI.(struct {
+					Noodle *struct{} `zcl:"noodle,block"`
+				}).Noodle == nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{{}, {}},
+			},
+			struct {
+				Noodle *struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating one diagnostic is good enough for this one.
+				return true
+			},
+			1,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{},
+			},
+			struct {
+				Noodle []struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				noodle := gotI.(struct {
+					Noodle []struct{} `zcl:"noodle,block"`
+				}).Noodle
+				return len(noodle) == 0
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{{}},
+			},
+			struct {
+				Noodle []struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				noodle := gotI.(struct {
+					Noodle []struct{} `zcl:"noodle,block"`
+				}).Noodle
+				return len(noodle) == 1
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": []map[string]interface{}{{}, {}},
+			},
+			struct {
+				Noodle []struct{} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				noodle := gotI.(struct {
+					Noodle []struct{} `zcl:"noodle,block"`
+				}).Noodle
+				return len(noodle) == 2
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{},
+			},
+			struct {
+				Noodle struct {
+					Name string `zcl:"name,label"`
+				} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// Generating two diagnostics is good enough for this one.
+				// (one for the missing noodle block and the other for
+				// the JSON serialization detecting the missing level of
+				// heirarchy for the label.)
+				return true
+			},
+			2,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{
+					"foo_foo": map[string]interface{}{},
+				},
+			},
+			struct {
+				Noodle struct {
+					Name string `zcl:"name,label"`
+				} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				noodle := gotI.(struct {
+					Noodle struct {
+						Name string `zcl:"name,label"`
+					} `zcl:"noodle,block"`
+				}).Noodle
+				return noodle.Name == "foo_foo"
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{
+					"foo_foo": map[string]interface{}{},
+					"bar_baz": map[string]interface{}{},
+				},
+			},
+			struct {
+				Noodle struct {
+					Name string `zcl:"name,label"`
+				} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				// One diagnostic is enough for this one.
+				return true
+			},
+			1,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{
+					"foo_foo": map[string]interface{}{},
+					"bar_baz": map[string]interface{}{},
+				},
+			},
+			struct {
+				Noodles []struct {
+					Name string `zcl:"name,label"`
+				} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				noodles := gotI.(struct {
+					Noodles []struct {
+						Name string `zcl:"name,label"`
+					} `zcl:"noodle,block"`
+				}).Noodles
+				return len(noodles) == 2 && (noodles[0].Name == "foo_foo" || noodles[0].Name == "bar_baz") && (noodles[1].Name == "foo_foo" || noodles[1].Name == "bar_baz") && noodles[0].Name != noodles[1].Name
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"noodle": map[string]interface{}{
+					"foo_foo": map[string]interface{}{
+						"type": "rice",
+					},
+				},
+			},
+			struct {
+				Noodle struct {
+					Name string `zcl:"name,label"`
+					Type string `zcl:"type"`
+				} `zcl:"noodle,block"`
+			}{},
+			func(gotI interface{}) bool {
+				noodle := gotI.(struct {
+					Noodle struct {
+						Name string `zcl:"name,label"`
+						Type string `zcl:"type"`
+					} `zcl:"noodle,block"`
+				}).Noodle
+				return noodle.Name == "foo_foo" && noodle.Type == "rice"
+			},
+			0,
+		},
+
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  34,
+			},
+			map[string]string(nil),
+			deepEquals(map[string]string{
+				"name": "Ermintrude",
+				"age":  "34",
+			}),
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  89,
+			},
+			map[string]*zcl.Attribute(nil),
+			func(gotI interface{}) bool {
+				got := gotI.(map[string]*zcl.Attribute)
+				return len(got) == 2 && got["name"] != nil && got["age"] != nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  13,
+			},
+			map[string]zcl.Expression(nil),
+			func(gotI interface{}) bool {
+				got := gotI.(map[string]zcl.Expression)
+				return len(got) == 2 && got["name"] != nil && got["age"] != nil
+			},
+			0,
+		},
+		{
+			map[string]interface{}{
+				"name": "Ermintrude",
+				"age":  13,
+			},
+			map[string]cty.Value(nil),
+			deepEquals(map[string]cty.Value{
+				"name": cty.StringVal("Ermintrude"),
+				"age":  cty.NumberIntVal(13),
+			}),
+			0,
+		},
+	}
+
+	for i, test := range tests {
+		// For convenience here we're going to use the JSON parser
+		// to process the given body.
+		buf, err := json.Marshal(test.Body)
+		if err != nil {
+			t.Fatalf("error JSON-encoding body for test %d: %s", i, err)
+		}
+
+		t.Run(string(buf), func(t *testing.T) {
+			file, diags := zclJSON.Parse(buf, "test.json")
+			if len(diags) != 0 {
+				t.Fatalf("diagnostics while parsing: %s", diags.Error())
+			}
+
+			targetVal := reflect.New(reflect.TypeOf(test.Target))
+
+			diags = DecodeBody(file.Body, nil, targetVal.Interface())
+			if len(diags) != test.DiagCount {
+				t.Errorf("wrong number of diagnostics %d; want %d", len(diags), test.DiagCount)
+				for _, diag := range diags {
+					t.Logf(" - %s", diag.Error())
+				}
+			}
+			got := targetVal.Elem().Interface()
+			if !test.Check(got) {
+				t.Errorf("wrong result\ngot:  %s", spew.Sdump(got))
+			}
+		})
+	}
+
+}
+
 func TestDecodeExpression(t *testing.T) {
 	tests := []struct {
 		Value     cty.Value

gozcl/types.go

@@ -0,0 +1,16 @@
+package gozcl
+
+import (
+	"reflect"
+
+	"github.com/apparentlymart/go-zcl/zcl"
+)
+
+var victimExpr zcl.Expression
+var victimBody zcl.Body
+
+var exprType = reflect.TypeOf(&victimExpr).Elem()
+var bodyType = reflect.TypeOf(&victimBody).Elem()
+var blockType = reflect.TypeOf((*zcl.Block)(nil))
+var attrType = reflect.TypeOf((*zcl.Attribute)(nil))
+var attrsType = reflect.TypeOf(zcl.Attributes(nil))