HCL をパースして、構造を組み替えて再出力する

 1variable "instance_type" {
 2  type        = string
 3  description = "EC2 instance type"
 4  default     = "t3.micro"
 5}
 6
 7variable "instance_counts" {
 8  type        = number
 9  description = "Number of instances to create"
10  default     = 2
11}
12
13output "instance_arns" {
14  value = aws_instance.instance.*.arn
15}

 1module "instances" {
 2  source = "./modules/instances"
 3
 4  // EC2 instance type
 5  // type: string
 6  instance_type = "t3.micro"
 7  // Number of instances to create
 8  // type: number
 9  instance_counts = 2
10}
11
12output "instances_instance_arns" {
13  value = module.instances.instance_arns
14}

1image_id = "abc123"

1resource "aws_instance" "example" {
2  ami = "abc123"
3
4  network_interface {
5    # ...
6  }
7}

 1type Config struct {
 2	Foo string `hcl:"foo"`
 3	Baz string `hcl:"baz"`
 4}
 5
 6const exampleConfig = `
 7	foo = "bar"
 8	baz = "boop"
 9	`
10
11var config Config
12err := hclsimple.Decode(
13	"example.hcl", []byte(exampleConfig),
14	nil, &config,
15)
16if err != nil {
17	log.Fatalf("Failed to load configuration: %s", err)
18}
19fmt.Printf("Configuration is %v\n", config)

 1f := hclwrite.NewEmptyFile()
 2
 3rootBody := f.Body()
 4moduleBlock := rootBody.AppendNewBlock("module", []string{m.Name})
 5moduleBody := moduleBlock.Body()
 6
 7moduleBody.SetAttributeValue("source", cty.StringVal(m.Source))
 8moduleBody.AppendNewline()
 9
10for _, v := range *m.Variables {
11        if isNoDefaults && !reflect.DeepEqual(v.Default, hclwrite.TokensForValue(cty.StringVal(""))) {
12                continue
13        }
14        moduleBody.AppendUnstructuredTokens(v.generateComment())
15        moduleBody.SetAttributeRaw(v.Name, v.Default)
16}

 1...
 2moduleBody.AppendUnstructuredTokens(v.generateComment())
 3...
 4func (v *Variable) generateComment() hclwrite.Tokens {
 5        tokens := hclwrite.Tokens{
 6                {
 7                        Type:  hclsyntax.TokenSlash,
 8                        Bytes: []byte("//"),
 9                },
10                {
11                        Type:  hclsyntax.TokenIdent,
12                        Bytes: []byte(v.Description),
13                },
14                {
15                        Type:  hclsyntax.TokenNewline,
16                        Bytes: []byte("\n"),
17                },
18                {
19                        Type:  hclsyntax.TokenSlash,
20                        Bytes: []byte("//"),
21                },
22                {
23                        Type:  hclsyntax.TokenIdent,
24                        Bytes: []byte("type:"),
25                },
26        }
27        tokens = append(tokens, v.Type...)
28        tokens = append(tokens, &hclwrite.Token{
29                Type:  hclsyntax.TokenNewline,
30                Bytes: []byte("\n"),
31        })
32        return tokens
33}

 1type Token struct {
 2	Type  hclsyntax.TokenType
 3	Bytes []byte
 4
 5	// We record the number of spaces before each token so that we can
 6	// reproduce the exact layout of the original file when we're making
 7	// surgical changes in-place. When _new_ code is created it will always
 8	// be in the canonical style, but we preserve layout of existing code.
 9	SpacesBefore int
10}

 1src, err := ioutil.ReadFile(path)
 2if err != nil {
 3        return err
 4}
 5
 6file, diags := hclwrite.ParseConfig(src, path, hcl.InitialPos)
 7if diags.HasErrors() {
 8        return diags
 9}
10
11body := file.Body()
12for _, block := range body.Blocks() {
13        switch block.Type() {
14        case "variable":
15                variables = append(variables, parseVariable(block))
16        case "output":
17                outputs = append(outputs, parseOutput(block))
18        case "resource":
19                resources = append(resources, parseResource(block))
20        }
21}