chore: Integrating vfs and optimizing some low-hanging fruit

Author: yhakbar

internal/cli/commands/catalog/tui/redesign/component_discovery.go

@@ -2,14 +2,14 @@ package redesign
 
 import (
 	"io/fs"
-	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/gruntwork-io/terragrunt/internal/errors"
 	"github.com/gruntwork-io/terragrunt/internal/services/catalog/ignore"
 	"github.com/gruntwork-io/terragrunt/internal/services/catalog/module"
 	"github.com/gruntwork-io/terragrunt/internal/util"
+	"github.com/gruntwork-io/terragrunt/internal/vfs"
 	"github.com/gruntwork-io/terragrunt/pkg/config"
 )
 
@@ -41,12 +41,13 @@ const (
 // Construct one via NewComponentDiscovery, customize it with the With*
 // methods, then call Discover on a repo.
 type ComponentDiscovery struct {
+	fsys             vfs.FS
 	extraIgnoreFile  string
 	walkWithSymlinks bool
 }
 
 // NewComponentDiscovery returns a ComponentDiscovery with default settings:
-// no symlink following, no extra ignore file.
+// no symlink following, no extra ignore file, the real OS filesystem.
 func NewComponentDiscovery() *ComponentDiscovery {
 	return &ComponentDiscovery{}
 }
@@ -65,6 +66,13 @@ func (cd *ComponentDiscovery) WithExtraIgnoreFile(i string) *ComponentDiscovery
 	return cd
 }
 
+// WithFS sets the filesystem used for the discovery walk and per-component
+// README reads. When unset, Discover uses vfs.NewOSFS().
+func (cd *ComponentDiscovery) WithFS(fsys vfs.FS) *ComponentDiscovery {
+	cd.fsys = fsys
+	return cd
+}
+
 // Discover runs component discovery against repo.
 func (cd *ComponentDiscovery) Discover(repo *module.Repo) (Components, error) {
 	if repo == nil {
@@ -78,18 +86,28 @@ func (cd *ComponentDiscovery) Discover(repo *module.Repo) (Components, error) {
 		return nil, errors.New("ComponentDiscovery.Discover: empty repo path")
 	}
 
-	walkFunc := filepath.WalkDir
+	fsys := cd.fsys
+	if fsys == nil {
+		fsys = vfs.NewOSFS()
+	}
+
+	// util.WalkDirWithSymlinks is OS-only; when symlink following is on, we
+	// continue using it and leave vfs integration as a future cleanup.
+	walkFunc := func(root string, fn fs.WalkDirFunc) error {
+		return vfs.WalkDir(fsys, root, fn)
+	}
+
 	if cd.walkWithSymlinks {
 		walkFunc = util.WalkDirWithSymlinks
 	}
 
-	ignoreMatcher, err := ignore.Load(repoPath)
+	ignoreMatcher, err := ignore.Load(fsys, repoPath)
 	if err != nil {
 		return nil, err
 	}
 
 	if cd.extraIgnoreFile != "" {
-		extraMatcher, err := ignore.LoadFile(cd.extraIgnoreFile)
+		extraMatcher, err := ignore.LoadFile(fsys, cd.extraIgnoreFile)
 		if err != nil {
 			return nil, err
 		}
@@ -126,7 +144,7 @@ func (cd *ComponentDiscovery) Discover(repo *module.Repo) (Components, error) {
 			return fs.SkipDir
 		}
 
-		kind, isComponent, err := classifyDir(dir)
+		kind, isComponent, err := classifyDir(fsys, dir)
 		if err != nil {
 			return err
 		}
@@ -135,7 +153,7 @@ func (cd *ComponentDiscovery) Discover(repo *module.Repo) (Components, error) {
 			return nil
 		}
 
-		c, err := newComponent(repo, repoPath, cloneURL, relDir, kind)
+		c, err := newComponent(fsys, repo, repoPath, cloneURL, relDir, kind)
 		if err != nil {
 			return err
 		}
@@ -164,8 +182,8 @@ func (cd *ComponentDiscovery) Discover(repo *module.Repo) (Components, error) {
 // classifyDir inspects a single directory and returns its ComponentKind.
 // Precedence: stack > unit > template > module. A terragrunt.stack.hcl wins
 // over a terragrunt.hcl, a .boilerplate/, and plain .tf files.
-func classifyDir(dir string) (ComponentKind, bool, error) {
-	entries, err := os.ReadDir(dir)
+func classifyDir(fsys vfs.FS, dir string) (ComponentKind, bool, error) {
+	entries, err := readDirEntries(fsys, dir)
 	if err != nil {
 		return 0, false, errors.New(err)
 	}
@@ -229,8 +247,8 @@ func isSkippableDir(name string) bool {
 // newComponent constructs a *Component for a directory that has been
 // classified. It populates the doc and URL fields the same way the legacy
 // module.NewModule does, but into the redesign-owned Component type.
-func newComponent(repo *module.Repo, repoPath, cloneURL, relDir string, kind ComponentKind) (*Component, error) {
-	doc, err := FindComponentDoc(filepath.Join(repoPath, relDir))
+func newComponent(fsys vfs.FS, repo *module.Repo, repoPath, cloneURL, relDir string, kind ComponentKind) (*Component, error) {
+	doc, err := FindComponentDoc(fsys, filepath.Join(repoPath, relDir))
 	if err != nil {
 		return nil, err
 	}

internal/cli/commands/catalog/tui/redesign/component_discovery_test.go

@@ -8,12 +8,31 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/cli/commands/catalog/tui/redesign"
 
 	"github.com/gruntwork-io/terragrunt/internal/services/catalog/module"
+	"github.com/gruntwork-io/terragrunt/internal/vfs"
 	"github.com/gruntwork-io/terragrunt/test/helpers"
 	"github.com/gruntwork-io/terragrunt/test/helpers/logger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+// TestDiscoverComponents_WithCustomFS proves discovery runs against an
+// injected vfs.FS — passing vfs.NewOSFS() explicitly produces the same
+// result as the zero-arg constructor's internal default.
+func TestDiscoverComponents_WithCustomFS(t *testing.T) {
+	t.Parallel()
+
+	repoDir := helpers.TmpDirWOSymlinks(t)
+	writeFile(t, filepath.Join(repoDir, "foo", "main.tf"), "# module")
+
+	repo := newFakeRepo(t, repoDir)
+
+	components, err := redesign.NewComponentDiscovery().WithFS(vfs.NewOSFS()).Discover(repo)
+	require.NoError(t, err)
+	require.Len(t, components, 1)
+	assert.Equal(t, "foo", components[0].Dir)
+	assert.Equal(t, redesign.ComponentKindModule, components[0].Kind)
+}
+
 // newFakeRepo creates a bare-minimum cloned repo on disk that module.NewRepo
 // can successfully consume (requires .git/config and .git/HEAD). The returned
 // *module.Repo has the walk-relevant Path() / CloneURL() pointing at repoDir.

internal/cli/commands/catalog/tui/redesign/component_doc.go

@@ -1,12 +1,13 @@
 package redesign
 
 import (
-	"os"
+	"io/fs"
 	"path/filepath"
 	"regexp"
 	"strings"
 
 	"github.com/gruntwork-io/terragrunt/internal/errors"
+	"github.com/gruntwork-io/terragrunt/internal/vfs"
 )
 
 // Note: this file is a redesign-owned fork of internal/services/catalog/module/doc.go.
@@ -113,17 +114,17 @@ func NewComponentDoc(rawContent, fileExt string) *ComponentDoc {
 	return doc
 }
 
-// FindComponentDoc reads the first README-like file in dir and returns a
-// populated ComponentDoc. Returns a zero-value *ComponentDoc (non-nil) when
-// no README is present.
-func FindComponentDoc(dir string) (*ComponentDoc, error) {
-	var filePath, fileExt string
-
-	files, err := os.ReadDir(dir)
+// FindComponentDoc reads the first README-like file in dir from fsys and
+// returns a populated ComponentDoc. Returns a zero-value *ComponentDoc
+// (non-nil) when no README is present.
+func FindComponentDoc(fsys vfs.FS, dir string) (*ComponentDoc, error) {
+	files, err := readDirEntries(fsys, dir)
 	if err != nil {
 		return nil, errors.New(err)
 	}
 
+	var filePath, fileExt string
+
 	for _, file := range files {
 		if file.IsDir() {
 			continue
@@ -147,14 +148,43 @@ func FindComponentDoc(dir string) (*ComponentDoc, error) {
 		return &ComponentDoc{}, nil
 	}
 
-	contentByte, err := os.ReadFile(filePath)
+	contentByte, err := vfs.ReadFile(fsys, filePath)
 	if err != nil {
 		return nil, errors.New(err)
 	}
 
 	return NewComponentDoc(string(contentByte), fileExt), nil
 }
 
+// readDirEntries opens dir on fsys and returns its entries. It prefers the
+// fs.ReadDirFile fast path when the backing file supports it.
+func readDirEntries(fsys vfs.FS, dir string) ([]fs.DirEntry, error) {
+	f, err := fsys.Open(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		_ = f.Close()
+	}()
+
+	if rdf, ok := f.(fs.ReadDirFile); ok {
+		return rdf.ReadDir(-1)
+	}
+
+	infos, err := f.Readdir(-1)
+	if err != nil {
+		return nil, err
+	}
+
+	entries := make([]fs.DirEntry, len(infos))
+	for i, info := range infos {
+		entries[i] = vfs.FileInfoDirEntry{FileInfo: info}
+	}
+
+	return entries, nil
+}
+
 // Title returns the doc title from frontmatter or the first H1.
 func (doc *ComponentDoc) Title() string {
 	if title := doc.parseFrontmatter(docTitle); title != "" {

internal/cli/commands/catalog/tui/redesign/copy.go

@@ -1,12 +1,14 @@
 package redesign
 
 import (
+	stderrors "errors"
 	"io"
 	"io/fs"
 	"os"
 	"path/filepath"
 
 	"github.com/gruntwork-io/terragrunt/internal/errors"
+	"github.com/gruntwork-io/terragrunt/internal/vfs"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/pkg/options"
 )
@@ -19,6 +21,7 @@ type CopyCmd struct {
 	component *Component
 	opts      *options.TerragruntOptions
 	logger    log.Logger
+	fsys      vfs.FS
 	result    copyResult
 }
 
@@ -35,15 +38,27 @@ func NewCopyCmd(logger log.Logger, opts *options.TerragruntOptions, c *Component
 	return &CopyCmd{component: c, opts: opts, logger: logger}
 }
 
+// WithFS overrides the filesystem used for source reads and destination writes.
+// When unset, Run uses vfs.NewOSFS().
+func (c *CopyCmd) WithFS(fsys vfs.FS) *CopyCmd {
+	c.fsys = fsys
+	return c
+}
+
 func (c *CopyCmd) Run() error {
+	fsys := c.fsys
+	if fsys == nil {
+		fsys = vfs.NewOSFS()
+	}
+
 	src, dst, err := c.resolvePaths()
 	if err != nil {
 		return err
 	}
 
 	c.logger.Debugf("Copying component %q to %q", src, dst)
 
-	if err := copyDir(src, dst); err != nil {
+	if err := copyDir(fsys, src, dst); err != nil {
 		return err
 	}
 
@@ -54,7 +69,7 @@ func (c *CopyCmd) Run() error {
 		return nil
 	}
 
-	refs, err := CollectValuesReferences(filepath.Join(src, configName))
+	refs, err := CollectValuesReferences(fsys, filepath.Join(src, configName))
 	if err != nil {
 		return err
 	}
@@ -65,7 +80,7 @@ func (c *CopyCmd) Run() error {
 
 	c.result.references = refs
 
-	written, err := WriteValuesStub(dst, refs)
+	written, err := WriteValuesStub(fsys, dst, refs)
 	if err != nil {
 		return err
 	}
@@ -120,10 +135,10 @@ func skipDuringCopy(name string) bool {
 	return name == ".terragrunt-cache" || name == ".terragrunt-stack"
 }
 
-// copyDir recursively copies src to dst, preserving file modes and skipping
-// regenerated artifact directories.
-func copyDir(src, dst string) error {
-	return filepath.WalkDir(src, func(path string, d fs.DirEntry, walkErr error) error {
+// copyDir recursively copies src to dst on fsys, preserving file modes and
+// skipping regenerated artifact directories.
+func copyDir(fsys vfs.FS, src, dst string) error {
+	return vfs.WalkDir(fsys, src, func(path string, d fs.DirEntry, walkErr error) error {
 		if walkErr != nil {
 			return walkErr
 		}
@@ -145,20 +160,20 @@ func copyDir(src, dst string) error {
 				return errors.New(err)
 			}
 
-			return os.MkdirAll(target, info.Mode().Perm())
+			return fsys.MkdirAll(target, info.Mode().Perm())
 		}
 
 		// Skip symlinks and irregular files; copy only regular files.
 		if !d.Type().IsRegular() {
 			return nil
 		}
 
-		return copyFile(path, target)
+		return copyFile(fsys, path, target)
 	})
 }
 
-func copyFile(src, dst string) error {
-	in, err := os.Open(src)
+func copyFile(fsys vfs.FS, src, dst string) error {
+	in, err := fsys.Open(src)
 	if err != nil {
 		return errors.New(err)
 	}
@@ -176,9 +191,9 @@ func copyFile(src, dst string) error {
 
 	// O_EXCL ensures we refuse to overwrite existing files in the working
 	// directory, so copying a unit or stack can't silently clobber user edits.
-	out, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_EXCL, info.Mode().Perm())
+	out, err := fsys.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_EXCL, info.Mode().Perm())
 	if err != nil {
-		if os.IsExist(err) {
+		if stderrors.Is(err, fs.ErrExist) {
 			return errors.Errorf("destination %q already exists; refusing to overwrite", dst)
 		}