From b3028bc65ac03b0bb4a88482519fb45700c675f3 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 4 Mar 2026 12:52:26 +0800 Subject: refstore/packed: Split --- refstore/packed/close.go | 6 +++ refstore/packed/list.go | 39 +++++++++++++++++ refstore/packed/new.go | 33 ++++++++++++++ refstore/packed/resolve.go | 28 ++++++++++++ refstore/packed/shorten.go | 18 ++++++++ refstore/packed/store.go | 104 --------------------------------------------- 6 files changed, 124 insertions(+), 104 deletions(-) create mode 100644 refstore/packed/close.go create mode 100644 refstore/packed/list.go create mode 100644 refstore/packed/new.go create mode 100644 refstore/packed/resolve.go create mode 100644 refstore/packed/shorten.go diff --git a/refstore/packed/close.go b/refstore/packed/close.go new file mode 100644 index 00000000..28c797cd --- /dev/null +++ b/refstore/packed/close.go @@ -0,0 +1,6 @@ +package packed + +// Close releases resources associated with the backend. +func (store *Store) Close() error { + return nil +} diff --git a/refstore/packed/list.go b/refstore/packed/list.go new file mode 100644 index 00000000..422c1026 --- /dev/null +++ b/refstore/packed/list.go @@ -0,0 +1,39 @@ +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 +} diff --git a/refstore/packed/new.go b/refstore/packed/new.go new file mode 100644 index 00000000..890d42ed --- /dev/null +++ b/refstore/packed/new.go @@ -0,0 +1,33 @@ +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 +} diff --git a/refstore/packed/resolve.go b/refstore/packed/resolve.go new file mode 100644 index 00000000..8be0a2a3 --- /dev/null +++ b/refstore/packed/resolve.go @@ -0,0 +1,28 @@ +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) { + 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 +} diff --git a/refstore/packed/shorten.go b/refstore/packed/shorten.go new file mode 100644 index 00000000..493b5422 --- /dev/null +++ b/refstore/packed/shorten.go @@ -0,0 +1,18 @@ +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 +} diff --git a/refstore/packed/store.go b/refstore/packed/store.go index 5ab9d602..92f69ec6 100644 --- a/refstore/packed/store.go +++ b/refstore/packed/store.go @@ -2,11 +2,6 @@ package packed import ( - "fmt" - "os" - "path" - - "codeberg.org/lindenii/furgit/objectid" "codeberg.org/lindenii/furgit/ref" "codeberg.org/lindenii/furgit/refstore" ) @@ -18,102 +13,3 @@ type Store struct { } var _ refstore.Store = (*Store)(nil) - -// 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 -} - -// Resolve resolves a packed reference name to a detached ref. -func (store *Store) Resolve(name string) (ref.Ref, error) { - 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 -} - -// 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 -} - -// 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 -} - -// Close releases resources associated with the backend. -func (store *Store) Close() error { - return nil -} -- cgit v1.3.1-10-gc9f91