parser

type BlockDefinition ¶

type BlockDefinition interface {

	// Spec must return a hcldec.Spec instance. This will be used to parse from
	// the root of the schema file.
	Spec() hcldec.Spec
}

BlockDefinition describes the methods that must be implemented by all definition packages for each root-level key.

type BlockRegistrar ¶

type BlockRegistrar interface {
	RegisterBlock(blockName string, blockDef BlockDefinition)
	AddRegistration(reg *Registration)
}

BlockRegistrar registers blocks by adding the given BlockDefinition for the root blockName.

type Builder ¶

type Builder interface {
	Build() hcldec.Spec
}

Builder builds and returns an hcldec.Spec used for further processing.

type FunctionInjector ¶

type FunctionInjector interface {
	BlockDefinition

	// Functions must return an instance of InjectableFunctions. These functions
	// will be passed through all BlockDefinition's that follow it allowing functions
	// created from this block to be available for all that follow.
	Functions(v cty.Value) InjectableFunctions
}

FunctionInjector allows injecting functions into a hcl.EvalContext after it has been created from the BlockDefinition's Spec() result.

type InjectableFunctions ¶

type InjectableFunctions map[string]function.Function

InjectableFunctions is a map of function names that correspond with a cty.Function of which will be injected into the context after processing Spec()

type InjectableVariables ¶

type InjectableVariables map[string]cty.Value

InjectableVariables is a map of variable names that correspond with a cty.Value of which will be injected into the running context after processing Spec()

type NamedBlockDefinition ¶

type NamedBlockDefinition interface {
	BlockDefinition

	// Name must return the name of the block to be registered.
	Name() string
}

NamedBlockDefinition describes the methods that musy be implemented by all definition packages for each root-level key when the definition can be self-registered by it's block name.

type NamedBlockDefinitions ¶

type NamedBlockDefinitions []NamedBlockDefinition

NamedBlockDefinitions represents a slice of individual NamedBlockDefinition's pre-ordered in the order they should be processed.

type Parser ¶

type Parser interface {
	Parse(body hcl.Body, ctx *hcl.EvalContext) hcl.Diagnostics
}

Parser accepts an hcl.Body and a pointer to an hcl.EvalContext, parses the hcl.Body against the hcl.EvalContext and returns any returned hcl.Diagnostics.

type Registrar ¶

type Registrar struct {
	NextOrder           int
	IncreaseNextOrderBy int
	// contains filtered or unexported fields
}

Registrar allows registering many root hcldec.Spec's at a given block or argument which are all called independently allowing variables to be injected into the context after each run for variable interpolation that includes variables created from previous schema blocks or arguments.

The registrar also allows injecting functions after specific hcldec.Spec's are processed, though in general this should be avoided.

func NewRegistrar(increaseNextOrderBy int) *Registrar

func (r *Registrar) AddRegistration(reg *Registration)

func (r *Registrar) Build() hcldec.Spec

func (r *Registrar) Parse(body hcl.Body, ctx *hcl.EvalContext) hcl.Diagnostics

func (r *Registrar) RegisterBlock(blockName string, blockDef BlockDefinition)

func (r *Registrar) Registrations() []*Registration

type Registration ¶

type Registration struct {
	BlockName  string
	Order      int
	Definition BlockDefinition
}

Registration adds a BlockDefinition for the BlockName to the Registrar that will allow parsing the block in the schema according to the returned hcldec.Spec from BlockDefinition's Spec() method.

type VariableInjector ¶

type VariableInjector interface {
	BlockDefinition

	// Variables must return an instance of InjectableVariables. These variables
	// will be passed through all BlockDefinition's that follow it allowing values
	// created from this block to be available for all that follow.
	Variables(v cty.Value) InjectableVariables
}

VariableInjector allows injecting variables into a hcl.EvalContext after it has been created from the BlockDefinition's Spec() result.