sequence

Makefile

@@ -28,10 +28,11 @@ test-coverage:
 	go test -short -timeout 300s -covermode=count -coverprofile=command.coverage ./command
 	go test -short -timeout 300s -covermode=count -coverprofile=config.coverage ./config
 	go test -short -timeout 300s -covermode=count -coverprofile=docs.coverage ./docs
-	# go test -short -timeout 300s -covermode=count -coverprofile=errors.coverage ./errors
+	go test -short -timeout 300s -covermode=count -coverprofile=errors.coverage ./errors
 	go test -short -timeout 300s -covermode=count -coverprofile=eval.coverage ./eval
 	go test -short -timeout 300s -covermode=count -coverprofile=handler.coverage ./handler
-	# go test -short -timeout 300s -covermode=count -coverprofile=logging.coverage ./logging
+	go test -short -timeout 300s -covermode=count -coverprofile=producer.coverage ./handler/producer
+	go test -short -timeout 300s -covermode=count -coverprofile=logging.coverage ./logging
 	go test -short -timeout 300s -covermode=count -coverprofile=server.coverage ./server
 	go test -short -timeout 300s -covermode=count -coverprofile=main.coverage ./
 
@@ -41,9 +42,10 @@ test-coverage-show:
 	go tool cover -html=command.coverage
 	go tool cover -html=config.coverage
 	go tool cover -html=docs.coverage
-	# go tool cover -html=errors.coverage
+	go tool cover -html=errors.coverage
 	go tool cover -html=eval.coverage
 	go tool cover -html=handler.coverage
-	# go tool cover -html=logging.coverage
+	go tool cover -html=producer.coverage
+	go tool cover -html=logging.coverage
 	go tool cover -html=server.coverage
 	go tool cover -html=main.coverage

config/body/collect.go

@@ -0,0 +1,102 @@
+package body
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+func CollectAttributes(bodies ...hcl.Body) []*hcl.Attribute {
+	allAttributes := make([]*hcl.Attribute, 0)
+
+	for _, b := range bodies {
+		switch sb := b.(type) {
+		case *hclsyntax.Body:
+			for _, attr := range sb.Attributes {
+				allAttributes = append(allAttributes, &hcl.Attribute{
+					Name:      attr.Name,
+					Expr:      attr.Expr,
+					Range:     attr.SrcRange,
+					NameRange: attr.NameRange,
+				})
+			}
+
+			for _, block := range sb.Blocks {
+				allAttributes = append(allAttributes, CollectAttributes(block.Body)...)
+			}
+		case *Body:
+			content, _, _ := sb.PartialContent(nil)
+			for _, attr := range content.Attributes {
+				allAttributes = append(allAttributes, attr)
+			}
+			for _, block := range content.Blocks {
+				allAttributes = append(allAttributes, CollectAttributes(block.Body)...)
+			}
+		case MergedBodies:
+			// top-level attrs
+			for _, attrs := range sb.JustAllAttributes() {
+				for _, attr := range attrs {
+					allAttributes = append(allAttributes, attr)
+				}
+			}
+
+			// nested block attrs
+			for _, mb := range sb {
+				allAttributes = append(allAttributes, CollectAttributes(mb)...)
+			}
+		}
+	}
+
+	return allAttributes
+}
+
+func CollectBlockTypes(bodies ...hcl.Body) []string {
+	unique := make(map[string]struct{})
+
+	addUniqueFn := func(types ...string) {
+		for _, t := range types {
+			if _, exist := unique[t]; exist {
+				continue
+			}
+			unique[t] = struct{}{}
+		}
+	}
+
+	for _, b := range bodies {
+		switch sb := b.(type) {
+		case *hclsyntax.Body:
+
+			for _, block := range sb.Blocks {
+				nested := append(append([]string{}, block.Type), CollectBlockTypes(block.Body)...)
+				addUniqueFn(nested...)
+			}
+		case *Body:
+			content, _, _ := sb.PartialContent(nil)
+			for _, block := range content.Blocks {
+				nested := append(append([]string{}, block.Type), CollectBlockTypes(block.Body)...)
+				addUniqueFn(nested...)
+			}
+		case MergedBodies:
+			// nested block
+			for _, mb := range sb {
+				nested := append([]string{}, CollectBlockTypes(mb)...)
+				addUniqueFn(nested...)
+			}
+		}
+	}
+
+	var result []string
+	for u := range unique {
+		result = append(result, u)
+	}
+
+	return result
+}
+
+func CollectExpressions(bodies ...hcl.Body) []hcl.Expression {
+	allExpressions := make([]hcl.Expression, 0)
+	for _, attr := range CollectAttributes(bodies...) {
+		allExpressions = append(allExpressions, attr.Expr)
+	}
+
+	return allExpressions
+}

config/configload/merged.go → config/body/merged.go

@@ -1,12 +1,11 @@
 // File based on "github.com/hashicorp/hcl/v2/merged.go" except diagnostic errors for duplicates
 // since we explicitly want them and apply an override.
 
-package configload
+package body
 
 import (
 	"fmt"
 
-	hclbody "github.com/avenga/couper/config/body"
 	"github.com/hashicorp/hcl/v2"
 )
 
@@ -15,30 +14,30 @@ var reportDuplicates = false
 
 // MergeBodies is like MergeFiles except it deals directly with bodies, rather
 // than with entire files.
-func MergeBodies(bodies []hcl.Body) hcl.Body {
+func MergeBodies(bodies ...hcl.Body) hcl.Body {
 	if len(bodies) == 0 {
 		// Swap out for our singleton empty body, to reduce the number of
 		// empty slices we have hanging around.
 		return EmptyBody()
 	}
 
 	// If any of the given bodies are already merged bodies, we'll unpack
-	// to flatten to a single mergedBodies, since that's conceptually simpler.
+	// to flatten to a single MergedBodies, since that's conceptually simpler.
 	// This also, as a side-effect, eliminates any empty bodies, since
 	// empties are merged bodies with no inner bodies.
 	var newLen int
 	var flatten bool
 	for _, body := range bodies {
-		if children, merged := body.(mergedBodies); merged {
+		if children, merged := body.(MergedBodies); merged {
 			newLen += len(children)
 			flatten = true
 		} else {
 			newLen++
 		}
 	}
 
-	if !flatten { // not just newLen == len, because we might have mergedBodies with single bodies inside
-		return mergedBodies(bodies)
+	if !flatten { // not just newLen == len, because we might have MergedBodies with single bodies inside
+		return MergedBodies(bodies)
 	}
 
 	if newLen == 0 {
@@ -48,24 +47,24 @@ func MergeBodies(bodies []hcl.Body) hcl.Body {
 
 	newBodies := make([]hcl.Body, 0, newLen)
 	for _, body := range bodies {
-		if children, merged := body.(mergedBodies); merged {
+		if children, merged := body.(MergedBodies); merged {
 			newBodies = append(newBodies, children...)
 		} else {
 			newBodies = append(newBodies, body)
 		}
 	}
-	return mergedBodies(newBodies)
+	return MergedBodies(newBodies)
 }
 
-var emptyBody = mergedBodies([]hcl.Body{})
+var emptyBody = MergedBodies([]hcl.Body{})
 
 // EmptyBody returns a body with no content. This body can be used as a
 // placeholder when a body is required but no body content is available.
 func EmptyBody() hcl.Body {
 	return emptyBody
 }
 
-type mergedBodies []hcl.Body
+type MergedBodies []hcl.Body
 
 // Content returns the content produced by applying the given schema to all
 // of the merged bodies and merging the result.
@@ -75,18 +74,18 @@ type mergedBodies []hcl.Body
 // with which to return good diagnostics. Applications working with merged
 // bodies may wish to mark all attributes as optional and then check for
 // required attributes afterwards, to produce better diagnostics.
-func (mb mergedBodies) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+func (mb MergedBodies) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
 	// the returned body will always be empty in this case, because mergedContent
 	// will only ever call Content on the child bodies.
 	content, _, diags := mb.mergedContent(schema, false)
 	return content, diags
 }
 
-func (mb mergedBodies) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+func (mb MergedBodies) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
 	return mb.mergedContent(schema, true)
 }
 
-func (mb mergedBodies) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+func (mb MergedBodies) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
 	attrs := make(map[string]*hcl.Attribute)
 	var diags hcl.Diagnostics
 
@@ -106,7 +105,7 @@ func (mb mergedBodies) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
 }
 
 // MissingItemRange returns the first non-empty range if any.
-func (mb mergedBodies) MissingItemRange() hcl.Range {
+func (mb MergedBodies) MissingItemRange() hcl.Range {
 	if len(mb) == 0 {
 		// Nothing useful to return here, so we'll return some garbage.
 		return hcl.Range{
@@ -124,7 +123,7 @@ func (mb mergedBodies) MissingItemRange() hcl.Range {
 	return mb[0].MissingItemRange()
 }
 
-func (mb mergedBodies) mergedContent(schema *hcl.BodySchema, partial bool) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+func (mb MergedBodies) mergedContent(schema *hcl.BodySchema, partial bool) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
 	// We need to produce a new schema with none of the attributes marked as
 	// required, since _any one_ of our bodies can contribute an attribute value.
 	// We'll separately check that all required attributes are present at
@@ -199,13 +198,12 @@ func (mb mergedBodies) mergedContent(schema *hcl.BodySchema, partial bool) (*hcl
 
 				diags = append(diags, mergeAttributes(contentAttrs, thisContentAttrs)...)
 
-				content.Blocks[idx].Body = MergeBodies([]hcl.Body{
+				content.Blocks[idx].Body = MergeBodies(
 					thisContentBlock.Body, // keep child blocks
-					hclbody.New(&hcl.BodyContent{
+					New(&hcl.BodyContent{
 						Attributes:       contentAttrs,
-						MissingItemRange: content.Blocks[idx].DefRange,
-					}),
-				})
+						MissingItemRange: content.Blocks[idx].DefRange}),
+				)
 			}
 		}
 	}
@@ -237,18 +235,18 @@ func (mb mergedBodies) mergedContent(schema *hcl.BodySchema, partial bool) (*hcl
 		}
 	}
 
-	leftoverBody := MergeBodies(mergedLeftovers)
+	leftoverBody := MergeBodies(mergedLeftovers...)
 	return content, leftoverBody, diags
 }
 
 // JustAllAttributes returns a list of attributes in order. Since these bodies got added as partialContent
 // we do not have to supply a scheme or handle the underlying diagnostics.
-func (mb mergedBodies) JustAllAttributes() []hcl.Attributes {
+func (mb MergedBodies) JustAllAttributes() []hcl.Attributes {
 	return mb.JustAllAttributesWithName("")
 }
 
 // JustAllAttributesWithName behaviour is the same as JustAllAttributes with a filtered slice.
-func (mb mergedBodies) JustAllAttributesWithName(name string) []hcl.Attributes {
+func (mb MergedBodies) JustAllAttributesWithName(name string) []hcl.Attributes {
 	var result []hcl.Attributes
 
 	for _, body := range mb {

config/configload/merged_test.go → config/body/merged_test.go

@@ -1,4 +1,4 @@
-package configload_test
+package body_test
 
 import (
 	"testing"
@@ -10,7 +10,7 @@ import (
 	"github.com/zclconf/go-cty/cty"
 
 	"github.com/avenga/couper/config"
-	"github.com/avenga/couper/config/configload"
+	"github.com/avenga/couper/config/body"
 	"github.com/avenga/couper/eval"
 )
 
@@ -83,7 +83,7 @@ block {
 	}
 
 	schema, _ = gohcl.ImpliedBodySchema(bodies.Block[0])
-	content, _, diags = configload.MergeBodies(hclBodies[:]).PartialContent(schema)
+	content, _, diags = body.MergeBodies(hclBodies[:]...).PartialContent(schema)
 	if diags.HasErrors() {
 		t.Error(diags)
 	}