shithub: furgit

--- a/refstore/loose/list.go

+++ /dev/null

@@ -1,114 +1,0 @@

-package loose

-import (

-	"errors"

-	"os"

-	"path"

-	"slices"

-	"codeberg.org/lindenii/furgit/ref"

-	"codeberg.org/lindenii/furgit/refstore"

-)

-// List lists loose references matching pattern.

-//

-// Pattern uses path.Match syntax against full reference names.

-// Empty pattern matches all references.

-func (store *Store) List(pattern string) ([]ref.Ref, error) {

-	matchAll := pattern == ""

-	if !matchAll {

-		_, err := path.Match(pattern, "HEAD")

-		if err != nil {

-			return nil, err

-		}

-	}

-	names, err := store.collectLooseRefNames()

-	if err != nil {

-		return nil, err

-	}

-	slices.Sort(names)

-	refs := make([]ref.Ref, 0, len(names))

-	for _, name := range names {

-		if !matchAll {

-			matched, err := path.Match(pattern, name)

-			if err != nil {

-				return nil, err

-			}

-			if !matched {

-				continue

-			}

-		}

-		resolved, err := store.resolveOne(name)

-		if err != nil {

-			if errors.Is(err, refstore.ErrReferenceNotFound) {

-				continue

-			}

-			return nil, err

-		}

-		refs = append(refs, resolved)

-	}

-	return refs, nil

-}

-// collectLooseRefNames returns loose ref names available in this backend.

-func (store *Store) collectLooseRefNames() ([]string, error) {

-	names := make([]string, 0, 16)

-	_, err := store.root.Stat("HEAD")

-	if err == nil {

-		names = append(names, "HEAD")

-	} else if !errors.Is(err, os.ErrNotExist) {

-		return nil, err

-	}

-	var walk func(string) error

-	walk = func(dir string) error {

-		file, err := store.root.Open(dir)

-		if err != nil {

-			if errors.Is(err, os.ErrNotExist) {

-				return nil

-			}

-			return err

-		}

-		defer func() { _ = file.Close() }()

-		entries, err := file.ReadDir(-1)

-		if err != nil {

-			return err

-		}

-		for _, entry := range entries {

-			name := path.Join(dir, entry.Name())

-			if entry.IsDir() {

-				err := walk(name)

-				if err != nil {

-					return err

-				}

-				continue

-			}

-			names = append(names, name)

-		}

-		return nil

-	}

-	err = walk("refs")

-	if err != nil {

-		return nil, err

-	}

-	return names, nil

-}

--- a/refstore/loose/loose_test.go

+++ /dev/null

@@ -1,264 +1,0 @@

-package loose_test

-import (

-	"errors"

-	"slices"

-	"testing"

-	"codeberg.org/lindenii/furgit/internal/testgit"

-	"codeberg.org/lindenii/furgit/objectid"

-	"codeberg.org/lindenii/furgit/ref"

-	"codeberg.org/lindenii/furgit/refstore"

-	"codeberg.org/lindenii/furgit/refstore/loose"

-)

-func openLooseStore(t *testing.T, testRepo *testgit.TestRepo, algo objectid.Algorithm) *loose.Store {

-	t.Helper()

-	root := testRepo.OpenGitRoot(t)

-	store, err := loose.New(root, algo)

-	if err != nil {

-		t.Fatalf("loose.New: %v", err)

-	}

-	return store

-}

-func TestLooseResolveAndResolveFully(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "loose refs commit")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		testRepo.SymbolicRef(t, "HEAD", "refs/heads/main")

-		store := openLooseStore(t, testRepo, algo)

-		resolvedHead, err := store.Resolve("HEAD")

-		if err != nil {

-			t.Fatalf("Resolve(HEAD): %v", err)

-		}

-		headSym, ok := resolvedHead.(ref.Symbolic)

-		if !ok {

-			t.Fatalf("Resolve(HEAD) type = %T, want ref.Symbolic", resolvedHead)

-		}

-		if headSym.Target != "refs/heads/main" {

-			t.Fatalf("Resolve(HEAD) target = %q, want %q", headSym.Target, "refs/heads/main")

-		}

-		resolvedMain, err := store.Resolve("refs/heads/main")

-		if err != nil {

-			t.Fatalf("Resolve(refs/heads/main): %v", err)

-		}

-		mainDet, ok := resolvedMain.(ref.Detached)

-		if !ok {

-			t.Fatalf("Resolve(main) type = %T, want ref.Detached", resolvedMain)

-		}

-		if mainDet.ID != commitID {

-			t.Fatalf("Resolve(main) id = %s, want %s", mainDet.ID, commitID)

-		}

-		fullHead, err := store.ResolveFully("HEAD")

-		if err != nil {

-			t.Fatalf("ResolveFully(HEAD): %v", err)

-		}

-		if fullHead.ID != commitID {

-			t.Fatalf("ResolveFully(HEAD) id = %s, want %s", fullHead.ID, commitID)

-		}

-		_, err = store.Resolve("refs/heads/does-not-exist")

-		if !errors.Is(err, refstore.ErrReferenceNotFound) {

-			t.Fatalf("Resolve(not-found) error = %v", err)

-		}

-	})

-}

-func TestLooseResolveFullyCycle(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		testRepo.SymbolicRef(t, "refs/heads/a", "refs/heads/b")

-		testRepo.SymbolicRef(t, "refs/heads/b", "refs/heads/a")

-		store := openLooseStore(t, testRepo, algo)

-		_, err := store.ResolveFully("refs/heads/a")

-		if err == nil {

-			t.Fatalf("ResolveFully(cycle) expected error")

-		}

-	})

-}

-func TestLooseListPattern(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "list refs commit")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		testRepo.UpdateRef(t, "refs/heads/feature", commitID)

-		testRepo.UpdateRef(t, "refs/tags/v1.0.0", commitID)

-		testRepo.SymbolicRef(t, "HEAD", "refs/heads/main")

-		store := openLooseStore(t, testRepo, algo)

-		allRefs, err := store.List("")

-		if err != nil {

-			t.Fatalf("List(\"\"): %v", err)

-		}

-		allNames := make([]string, 0, len(allRefs))

-		for _, entry := range allRefs {

-			allNames = append(allNames, entry.Name())

-		}

-		slices.Sort(allNames)

-		wantAll := []string{"HEAD", "refs/heads/feature", "refs/heads/main", "refs/tags/v1.0.0"}

-		if !slices.Equal(allNames, wantAll) {

-			t.Fatalf("List(\"\") names = %v, want %v", allNames, wantAll)

-		}

-		headRefs, err := store.List("refs/heads/*")

-		if err != nil {

-			t.Fatalf("List(refs/heads/*): %v", err)

-		}

-		headNames := make([]string, 0, len(headRefs))

-		for _, entry := range headRefs {

-			headNames = append(headNames, entry.Name())

-		}

-		slices.Sort(headNames)

-		wantHeads := []string{"refs/heads/feature", "refs/heads/main"}

-		if !slices.Equal(headNames, wantHeads) {

-			t.Fatalf("List(refs/heads/*) names = %v, want %v", headNames, wantHeads)

-		}

-	})

-}

-func TestLooseListPatternMatrix(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "loose refs pattern matrix")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		testRepo.UpdateRef(t, "refs/heads/feature/one", commitID)

-		testRepo.UpdateRef(t, "refs/notes/review", commitID)

-		testRepo.UpdateRef(t, "refs/tags/v1", commitID)

-		testRepo.SymbolicRef(t, "HEAD", "refs/heads/main")

-		store := openLooseStore(t, testRepo, algo)

-		tests := []struct {

-			pattern string

-			want    []string

-		}{

-			{

-				pattern: "refs/heads/*",

-				want:    []string{"refs/heads/main"},

-			},

-			{

-				pattern: "refs/heads/*/*",

-				want:    []string{"refs/heads/feature/one"},

-			},

-			{

-				pattern: "refs/*/feature/one",

-				want:    []string{"refs/heads/feature/one"},

-			},

-			{

-				pattern: "refs/heads/feat?re/one",

-				want:    []string{"refs/heads/feature/one"},

-			},

-			{

-				pattern: "refs/tags/v[0-9]",

-				want:    []string{"refs/tags/v1"},

-			},

-			{

-				pattern: "refs/*/*",

-				want:    []string{"refs/heads/main", "refs/notes/review", "refs/tags/v1"},

-			},

-		}

-		for _, tt := range tests {

-			t.Run(tt.pattern, func(t *testing.T) {

-				got, err := store.List(tt.pattern)

-				if err != nil {

-					t.Fatalf("List(%q): %v", tt.pattern, err)

-				}

-				gotNames := make([]string, 0, len(got))

-				for _, entry := range got {

-					gotNames = append(gotNames, entry.Name())

-				}

-				slices.Sort(gotNames)

-				wantNames := append([]string(nil), tt.want...)

-				slices.Sort(wantNames)

-				if !slices.Equal(gotNames, wantNames) {

-					t.Fatalf("List(%q) names = %v, want %v", tt.pattern, gotNames, wantNames)

-				}

-			})

-		}

-	})

-}

-func TestLooseMalformedDetachedRef(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		testRepo.WriteFileAll(t, "refs/heads/bad", []byte("not-a-hash\n"), 0o755, 0o644)

-		store := openLooseStore(t, testRepo, algo)

-		_, err := store.Resolve("refs/heads/bad")

-		if err == nil {

-			t.Fatalf("Resolve(malformed) expected error")

-		}

-	})

-}

-func TestLooseShorten(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "shorten refs commit")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		testRepo.UpdateRef(t, "refs/tags/main", commitID)

-		testRepo.UpdateRef(t, "refs/remotes/origin/main", commitID)

-		store := openLooseStore(t, testRepo, algo)

-		shortHead, err := store.Shorten("refs/heads/main")

-		if err != nil {

-			t.Fatalf("Shorten(head): %v", err)

-		}

-		if shortHead != "heads/main" {

-			t.Fatalf("Shorten(refs/heads/main) = %q, want %q", shortHead, "heads/main")

-		}

-		shortRemote, err := store.Shorten("refs/remotes/origin/main")

-		if err != nil {

-			t.Fatalf("Shorten(remote): %v", err)

-		}

-		if shortRemote != "origin/main" {

-			t.Fatalf("Shorten(remote) = %q, want %q", shortRemote, "origin/main")

-		}

-		_, err = store.Shorten("refs/heads/does-not-exist")

-		if !errors.Is(err, refstore.ErrReferenceNotFound) {

-			t.Fatalf("Shorten(not-found) error = %v", err)

-		}

-	})

-}

--- a/refstore/loose/resolve.go

+++ /dev/null

@@ -1,98 +1,0 @@

-package loose

-import (

-	"errors"

-	"fmt"

-	"os"

-	"strings"

-	"codeberg.org/lindenii/furgit/objectid"

-	"codeberg.org/lindenii/furgit/ref"

-	"codeberg.org/lindenii/furgit/refstore"

-)

-// Resolve resolves a loose reference name to symbolic or detached form.

-func (store *Store) Resolve(name string) (ref.Ref, error) { //nolint:ireturn

-	if name == "" {

-		return nil, refstore.ErrReferenceNotFound

-	}

-	resolved, err := store.resolveOne(name)

-	if err != nil {

-		return nil, err

-	}

-	return resolved, nil

-}

-// ResolveFully resolves symbolic references within the loose backend only.

-func (store *Store) ResolveFully(name string) (ref.Detached, error) {

-	if name == "" {

-		return ref.Detached{}, refstore.ErrReferenceNotFound

-	}

-	cur := name

-	seen := make(map[string]struct{})

-	for {

-		if _, ok := seen[cur]; ok {

-			return ref.Detached{}, fmt.Errorf("refstore/loose: symbolic reference cycle at %q", cur)

-		}

-		seen[cur] = struct{}{}

-		resolved, err := store.resolveOne(cur)

-		if err != nil {

-			return ref.Detached{}, err

-		}

-		switch resolved := resolved.(type) {

-		case ref.Detached:

-			return resolved, nil

-		case ref.Symbolic:

-			target := strings.TrimSpace(resolved.Target)

-			if target == "" {

-				return ref.Detached{}, fmt.Errorf("refstore/loose: symbolic reference %q has empty target", resolved.Name())

-			}

-			cur = target

-		default:

-			return ref.Detached{}, fmt.Errorf("refstore/loose: unsupported reference type %T", resolved)

-		}

-	}

-}

-// resolveOne resolves one loose ref file without symbolic recursion.

-func (store *Store) resolveOne(name string) (ref.Ref, error) { //nolint:ireturn

-	data, err := store.root.ReadFile(name)

-	if err != nil {

-		if errors.Is(err, os.ErrNotExist) {

-			return nil, refstore.ErrReferenceNotFound

-		}

-		return nil, err

-	}

-	line := strings.TrimSpace(string(data))

-	if strings.HasPrefix(line, "ref: ") {

-		target := strings.TrimSpace(line[len("ref: "):])

-		if target == "" {

-			return nil, fmt.Errorf("refstore/loose: symbolic reference %q has empty target", name)

-		}

-		return ref.Symbolic{

-			RefName: name,

-			Target:  target,

-		}, nil

-	}

-	id, err := objectid.ParseHex(store.algo, line)

-	if err != nil {

-		return nil, fmt.Errorf("refstore/loose: invalid detached reference %q: %w", name, err)

-	}

-	return ref.Detached{

-		RefName: name,

-		ID:      id,

-	}, nil

-}

--- a/refstore/loose/shorten.go

+++ /dev/null

@@ -1,35 +1,0 @@

-package loose

-import (

-	"codeberg.org/lindenii/furgit/refstore"

-)

-// Shorten returns the shortest unambiguous shorthand for a loose ref name.

-func (store *Store) Shorten(name string) (string, error) {

-	refs, err := store.List("")

-	if err != nil {

-		return "", err

-	}

-	names := make([]string, 0, len(refs))

-	found := false

-	for _, entry := range refs {

-		if entry == nil {

-			continue

-		}

-		full := entry.Name()

-		names = append(names, full)

-		if full == name {

-			found = true

-		}

-	}

-	if !found {

-		return "", refstore.ErrReferenceNotFound

-	}

-	return refstore.ShortenName(name, names), nil

-}

--- a/refstore/loose/store.go

+++ /dev/null

@@ -1,38 +1,0 @@

-// Package loose provides a loose ref backend.

-package loose

-import (

-	"os"

-	"codeberg.org/lindenii/furgit/objectid"

-	"codeberg.org/lindenii/furgit/refstore"

-)

-// Store reads loose references from a repository root.

-//

-// Store owns root and closes it in Close.

-type Store struct {

-	// root is the repository root capability.

-	root *os.Root

-	// algo is the object ID algorithm used by this repository.

-	algo objectid.Algorithm

-}

-var _ refstore.ReadingStore = (*Store)(nil)

-// New creates a loose ref store rooted at a repository root.

-func New(root *os.Root, algo objectid.Algorithm) (*Store, error) {

-	if algo.Size() == 0 {

-		return nil, objectid.ErrInvalidAlgorithm

-	}

-	return &Store{

-		root: root,

-		algo: algo,

-	}, nil

-}

-// Close releases resources associated with the backend.

-func (store *Store) Close() error {

-	return store.root.Close()

-}

--- a/refstore/packed/TODO

+++ /dev/null

@@ -1,1 +1,0 @@

-Make ref name and parse-line validations stricter.

--- a/refstore/packed/close.go

+++ /dev/null

@@ -1,6 +1,0 @@

-package packed

-// Close releases resources associated with the backend.

-func (store *Store) Close() error {

-	return nil

-}

--- a/refstore/packed/list.go

+++ /dev/null

@@ -1,39 +1,0 @@

-package packed

-import (

-	"path"

-	"codeberg.org/lindenii/furgit/ref"

-)

-// List lists packed references matching pattern.

-//

-// Pattern uses path.Match syntax against full reference names.

-// Empty pattern matches all references.

-func (store *Store) List(pattern string) ([]ref.Ref, error) {

-	matchAll := pattern == ""

-	if !matchAll {

-		_, err := path.Match(pattern, "refs/heads/main")

-		if err != nil {

-			return nil, err

-		}

-	}

-	refs := make([]ref.Ref, 0, len(store.ordered))

-	for _, entry := range store.ordered {

-		if !matchAll {

-			matched, err := path.Match(pattern, entry.Name())

-			if err != nil {

-				return nil, err

-			}

-			if !matched {

-				continue

-			}

-		}

-		refs = append(refs, entry)

-	}

-	return refs, nil

-}

--- a/refstore/packed/new.go

+++ /dev/null

@@ -1,33 +1,0 @@

-package packed

-import (

-	"fmt"

-	"os"

-	"codeberg.org/lindenii/furgit/objectid"

-)

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

-	}

-	packedRefs, err := root.Open("packed-refs")

-	if err != nil {

-		return nil, fmt.Errorf("refstore/packed: open packed-refs: %w", err)

-	}

-	defer func() { _ = packedRefs.Close() }()

-	byName, ordered, err := parsePackedRefs(packedRefs, algo)

-	if err != nil {

-		return nil, err

-	}

-	return &Store{

-		byName:  byName,

-		ordered: ordered,

-	}, nil

-}

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

+++ /dev/null

@@ -1,299 +1,0 @@

-package packed_test

-import (

-	"bytes"

-	"errors"

-	"os"

-	"slices"

-	"testing"

-	"codeberg.org/lindenii/furgit/internal/testgit"

-	"codeberg.org/lindenii/furgit/objectid"

-	"codeberg.org/lindenii/furgit/ref"

-	"codeberg.org/lindenii/furgit/refstore"

-	"codeberg.org/lindenii/furgit/refstore/packed"

-)

-func openPackedRefStoreFromRepo(t *testing.T, testRepo *testgit.TestRepo, algo objectid.Algorithm) *packed.Store {

-	t.Helper()

-	root := testRepo.OpenGitRoot(t)

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

-	root, err := os.OpenRoot(dir)

-	if err != nil {

-		t.Fatalf("OpenRoot(temp): %v", err)

-	}

-	defer func() { _ = root.Close() }()

-	err = root.WriteFile("packed-refs", []byte(content), 0o644)

-	if err != nil {

-		t.Fatalf("WriteFile(packed-refs): %v", err)

-	}

-	return packed.New(root, algo)

-}

-func TestPackedResolveAndPeeled(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "packed refs commit")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		tagID := testRepo.TagAnnotated(t, "v1.0.0", commitID, "annotated tag")

-		testRepo.PackRefs(t, "--all", "--prune")

-		store := openPackedRefStoreFromRepo(t, testRepo, algo)

-		resolvedMain, err := store.Resolve("refs/heads/main")

-		if err != nil {

-			t.Fatalf("Resolve(main): %v", err)

-		}

-		mainDet, ok := resolvedMain.(ref.Detached)

-		if !ok {

-			t.Fatalf("Resolve(main) type = %T, want ref.Detached", resolvedMain)

-		}

-		if mainDet.ID != commitID {

-			t.Fatalf("Resolve(main) id = %s, want %s", mainDet.ID, commitID)

-		}

-		resolvedTag, err := store.Resolve("refs/tags/v1.0.0")

-		if err != nil {

-			t.Fatalf("Resolve(tag): %v", err)

-		}

-		tagDet, ok := resolvedTag.(ref.Detached)

-		if !ok {

-			t.Fatalf("Resolve(tag) type = %T, want ref.Detached", resolvedTag)

-		}

-		if tagDet.ID != tagID {

-			t.Fatalf("Resolve(tag) id = %s, want %s", tagDet.ID, tagID)

-		}

-		if tagDet.Peeled == nil {

-			t.Fatalf("Resolve(tag) peeled = nil, want commit")

-		}

-		if *tagDet.Peeled != commitID {

-			t.Fatalf("Resolve(tag) peeled = %s, want %s", *tagDet.Peeled, commitID)

-		}

-		fullTag, err := store.ResolveFully("refs/tags/v1.0.0")

-		if err != nil {

-			t.Fatalf("ResolveFully(tag): %v", err)

-		}

-		if fullTag.ID != tagDet.ID {

-			t.Fatalf("ResolveFully(tag) id = %s, want %s", fullTag.ID, tagDet.ID)

-		}

-		_, err = store.Resolve("refs/heads/does-not-exist")

-		if !errors.Is(err, refstore.ErrReferenceNotFound) {

-			t.Fatalf("Resolve(not-found) error = %v", err)

-		}

-	})

-}

-func TestPackedListAndShorten(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "packed refs list commit")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		testRepo.UpdateRef(t, "refs/tags/main", commitID)

-		testRepo.UpdateRef(t, "refs/remotes/origin/main", commitID)

-		testRepo.PackRefs(t, "--all", "--prune")

-		store := openPackedRefStoreFromRepo(t, testRepo, algo)

-		all, err := store.List("")

-		if err != nil {

-			t.Fatalf("List(all): %v", err)

-		}

-		allNames := make([]string, 0, len(all))

-		for _, entry := range all {

-			allNames = append(allNames, entry.Name())

-		}

-		slices.Sort(allNames)

-		wantAll := []string{"refs/heads/main", "refs/remotes/origin/main", "refs/tags/main"}

-		if !slices.Equal(allNames, wantAll) {

-			t.Fatalf("List(all) names = %v, want %v", allNames, wantAll)

-		}

-		filtered, err := store.List("refs/heads/*")

-		if err != nil {

-			t.Fatalf("List(pattern): %v", err)

-		}

-		if len(filtered) != 1 || filtered[0].Name() != "refs/heads/main" {

-			t.Fatalf("List(refs/heads/*) = %v, want refs/heads/main only", filtered)

-		}

-		short, err := store.Shorten("refs/heads/main")

-		if err != nil {

-			t.Fatalf("Shorten(main): %v", err)

-		}

-		if short != "heads/main" {

-			t.Fatalf("Shorten(main) = %q, want %q", short, "heads/main")

-		}

-		_, err = store.Shorten("refs/heads/does-not-exist")

-		if !errors.Is(err, refstore.ErrReferenceNotFound) {

-			t.Fatalf("Shorten(not-found) error = %v", err)

-		}

-	})

-}

-func TestPackedListPatternMatrix(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

-		_, _, commitID := testRepo.MakeCommit(t, "packed refs pattern matrix")

-		testRepo.UpdateRef(t, "refs/heads/main", commitID)

-		testRepo.UpdateRef(t, "refs/heads/feature/one", commitID)

-		testRepo.UpdateRef(t, "refs/notes/review", commitID)

-		testRepo.UpdateRef(t, "refs/tags/v1", commitID)

-		testRepo.PackRefs(t, "--all", "--prune")

-		store := openPackedRefStoreFromRepo(t, testRepo, algo)

-		tests := []struct {

-			pattern string

-			want    []string

-		}{

-			{

-				pattern: "refs/heads/*",

-				want:    []string{"refs/heads/main"},

-			},

-			{

-				pattern: "refs/heads/*/*",

-				want:    []string{"refs/heads/feature/one"},

-			},

-			{

-				pattern: "refs/*/feature/one",

-				want:    []string{"refs/heads/feature/one"},

-			},

-			{

-				pattern: "refs/heads/feat?re/one",

-				want:    []string{"refs/heads/feature/one"},

-			},

-			{

-				pattern: "refs/tags/v[0-9]",

-				want:    []string{"refs/tags/v1"},

-			},

-			{

-				pattern: "refs/*/*",

-				want:    []string{"refs/heads/main", "refs/notes/review", "refs/tags/v1"},

-			},

-		}

-		for _, tt := range tests {

-			t.Run(tt.pattern, func(t *testing.T) {

-				got, err := store.List(tt.pattern)

-				if err != nil {

-					t.Fatalf("List(%q): %v", tt.pattern, err)

-				}

-				gotNames := refNames(got)

-				slices.Sort(gotNames)

-				wantNames := append([]string(nil), tt.want...)

-				slices.Sort(wantNames)

-				if !slices.Equal(gotNames, wantNames) {

-					t.Fatalf("List(%q) names = %v, want %v", tt.pattern, gotNames, wantNames)

-				}

-			})

-		}

-	})

-}

-func TestPackedParseErrors(t *testing.T) {

-	t.Parallel()

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		cases := []struct {

-			name string

-			data string

-		}{

-			{

-				name: "peeled without ref",

-				data: "^" + stringsOfLen("0", algo.HexLen()) + "\n",

-			},

-			{

-				name: "invalid entry",

-				data: "not-a-valid-line\n",

-			},

-			{

-				name: "duplicate ref",

-				data: stringsOfLen("0", algo.HexLen()) + " refs/heads/main\n" +

-					stringsOfLen("1", algo.HexLen()) + " refs/heads/main\n",

-			},

-		}

-		for _, tt := range cases {

-			t.Run(tt.name, func(t *testing.T) {

-				_, err := openPackedRefStoreFromContent(t, tt.data, algo)

-				if err == nil {

-					t.Fatalf("packed.New expected parse error")

-				}

-			})

-		}

-	})

-}

-func TestPackedNewValidation(t *testing.T) {

-	t.Parallel()

-	dir := t.TempDir()

-	root, err := os.OpenRoot(dir)

-	if err != nil {

-		t.Fatalf("OpenRoot(temp): %v", err)

-	}

-	defer func() { _ = root.Close() }()

-	_, err = packed.New(root, objectid.AlgorithmUnknown)

-	if !errors.Is(err, objectid.ErrInvalidAlgorithm) {

-		t.Fatalf("packed.New invalid algorithm error = %v", err)

-	}

-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper

-		_, err = packed.New(root, algo)

-		if !errors.Is(err, os.ErrNotExist) {

-			t.Fatalf("packed.New missing packed-refs error = %v", err)

-		}

-	})

-}

-func refNames(refs []ref.Ref) []string {

-	names := make([]string, 0, len(refs))

-	for _, entry := range refs {

-		names = append(names, entry.Name())

-	}

-	return names

-}

-func stringsOfLen(ch string, n int) string {

-	return string(bytes.Repeat([]byte(ch), n))

-}

--- a/refstore/packed/parse.go

+++ /dev/null

@@ -1,112 +1,0 @@

-package packed

-import (

-	"bufio"

-	"fmt"

-	"io"

-	"strings"

-	"codeberg.org/lindenii/furgit/objectid"

-	"codeberg.org/lindenii/furgit/ref"

-)

-// parsePackedRefs parses packed-refs content into detached refs.

-func parsePackedRefs(r io.Reader, algo objectid.Algorithm) (map[string]ref.Detached, []ref.Detached, error) {

-	byName := make(map[string]ref.Detached)

-	ordered := make([]ref.Detached, 0, 32)

-	br := bufio.NewReader(r)

-	prev := -1

-	lineNum := 0

-	for {

-		line, err := br.ReadString('\n')

-		if err != nil && err != io.EOF {

-			return nil, nil, err

-		}

-		if line == "" && err == io.EOF {

-			break

-		}

-		lineNum++

-		line = strings.TrimSuffix(line, "\n")

-		line = strings.TrimSuffix(line, "\r")

-		line = strings.TrimSpace(line)

-		if line == "" {

-			if err == io.EOF {

-				break

-			}

-			continue

-		}

-		if strings.HasPrefix(line, "#") {

-			if err == io.EOF {

-				break

-			}

-			continue

-		}

-		if strings.HasPrefix(line, "^") {

-			if prev < 0 {

-				return nil, nil, fmt.Errorf("refstore/packed: line %d: peeled line without preceding ref", lineNum)

-			}

-			peeledHex := strings.TrimSpace(strings.TrimPrefix(line, "^"))

-			peeled, parseErr := objectid.ParseHex(algo, peeledHex)

-			if parseErr != nil {

-				return nil, nil, fmt.Errorf("refstore/packed: line %d: invalid peeled oid: %w", lineNum, parseErr)

-			}

-			peeledCopy := peeled

-			cur := ordered[prev]

-			cur.Peeled = &peeledCopy

-			ordered[prev] = cur

-			byName[cur.Name()] = cur

-			if err == io.EOF {

-				break

-			}

-			continue

-		}

-		fields := strings.Fields(line)

-		if len(fields) != 2 {

-			return nil, nil, fmt.Errorf("refstore/packed: line %d: malformed entry", lineNum)

-		}

-		id, parseErr := objectid.ParseHex(algo, fields[0])

-		if parseErr != nil {

-			return nil, nil, fmt.Errorf("refstore/packed: line %d: invalid oid: %w", lineNum, parseErr)

-		}

-		name := fields[1]

-		if name == "" {

-			return nil, nil, fmt.Errorf("refstore/packed: line %d: empty ref name", lineNum)

-		}

-		if _, exists := byName[name]; exists {

-			return nil, nil, fmt.Errorf("refstore/packed: line %d: duplicate ref %q", lineNum, name)

-		}

-		detached := ref.Detached{

-			RefName: name,

-			ID:      id,

-		}

-		ordered = append(ordered, detached)

-		prev = len(ordered) - 1

-		byName[name] = detached

-		if err == io.EOF {

-			break

-		}

-	}

-	return byName, ordered, nil

-}

--- a/refstore/packed/resolve.go

+++ /dev/null

@@ -1,28 +1,0 @@

-package packed

-import (

-	"codeberg.org/lindenii/furgit/ref"

-	"codeberg.org/lindenii/furgit/refstore"

-)

-// Resolve resolves a packed reference name to a detached ref.

-func (store *Store) Resolve(name string) (ref.Ref, error) { //nolint:ireturn

-	detached, ok := store.byName[name]

-	if !ok {

-		return nil, refstore.ErrReferenceNotFound

-	}

-	return detached, nil

-}

-// ResolveFully resolves a packed reference name to a detached ref.

-//

-// Packed refs are detached-only, so ResolveFully is equivalent to Resolve.

-func (store *Store) ResolveFully(name string) (ref.Detached, error) {

-	detached, ok := store.byName[name]

-	if !ok {

-		return ref.Detached{}, refstore.ErrReferenceNotFound

-	}

-	return detached, nil

-}

--- a/refstore/packed/shorten.go

+++ /dev/null

@@ -1,18 +1,0 @@

-package packed

-import "codeberg.org/lindenii/furgit/refstore"

-// Shorten returns the shortest unambiguous shorthand for a packed ref name.

-func (store *Store) Shorten(name string) (string, error) {

-	_, ok := store.byName[name]

-	if !ok {

-		return "", refstore.ErrReferenceNotFound

-	}

-	names := make([]string, 0, len(store.ordered))

-	for _, entry := range store.ordered {

-		names = append(names, entry.Name())

-	}

-	return refstore.ShortenName(name, names), nil

-}

--- a/refstore/packed/store.go

+++ /dev/null

@@ -1,15 +1,0 @@

-// Package packed provides a packed refs backend.

-package packed

-import (

-	"codeberg.org/lindenii/furgit/ref"

-	"codeberg.org/lindenii/furgit/refstore"

-)

-// Store reads references from a parsed packed-refs snapshot.

-type Store struct {

-	byName  map[string]ref.Detached

-	ordered []ref.Detached

-}

-var _ refstore.ReadingStore = (*Store)(nil)

--

⑨