mirror of
https://github.com/opentffoundation/opentf.git
synced 2025-12-19 17:59:05 -05:00
cdd9464f9a
This is part of a general effort to move all of Terraform's non-library package surface under internal in order to reinforce that these are for internal use within Terraform only. If you were previously importing packages under this prefix into an external codebase, you could pin to an earlier release tag as an interim solution until you've make a plan to achieve the same functionality some other way.
120 lines
4.2 KiB
Go
120 lines
4.2 KiB
Go
package jsonconfig
|
|
|
|
import (
|
|
"encoding/json"
|
|
|
|
"github.com/hashicorp/hcl/v2"
|
|
"github.com/hashicorp/hcl/v2/hcldec"
|
|
"github.com/hashicorp/terraform/internal/configs/configschema"
|
|
"github.com/hashicorp/terraform/internal/lang"
|
|
"github.com/zclconf/go-cty/cty"
|
|
ctyjson "github.com/zclconf/go-cty/cty/json"
|
|
)
|
|
|
|
// expression represents any unparsed expression
|
|
type expression struct {
|
|
// "constant_value" is set only if the expression contains no references to
|
|
// other objects, in which case it gives the resulting constant value. This
|
|
// is mapped as for the individual values in the common value
|
|
// representation.
|
|
ConstantValue json.RawMessage `json:"constant_value,omitempty"`
|
|
|
|
// Alternatively, "references" will be set to a list of references in the
|
|
// expression. Multi-step references will be unwrapped and duplicated for
|
|
// each significant traversal step, allowing callers to more easily
|
|
// recognize the objects they care about without attempting to parse the
|
|
// expressions. Callers should only use string equality checks here, since
|
|
// the syntax may be extended in future releases.
|
|
References []string `json:"references,omitempty"`
|
|
}
|
|
|
|
func marshalExpression(ex hcl.Expression) expression {
|
|
var ret expression
|
|
if ex != nil {
|
|
val, _ := ex.Value(nil)
|
|
if val != cty.NilVal {
|
|
valJSON, _ := ctyjson.Marshal(val, val.Type())
|
|
ret.ConstantValue = valJSON
|
|
}
|
|
vars, _ := lang.ReferencesInExpr(ex)
|
|
var varString []string
|
|
if len(vars) > 0 {
|
|
for _, v := range vars {
|
|
varString = append(varString, v.Subject.String())
|
|
}
|
|
ret.References = varString
|
|
}
|
|
return ret
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (e *expression) Empty() bool {
|
|
return e.ConstantValue == nil && e.References == nil
|
|
}
|
|
|
|
// expressions is used to represent the entire content of a block. Attribute
|
|
// arguments are mapped directly with the attribute name as key and an
|
|
// expression as value.
|
|
type expressions map[string]interface{}
|
|
|
|
func marshalExpressions(body hcl.Body, schema *configschema.Block) expressions {
|
|
// Since we want the raw, un-evaluated expressions we need to use the
|
|
// low-level HCL API here, rather than the hcldec decoder API. That means we
|
|
// need the low-level schema.
|
|
lowSchema := hcldec.ImpliedSchema(schema.DecoderSpec())
|
|
// (lowSchema is an hcl.BodySchema:
|
|
// https://godoc.org/github.com/hashicorp/hcl/v2/hcl#BodySchema )
|
|
|
|
// Use the low-level schema with the body to decode one level We'll just
|
|
// ignore any additional content that's not covered by the schema, which
|
|
// will effectively ignore "dynamic" blocks, and may also ignore other
|
|
// unknown stuff but anything else would get flagged by Terraform as an
|
|
// error anyway, and so we wouldn't end up in here.
|
|
content, _, _ := body.PartialContent(lowSchema)
|
|
if content == nil {
|
|
// Should never happen for a valid body, but we'll just generate empty
|
|
// if there were any problems.
|
|
return nil
|
|
}
|
|
|
|
ret := make(expressions)
|
|
|
|
// Any attributes we encode directly as expression objects.
|
|
for name, attr := range content.Attributes {
|
|
ret[name] = marshalExpression(attr.Expr) // note: singular expression for this one
|
|
}
|
|
|
|
// Any nested blocks require a recursive call to produce nested expressions
|
|
// objects.
|
|
for _, block := range content.Blocks {
|
|
typeName := block.Type
|
|
blockS, exists := schema.BlockTypes[typeName]
|
|
if !exists {
|
|
// Should never happen since only block types in the schema would be
|
|
// put in blocks list
|
|
continue
|
|
}
|
|
|
|
switch blockS.Nesting {
|
|
case configschema.NestingSingle, configschema.NestingGroup:
|
|
ret[typeName] = marshalExpressions(block.Body, &blockS.Block)
|
|
case configschema.NestingList, configschema.NestingSet:
|
|
if _, exists := ret[typeName]; !exists {
|
|
ret[typeName] = make([]map[string]interface{}, 0, 1)
|
|
}
|
|
ret[typeName] = append(ret[typeName].([]map[string]interface{}), marshalExpressions(block.Body, &blockS.Block))
|
|
case configschema.NestingMap:
|
|
if _, exists := ret[typeName]; !exists {
|
|
ret[typeName] = make(map[string]map[string]interface{})
|
|
}
|
|
// NestingMap blocks always have the key in the first (and only) label
|
|
key := block.Labels[0]
|
|
retMap := ret[typeName].(map[string]map[string]interface{})
|
|
retMap[key] = marshalExpressions(block.Body, &blockS.Block)
|
|
}
|
|
}
|
|
|
|
return ret
|
|
}
|