refstore/{loose,packed}: Delete

5 files changed, 0 insertions, 549 deletions

diff --git a/refstore/loose/list.go b/refstore/loose/list.go
deleted file mode 100644
index 1fa0adee..00000000
--- a/refstore/loose/list.go
+++ /dev/null
@@ -1,114 +0,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
-}
diff --git a/refstore/loose/loose_test.go b/refstore/loose/loose_test.go
deleted file mode 100644
index 912d7c9e..00000000
--- a/refstore/loose/loose_test.go
+++ /dev/null
@@ -1,264 +0,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)
-		}
-	})
-}
diff --git a/refstore/loose/resolve.go b/refstore/loose/resolve.go
deleted file mode 100644
index e43f614f..00000000
--- a/refstore/loose/resolve.go
+++ /dev/null
@@ -1,98 +0,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
-}
diff --git a/refstore/loose/shorten.go b/refstore/loose/shorten.go
deleted file mode 100644
index e863d783..00000000
--- a/refstore/loose/shorten.go
+++ /dev/null
@@ -1,35 +0,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
-}
diff --git a/refstore/loose/store.go b/refstore/loose/store.go
deleted file mode 100644
index 081e3718..00000000
--- a/refstore/loose/store.go
+++ /dev/null
@@ -1,38 +0,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()
-}