4 files changed, 543 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/decode.go b/vendor/github.com/hashicorp/hcl2/gohcl/decode.go
new file mode 100644
index 0000000..3a149a8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/decode.go
@@ -0,0 +1,304 @@
+package gohcl
+
+import (
+        "fmt"
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+// DecodeBody extracts the configuration within the given body into the given
+// value. This value must be a non-nil pointer to either a struct or
+// a map, where in the former case the configuration will be decoded using
+// struct tags and in the latter case only attributes are allowed and their
+// values are decoded into the map.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeBody(body hcl.Body, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+        rv := reflect.ValueOf(val)
+        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 hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.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 hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+        schema, partial := ImpliedBodySchema(val.Interface())
+
+        var content *hcl.BodyContent
+        var leftovers hcl.Body
+        var diags hcl.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, fieldIdx := range tags.Attributes {
+                attr := content.Attributes[name]
+                field := val.Type().Field(fieldIdx)
+                fieldV := val.Field(fieldIdx)
+
+                if attr == nil {
+                        if !exprType.AssignableTo(field.Type) {
+                                continue
+                        }
+
+                        // As a special case, if the target is of type hcl.Expression then
+                        // we'll assign an actual expression that evalues to a cty null,
+                        // so the caller can deal with it within the cty realm rather
+                        // than within the Go realm.
+                        synthExpr := hcl.StaticExpr(cty.NullVal(cty.DynamicPseudoType), body.MissingItemRange())
+                        fieldV.Set(reflect.ValueOf(synthExpr))
+                        continue
+                }
+
+                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, &hcl.Diagnostic{
+                                Severity: hcl.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, &hcl.Diagnostic{
+                                        Severity: hcl.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 hcl.Body, ctx *hcl.EvalContext, v reflect.Value) hcl.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 *hcl.Block, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+        var diags hcl.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
+// value. This value must be something that gocty is able to decode into,
+// since the final decoding is delegated to that package.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeExpression(expr hcl.Expression, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+        srcVal, diags := expr.Value(ctx)
+
+        convTy, err := gocty.ImpliedType(val)
+        if err != nil {
+                panic(fmt.Sprintf("unsuitable DecodeExpression target: %s", err))
+        }
+
+        srcVal, err = convert.Convert(srcVal, convTy)
+        if err != nil {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Unsuitable value type",
+                        Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+                        Subject:  expr.StartRange().Ptr(),
+                        Context:  expr.Range().Ptr(),
+                })
+                return diags
+        }
+
+        err = gocty.FromCtyValue(srcVal, val)
+        if err != nil {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Unsuitable value type",
+                        Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+                        Subject:  expr.StartRange().Ptr(),
+                        Context:  expr.Range().Ptr(),
+                })
+        }
+
+        return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/doc.go b/vendor/github.com/hashicorp/hcl2/gohcl/doc.go
new file mode 100644
index 0000000..8500214
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/doc.go
@@ -0,0 +1,49 @@
+// Package gohcl allows decoding HCL configurations into Go data structures.
+//
+// It provides a convenient and concise way of describing the schema for
+// configuration and then accessing the resulting data via native Go
+// types.
+//
+// A struct field tag scheme is used, similar to other decoding and
+// unmarshalling libraries. The tags are formatted as in the following example:
+//
+//    ThingType string `hcl:"thing_type,attr"`
+//
+// Within each tag there are two comma-separated tokens. The first is the
+// name of the corresponding construct in configuration, while the second
+// is a keyword giving the kind of construct expected. The following
+// kind keywords are supported:
+//
+//    attr (the default) indicates that the value is to be populated from an attribute
+//    block indicates that the value is to populated from a block
+//    label indicates that the value is to populated from a block label
+//    remain indicates that the value is to be populated from the remaining body after populating other fields
+//
+// "attr" fields may either be of type *hcl.Expression, in which case the raw
+// expression is assigned, or of any type accepted by gocty, in which case
+// gocty will be used to assign the value to a native Go type.
+//
+// "block" fields may be of type *hcl.Block or hcl.Body, in which case the
+// corresponding raw value is assigned, or may be a struct that recursively
+// uses the same tags. Block fields may also be slices of any of these types,
+// in which case multiple blocks of the corresponding type are decoded into
+// the slice.
+//
+// "label" fields are considered only in a struct used as the type of a field
+// marked as "block", and are used sequentially to capture the labels of
+// the blocks being decoded. In this case, the name token is used only as
+// an identifier for the label in diagnostic messages.
+//
+// "remain" can be placed on a single field that may be either of type
+// hcl.Body or hcl.Attributes, in which case any remaining body content is
+// placed into this field for delayed processing. If no "remain" field is
+// present then any attributes or blocks not matched by another valid tag
+// will cause an error diagnostic.
+//
+// Broadly-speaking this package deals with two types of error. The first is
+// errors in the configuration itself, which are returned as diagnostics
+// written with the configuration author as the target audience. The second
+// is bugs in the calling program, such as invalid struct tags, which are
+// surfaced via panics since there can be no useful runtime handling of such
+// errors and they should certainly not be returned to the user as diagnostics.
+package gohcl
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/schema.go b/vendor/github.com/hashicorp/hcl2/gohcl/schema.go
new file mode 100644
index 0000000..88164cb
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/schema.go
@@ -0,0 +1,174 @@
+package gohcl
+
+import (
+        "fmt"
+        "reflect"
+        "sort"
+        "strings"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// ImpliedBodySchema produces a hcl.BodySchema derived from the type of the
+// given value, which must be a struct value or a pointer to one. If an
+// inappropriate value is passed, this function will panic.
+//
+// The second return argument indicates whether the given struct includes
+// a "remain" field, and thus the returned schema is non-exhaustive.
+//
+// This uses the tags on the fields of the struct to discover how each
+// field's value should be expressed within configuration. If an invalid
+// mapping is attempted, this function will panic.
+func ImpliedBodySchema(val interface{}) (schema *hcl.BodySchema, partial bool) {
+        ty := reflect.TypeOf(val)
+
+        if ty.Kind() == reflect.Ptr {
+                ty = ty.Elem()
+        }
+
+        if ty.Kind() != reflect.Struct {
+                panic(fmt.Sprintf("given value must be struct, not %T", val))
+        }
+
+        var attrSchemas []hcl.AttributeSchema
+        var blockSchemas []hcl.BlockHeaderSchema
+
+        tags := getFieldTags(ty)
+
+        attrNames := make([]string, 0, len(tags.Attributes))
+        for n := range tags.Attributes {
+                attrNames = append(attrNames, n)
+        }
+        sort.Strings(attrNames)
+        for _, n := range attrNames {
+                idx := tags.Attributes[n]
+                optional := tags.Optional[n]
+                field := ty.Field(idx)
+
+                var required bool
+
+                switch {
+                case field.Type.AssignableTo(exprType):
+                        // If we're decoding to hcl.Expression then absense can be
+                        // indicated via a null value, so we don't specify that
+                        // the field is required during decoding.
+                        required = false
+                case field.Type.Kind() != reflect.Ptr && !optional:
+                        required = true
+                default:
+                        required = false
+                }
+
+                attrSchemas = append(attrSchemas, hcl.AttributeSchema{
+                        Name:     n,
+                        Required: required,
+                })
+        }
+
+        blockNames := make([]string, 0, len(tags.Blocks))
+        for n := range tags.Blocks {
+                blockNames = append(blockNames, n)
+        }
+        sort.Strings(blockNames)
+        for _, n := range blockNames {
+                idx := tags.Blocks[n]
+                field := ty.Field(idx)
+                fty := field.Type
+                if fty.Kind() == reflect.Slice {
+                        fty = fty.Elem()
+                }
+                if fty.Kind() == reflect.Ptr {
+                        fty = fty.Elem()
+                }
+                if fty.Kind() != reflect.Struct {
+                        panic(fmt.Sprintf(
+                                "hcl 'block' tag kind cannot be applied to %s field %s: struct required", field.Type.String(), field.Name,
+                        ))
+                }
+                ftags := getFieldTags(fty)
+                var labelNames []string
+                if len(ftags.Labels) > 0 {
+                        labelNames = make([]string, len(ftags.Labels))
+                        for i, l := range ftags.Labels {
+                                labelNames[i] = l.Name
+                        }
+                }
+
+                blockSchemas = append(blockSchemas, hcl.BlockHeaderSchema{
+                        Type:       n,
+                        LabelNames: labelNames,
+                })
+        }
+
+        partial = tags.Remain != nil
+        schema = &hcl.BodySchema{
+                Attributes: attrSchemas,
+                Blocks:     blockSchemas,
+        }
+        return schema, partial
+}
+
+type fieldTags struct {
+        Attributes map[string]int
+        Blocks     map[string]int
+        Labels     []labelField
+        Remain     *int
+        Optional   map[string]bool
+}
+
+type labelField struct {
+        FieldIndex int
+        Name       string
+}
+
+func getFieldTags(ty reflect.Type) *fieldTags {
+        ret := &fieldTags{
+                Attributes: map[string]int{},
+                Blocks:     map[string]int{},
+                Optional:   map[string]bool{},
+        }
+
+        ct := ty.NumField()
+        for i := 0; i < ct; i++ {
+                field := ty.Field(i)
+                tag := field.Tag.Get("hcl")
+                if tag == "" {
+                        continue
+                }
+
+                comma := strings.Index(tag, ",")
+                var name, kind string
+                if comma != -1 {
+                        name = tag[:comma]
+                        kind = tag[comma+1:]
+                } else {
+                        name = tag
+                        kind = "attr"
+                }
+
+                switch kind {
+                case "attr":
+                        ret.Attributes[name] = i
+                case "block":
+                        ret.Blocks[name] = i
+                case "label":
+                        ret.Labels = append(ret.Labels, labelField{
+                                FieldIndex: i,
+                                Name:       name,
+                        })
+                case "remain":
+                        if ret.Remain != nil {
+                                panic("only one 'remain' tag is permitted")
+                        }
+                        idx := i // copy, because this loop will continue assigning to i
+                        ret.Remain = &idx
+                case "optional":
+                        ret.Attributes[name] = i
+                        ret.Optional[name] = true
+                default:
+                        panic(fmt.Sprintf("invalid hcl field tag kind %q on %s %q", kind, field.Type.String(), field.Name))
+                }
+        }
+
+        return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/types.go b/vendor/github.com/hashicorp/hcl2/gohcl/types.go
new file mode 100644
index 0000000..a94f275
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/types.go
@@ -0,0 +1,16 @@
+package gohcl
+
+import (
+        "reflect"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+var victimExpr hcl.Expression
+var victimBody hcl.Body
+
+var exprType = reflect.TypeOf(&victimExpr).Elem()
+var bodyType = reflect.TypeOf(&victimBody).Elem()
+var blockType = reflect.TypeOf((*hcl.Block)(nil))
+var attrType = reflect.TypeOf((*hcl.Attribute)(nil))
+var attrsType = reflect.TypeOf(hcl.Attributes(nil))