refstore/packed: Use os.Root v0.1.42

3 files changed, 43 insertions, 20 deletions

diff --git a/refstore/packed/packed_test.go b/refstore/packed/packed_test.go
index 77d15640..dffed2a8 100644
--- a/refstore/packed/packed_test.go
+++ b/refstore/packed/packed_test.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"errors"
 	"os"
-	"path/filepath"
 	"slices"
 	"testing"
 
@@ -17,19 +16,33 @@ import (
 
 func openPackedRefStoreFromRepo(t *testing.T, repoPath string, algo objectid.Algorithm) *packed.Store {
 	t.Helper()
-	file, err := os.Open(filepath.Join(repoPath, "packed-refs")) //#nosec G304
+	root, err := os.OpenRoot(repoPath)
 	if err != nil {
-		t.Fatalf("open packed-refs: %v", err)
+		t.Fatalf("OpenRoot(repo): %v", err)
 	}
-	defer func() { _ = file.Close() }()
+	defer func() { _ = root.Close() }()
 
-	store, err := packed.New(file, algo)
+	store, err := packed.New(root, algo)
 	if err != nil {
 		t.Fatalf("packed.New: %v", err)
 	}
 	return store
 }
 
+func openPackedRefStoreFromContent(t *testing.T, content string, algo objectid.Algorithm) (*packed.Store, error) {
+	t.Helper()
+	dir := t.TempDir()
+	if err := os.WriteFile(dir+"/packed-refs", []byte(content), 0o644); err != nil {
+		t.Fatalf("WriteFile(packed-refs): %v", err)
+	}
+	root, err := os.OpenRoot(dir)
+	if err != nil {
+		t.Fatalf("OpenRoot(temp): %v", err)
+	}
+	defer func() { _ = root.Close() }()
+	return packed.New(root, algo)
+}
+
 func TestPackedResolveAndPeeled(t *testing.T) {
 	t.Parallel()
 	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
@@ -218,7 +231,7 @@ func TestPackedParseErrors(t *testing.T) {
 
 		for _, tt := range cases {
 			t.Run(tt.name, func(t *testing.T) {
-				if _, err := packed.New(bytes.NewBufferString(tt.data), algo); err == nil {
+				if _, err := openPackedRefStoreFromContent(t, tt.data, algo); err == nil {
 					t.Fatalf("packed.New expected parse error")
 				}
 			})
@@ -228,11 +241,18 @@ func TestPackedParseErrors(t *testing.T) {
 
 func TestPackedNewValidation(t *testing.T) {
 	t.Parallel()
-	if _, err := packed.New(bytes.NewReader(nil), objectid.AlgorithmUnknown); !errors.Is(err, objectid.ErrInvalidAlgorithm) {
+	dir := t.TempDir()
+	root, err := os.OpenRoot(dir)
+	if err != nil {
+		t.Fatalf("OpenRoot(temp): %v", err)
+	}
+	defer func() { _ = root.Close() }()
+
+	if _, err := packed.New(root, objectid.AlgorithmUnknown); !errors.Is(err, objectid.ErrInvalidAlgorithm) {
 		t.Fatalf("packed.New invalid algorithm error = %v", err)
 	}
-	if _, err := packed.New(nil, objectid.AlgorithmSHA1); err == nil {
-		t.Fatalf("packed.New nil reader expected error")
+	if _, err := packed.New(root, objectid.AlgorithmSHA256); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("packed.New missing packed-refs error = %v", err)
 	}
 }
 
diff --git a/refstore/packed/store.go b/refstore/packed/store.go
index d792e738..7705dacb 100644
--- a/refstore/packed/store.go
+++ b/refstore/packed/store.go
@@ -2,7 +2,8 @@
 package packed
 
 import (
-	"io"
+	"fmt"
+	"os"
 	"path"
 
 	"codeberg.org/lindenii/furgit/objectid"
@@ -18,15 +19,19 @@ type Store struct {
 
 var _ refstore.Store = (*Store)(nil)
 
-// New parses packed-refs content from r using the given object ID algorithm.
-func New(r io.Reader, algo objectid.Algorithm) (*Store, error) {
+// New parses packed-refs from one repository root using the given object ID
+// algorithm.
+func New(root *os.Root, algo objectid.Algorithm) (*Store, error) {
 	if algo.Size() == 0 {
 		return nil, objectid.ErrInvalidAlgorithm
 	}
-	if r == nil {
-		return nil, io.ErrUnexpectedEOF
+	packedRefs, err := root.Open("packed-refs")
+	if err != nil {
+		return nil, fmt.Errorf("refstore/packed: open packed-refs: %w", err)
 	}
-	byName, ordered, err := parsePackedRefs(r, algo)
+	defer func() { _ = packedRefs.Close() }()
+
+	byName, ordered, err := parsePackedRefs(packedRefs, algo)
 	if err != nil {
 		return nil, err
 	}
diff --git a/repository/repository.go b/repository/repository.go
index 4604dcbd..31034d2a 100644
--- a/repository/repository.go
+++ b/repository/repository.go
@@ -216,10 +216,8 @@ func openRefStore(root *os.Root, algo objectid.Algorithm) (out refstore.Store, e
 	}
 	backends := []refstore.Store{looseStore}
 
-	packedRefsFile, err := root.Open("packed-refs")
-	if err == nil {
-		packedStore, packedErr := refpacked.New(packedRefsFile, algo)
-		_ = packedRefsFile.Close()
+	if _, err := root.Stat("packed-refs"); err == nil {
+		packedStore, packedErr := refpacked.New(root, algo)
 		if packedErr != nil {
 			_ = looseStore.Close()
 			return nil, packedErr
@@ -227,7 +225,7 @@ func openRefStore(root *os.Root, algo objectid.Algorithm) (out refstore.Store, e
 		backends = append(backends, packedStore)
 	} else if !errors.Is(err, os.ErrNotExist) {
 		_ = looseStore.Close()
-		return nil, fmt.Errorf("repository: open packed-refs: %w", err)
+		return nil, fmt.Errorf("repository: stat packed-refs: %w", err)
 	}
 
 	return refchain.New(backends...), nil