shithub: furgit

Info  •  Files  •  Log  •  Branches

refstore/packed: Use os.Root

--- a/refstore/packed/packed_test.go

+++ b/refstore/packed/packed_test.go

@@ -4,7 +4,6 @@

 	"bytes"

 	"errors"

 	"os"

-	"path/filepath"

 	"slices"

 	"testing"

@@ -17,13 +16,13 @@

 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)

 	}

@@ -30,6 +29,20 @@

 	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 @@

 		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 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)

 	}

 }

--- 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 @@

 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

 	}

--- a/repository/repository.go

+++ b/repository/repository.go

@@ -216,10 +216,8 @@

 	}

 	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 @@

 		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

-- 

⑨