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,
  },