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
@@ -69,17 +68,14 @@ func symwalk(path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
     if IsSymlink(info) {
         resolved, err := filepath.EvalSymlinks(path)
         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 {
             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 {

pkg/ignore/rules.go

@@ -88,6 +88,7 @@ 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.
     if path == "" {
@@ -100,22 +101,34 @@ func (r *Rules) Ignore(path string, fi os.FileInfo) bool {
     if path == "." || path == "./" {
         return false
     }
+
+    // Check for symlink and ignore based on pattern
+    if fi.Mode()&os.ModeSymlink != 0 {
+        resolvedPath, err := filepath.EvalSymlinks(path)
+        if err != nil {
+            log.Printf("Ignoring broken symlink: %s -> %s", path, resolvedPath) // Log and ignore broken symlink
+            return false // Skip this symlink and continue
+        }
         for _, p := range r.patterns {
             if p.match == nil {
                 log.Printf("ignore: no matcher supplied for %q", p.raw)
                 return false
             }
-
-		// For negative rules, we need to capture and return non-matches,
-		// and continue for matches.
-		if p.negate {
             if p.mustDir && !fi.IsDir() {
-				return true
+                continue
             }
-			if !p.match(path, fi) {
+            if p.match(resolvedPath, fi) {
+                log.Printf("Ignoring symlink path: %s", path)
                 return true
             }
-			continue
+        }
+        return false // Skip further evaluation for this symlink
+    }
+
+    for _, p := range r.patterns {
+        if p.match == nil {
+            log.Printf("ignore: no matcher supplied for %q", p.raw)
+            return false
         }
 
         // If the rule is looking for directories, and this is not a directory,