refactor: asynchronous loading of root module parts (#219)

* rootmodules: Surface whole RootModule candidates instead of paths

* refactor: asynchronous loading of root module parts

* make test data accessible for linux & windows too

* address PR feedback

commands/completion_command.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 
@@ -47,6 +48,13 @@ func (c *CompletionCommand) Run(args []string) int {
 	}
 
 	path := f.Arg(0)
+
+	path, err := filepath.Abs(path)
+	if err != nil {
+		c.Ui.Output(err.Error())
+		return 1
+	}
+
 	content, err := ioutil.ReadFile(path)
 	if err != nil {
 		c.Ui.Error(fmt.Sprintf("reading file at %q failed: %s", path, err))
@@ -102,16 +110,20 @@ func (c *CompletionCommand) Run(args []string) int {
 
 	w, err := rootmodule.NewRootModule(context.Background(), fh.Dir())
 	if err != nil {
-		c.Ui.Error(err.Error())
+		c.Ui.Error(fmt.Sprintf("failed to load root module: %s", err.Error()))
+		return 1
+	}
+	p, err := w.Parser()
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("failed to find parser: %s", err.Error()))
 		return 1
 	}
-	p := w.Parser()
 
 	pos := fPos.Position()
 
 	candidates, err := p.CompletionCandidatesAtPos(hclFile, pos)
 	if err != nil {
-		c.Ui.Error(err.Error())
+		c.Ui.Error(fmt.Sprintf("failed to find candidates: %s", err.Error()))
 		return 1
 	}
 

go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/creachadair/jrpc2 v0.8.1
 	github.com/fsnotify/fsnotify v1.4.9
 	github.com/google/go-cmp v0.4.0
-	github.com/hashicorp/go-multierror v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.0
 	github.com/hashicorp/go-version v1.2.0
 	github.com/hashicorp/hcl/v2 v2.5.2-0.20200528183353-fa7c453538de
 	github.com/hashicorp/terraform-json v0.5.0

internal/terraform/exec/exec.go

@@ -33,10 +33,9 @@ type cmdCtxFunc func(context.Context, string, ...string) *exec.Cmd
 
 // ExecutorFactory can be used in external consumers of exec pkg
 // to enable easy swapping with MockExecutor
-type ExecutorFactory func(ctx context.Context, path string) *Executor
+type ExecutorFactory func(path string) *Executor
 
 type Executor struct {
-	ctx     context.Context
 	timeout time.Duration
 
 	execPath    string
@@ -55,9 +54,8 @@ type command struct {
 	StderrBuffer *bytes.Buffer
 }
 
-func NewExecutor(ctx context.Context, path string) *Executor {
+func NewExecutor(path string) *Executor {
 	return &Executor{
-		ctx:      ctx,
 		timeout:  defaultExecTimeout,
 		execPath: path,
 		logger:   log.New(ioutil.Discard, "", 0),
@@ -87,15 +85,14 @@ func (e *Executor) GetExecPath() string {
 	return e.execPath
 }
 
-func (e *Executor) cmd(args ...string) (*command, error) {
+func (e *Executor) cmd(ctx context.Context, args ...string) (*command, error) {
 	if e.workDir == "" {
 		return nil, fmt.Errorf("no work directory set")
 	}
 
-	ctx := e.ctx
 	cancel := func() {}
 	if e.timeout > 0 {
-		ctx, cancel = context.WithTimeout(e.ctx, e.timeout)
+		ctx, cancel = context.WithTimeout(ctx, e.timeout)
 	}
 
 	var outBuf bytes.Buffer
@@ -186,8 +183,8 @@ func (e *Executor) runCmd(command *command) ([]byte, error) {
 	return e.waitCmd(command)
 }
 
-func (e *Executor) run(args ...string) ([]byte, error) {
-	cmd, err := e.cmd(args...)
+func (e *Executor) run(ctx context.Context, args ...string) ([]byte, error) {
+	cmd, err := e.cmd(ctx, args...)
 	e.logger.Printf("running with timeout %s", e.timeout)
 	defer cmd.CancelFunc()
 	if err != nil {
@@ -196,8 +193,8 @@ func (e *Executor) run(args ...string) ([]byte, error) {
 	return e.runCmd(cmd)
 }
 
-func (e *Executor) Format(input []byte) ([]byte, error) {
-	cmd, err := e.cmd("fmt", "-")
+func (e *Executor) Format(ctx context.Context, input []byte) ([]byte, error) {
+	cmd, err := e.cmd(ctx, "fmt", "-")
 	if err != nil {
 		return nil, err
 	}
@@ -236,8 +233,8 @@ func writeAndClose(w io.WriteCloser, input []byte) (int, error) {
 	return n, nil
 }
 
-func (e *Executor) Version() (string, error) {
-	out, err := e.run("version")
+func (e *Executor) Version(ctx context.Context) (string, error) {
+	out, err := e.run(ctx, "version")
 	if err != nil {
 		return "", fmt.Errorf("failed to get version: %w", err)
 	}
@@ -251,8 +248,8 @@ func (e *Executor) Version() (string, error) {
 	return version, nil
 }
 
-func (e *Executor) VersionIsSupported(c version.Constraints) error {
-	v, err := e.Version()
+func (e *Executor) VersionIsSupported(ctx context.Context, c version.Constraints) error {
+	v, err := e.Version(ctx)
 	if err != nil {
 		return err
 	}
@@ -269,8 +266,8 @@ func (e *Executor) VersionIsSupported(c version.Constraints) error {
 	return nil
 }
 
-func (e *Executor) ProviderSchemas() (*tfjson.ProviderSchemas, error) {
-	outBytes, err := e.run("providers", "schema", "-json")
+func (e *Executor) ProviderSchemas(ctx context.Context) (*tfjson.ProviderSchemas, error) {
+	outBytes, err := e.run(ctx, "providers", "schema", "-json")
 	if err != nil {
 		return nil, fmt.Errorf("failed to get schemas: %w", err)
 	}

internal/terraform/exec/exec_mock.go

@@ -78,15 +78,15 @@ func (mc *MockQueue) NextMockItem() *MockItem {
 }
 
 func MockExecutor(md MockItemDispenser) ExecutorFactory {
-	return func(ctx context.Context, path string) *Executor {
+	return func(path string) *Executor {
 		if md == nil {
 			md = &MockCall{
 				MockError: "no mocks provided",
 			}
 		}
 
 		path, ctxFunc := mockCommandCtxFunc(md)
-		executor := NewExecutor(context.Background(), path)
+		executor := NewExecutor(path)
 		executor.cmdCtxFunc = ctxFunc
 		return executor
 	}

internal/terraform/exec/exec_test.go

@@ -14,13 +14,13 @@ func TestExec_timeout(t *testing.T) {
 		Args:          []string{"version"},
 		SleepDuration: 100 * time.Millisecond,
 		Stdout:        "Terraform v0.12.0\n",
-	})(context.Background(), "")
+	})("")
 	e.SetWorkdir(os.TempDir())
 	e.timeout = 1 * time.Millisecond
 
 	expectedErr := ExecTimeoutError([]string{"terraform", "version"}, e.timeout)
 
-	_, err := e.Version()
+	_, err := e.Version(context.Background())
 	if err != nil {
 		if errors.Is(err, expectedErr) {
 			return
@@ -38,9 +38,9 @@ func TestExec_Version(t *testing.T) {
 		Args:     []string{"version"},
 		Stdout:   "Terraform v0.12.0\n",
 		ExitCode: 0,
-	})(context.Background(), "")
+	})("")
 	e.SetWorkdir(os.TempDir())
-	v, err := e.Version()
+	v, err := e.Version(context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -55,9 +55,9 @@ func TestExec_Format(t *testing.T) {
 		Args:     []string{"fmt", "-"},
 		Stdout:   string(expectedOutput),
 		ExitCode: 0,
-	})(context.Background(), "")
+	})("")
 	e.SetWorkdir(os.TempDir())
-	out, err := e.Format([]byte("unformatted"))
+	out, err := e.Format(context.Background(), []byte("unformatted"))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -73,10 +73,10 @@ func TestExec_ProviderSchemas(t *testing.T) {
 		Args:     []string{"providers", "schema", "-json"},
 		Stdout:   `{"format_version": "0.1"}`,
 		ExitCode: 0,
-	})(context.Background(), "")
+	})("")
 	e.SetWorkdir(os.TempDir())
 
-	ps, err := e.ProviderSchemas()
+	ps, err := e.ProviderSchemas(context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}

internal/terraform/rootmodule/file.go

@@ -0,0 +1,43 @@
+package rootmodule
+
+import (
+	"fmt"
+	"os"
+)
+
+func findFile(paths []string) (File, error) {
+	var lf File
+	var err error
+
+	for _, path := range paths {
+		lf, err = newFile(path)
+		if err == nil {
+			return lf, nil
+		}
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	return nil, err
+}
+
+type file struct {
+	path string
+}
+
+func (f *file) Path() string {
+	return f.path
+}
+
+func newFile(path string) (File, error) {
+	fi, err := os.Stat(path)
+	if err != nil {
+		return nil, err
+	}
+	if fi.IsDir() {
+		return nil, fmt.Errorf("expected %s to be a file, not a dir", path)
+	}
+
+	return &file{path: path}, nil
+}