fix: Consolidating some duplicate logic

Author: yhakbar

internal/component/component.go

@@ -8,12 +8,12 @@
 package component
 
 import (
-	"path/filepath"
 	"slices"
 	"sort"
 	"sync"
 
 	"github.com/gruntwork-io/terragrunt/internal/errors"
+	"github.com/gruntwork-io/terragrunt/internal/util"
 )
 
 // Kind is the type of Terragrunt component.
@@ -255,7 +255,7 @@ func NewThreadSafeComponents(components Components) *ThreadSafeComponents {
 
 	// Pre-populate resolved paths cache for initial components
 	for _, c := range components {
-		tsc.resolvedPaths[c.Path()] = resolvePath(c.Path())
+		tsc.resolvedPaths[c.Path()] = util.ResolvePath(c.Path())
 	}
 
 	return tsc
@@ -269,7 +269,7 @@ func (tsc *ThreadSafeComponents) resolvedPathFor(path string) string {
 		return resolved
 	}
 
-	return resolvePath(path)
+	return util.ResolvePath(path)
 }
 
 // EnsureComponent adds a component to the components list if it's not already present.
@@ -293,7 +293,7 @@ func (tsc *ThreadSafeComponents) findComponent(c Component) (Component, bool) {
 	tsc.mu.RLock()
 	defer tsc.mu.RUnlock()
 
-	searchResolved := resolvePath(c.Path())
+	searchResolved := util.ResolvePath(c.Path())
 
 	idx := slices.IndexFunc(tsc.components, func(cc Component) bool {
 		return tsc.resolvedPathFor(cc.Path()) == searchResolved
@@ -313,7 +313,7 @@ func (tsc *ThreadSafeComponents) addComponent(c Component) (Component, bool) {
 	tsc.mu.Lock()
 	defer tsc.mu.Unlock()
 
-	searchResolved := resolvePath(c.Path())
+	searchResolved := util.ResolvePath(c.Path())
 
 	// Do one last check to see if the component is already in the components list
 	// to avoid a TOCTOU race condition. Uses resolved paths for comparison.
@@ -339,7 +339,7 @@ func (tsc *ThreadSafeComponents) FindByPath(path string) Component {
 	tsc.mu.RLock()
 	defer tsc.mu.RUnlock()
 
-	resolvedSearchPath := resolvePath(path)
+	resolvedSearchPath := util.ResolvePath(path)
 
 	for _, c := range tsc.components {
 		if tsc.resolvedPathFor(c.Path()) == resolvedSearchPath {
@@ -369,14 +369,3 @@ func (tsc *ThreadSafeComponents) Len() int {
 
 	return len(tsc.components)
 }
-
-// resolvePath resolves symlinks in a path for consistent comparison across platforms.
-// On macOS, /var is a symlink to /private/var, so paths must be resolved.
-func resolvePath(path string) string {
-	resolved, err := filepath.EvalSymlinks(path)
-	if err != nil {
-		return path
-	}
-
-	return resolved
-}

internal/discovery/discovery.go

@@ -631,10 +631,10 @@ func buildDependentsIndex(components component.Components) map[string][]string {
 	dependentUnits := make(map[string][]string)
 
 	for _, c := range components {
-		cPath := resolvePath(c.Path())
+		cPath := util.ResolvePath(c.Path())
 
 		for _, dep := range c.Dependencies() {
-			depPath := resolvePath(dep.Path())
+			depPath := util.ResolvePath(dep.Path())
 			dependentUnits[depPath] = util.RemoveDuplicates(append(dependentUnits[depPath], cPath))
 		}
 	}
@@ -697,7 +697,7 @@ func filterByAllowSet(components component.Components, allowed map[string]struct
 	filtered := make(component.Components, 0, len(components))
 
 	for _, c := range components {
-		resolvedPath := resolvePath(c.Path())
+		resolvedPath := util.ResolvePath(c.Path())
 		if _, ok := allowed[resolvedPath]; ok {
 			filtered = append(filtered, c)
 		}

internal/discovery/helpers.go

@@ -28,17 +28,6 @@ const (
 // DefaultConfigFilenames are the default Terragrunt config filenames used in discovery.
 var DefaultConfigFilenames = []string{config.DefaultTerragruntConfigPath, config.DefaultStackFile}
 
-// resolvePath resolves symlinks in a path for consistent comparison across platforms.
-// On macOS, /var is a symlink to /private/var, so paths must be resolved.
-func resolvePath(path string) string {
-	resolved, err := filepath.EvalSymlinks(path)
-	if err != nil {
-		return path
-	}
-
-	return resolved
-}
-
 // isExternal checks if a component path is outside the given working directory.
 // A path is considered external if it's not within or equal to the working directory.
 // We conservatively evaluate paths as external if we cannot determine their absolute path.

internal/discovery/phase_graph.go

@@ -546,20 +546,20 @@ func (p *GraphPhase) discoverDependentsUpstream(
 		return nil
 	}
 
-	resolvedTargetPath := resolvePath(target.Path())
+	resolvedTargetPath := util.ResolvePath(target.Path())
 
 	// When the target is from a worktree, we need to compare using relative suffixes
 	// because the absolute paths will differ (worktree vs original directory).
 	// We resolve paths to handle symlinks (e.g., /var -> /private/var on macOS).
 	targetRelSuffix := ""
 
 	if targetDCtx := target.DiscoveryContext(); targetDCtx != nil && targetDCtx.WorkingDir != "" {
-		resolvedWorkingDir := resolvePath(targetDCtx.WorkingDir)
+		resolvedWorkingDir := util.ResolvePath(targetDCtx.WorkingDir)
 		targetRelSuffix = strings.TrimPrefix(resolvedTargetPath, resolvedWorkingDir)
 	}
 
 	// Resolve discovery.workingDir for consistent path comparison.
-	resolvedDiscoveryWorkingDir := resolvePath(discovery.workingDir)
+	resolvedDiscoveryWorkingDir := util.ResolvePath(discovery.workingDir)
 
 	var (
 		errs  []error
@@ -724,7 +724,7 @@ func (p *GraphPhase) discoverDependentsUpstream(
 
 				// Compare paths: first try exact match, then try relative suffix match
 				// for worktree scenarios where target is in a different directory.
-				resolvedDep := resolvePath(dep)
+				resolvedDep := util.ResolvePath(dep)
 
 				switch {
 				case resolvedDep == resolvedTargetPath:
@@ -913,7 +913,7 @@ func extractDependencyPaths(cfg *config.TerragruntConfig, c component.Component)
 			depPath = filepath.Clean(filepath.Join(c.Path(), depPath))
 		}
 
-		depPath = resolvePath(depPath)
+		depPath = util.ResolvePath(depPath)
 		deduped[depPath] = struct{}{}
 	}
 
@@ -923,7 +923,7 @@ func extractDependencyPaths(cfg *config.TerragruntConfig, c component.Component)
 				dependency = filepath.Clean(filepath.Join(c.Path(), dependency))
 			}
 
-			dependency = resolvePath(dependency)
+			dependency = util.ResolvePath(dependency)
 			deduped[dependency] = struct{}{}
 		}
 	}

internal/filter/evaluator.go

@@ -275,7 +275,7 @@ func evaluateGraphExpression(l log.Logger, expr *GraphExpression, components com
 		}
 
 		for _, target := range targetMatches {
-			traverseGraph(l, target, resultSet, visited, graphDirectionDependencies, depth, warnOnLimit)
+			traverseGraph(l, target, resultSet, visited, GraphDirectionDependencies, depth, warnOnLimit)
 		}
 	}
 
@@ -291,7 +291,7 @@ func evaluateGraphExpression(l log.Logger, expr *GraphExpression, components com
 		}
 
 		for _, target := range targetMatches {
-			traverseGraph(l, target, resultSet, visited, graphDirectionDependents, depth, warnOnLimit)
+			traverseGraph(l, target, resultSet, visited, GraphDirectionDependents, depth, warnOnLimit)
 		}
 	}
 
@@ -322,25 +322,6 @@ func evaluateGitFilter(filter *GitExpression, components component.Components) (
 	return results, nil
 }
 
-// graphDirection represents the direction of graph traversal.
-type graphDirection int
-
-const (
-	graphDirectionDependencies graphDirection = iota
-	graphDirectionDependents
-)
-
-func (d graphDirection) String() string {
-	switch d {
-	case graphDirectionDependencies:
-		return "dependencies"
-	case graphDirectionDependents:
-		return "dependents"
-	}
-
-	return "unknown"
-}
-
 // traverseGraph recursively traverses the graph in the specified direction (dependencies or dependents).
 // The visited map tracks the maximum remaining depth at which each node was visited, allowing re-traversal
 // when a node is reached with more remaining depth (e.g., from a closer target).
@@ -350,7 +331,7 @@ func traverseGraph(
 	c component.Component,
 	resultSet map[string]component.Component,
 	visited map[string]int,
-	direction graphDirection,
+	direction GraphDirection,
 	remainingDepth int,
 	warnOnLimit bool,
 ) {
@@ -379,7 +360,7 @@ func traverseGraph(
 	visited[path] = remainingDepth
 
 	var relatedComponents []component.Component
-	if direction == graphDirectionDependencies {
+	if direction == GraphDirectionDependencies {
 		relatedComponents = c.Dependencies()
 	} else {
 		relatedComponents = c.Dependents()

internal/util/file.go

@@ -1188,6 +1188,18 @@ func SanitizePath(baseDir string, file string) (string, error) {
 	return fullPath, nil
 }
 
+// ResolvePath resolves symlinks in a path for consistent comparison across platforms.
+// On macOS, /var is a symlink to /private/var, so paths must be resolved.
+// Returns the original path if symlink resolution fails.
+func ResolvePath(path string) string {
+	resolved, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		return path
+	}
+
+	return resolved
+}
+
 // MoveFile attempts to rename a file from source to destination, if this fails
 // due to invalid cross-device link it falls back to copying the file contents
 // and deleting the original file.