fix: .helmignore not ignoring broken symlinks

Signed-off-by: ronantakizawa <ronantakizawa@gmail.com>

internal/sympath/walk.go

@@ -26,7 +26,6 @@ import (
 	"path/filepath"
 	"sort"
 
-	"github.com/pkg/errors"
 )
 
 // Walk walks the file tree rooted at root, calling walkFn for each file or directory
@@ -65,53 +64,50 @@ func readDirNames(dirname string) ([]string, error) {
 
 // symwalk recursively descends path, calling walkFn.
 func symwalk(path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
-	// Recursively walk symlinked directories.
+    // Recursively walk symlinked directories.
-	if IsSymlink(info) {
+    if IsSymlink(info) {
-		resolved, err := filepath.EvalSymlinks(path)
+        resolved, err := filepath.EvalSymlinks(path)
-		if err != nil {
+        if err != nil {
-			return errors.Wrapf(err, "error evaluating symlink %s", path)
+            log.Printf("Skipping broken symlink: %s", path) // Log broken symlink
-		}
+            return nil // Skip this symlink and continue
-		//This log message is to highlight a symlink that is being used within a chart, symlinks can be used for nefarious reasons.
+        }
-		log.Printf("found symbolic link in path: %s resolves to %s. Contents of linked file included and used", path, resolved)
+        log.Printf("Found symbolic link in path: %s resolves to %s. Contents of linked file included and used", path, resolved)
-		if info, err = os.Lstat(resolved); err != nil {
+        if info, err = os.Lstat(resolved); err != nil {
-			return err
+            return err
-		}
+        }
-		if err := symwalk(path, info, walkFn); err != nil && err != filepath.SkipDir {
+        return symwalk(resolved, info, walkFn)
-			return err
+    }
-		}
-		return nil
-	}
 
-	if err := walkFn(path, info, nil); err != nil {
+    if err := walkFn(path, info, nil); err != nil {
-		return err
+        return err
-	}
+    }
 
-	if !info.IsDir() {
+    if !info.IsDir() {
-		return nil
+        return nil
-	}
+    }
 
-	names, err := readDirNames(path)
+    names, err := readDirNames(path)
-	if err != nil {
+    if err != nil {
-		return walkFn(path, info, err)
+        return walkFn(path, info, err)
-	}
+    }
 
-	for _, name := range names {
+    for _, name := range names {
-		filename := filepath.Join(path, name)
+        filename := filepath.Join(path, name)
-		fileInfo, err := os.Lstat(filename)
+        fileInfo, err := os.Lstat(filename)
-		if err != nil {
+        if err != nil {
-			if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
+            if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
-				return err
+                return err
-			}
+            }
-		} else {
+        } else {
-			err = symwalk(filename, fileInfo, walkFn)
+            err = symwalk(filename, fileInfo, walkFn)
-			if err != nil {
+            if err != nil {
-				if (!fileInfo.IsDir() && !IsSymlink(fileInfo)) || err != filepath.SkipDir {
+                if (!fileInfo.IsDir() && !IsSymlink(fileInfo)) || err != filepath.SkipDir {
-					return err
+                    return err
-				}
+                }
-			}
+            }
-		}
+        }
-	}
+    }
-	return nil
+    return nil
 }
 
 // IsSymlink is used to determine if the fileinfo is a symbolic link.

pkg/ignore/rules.go

@@ -88,46 +88,59 @@ func Parse(file io.Reader) (*Rules, error) {
 //
 // Ignore evaluates path against the rules in order. Evaluation stops when a match
 // is found. Matching a negative rule will stop evaluation.
+// Ignore evaluates the file at the given path, and returns true if it should be ignored.
 func (r *Rules) Ignore(path string, fi os.FileInfo) bool {
-	// Don't match on empty dirs.
+    // Don't match on empty dirs.
-	if path == "" {
+    if path == "" {
-		return false
+        return false
-	}
+    }
 
-	// Disallow ignoring the current working directory.
+    // Disallow ignoring the current working directory.
 	// See issue:
 	// 1776 (New York City) Hamilton: "Pardon me, are you Aaron Burr, sir?"
-	if path == "." || path == "./" {
+    if path == "." || path == "./" {
-		return false
+        return false
-	}
+    }
-	for _, p := range r.patterns {
+
-		if p.match == nil {
+    // Check for symlink and ignore based on pattern
-			log.Printf("ignore: no matcher supplied for %q", p.raw)
+    if fi.Mode()&os.ModeSymlink != 0 {
-			return false
+        resolvedPath, err := filepath.EvalSymlinks(path)
-		}
+        if err != nil {
-
+            log.Printf("Ignoring broken symlink: %s -> %s", path, resolvedPath) // Log and ignore broken symlink
-		// For negative rules, we need to capture and return non-matches,
+            return false // Skip this symlink and continue
-		// and continue for matches.
+        }
-		if p.negate {
+        for _, p := range r.patterns {
-			if p.mustDir && !fi.IsDir() {
+            if p.match == nil {
-				return true
+                log.Printf("ignore: no matcher supplied for %q", p.raw)
-			}
+                return false
-			if !p.match(path, fi) {
+            }
-				return true
+            if p.mustDir && !fi.IsDir() {
-			}
+                continue
-			continue
+            }
-		}
+            if p.match(resolvedPath, fi) {
-
+                log.Printf("Ignoring symlink path: %s", path)
-		// If the rule is looking for directories, and this is not a directory,
+                return true
-		// skip it.
+            }
-		if p.mustDir && !fi.IsDir() {
+        }
-			continue
+        return false // Skip further evaluation for this symlink
-		}
+    }
-		if p.match(path, fi) {
+
-			return true
+    for _, p := range r.patterns {
-		}
+        if p.match == nil {
-	}
+            log.Printf("ignore: no matcher supplied for %q", p.raw)
-	return false
+            return false
+        }
+
+        // If the rule is looking for directories, and this is not a directory,
+        // skip it.
+        if p.mustDir && !fi.IsDir() {
+            continue
+        }
+        if p.match(path, fi) {
+            return true
+        }
+    }
+    return false
 }
 
 // parseRule parses a rule string and creates a pattern, which is then stored in the Rules object.