Fix .juliabundleignore: directory patterns, comments, and content exclusion

Three bugs in the bundleignore parser:

1. Directory patterns (e.g. "output-data/") were compiled into
   Glob.FilenameMatch which only matched the literal string, not files
   inside the directory. A pattern "foo/" would exclude the entry "foo/"
   but NOT "foo/bar.jl".

   Fix: plain directory prefixes (no glob chars) are matched via
   startswith(). Glob-containing directory patterns (e.g. "*/bar/")
   emit both the dir match and a "*/bar/*" contents match.

2. Comment lines (starting with #) and blank lines were compiled into
   Glob.FilenameMatch patterns, potentially causing spurious matches.

   Fix: _parse_bundleignore_line() skips comments and blanks.

3. A file named "foo.csv" could be incorrectly excluded by a directory
   pattern "foo.csv/" because joinpath("foo.csv", "") == "foo.csv/".

   Fix: the rpath_dir startswith check is only applied when the path
   is actually a directory (isdir guard).

Updates existing tests to reflect the corrected behavior: files inside
directories matched by "*/bar/" patterns are now properly excluded.

Relates to #130 (negated paths — this fix is a prerequisite, cleaning
up the same code path).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Alex Jones

src/PackageBundler/utils.jl

@@ -73,16 +73,46 @@ function is_subpath(dir, subpath)
     return startswith(norm_subpath, norm_dir)
 end
 
+"""
+    _parse_bundleignore_line(line) -> Vector of patterns (Glob.FilenameMatch or String), or nothing
+
+Parse a single line from a `.juliabundleignore` file.  Returns `nothing` for
+blank lines and comments (lines starting with `#`).
+
+For directory patterns (ending with `/`):
+- If the pattern contains glob characters (`*`, `?`, `[`), emit both the
+  directory glob itself AND a `<pattern>*` glob to match contents.
+- If it's a plain prefix (e.g. `output-data/`), emit it as a `String` for
+  `startswith` matching.
+
+All other lines are compiled into `Glob.FilenameMatch` patterns.
+"""
+function _parse_bundleignore_line(line)
+    s = strip(line)
+    (isempty(s) || startswith(s, '#')) && return nothing
+    if endswith(s, '/')
+        has_glob = any(c -> c in ('*', '?', '['), s)
+        if has_glob
+            # Glob directory pattern: match both the dir and its contents
+            return [Glob.FilenameMatch(s), Glob.FilenameMatch(s * "*")]
+        else
+            # Plain directory prefix: use startswith matching
+            return [String(s)]
+        end
+    end
+    return [Glob.FilenameMatch(s)]
+end
+
 function get_bundleignore(file, top)
     dir = dirname(file)
     patterns = Set{Any}()
     try
         while true
             if isfile(joinpath(dir, ".juliabundleignore"))
-                union!(
-                    patterns,
-                    Glob.FilenameMatch.(strip.(readlines(joinpath(dir, ".juliabundleignore")))),
-                )
+                for line in readlines(joinpath(dir, ".juliabundleignore"))
+                    parsed = _parse_bundleignore_line(line)
+                    parsed !== nothing && union!(patterns, parsed)
+                end
                 return patterns, dir
             end
             if dir == dirname(dir) || dir == top
@@ -117,16 +147,22 @@ function path_filterer(top)
 
         patterns, ignorepath = get_bundleignore(path, top)
 
-        rpath = relpath(path, ignorepath)
-
-        return !(
-            any(p -> occursin(p, sanitize_windows_path(rpath)), patterns) ||
-            # directories specifically can be excluded by patterns that end with a
-            # path separator, and to match them in case `path` does not have that
-            # path separator appended, we append it ourselves before matching
-            isdir(path) &&
-            any(p -> occursin(p, sanitize_windows_path(joinpath(rpath, ""))), patterns)
-        )
+        rpath = sanitize_windows_path(relpath(path, ignorepath))
+        # Ensure rpath uses forward slashes for consistent matching
+        rpath_dir = sanitize_windows_path(joinpath(relpath(path, ignorepath), ""))
+
+        return !(any(patterns) do p
+            if p isa Glob.FilenameMatch
+                # Glob pattern: match against the relative path
+                occursin(p, rpath) || (isdir(path) && occursin(p, rpath_dir))
+            else
+                # String directory prefix (e.g. "script/experiment/"):
+                # exclude if the relative path starts with the prefix.
+                # Only match the rpath_dir form for actual directories,
+                # to avoid "foo.csv/" matching a FILE named "foo.csv".
+                startswith(rpath, p) || (isdir(path) && startswith(rpath_dir, p))
+            end
+        end)
     end
 end
 

test/packagebundler.jl

@@ -240,10 +240,9 @@ end
         @test !pred(joinpath(dir, "Pkg3", "test", "foo"))
         @test pred(joinpath(dir, "Pkg3", "test", "fooo", "test"))
 
-        # Note: even though the test/foo and test/bar directories are
-        # excluded, the predicate function does not return false if you
-        # check for file within the directories.
-        @test pred(joinpath(dir, "Pkg3", "test", "bar", "test"))
+        # Directory patterns (*/bar/) now correctly exclude contents
+        @test !pred(joinpath(dir, "Pkg3", "test", "bar", "test"))
+        # */foo is a file glob (no trailing /), so only matches the file, not contents
         @test pred(joinpath(dir, "Pkg3", "test", "foo", "test"))
     end
     @testset "toplevel" begin
@@ -259,10 +258,9 @@ end
         @test !pred(joinpath(dir, "test", "foo"))
         @test pred(joinpath(dir, "test", "fooo", "test"))
 
-        # Note: even though the test/foo and test/bar directories are
-        # excluded, the predicate function does not return false if you
-        # check for file within the directories.
-        @test pred(joinpath(dir, "test", "bar", "test"))
+        # Directory patterns (*/bar/) now correctly exclude contents
+        @test !pred(joinpath(dir, "test", "bar", "test"))
+        # */foo is a file glob (no trailing /), so only matches the file, not contents
         @test pred(joinpath(dir, "test", "foo", "test"))
     end
 end