parser

type BuildData struct {
	Locals    map[string]interface{}
	Variables map[string]interface{}
	Values    map[string]interface{}
	Terrafile *Terrafile
	// RelativeDir is the relative directory from the root Terrafile to the
	// Terrafile being built
	RelativeDir string
	// RelativePath is the relative path from the root Terrafile to the Terrafile
	// being built
	RelativePath string
	// RelativeRootDir is the relative directory of the root Terrafile
	RelativeRootDir string
	// RootDir is the absolute directory of the root Terrafile
	RootDir string
}

type Config struct {
	Chdir string
}

type ExecBlock struct {
	Skip      bool           `hcl:"skip,optional"`
	ExtraArgs []string       `hcl:"extra_args,optional"`
	PlanBlock *ExecPlanBlock `hcl:"plan,block"`
}

type ExecPlanBlock struct {
	Input bool `hcl:"input,optional"`
	Lock  bool `hcl:"lock,optional"`
	// Out specifies the name of the Terraform plan file to create (if any)
	Out string `hcl:"out,optional"`
	// SkipOut says whether to avoid creating a plan file or not. Useful in cases
	// such as running Terraform Cloud remotely, where plans cannot be created.
	SkipOut bool `hcl:"skip_out,optional"`
}

type RequiredProvider struct {
	Source  string `hcl:"source,attr" cty:"source"`
	Version string `hcl:"version,attr" cty:"version"`
}

type TerraConfig struct {
	Terrafiles       []*Terrafile
	WorkingDirectory string
}

type TerraLocals struct {
	Locals map[string]cty.Value `hcl:",remain"`
}

type TerraRequiredProviders struct {
	RequiredProviders map[string]RequiredProvider `hcl:",remain"`
}

type TerraTemplate struct {
	Name     string `hcl:",label"`
	Contents string `hcl:"contents,attr"`
	// Target defines the target file to generate.
	// Defaults to the Name of the template with a ".tp.tf" extension
	Target string `hcl:"target,optional"`
	// ConditionAttr defines a string boolean that specifies whether this template
	// should be built or not.
	// The string can include Go templates, which means you can have dynamic
	// behaviour based on the Terrafile
	ConditionAttr string `hcl:"condition,optional"`
}

type TerraValues struct {
	Values map[string]cty.Value `hcl:",remain"`
}

type TerraVariables struct {
	Variables map[string]cty.Value `hcl:",remain"`
}

type Terrafile struct {
	// Path
	Path string
	Dir  string
	// IsRoot tells whether this terrafile is for a root module
	IsRoot bool
	// Templates defines the list of templates that this Terrafile defines
	Templates []*TerraTemplate `hcl:"template,block"`

	LocalsBlock    *TerraLocals    `hcl:"locals,block"`
	VariablesBlock *TerraVariables `hcl:"variables,block"`
	ValuesBlock    *TerraValues    `hcl:"values,block"`

	TerraformBlock *TerraformBlock `hcl:"terraform,block"`

	// BuildBlock *BuildBlock `hcl:"build,block"`
	ExecBlock *ExecBlock `hcl:"exec,block"`

	// Ancestor defines any parent/ancestor Terrafiles that this Terrafile
	// should inherit from
	Ancestor *Terrafile

	// Children contains any child Terrafiles to this Terrafile
	Children []*Terrafile
}

type TerraformBlock struct {
	RequiredVersion        string                  `hcl:"required_version,optional"`
	RequiredProvidersBlock *TerraRequiredProviders `hcl:"required_providers,block"`
}