chore: add initial work for basic tf file parsing

Author: Emyrk

attr.go

@@ -0,0 +1,90 @@
+package preview
+
+import (
+	"fmt"
+
+	"github.com/aquasecurity/trivy/pkg/iac/terraform"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type attributeParser struct {
+	block *terraform.Block
+	diags hcl.Diagnostics
+}
+
+func newAttributeParser(block *terraform.Block) *attributeParser {
+	return &attributeParser{
+		block: block,
+		diags: make(hcl.Diagnostics, 0),
+	}
+}
+
+func (a *attributeParser) attr(key string) *expectedAttribute {
+	return &expectedAttribute{
+		Key: key,
+		p:   a,
+	}
+}
+
+type expectedAttribute struct {
+	Key  string
+	diag hcl.Diagnostics
+	p    *attributeParser
+}
+
+func (a *expectedAttribute) error(diag hcl.Diagnostics) *expectedAttribute {
+	if a.diag != nil {
+		return a // already have an error, don't overwrite
+	}
+
+	a.p.diags = a.p.diags.Extend(diag)
+	a.diag = diag
+	return a
+}
+
+func (a *expectedAttribute) required() *expectedAttribute {
+	attr := a.p.block.GetAttribute(a.Key)
+	if attr.IsNil() {
+		r := a.p.block.HCLBlock().Body.MissingItemRange()
+		a.error(hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Missing required attribute %q", a.Key),
+				Subject:  &r,
+				Extra:    nil,
+			},
+		})
+	}
+
+	return a
+}
+
+func (a *expectedAttribute) string() string {
+	attr := a.p.block.GetAttribute(a.Key)
+	if attr.IsNil() {
+		return ""
+	}
+
+	if attr.Type() != cty.String {
+		a.expectedTypeError(attr, "string")
+		return ""
+	}
+
+	return attr.Value().AsString()
+}
+
+func (a *expectedAttribute) expectedTypeError(attr *terraform.Attribute, expectedType string) {
+	a.error(hcl.Diagnostics{
+		{
+			Severity:   hcl.DiagError,
+			Summary:    "Invalid attribute type",
+			Detail:     fmt.Sprintf("The attribute %q must be of type %q, found type %q", attr.Name(), expectedType, attr.Type().FriendlyNameForConstraint()),
+			Subject:    &attr.HCLAttribute().Range,
+			Context:    &a.p.block.HCLBlock().DefRange,
+			Expression: attr.HCLAttribute().Expr,
+
+			EvalContext: a.p.block.Context().Inner(),
+		},
+	})
+}

cli/clidisplay/diags.go

@@ -0,0 +1,16 @@
+package clidisplay
+
+import (
+	"io"
+	"log"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+func WriteDiagnostics(out io.Writer, files map[string]*hcl.File, diags hcl.Diagnostics) {
+	wr := hcl.NewDiagnosticTextWriter(out, files, 80, true)
+	werr := wr.WriteDiagnostics(diags)
+	if werr != nil {
+		log.Printf("diagnostic writer: %s", werr.Error())
+	}
+}

cli/clidisplay/resources.go

@@ -0,0 +1,107 @@
+package clidisplay
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/coder/preview/types"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/jedib0t/go-pretty/v6/table"
+)
+
+func WorkspaceTags(writer io.Writer, tags types.TagBlocks) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	tableWriter := table.NewWriter()
+	tableWriter.SetTitle("Provisioner Tags")
+	tableWriter.SetStyle(table.StyleLight)
+	tableWriter.Style().Options.SeparateColumns = false
+	row := table.Row{"Key", "Value", "Refs"}
+	tableWriter.AppendHeader(row)
+	for _, tb := range tags {
+		for _, tag := range tb.Tags {
+			if tag.IsKnown() {
+				k, v := tag.AsStrings()
+				tableWriter.AppendRow(table.Row{k, v, ""})
+				continue
+				//diags = diags.Extend(tDiags)
+				//if !diags.HasErrors() {
+				//	tableWriter.AppendRow(table.Row{k, v, ""})
+				//	continue
+				//}
+			}
+
+			k := tag.SafeKeyString()
+			refs := tag.References()
+			tableWriter.AppendRow(table.Row{k, "??", strings.Join(refs, "\n")})
+
+			//refs := tb.AllReferences()
+			//refsStr := make([]string, 0, len(refs))
+			//for _, ref := range refs {
+			//	refsStr = append(refsStr, ref.String())
+			//}
+			//tableWriter.AppendRow(table.Row{unknown, "???", strings.Join(refsStr, "\n")})
+		}
+	}
+	_, _ = fmt.Fprintln(writer, tableWriter.Render())
+	return diags
+}
+
+func Parameters(writer io.Writer, params []types.Parameter) {
+	tableWriter := table.NewWriter()
+	//tableWriter.SetTitle("Parameters")
+	tableWriter.SetStyle(table.StyleLight)
+	tableWriter.Style().Options.SeparateColumns = false
+	row := table.Row{"Parameter"}
+	tableWriter.AppendHeader(row)
+	for _, p := range params {
+		strVal := ""
+		value := p.Value.Value
+
+		if value.IsNull() {
+			strVal = "null"
+		} else if !p.Value.Value.IsKnown() {
+			strVal = "unknown"
+		} else {
+			strVal = value.AsString()
+		}
+
+		tableWriter.AppendRow(table.Row{
+			fmt.Sprintf("%s: %s\n%s", p.Name, p.Description, formatOptions(strVal, p.Options)),
+		})
+		tableWriter.AppendSeparator()
+	}
+	_, _ = fmt.Fprintln(writer, tableWriter.Render())
+}
+
+func formatOptions(selected string, options []*types.RichParameterOption) string {
+	var str strings.Builder
+	sep := ""
+	found := false
+	for _, opt := range options {
+		str.WriteString(sep)
+		prefix := "[ ]"
+		if opt.Value == selected {
+			prefix = "[X]"
+			found = true
+		}
+		str.WriteString(fmt.Sprintf("%s %s (%s)", prefix, opt.Name, opt.Value))
+		if opt.Description != "" {
+			str.WriteString(fmt.Sprintf(": %s", maxLength(opt.Description, 20)))
+		}
+		sep = "\n"
+	}
+	if !found {
+		str.WriteString(sep)
+		str.WriteString(fmt.Sprintf("= %s", selected))
+	}
+	return str.String()
+}
+
+func maxLength(s string, max int) string {
+	if len(s) > max {
+		return s[:max] + "..."
+	}
+	return s
+}

cli/root.go

@@ -0,0 +1,102 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+
+	"github.com/coder/preview"
+	"github.com/coder/preview/cli/clidisplay"
+	"github.com/coder/preview/types"
+	"github.com/coder/serpent"
+)
+
+type RootCmd struct {
+	Files map[string]*hcl.File
+}
+
+func (r *RootCmd) Root() *serpent.Command {
+	var (
+		dir  string
+		vars []string
+	)
+	cmd := &serpent.Command{
+		Use:   "codertf",
+		Short: "codertf is a command line tool for previewing terraform template outputs.",
+		Options: serpent.OptionSet{
+			{
+				Name:          "dir",
+				Description:   "Directory with terraform files.",
+				Flag:          "dir",
+				FlagShorthand: "d",
+				Default:       ".",
+				Value:         serpent.StringOf(&dir),
+			},
+			{
+				Name:          "vars",
+				Description:   "Variables.",
+				Flag:          "vars",
+				FlagShorthand: "v",
+				Default:       ".",
+				Value:         serpent.StringArrayOf(&vars),
+			},
+		},
+		Handler: func(i *serpent.Invocation) error {
+			dfs := os.DirFS(dir)
+
+			var rvars map[string]types.ParameterValue
+			for _, val := range vars {
+				parts := strings.Split(val, "=")
+				if len(parts) != 2 {
+					continue
+				}
+				rvars[parts[0]] = types.ParameterValue{
+					Value: cty.StringVal(parts[1]),
+				}
+			}
+
+			input := preview.Input{
+				ParameterValues: rvars,
+			}
+
+			ctx := i.Context()
+			output, diags := preview.Preview(ctx, input, dfs)
+			if output == nil {
+				return diags
+			}
+			r.Files = output.Files
+
+			if len(diags) > 0 {
+				_, _ = fmt.Fprintf(os.Stderr, "Parsing Diagnostics:\n")
+				clidisplay.WriteDiagnostics(os.Stderr, output.Files, diags)
+			}
+
+			diags = clidisplay.WorkspaceTags(os.Stdout, output.WorkspaceTags)
+			if len(diags) > 0 {
+				_, _ = fmt.Fprintf(os.Stderr, "Workspace Tags Diagnostics:\n")
+				clidisplay.WriteDiagnostics(os.Stderr, output.Files, diags)
+			}
+
+			clidisplay.Parameters(os.Stdout, output.Parameters)
+
+			return nil
+		},
+	}
+	return cmd
+}
+
+func hclExpr(expr string) hcl.Expression {
+	file, diags := hclsyntax.ParseConfig([]byte(fmt.Sprintf(`expr = %s`, expr)), "test.tf", hcl.InitialPos)
+	if diags.HasErrors() {
+		panic(diags)
+	}
+	attributes, diags := file.Body.JustAttributes()
+	if diags.HasErrors() {
+		panic(diags)
+	}
+	return attributes["expr"].Expr
+}

cmd/preview/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"errors"
+	"log"
+	"os"
+
+	"github.com/coder/preview/cli"
+	"github.com/hashicorp/hcl/v2"
+)
+
+func main() {
+	log.SetOutput(os.Stderr)
+	root := &cli.RootCmd{}
+	cmd := root.Root()
+
+	err := cmd.Invoke().WithOS().Run()
+	if err != nil {
+		var diags hcl.Diagnostics
+		if errors.As(err, &diags) {
+			var files map[string]*hcl.File
+			if root.Files != nil {
+				files = root.Files
+			}
+			wr := hcl.NewDiagnosticTextWriter(os.Stderr, files, 80, true)
+			werr := wr.WriteDiagnostics(diags)
+			if werr != nil {
+				log.Printf("diagnostic writer: %s", werr.Error())
+			}
+		}
+		log.Fatal(err.Error())
+		os.Exit(1)
+	}
+}