Fix project.toml directory exclusion behavior (#2402)

This change fixes unexpected behavior when excluding directories with trailing
slash patterns in project.toml. Previously, patterns like "foo/" would exclude
files within the directory but still create empty directory entries in the
final image.

Changes:
- Enhanced getFileFilter() to properly exclude directories when patterns end with "/"
- Modified WriteDirToTar() to skip entire directory trees using filepath.SkipDir
- Fixed isNil() function in testhelpers to properly handle nil function pointers
- Added comprehensive tests for directory exclusion scenarios

The fix ensures that when users specify exclude = ["foo/"] in project.toml,
the directory "foo" and all its contents are completely excluded from the build
process, eliminating the unexpected empty directory artifacts.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: jjbustamante

pkg/archive/archive.go

@@ -179,6 +179,10 @@ func WriteDirToTar(tw TarWriter, srcDir, basePath string, uid, gid int, mode int
 				return err
 			}
 			if !fileFilter(relPath) {
+				// If this is a directory that doesn't match the filter, skip the entire directory tree
+				if fi != nil && fi.IsDir() {
+					return filepath.SkipDir
+				}
 				return nil
 			}
 		}

pkg/archive/archive_test.go

@@ -312,6 +312,32 @@ func testArchive(t *testing.T, when spec.G, it spec.S) {
 				}
 			})
 
+			it("excludes directories and their contents when directory is filtered", func() {
+				tarFile := filepath.Join(tmpDir, "some.tar")
+				fh, err := os.Create(tarFile)
+				h.AssertNil(t, err)
+
+				tw := tar.NewWriter(fh)
+
+				err = archive.WriteDirToTar(tw, src, "/nested/dir/dir-in-archive", 1234, 2345, 0777, true, false, func(path string) bool {
+					// Exclude the sub-dir directory entirely
+					return path != "sub-dir"
+				})
+				h.AssertNil(t, err)
+				h.AssertNil(t, tw.Close())
+				h.AssertNil(t, fh.Close())
+
+				file, err := os.Open(filepath.Join(tmpDir, "some.tar"))
+				h.AssertNil(t, err)
+				defer file.Close()
+
+				tr := tar.NewReader(file)
+
+				verify := h.NewTarVerifier(t, tr, 1234, 2345)
+				verify.NextFile("/nested/dir/dir-in-archive/some-file.txt", "some-content", int64(os.ModePerm))
+				verify.NoMoreFilesExist()
+			})
+
 			it("filter is only handed relevant section of the filepath", func() {
 				tarFile := filepath.Join(tmpDir, "some.tar")
 				fh, err := os.Create(tarFile)

pkg/client/build.go

@@ -894,12 +894,31 @@ func getFileFilter(descriptor projectTypes.Descriptor) (func(string) bool, error
 	if len(descriptor.Build.Exclude) > 0 {
 		excludes := ignore.CompileIgnoreLines(descriptor.Build.Exclude...)
 		return func(fileName string) bool {
-			return !excludes.MatchesPath(fileName)
+			// Check if the file/directory matches directly
+			if excludes.MatchesPath(fileName) {
+				return false
+			}
+			// For directories, also check if adding a trailing slash would match
+			// This handles patterns like "foo/" that should exclude the "foo" directory
+			if excludes.MatchesPath(fileName + "/") {
+				return false
+			}
+			return true
 		}, nil
 	}
 	if len(descriptor.Build.Include) > 0 {
 		includes := ignore.CompileIgnoreLines(descriptor.Build.Include...)
-		return includes.MatchesPath, nil
+		return func(fileName string) bool {
+			// Check if the file/directory matches directly
+			if includes.MatchesPath(fileName) {
+				return true
+			}
+			// For directories, also check if adding a trailing slash would match
+			if includes.MatchesPath(fileName + "/") {
+				return true
+			}
+			return false
+		}, nil
 	}
 
 	return nil, nil

pkg/client/build_test.go

@@ -156,6 +156,65 @@ func testBuild(t *testing.T, when spec.G, it spec.S) {
 		h.AssertNilE(t, fakeLifecycleImage.Cleanup())
 	})
 
+	when("#getFileFilter", func() {
+		when("exclude patterns", func() {
+			it("creates filter that excludes files matching patterns", func() {
+				descriptor := projectTypes.Descriptor{
+					Build: projectTypes.Build{
+						Exclude: []string{"*.log", "tmp/"},
+					},
+				}
+
+				filter, err := getFileFilter(descriptor)
+				h.AssertNil(t, err)
+				h.AssertNotNil(t, filter)
+
+				// Files matching patterns should be excluded (filter returns false)
+				h.AssertEq(t, filter("app.log"), false)
+				h.AssertEq(t, filter("tmp/cache.dat"), false)
+				h.AssertEq(t, filter("tmp"), false) // Directory "tmp" should be excluded due to "tmp/" pattern
+
+				// Files not matching patterns should be included (filter returns true)
+				h.AssertEq(t, filter("app.js"), true)
+				h.AssertEq(t, filter("src/main.go"), true)
+			})
+		})
+
+		when("include patterns", func() {
+			it("creates filter that includes only files matching patterns", func() {
+				descriptor := projectTypes.Descriptor{
+					Build: projectTypes.Build{
+						Include: []string{"src/", "*.md"},
+					},
+				}
+
+				filter, err := getFileFilter(descriptor)
+				h.AssertNil(t, err)
+				h.AssertNotNil(t, filter)
+
+				// Files matching patterns should be included (filter returns true)
+				h.AssertEq(t, filter("src/main.go"), true)
+				h.AssertEq(t, filter("README.md"), true)
+
+				// Files not matching patterns should be excluded (filter returns false)
+				h.AssertEq(t, filter("app.log"), false)
+				h.AssertEq(t, filter("tmp/cache.dat"), false)
+			})
+		})
+
+		when("both exclude and include are empty", func() {
+			it("returns nil filter", func() {
+				descriptor := projectTypes.Descriptor{
+					Build: projectTypes.Build{},
+				}
+
+				filter, err := getFileFilter(descriptor)
+				h.AssertNil(t, err)
+				h.AssertNil(t, filter)
+			})
+		})
+	})
+
 	when("#Build", func() {
 		when("ephemeral builder is not needed", func() {
 			it("does not create one", func() {

testhelpers/testhelpers.go

@@ -327,7 +327,14 @@ func AssertTarball(t *testing.T, path string) {
 }
 
 func isNil(value interface{}) bool {
-	return value == nil || (reflect.TypeOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil())
+	if value == nil {
+		return true
+	}
+	rv := reflect.ValueOf(value)
+	kind := rv.Kind()
+	// Check for types that can be nil
+	return (kind == reflect.Ptr || kind == reflect.Func || kind == reflect.Interface ||
+		kind == reflect.Chan || kind == reflect.Map || kind == reflect.Slice) && rv.IsNil()
 }
 
 func hasMatches(actual, exp string) bool {