Allow parsing module from any filesystem

tfconfig/filesystem.go

@@ -0,0 +1,41 @@
+package tfconfig
+
+import (
+	"io/ioutil"
+	"os"
+)
+
+// FS represents a minimal filesystem implementation
+// See io/fs.FS in http://golang.org/s/draft-iofs-design
+type FS interface {
+	Open(name string) (File, error)
+	ReadFile(name string) ([]byte, error)
+	ReadDir(dirname string) ([]os.FileInfo, error)
+}
+
+// File represents an open file in FS
+// See io/fs.File in http://golang.org/s/draft-iofs-design
+type File interface {
+	Stat() (os.FileInfo, error)
+	Read([]byte) (int, error)
+	Close() error
+}
+
+type osFs struct{}
+
+func (fs *osFs) Open(name string) (File, error) {
+	return os.Open(name)
+}
+
+func (fs *osFs) ReadFile(name string) ([]byte, error) {
+	return ioutil.ReadFile(name)
+}
+
+func (fs *osFs) ReadDir(dirname string) ([]os.FileInfo, error) {
+	return ioutil.ReadDir(dirname)
+}
+
+// NewOsFs provides a basic implementation of FS for an OS filesystem
+func NewOsFs() FS {
+	return &osFs{}
+}

tfconfig/load.go

@@ -2,7 +2,6 @@ package tfconfig
 
 import (
 	"fmt"
-	"io/ioutil"
 	"path/filepath"
 	"strings"
 
@@ -12,18 +11,23 @@ import (
 // LoadModule reads the directory at the given path and attempts to interpret
 // it as a Terraform module.
 func LoadModule(dir string) (*Module, Diagnostics) {
+	return LoadModuleFromFilesystem(NewOsFs(), dir)
+}
 
+// LoadModuleFromFilesystem reads the directory at the given path
+// in the given FS and attempts to interpret it as a Terraform module
+func LoadModuleFromFilesystem(fs FS, dir string) (*Module, Diagnostics) {
 	// For broad compatibility here we actually have two separate loader
 	// codepaths. The main one uses the new HCL parser and API and is intended
 	// for configurations from Terraform 0.12 onwards (though will work for
 	// many older configurations too), but we'll also fall back on one that
 	// uses the _old_ HCL implementation so we can deal with some edge-cases
 	// that are not valid in new HCL.
 
-	module, diags := loadModule(dir)
+	module, diags := loadModule(fs, dir)
 	if diags.HasErrors() {
 		// Try using the legacy HCL parser and see if we fare better.
-		legacyModule, legacyDiags := loadModuleLegacyHCL(dir)
+		legacyModule, legacyDiags := loadModuleLegacyHCL(fs, dir)
 		if !legacyDiags.HasErrors() {
 			legacyModule.init(legacyDiags)
 			return legacyModule, legacyDiags
@@ -37,7 +41,14 @@ func LoadModule(dir string) (*Module, Diagnostics) {
 // IsModuleDir checks if the given path contains terraform configuration files.
 // This allows the caller to decide how to handle directories that do not have tf files.
 func IsModuleDir(dir string) bool {
-	primaryPaths, _ := dirFiles(dir)
+	return IsModuleDirOnFilesystem(NewOsFs(), dir)
+}
+
+// IsModuleDirOnFilesystem checks if the given path in the given FS contains
+// Terraform configuration files. This allows the caller to decide
+// how to handle directories that do not have tf files.
+func IsModuleDirOnFilesystem(fs FS, dir string) bool {
+	primaryPaths, _ := dirFiles(fs, dir)
 	if len(primaryPaths) == 0 {
 		return false
 	}
@@ -67,8 +78,8 @@ func (m *Module) init(diags Diagnostics) {
 	m.Diagnostics = diags
 }
 
-func dirFiles(dir string) (primary []string, diags hcl.Diagnostics) {
-	infos, err := ioutil.ReadDir(dir)
+func dirFiles(fs FS, dir string) (primary []string, diags hcl.Diagnostics) {
+	infos, err := fs.ReadDir(dir)
 	if err != nil {
 		diags = append(diags, &hcl.Diagnostic{
 			Severity: hcl.DiagError,

tfconfig/load_hcl.go

@@ -13,19 +13,29 @@ import (
 	ctyjson "github.com/zclconf/go-cty/cty/json"
 )
 
-func loadModule(dir string) (*Module, Diagnostics) {
+func loadModule(fs FS, dir string) (*Module, Diagnostics) {
 	mod := newModule(dir)
-	primaryPaths, diags := dirFiles(dir)
+	primaryPaths, diags := dirFiles(fs, dir)
 
 	parser := hclparse.NewParser()
 
 	for _, filename := range primaryPaths {
 		var file *hcl.File
 		var fileDiags hcl.Diagnostics
+
+		b, err := fs.ReadFile(filename)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to read file",
+				Detail:   fmt.Sprintf("The configuration file %q could not be read.", filename),
+			})
+			continue
+		}
 		if strings.HasSuffix(filename, ".json") {
-			file, fileDiags = parser.ParseJSONFile(filename)
+			file, fileDiags = parser.ParseJSON(b, filename)
 		} else {
-			file, fileDiags = parser.ParseHCLFile(filename)
+			file, fileDiags = parser.ParseHCL(b, filename)
 		}
 		diags = append(diags, fileDiags...)
 		if file == nil {

tfconfig/load_legacy.go

@@ -1,28 +1,27 @@
 package tfconfig
 
 import (
-	"io/ioutil"
 	"strings"
 
 	legacyhcl "github.com/hashicorp/hcl"
 	legacyast "github.com/hashicorp/hcl/hcl/ast"
 )
 
-func loadModuleLegacyHCL(dir string) (*Module, Diagnostics) {
+func loadModuleLegacyHCL(fs FS, dir string) (*Module, Diagnostics) {
 	// This implementation is intentionally more quick-and-dirty than the
 	// main loader. In particular, it doesn't bother to keep careful track
 	// of multiple error messages because we always fall back on returning
 	// the main parser's error message if our fallback parsing produces
 	// an error, and thus the errors here are not seen by the end-caller.
 	mod := newModule(dir)
 
-	primaryPaths, diags := dirFiles(dir)
+	primaryPaths, diags := dirFiles(fs, dir)
 	if diags.HasErrors() {
 		return mod, diagnosticsHCL(diags)
 	}
 
 	for _, filename := range primaryPaths {
-		src, err := ioutil.ReadFile(filename)
+		src, err := fs.ReadFile(filename)
 		if err != nil {
 			return mod, diagnosticsErrorf("Error reading %s: %s", filename, err)
 		}
@@ -320,7 +319,7 @@ func unwrapLegacyHCLObjectKeysFromJSON(item *legacyast.ObjectItem, depth int) {
 			item.Val = &legacyast.ObjectType{
 				List: &legacyast.ObjectList{
 					Items: []*legacyast.ObjectItem{
-						&legacyast.ObjectItem{
+						{
 							Keys: []*legacyast.ObjectKey{key},
 							Val:  item.Val,
 						},