functions

Documentation

Index

• Variables
• func ExtractUserFunctions(bodies []hcl.Body, evalCtx *hcl.EvalContext) (map[string]function.Function, []hcl.Body, hcl.Diagnostics)
• func GetLogFunctions(logger *zap.Logger) map[string]function.Function
• func GetStandardLibraryFunctions() map[string]function.Function

Variables

var DiffFunc = function.New(&function.Spec{
	Params: []function.Parameter{
		{Name: "a", Type: cty.DynamicPseudoType},
		{Name: "b", Type: cty.DynamicPseudoType},
	},
	Type: function.StaticReturnType(cty.DynamicPseudoType),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
		a, err := go2cty2go.CtyToAny(args[0])
		if err != nil {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("unable to convert first argument: %s", err)
		}
		b, err := go2cty2go.CtyToAny(args[1])
		if err != nil {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("unable to convert second argument: %s", err)
		}

		diff, err := structdiff.Diff(a, b)
		if err != nil {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("unable to diff values: %s", err)
		}

		return go2cty2go.AnyToCty(diff)
	},
})

var ErrorFunc = function.New(&function.Spec{
	Description: "Returns an error with the given message",
	Params: []function.Parameter{
		{Name: "message", Type: cty.String},
	},
	Type: function.StaticReturnType(cty.String),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
		return args[0], errors.New(args[0].AsString())
	},
})

var PatchFunc = function.New(&function.Spec{
	Params: []function.Parameter{
		{Name: "target", Type: cty.DynamicPseudoType},
		{Name: "patch", Type: cty.DynamicPseudoType},
	},
	Type: function.StaticReturnType(cty.DynamicPseudoType),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
		target, err := go2cty2go.CtyToAny(args[0])
		if err != nil {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("unable to convert target argument: %s", err)
		}
		patch, err := go2cty2go.CtyToAny(args[1])
		if err != nil {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("unable to convert patch argument: %s", err)
		}

		patchMap, ok := patch.(map[string]any)
		if !ok {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("patch must be a map")
		}

		targetMap, ok := target.(map[string]any)
		if !ok {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("target must be a map")
		}

		err = structdiff.Apply(&targetMap, patchMap)
		if err != nil {
			return cty.UnknownVal(cty.NilType), fmt.Errorf("unable to apply patch: %s", err)
		}

		return go2cty2go.AnyToCty(targetMap)
	},
})

var TypeOfFunc = function.New(&function.Spec{
	Params: []function.Parameter{
		{Name: "value", Type: cty.DynamicPseudoType},
	},
	Type: function.StaticReturnType(cty.String),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
		return cty.StringVal(args[0].Type().FriendlyName()), nil
	},
})

TypeOfFunc returns the friendly name of the type of a given value

Functions

func ExtractUserFunctions

func ExtractUserFunctions(bodies []hcl.Body, evalCtx *hcl.EvalContext) (map[string]function.Function, []hcl.Body, hcl.Diagnostics)

ExtractUserFunctions extracts user-defined functions from HCL bodies

func GetLogFunctions

func GetLogFunctions(logger *zap.Logger) map[string]function.Function

GetLogFunctions returns HCL functions for logging with zap logger

func GetStandardLibraryFunctions

func GetStandardLibraryFunctions() map[string]function.Function

GetStandardLibraryFunctions returns a map of all cty standard library functions suitable for providing to an HCL evaluation context.