vercel · kodiakhq · Jun 28, 2022 · Jun 28, 2022 · Jun 28, 2022 · Jun 28, 2022
@@ -25,39 +25,40 @@ type PackageDepsOptions struct {
 
 // GetPackageDeps Builds an object containing git hashes for the files under the specified `packagePath` folder.
 func GetPackageDeps(rootPath AbsolutePath, p *PackageDepsOptions) (map[turbopath.AnchoredUnixPath]string, error) {
+	pkgPath := rootPath.Join(p.PackagePath)
 	// Add all the checked in hashes.
 	var result map[turbopath.AnchoredUnixPath]string
 	if len(p.InputPatterns) == 0 {
-		gitLsTreeOutput, err := gitLsTree(rootPath.Join(p.PackagePath))
+		gitLsTreeOutput, err := gitLsTree(pkgPath)
 		if err != nil {
 			return nil, fmt.Errorf("could not get git hashes for files in package %s: %w", p.PackagePath, err)
 		}
 		result = gitLsTreeOutput
 	} else {
-		gitLsFilesOutput, err := gitLsFiles(rootPath.Join(p.PackagePath), p.InputPatterns)
+		gitLsFilesOutput, err := gitLsFiles(pkgPath, p.InputPatterns)
 		if err != nil {
 			return nil, fmt.Errorf("could not get git hashes for file patterns %v in package %s: %w", p.InputPatterns, p.PackagePath, err)
 		}
 		result = gitLsFilesOutput
 	}
 
 	// Update the checked in hashes with the current repo status
-	gitStatusOutput, err := gitStatus(rootPath.Join(p.PackagePath), p.InputPatterns)
+	// The paths returned from this call are anchored at the package directory
+	gitStatusOutput, err := gitStatus(pkgPath, p.InputPatterns)
 	if err != nil {
 		return nil, fmt.Errorf("Could not get git hashes from git status: %v", err)
 	}
 
-	var filesToHash []turbopath.AnchoredUnixPath
+	var filesToHash []turbopath.AnchoredSystemPath
 	for filePath, status := range gitStatusOutput {
 		if status.isDelete() {
 			delete(result, filePath)
 		} else {
-			filesToHash = append(filesToHash, filePath)
+			filesToHash = append(filesToHash, filePath.ToSystemPath())
 		}
 	}
 
-	convertedRootPath := turbopath.AbsoluteSystemPathFromUpstream(rootPath.ToString())
-	hashes, err := gitHashObject(convertedRootPath, turbopath.AnchoredUnixPathArray(filesToHash).ToSystemPathArray())
+	hashes, err := gitHashObject(turbopath.AbsoluteSystemPathFromUpstream(pkgPath.ToString()), filesToHash)
 	if err != nil {
 		return nil, err
 	}
@@ -89,10 +90,10 @@ func GetHashableDeps(rootPath AbsolutePath, files []turbopath.AbsoluteSystemPath
 // gitHashObject returns a map of paths to their SHA hashes calculated by passing the paths `git hash-object`.
 // `git hash-object` expects paths to use Unix separators, even on Windows.
 //
-// Note: paths of files to hash passed to `git hash-object` are processed as relative to the *repository* root.
-// For that reason we convert all input paths and make them relative to the rootPath prior to passing them
+// Note: paths of files to hash passed to `git hash-object` are processed as relative to the given anchor.
+// For that reason we convert all input paths and make them relative to the anchor prior to passing them
 // to `git hash-object`.
-func gitHashObject(rootPath turbopath.AbsoluteSystemPath, filesToHash []turbopath.AnchoredSystemPath) (map[turbopath.AnchoredUnixPath]string, error) {
+func gitHashObject(anchor turbopath.AbsoluteSystemPath, filesToHash []turbopath.AnchoredSystemPath) (map[turbopath.AnchoredUnixPath]string, error) {
 	fileCount := len(filesToHash)
 	output := make(map[turbopath.AnchoredUnixPath]string, fileCount)
 
@@ -102,7 +103,7 @@ func gitHashObject(rootPath turbopath.AbsoluteSystemPath, filesToHash []turbopat
 			"hash-object",   // hash a file,
 			"--stdin-paths", // using a list of newline-separated paths from stdin.
 		)
-		cmd.Dir = rootPath.ToString() // Start at this directory.
+		cmd.Dir = anchor.ToString() // Start at this directory.
 
 		// The functionality for gitHashObject is different enough that it isn't reasonable to
 		// generalize the behavior for `runGitCmd`. In fact, it doesn't even use the `gitoutput`
@@ -125,7 +126,7 @@ func gitHashObject(rootPath turbopath.AbsoluteSystemPath, filesToHash []turbopat
 			// This function's result needs to be relative to `rootPath`.
 			// We convert all files to absolute paths and assume that they will be inside of the repository.
 			for _, file := range filesToHash {
-				converted := file.RestoreAnchor(rootPath)
+				converted := file.RestoreAnchor(anchor)
 
 				// `git hash-object` expects paths to use Unix separators, even on Windows.
 				// `git hash-object` expects paths to be one per line so we must escape newlines.

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
@@ -215,6 +216,78 @@ func Test_getTraversePath(t *testing.T) {
 	}
 }
 
+func requireGitCmd(t *testing.T, repoRoot AbsolutePath, args ...string) {
+	t.Helper()
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repoRoot.ToString()
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git commit failed: %v %v", err, string(out))
+	}
+}
+
+func TestGetPackageDeps(t *testing.T) {
+	// Directory structure:
+	// <root>/
+	//   my-pkg/
+	//     committed-file
+	//     deleted-file
+	//     uncommitted-file <- new file not added to git
+
+	repoRoot := AbsolutePathFromUpstream(t.TempDir())
+	myPkgDir := repoRoot.Join("my-pkg")
+	committedFilePath := myPkgDir.Join("committed-file")
+	err := committedFilePath.EnsureDir()
+	assert.NilError(t, err, "EnsureDir")
+	err = committedFilePath.WriteFile([]byte("committed bytes"), 0644)
+	assert.NilError(t, err, "WriteFile")
+	deletedFilePath := myPkgDir.Join("deleted-file")
+	err = deletedFilePath.WriteFile([]byte("delete-me"), 0644)
+	assert.NilError(t, err, "WriteFile")
+	requireGitCmd(t, repoRoot, "init", ".")
+	requireGitCmd(t, repoRoot, "config", "--local", "user.name", "test")
+	requireGitCmd(t, repoRoot, "config", "--local", "user.email", "test@example.com")
+	requireGitCmd(t, repoRoot, "add", ".")
+	requireGitCmd(t, repoRoot, "commit", "-m", "foo")
+	err = deletedFilePath.Remove()
+	assert.NilError(t, err, "Remove")
+	uncommittedFilePath := myPkgDir.Join("uncommitted-file")
+	err = uncommittedFilePath.WriteFile([]byte("uncommitted bytes"), 0644)
+	assert.NilError(t, err, "WriteFile")
+
+	tests := []struct {
+		opts     *PackageDepsOptions
+		expected map[turbopath.AnchoredUnixPath]string
+	}{
+		{
+			opts: &PackageDepsOptions{
+				PackagePath: "my-pkg",
+			},
+			expected: map[turbopath.AnchoredUnixPath]string{
+				"committed-file":   "3a29e62ea9ba15c4a4009d1f605d391cdd262033",
+				"uncommitted-file": "4e56ad89387e6379e4e91ddfe9872cf6a72c9976",
+			},
+		},
+		{
+			opts: &PackageDepsOptions{
+				PackagePath:   "my-pkg",
+				InputPatterns: []string{"uncommitted-file"},
+			},
+			expected: map[turbopath.AnchoredUnixPath]string{
+				"uncommitted-file": "4e56ad89387e6379e4e91ddfe9872cf6a72c9976",
+			},
+		},
+	}
+	for _, tt := range tests {
+		got, err := GetPackageDeps(repoRoot, tt.opts)
+		if err != nil {
+			t.Errorf("GetPackageDeps got error %v", err)
+			continue
+		}
+		assert.DeepEqual(t, got, tt.expected)
+	}
+}
+
 func Test_memoizedGetTraversePath(t *testing.T) {
 	fixturePath := getFixture(1)