hcldec: BlockSetSpec and BlockMapSpec decode implementations

hcldec/public_test.go

@@ -245,6 +245,149 @@ b {}
 			cty.ListVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}),
 			1, // insufficient b blocks
 		},
+		{
+			`
+b {}
+b {}
+`,
+			&BlockSetSpec{
+				TypeName: "b",
+				Nested:   ObjectSpec{},
+				MaxItems: 2,
+			},
+			nil,
+			cty.SetVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}),
+			0,
+		},
+		{
+			`
+b "foo" {}
+b "bar" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapVal(map[string]cty.Value{"foo": cty.EmptyObjectVal, "bar": cty.EmptyObjectVal}),
+			0,
+		},
+		{
+			`
+b "foo" "bar" {}
+b "bar" "baz" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key1", "key2"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapVal(map[string]cty.Value{
+				"foo": cty.MapVal(map[string]cty.Value{
+					"bar": cty.EmptyObjectVal,
+				}),
+				"bar": cty.MapVal(map[string]cty.Value{
+					"baz": cty.EmptyObjectVal,
+				}),
+			}),
+			0,
+		},
+		{
+			`
+b "foo" "bar" {}
+b "bar" "bar" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key1", "key2"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapVal(map[string]cty.Value{
+				"foo": cty.MapVal(map[string]cty.Value{
+					"bar": cty.EmptyObjectVal,
+				}),
+				"bar": cty.MapVal(map[string]cty.Value{
+					"bar": cty.EmptyObjectVal,
+				}),
+			}),
+			0,
+		},
+		{
+			`
+b "foo" "bar" {}
+b "foo" "baz" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key1", "key2"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapVal(map[string]cty.Value{
+				"foo": cty.MapVal(map[string]cty.Value{
+					"bar": cty.EmptyObjectVal,
+					"baz": cty.EmptyObjectVal,
+				}),
+			}),
+			0,
+		},
+		{
+			`
+b "foo" "bar" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapValEmpty(cty.DynamicPseudoType),
+			1, // too many labels
+		},
+		{
+			`
+b "bar" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key1", "key2"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapValEmpty(cty.DynamicPseudoType),
+			1, // not enough labels
+		},
+		{
+			`
+b "foo" {}
+b "foo" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapVal(map[string]cty.Value{"foo": cty.EmptyObjectVal}),
+			1, // duplicate b block
+		},
+		{
+			`
+b "foo" "bar" {}
+b "foo" "bar" {}
+`,
+			&BlockMapSpec{
+				TypeName:   "b",
+				LabelNames: []string{"key1", "key2"},
+				Nested:     ObjectSpec{},
+			},
+			nil,
+			cty.MapVal(map[string]cty.Value{"foo": cty.MapVal(map[string]cty.Value{"bar": cty.EmptyObjectVal})}),
+			1, // duplicate b block
+		},
 	}
 
 	for i, test := range tests {

hcldec/spec.go

@@ -1,6 +1,7 @@
 package hcldec
 
 import (
+	"bytes"
 	"fmt"
 
 	"github.com/hashicorp/hcl2/hcl"
@@ -391,7 +392,7 @@ func (s *BlockListSpec) decode(content *hcl.BodyContent, block *hcl.Block, ctx *
 	var diags hcl.Diagnostics
 
 	if s.Nested == nil {
-		panic("BlockSpec with no Nested Spec")
+		panic("BlockListSpec with no Nested Spec")
 	}
 
 	var elems []cty.Value
@@ -470,8 +471,77 @@ func (s *BlockSetSpec) visitSameBodyChildren(cb visitFunc) {
 	// leaf node ("Nested" does not use the same body)
 }
 
+// blockSpec implementation
+func (s *BlockSetSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type: s.TypeName,
+		},
+	}
+}
+
+// specNeedingVariables implementation
+func (s *BlockSetSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
 func (s *BlockSetSpec) decode(content *hcl.BodyContent, block *hcl.Block, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
-	panic("BlockSetSpec.decode not yet implemented")
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockSetSpec with no Nested Spec")
+	}
+
+	var elems []cty.Value
+	var sourceRanges []hcl.Range
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, childBlock, ctx, s.Nested, false)
+		diags = append(diags, childDiags...)
+		elems = append(elems, val)
+		sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, childBlock, s.Nested))
+	}
+
+	if len(elems) < s.MinItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Insufficient %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName),
+			Subject:  &content.MissingItemRange,
+		})
+	} else if s.MaxItems > 0 && len(elems) > s.MaxItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Too many %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName),
+			Subject:  &sourceRanges[s.MaxItems],
+		})
+	}
+
+	var ret cty.Value
+
+	if len(elems) == 0 {
+		// FIXME: We don't currently have enough info to construct a type for
+		// an empty list, so we'll just stub it out.
+		ret = cty.SetValEmpty(cty.DynamicPseudoType)
+	} else {
+		ret = cty.SetVal(elems)
+	}
+
+	return ret, diags
 }
 
 func (s *BlockSetSpec) sourceRange(content *hcl.BodyContent, block *hcl.Block) hcl.Range {
@@ -510,8 +580,97 @@ func (s *BlockMapSpec) visitSameBodyChildren(cb visitFunc) {
 	// leaf node ("Nested" does not use the same body)
 }
 
+// blockSpec implementation
+func (s *BlockMapSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: s.LabelNames,
+		},
+	}
+}
+
+// specNeedingVariables implementation
+func (s *BlockMapSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
 func (s *BlockMapSpec) decode(content *hcl.BodyContent, block *hcl.Block, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
-	panic("BlockMapSpec.decode not yet implemented")
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockSetSpec with no Nested Spec")
+	}
+
+	elems := map[string]interface{}{}
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, childBlock, ctx, s.Nested, false)
+		targetMap := elems
+		for _, key := range childBlock.Labels[:len(childBlock.LabelRanges)-1] {
+			if _, exists := targetMap[key]; !exists {
+				targetMap[key] = make(map[string]interface{})
+			}
+			targetMap = targetMap[key].(map[string]interface{})
+		}
+
+		diags = append(diags, childDiags...)
+
+		key := childBlock.Labels[len(childBlock.Labels)-1]
+		if _, exists := targetMap[key]; exists {
+			labelsBuf := bytes.Buffer{}
+			for _, label := range childBlock.Labels {
+				fmt.Fprintf(&labelsBuf, " %q", label)
+			}
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block for %s%s was already defined. The %s labels must be unique.",
+					s.TypeName, labelsBuf.String(), s.TypeName,
+				),
+				Subject: &childBlock.DefRange,
+			})
+			continue
+		}
+
+		targetMap[key] = val
+	}
+
+	var ctyMap func(map[string]interface{}, int) cty.Value
+	ctyMap = func(raw map[string]interface{}, depth int) cty.Value {
+		if len(raw) == 0 {
+			// FIXME: We don't currently have enough info to construct a type for
+			// an empty map, so we'll just stub it out.
+			return cty.MapValEmpty(cty.DynamicPseudoType)
+		}
+		vals := make(map[string]cty.Value, len(raw))
+		if depth == 1 {
+			for k, v := range raw {
+				vals[k] = v.(cty.Value)
+			}
+		} else {
+			for k, v := range raw {
+				vals[k] = ctyMap(v.(map[string]interface{}), depth-1)
+			}
+		}
+		return cty.MapVal(vals)
+	}
+
+	return ctyMap(elems, len(s.LabelNames)), diags
 }
 
 func (s *BlockMapSpec) sourceRange(content *hcl.BodyContent, block *hcl.Block) hcl.Range {