aboutsummaryrefslogtreecommitdiff
path: root/object/fetch
diff options
context:
space:
mode:
Diffstat (limited to 'object/fetch')
-rw-r--r--object/fetch/blob.go97
-rw-r--r--object/fetch/commit.go74
-rw-r--r--object/fetch/doc.go12
-rw-r--r--object/fetch/errors.go19
-rw-r--r--object/fetch/fetcher.go20
-rw-r--r--object/fetch/header.go30
-rw-r--r--object/fetch/object.go36
-rw-r--r--object/fetch/path.go91
-rw-r--r--object/fetch/reader.go26
-rw-r--r--object/fetch/tag.go26
-rw-r--r--object/fetch/tree.go86
-rw-r--r--object/fetch/treefs.go451
-rw-r--r--object/fetch/treefs_test.go172
13 files changed, 1140 insertions, 0 deletions
diff --git a/object/fetch/blob.go b/object/fetch/blob.go
new file mode 100644
index 00000000..d40ec875
--- /dev/null
+++ b/object/fetch/blob.go
@@ -0,0 +1,97 @@
+package fetch
+
+import (
+ "io"
+
+ "lindenii.org/go/furgit/errs"
+ "lindenii.org/go/furgit/object/blob"
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/stored"
+ "lindenii.org/go/furgit/object/tag"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+// ExactBlob reads, parses, and wraps the blob at id.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) ExactBlob(id oid.ObjectID) (*stored.Stored[*blob.Blob], error) {
+ parsed, err := fetcher.parseObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ blob, ok := parsed.(*blob.Blob)
+ if !ok {
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Blob}
+ }
+
+ return stored.New(id, blob), nil
+}
+
+// ExactBlobReader returns a reader for the content of the blob at id,
+// together with its content size in bytes.
+//
+// Labels: Life-Parent, Close-Caller.
+func (fetcher *Fetcher) ExactBlobReader(id oid.ObjectID) (io.ReadCloser, int, error) {
+ return fetcher.exactReader(id, typ.Blob)
+}
+
+// PeelToBlob peels tags until it reaches a blob.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) PeelToBlob(id oid.ObjectID) (*stored.Stored[*blob.Blob], error) {
+ for {
+ obj, err := fetcher.ExactObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parsed := obj.Object().(type) {
+ case *blob.Blob:
+ return stored.New(id, parsed), nil
+ case *tag.Tag:
+ id = parsed.TargetID
+ default:
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Blob}
+ }
+ }
+}
+
+// PeelToBlobID peels tags until it reaches a blob object ID.
+func (fetcher *Fetcher) PeelToBlobID(id oid.ObjectID) (oid.ObjectID, error) {
+ for {
+ ty, _, err := fetcher.Header(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ switch ty {
+ case typ.Blob:
+ return id, nil
+ case typ.Tag:
+ tag, err := fetcher.ExactTag(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ id = tag.Object().TargetID
+ case typ.Unknown, typ.Commit, typ.Tree:
+ return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Blob}
+ default:
+ return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Blob}
+ }
+ }
+}
+
+// PeelToBlobReader returns a reader for the content of the peeled blob at id,
+// together with its content size in bytes.
+//
+// Labels: Life-Parent, Close-Caller.
+func (fetcher *Fetcher) PeelToBlobReader(id oid.ObjectID) (io.ReadCloser, int, error) {
+ blobID, err := fetcher.PeelToBlobID(id)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ return fetcher.ExactBlobReader(blobID)
+}
diff --git a/object/fetch/commit.go b/object/fetch/commit.go
new file mode 100644
index 00000000..f6f308e8
--- /dev/null
+++ b/object/fetch/commit.go
@@ -0,0 +1,74 @@
+package fetch
+
+import (
+ "lindenii.org/go/furgit/errs"
+ "lindenii.org/go/furgit/object/commit"
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/stored"
+ "lindenii.org/go/furgit/object/tag"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+// ExactCommit reads, parses, and wraps the commit at id.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) ExactCommit(id oid.ObjectID) (*stored.Stored[*commit.Commit], error) {
+ parsed, err := fetcher.parseObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ commit, ok := parsed.(*commit.Commit)
+ if !ok {
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Commit}
+ }
+
+ return stored.New(id, commit), nil
+}
+
+// PeelToCommit peels tags until it reaches a commit.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) PeelToCommit(id oid.ObjectID) (*stored.Stored[*commit.Commit], error) {
+ for {
+ obj, err := fetcher.ExactObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parsed := obj.Object().(type) {
+ case *commit.Commit:
+ return stored.New(id, parsed), nil
+ case *tag.Tag:
+ id = parsed.TargetID
+ default:
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Commit}
+ }
+ }
+}
+
+// PeelToCommitID peels tags until it reaches a commit object ID.
+func (fetcher *Fetcher) PeelToCommitID(id oid.ObjectID) (oid.ObjectID, error) {
+ for {
+ ty, _, err := fetcher.Header(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ switch ty {
+ case typ.Commit:
+ return id, nil
+ case typ.Tag:
+ tag, err := fetcher.ExactTag(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ id = tag.Object().TargetID
+ case typ.Unknown, typ.Tree, typ.Blob:
+ return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Commit}
+ default:
+ return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Commit}
+ }
+ }
+}
diff --git a/object/fetch/doc.go b/object/fetch/doc.go
new file mode 100644
index 00000000..2ceda59c
--- /dev/null
+++ b/object/fetch/doc.go
@@ -0,0 +1,12 @@
+// Package fetch loads typed Git objects from object storage
+// and provides higher-level object queries.
+//
+// Fetching is above
+// [lindenii.org/go/furgit/object/store]:
+// it parses stored objects
+// into blobs, trees, commits, and tags,
+// exposes object metadata,
+// peels tree-ish or commit-ish objects,
+// resolves paths within trees,
+// and can expose one tree as an [io/fs].
+package fetch
diff --git a/object/fetch/errors.go b/object/fetch/errors.go
new file mode 100644
index 00000000..84a21bbb
--- /dev/null
+++ b/object/fetch/errors.go
@@ -0,0 +1,19 @@
+package fetch
+
+import (
+ "errors"
+
+ "lindenii.org/go/furgit/errs"
+ "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/store"
+)
+
+// wrapObjectReadError maps raw object-store lookup failures to fetcher-level
+// object lookup errors.
+func wrapObjectReadError(id id.ObjectID, err error) error {
+ if errors.Is(err, store.ErrObjectNotFound) {
+ return &errs.ObjectMissingError{OID: id}
+ }
+
+ return err
+}
diff --git a/object/fetch/fetcher.go b/object/fetch/fetcher.go
new file mode 100644
index 00000000..653baf22
--- /dev/null
+++ b/object/fetch/fetcher.go
@@ -0,0 +1,20 @@
+package fetch
+
+import "lindenii.org/go/furgit/object/store"
+
+// Fetcher provides ordinary object access above an object store.
+//
+// It exposes object metadata, typed object loading, tree-ish and commit-ish
+// peeling, path resolution, one-tree fs views, and blob content streaming.
+//
+// Labels: MT-Safe.
+type Fetcher struct {
+ store store.ObjectReader
+}
+
+// New returns a Fetcher that reads objects from store.
+//
+// Labels: Deps-Borrowed, Life-Parent.
+func New(store store.ObjectReader) *Fetcher {
+ return &Fetcher{store: store}
+}
diff --git a/object/fetch/header.go b/object/fetch/header.go
new file mode 100644
index 00000000..ee02ef69
--- /dev/null
+++ b/object/fetch/header.go
@@ -0,0 +1,30 @@
+package fetch
+
+import (
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+// Header returns the object type and content size at id.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) Header(id oid.ObjectID) (typ.Type, int, error) {
+ ty, size, err := fetcher.store.ReadHeader(id)
+ if err != nil {
+ return typ.Unknown, 0, wrapObjectReadError(id, err)
+ }
+
+ return ty, size, nil
+}
+
+// Size returns the object content size at id.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) Size(id oid.ObjectID) (int, error) {
+ size, err := fetcher.store.ReadSize(id)
+ if err != nil {
+ return 0, wrapObjectReadError(id, err)
+ }
+
+ return size, nil
+}
diff --git a/object/fetch/object.go b/object/fetch/object.go
new file mode 100644
index 00000000..fdb46634
--- /dev/null
+++ b/object/fetch/object.go
@@ -0,0 +1,36 @@
+package fetch
+
+import (
+ "fmt"
+
+ "lindenii.org/go/furgit/object"
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/stored"
+)
+
+// ExactObject reads, parses, and wraps the object at id without constraining
+// its concrete object kind.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) ExactObject(id oid.ObjectID) (*stored.Stored[object.Object], error) {
+ parsed, err := fetcher.parseObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ return stored.New(id, parsed), nil
+}
+
+func (fetcher *Fetcher) parseObject(id oid.ObjectID) (object.Object, error) { //nolint:ireturn
+ ty, content, err := fetcher.store.ReadBytesContent(id)
+ if err != nil {
+ return nil, wrapObjectReadError(id, err)
+ }
+
+ parsed, err := object.ParseWithoutHeader(ty, content, id.ObjectFormat())
+ if err != nil {
+ return nil, fmt.Errorf("object/fetch: parse object %s (%s): %w", id, ty.Name(), err)
+ }
+
+ return parsed, nil
+}
diff --git a/object/fetch/path.go b/object/fetch/path.go
new file mode 100644
index 00000000..e8b12481
--- /dev/null
+++ b/object/fetch/path.go
@@ -0,0 +1,91 @@
+package fetch
+
+import (
+ "errors"
+ "fmt"
+
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/tree"
+ "lindenii.org/go/furgit/object/tree/mode"
+)
+
+var ErrPathInvalid = errors.New("object/fetch: invalid tree path")
+
+// PathNotFoundError indicates that one tree path segment was not found.
+type PathNotFoundError struct {
+ Index int
+ Name []byte
+}
+
+func (err *PathNotFoundError) Error() string {
+ return fmt.Sprintf("object/fetch: tree entry %q not found at index %d", err.Name, err.Index)
+}
+
+// PathNotTreeError indicates that one intermediate path segment was not a tree.
+type PathNotTreeError struct {
+ Index int
+ Name []byte
+}
+
+func (err *PathNotTreeError) Error() string {
+ return fmt.Sprintf("object/fetch: path segment %q at index %d is not a tree", err.Name, err.Index)
+}
+
+// Path resolves parts within the tree identified by root
+// and returns the final tree entry.
+//
+// The root object may be any tree-ish object accepted by PeelToTree.
+//
+// parts must contain at least one path segment.
+// Intermediate path segments must resolve to tree entries.
+// The final entry is returned without loading its object.
+// Path segments may not contain \x00.
+//
+// If your entry names are valid UTF-8
+// and uses / solely as segment separators,
+// it may be convenient to use TreeFS
+// for an io/fs.FS-like interface.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) Path(root oid.ObjectID, parts [][]byte) (tree.Entry, error) {
+ if len(parts) == 0 {
+ return tree.Entry{}, ErrPathInvalid
+ }
+
+ current, err := fetcher.PeelToTree(root)
+ if err != nil {
+ return tree.Entry{}, err
+ }
+
+ for i, part := range parts {
+ if len(part) == 0 {
+ return tree.Entry{}, ErrPathInvalid
+ }
+
+ entry, ok := current.Object().Find(part)
+ if !ok {
+ return tree.Entry{}, &PathNotFoundError{
+ Index: i,
+ Name: append([]byte(nil), part...),
+ }
+ }
+
+ if i == len(parts)-1 {
+ return entry, nil
+ }
+
+ if entry.Mode != mode.Directory {
+ return tree.Entry{}, &PathNotTreeError{
+ Index: i,
+ Name: append([]byte(nil), part...),
+ }
+ }
+
+ current, err = fetcher.ExactTree(entry.ID)
+ if err != nil {
+ return tree.Entry{}, err
+ }
+ }
+
+ return tree.Entry{}, &PathNotFoundError{Index: len(parts) - 1}
+}
diff --git a/object/fetch/reader.go b/object/fetch/reader.go
new file mode 100644
index 00000000..b1b4f7c2
--- /dev/null
+++ b/object/fetch/reader.go
@@ -0,0 +1,26 @@
+package fetch
+
+import (
+ "io"
+
+ "lindenii.org/go/furgit/errs"
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+// exactReader reads one object's content stream
+// and verifies that its header type matches wantType.
+func (fetcher *Fetcher) exactReader(id oid.ObjectID, wantType typ.Type) (io.ReadCloser, int, error) {
+ gotType, size, rc, err := fetcher.store.ReadReaderContent(id)
+ if err != nil {
+ return nil, 0, wrapObjectReadError(id, err)
+ }
+
+ if gotType != wantType {
+ _ = rc.Close()
+
+ return nil, 0, &errs.ObjectTypeError{OID: id, Got: gotType, Want: wantType}
+ }
+
+ return rc, size, nil
+}
diff --git a/object/fetch/tag.go b/object/fetch/tag.go
new file mode 100644
index 00000000..205bb127
--- /dev/null
+++ b/object/fetch/tag.go
@@ -0,0 +1,26 @@
+package fetch
+
+import (
+ "lindenii.org/go/furgit/errs"
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/stored"
+ "lindenii.org/go/furgit/object/tag"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+// ExactTag reads, parses, and wraps the tag at id.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) ExactTag(id oid.ObjectID) (*stored.Stored[*tag.Tag], error) {
+ parsed, err := fetcher.parseObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ tag, ok := parsed.(*tag.Tag)
+ if !ok {
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Tag}
+ }
+
+ return stored.New(id, tag), nil
+}
diff --git a/object/fetch/tree.go b/object/fetch/tree.go
new file mode 100644
index 00000000..9ac3875f
--- /dev/null
+++ b/object/fetch/tree.go
@@ -0,0 +1,86 @@
+package fetch
+
+import (
+ "lindenii.org/go/furgit/errs"
+ "lindenii.org/go/furgit/object/commit"
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/stored"
+ "lindenii.org/go/furgit/object/tag"
+ "lindenii.org/go/furgit/object/tree"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+// ExactTree reads, parses, and wraps the tree at id.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) ExactTree(id oid.ObjectID) (*stored.Stored[*tree.Tree], error) {
+ parsed, err := fetcher.parseObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ tree, ok := parsed.(*tree.Tree)
+ if !ok {
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Tree}
+ }
+
+ return stored.New(id, tree), nil
+}
+
+// PeelToTree peels tags until it reaches a tree or commit. If it reaches a
+// commit, it returns the commit's root tree.
+//
+// Labels: Life-Parent.
+func (fetcher *Fetcher) PeelToTree(id oid.ObjectID) (*stored.Stored[*tree.Tree], error) {
+ for {
+ obj, err := fetcher.ExactObject(id)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parsed := obj.Object().(type) {
+ case *tree.Tree:
+ return stored.New(id, parsed), nil
+ case *commit.Commit:
+ return fetcher.ExactTree(parsed.Tree)
+ case *tag.Tag:
+ id = parsed.TargetID
+ default:
+ return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Tree}
+ }
+ }
+}
+
+// PeelToTreeID peels tags until it reaches a tree object ID, or a commit whose
+// root tree object ID is then returned.
+func (fetcher *Fetcher) PeelToTreeID(id oid.ObjectID) (oid.ObjectID, error) {
+ for {
+ ty, _, err := fetcher.Header(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ switch ty {
+ case typ.Tree:
+ return id, nil
+ case typ.Commit:
+ commit, err := fetcher.ExactCommit(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ return commit.Object().Tree, nil
+ case typ.Tag:
+ tag, err := fetcher.ExactTag(id)
+ if err != nil {
+ return oid.ObjectID{}, err
+ }
+
+ id = tag.Object().TargetID
+ case typ.Unknown, typ.Blob:
+ return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Tree}
+ default:
+ return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Tree}
+ }
+ }
+}
diff --git a/object/fetch/treefs.go b/object/fetch/treefs.go
new file mode 100644
index 00000000..d12e3dd6
--- /dev/null
+++ b/object/fetch/treefs.go
@@ -0,0 +1,451 @@
+package fetch
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "io"
+ "io/fs"
+ "time"
+
+ oid "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/tree"
+ "lindenii.org/go/furgit/object/tree/mode"
+)
+
+// TreeFS exposes one Git tree as an fs.FS view backed by a Fetcher.
+//
+// TreeFS interprets names using io/fs path rules.
+// Those rules do not match raw Git tree entry naming exactly:
+// names are UTF-8, slash-separated, and must be valid fs.FS paths.
+// Tree entries that cannot be represented under those rules
+// are not addressable through this API.
+//
+// Labels: MT-Safe.
+type TreeFS struct {
+ fetcher *Fetcher
+ rootTree oid.ObjectID
+ rootEntry *tree.Entry
+}
+
+var (
+ _ fs.FS = (*TreeFS)(nil)
+ _ fs.ReadFileFS = (*TreeFS)(nil)
+ _ fs.ReadDirFS = (*TreeFS)(nil)
+ _ fs.StatFS = (*TreeFS)(nil)
+ _ fs.SubFS = (*TreeFS)(nil)
+)
+
+// ErrGitlinkNotFile reports that
+// a gitlink (submodule) entry was opened or read as a file.
+// It wraps [fs.ErrInvalid] so that
+// generic fs consumers classify it correctly.
+var ErrGitlinkNotFile = fmt.Errorf("%w: object/fetch: gitlink entries are not readable as files", fs.ErrInvalid)
+
+// ErrIsDirectory reports that
+// a directory entry was read as a file.
+// It wraps [fs.ErrInvalid] so that
+// generic fs consumers classify it correctly.
+var ErrIsDirectory = fmt.Errorf("%w: object/fetch: is a directory", fs.ErrInvalid)
+
+func splitPath(path string) [][]byte {
+ if len(path) == 0 {
+ return nil
+ }
+
+ return bytes.Split([]byte(path), []byte("/"))
+}
+
+type treeEntryValue struct {
+ name string
+ mode mode.Mode
+ objectID oid.ObjectID
+ treeID oid.ObjectID
+ treeEntry *tree.Entry
+}
+
+func (entry treeEntryValue) isDir() bool {
+ return entry.mode == mode.Directory
+}
+
+func (entry treeEntryValue) blobSize(fetcher *Fetcher) (int, error) {
+ return fetcher.Size(entry.objectID)
+}
+
+func (entry treeEntryValue) subtreeID() (oid.ObjectID, error) {
+ if entry.name == "." {
+ return entry.treeID, nil
+ }
+
+ if entry.mode != mode.Directory {
+ return oid.ObjectID{}, fmt.Errorf("object/fetch: path %q is not a tree", entry.name) //nolint:err113 // Never user-visible.
+ }
+
+ return entry.objectID, nil
+}
+
+type treeFSInfo struct {
+ name string
+ mode fs.FileMode
+ size int64
+ sys any
+ isDir bool
+}
+
+var (
+ _ fs.FileInfo = (*treeFSInfo)(nil)
+ _ fs.DirEntry = (*treeFSInfo)(nil)
+)
+
+func (info *treeFSInfo) Name() string { return info.name }
+func (info *treeFSInfo) Size() int64 { return info.size }
+func (info *treeFSInfo) Mode() fs.FileMode { return info.mode }
+func (info *treeFSInfo) Type() fs.FileMode { return info.mode.Type() }
+func (info *treeFSInfo) IsDir() bool { return info.isDir }
+func (info *treeFSInfo) ModTime() time.Time { return time.Time{} }
+func (info *treeFSInfo) Sys() any { return info.sys }
+func (info *treeFSInfo) Info() (fs.FileInfo, error) {
+ return info, nil
+}
+
+func treeFSEntryMode(mod mode.Mode) fs.FileMode {
+ switch mod {
+ case mode.Directory:
+ return fs.ModeDir | 0o555
+ case mode.Regular:
+ return 0o444
+ case mode.Executable:
+ return 0o555
+ case mode.Symlink:
+ return fs.ModeSymlink | 0o444
+ case mode.Gitlink:
+ return fs.ModeIrregular
+ default:
+ return fs.ModeIrregular
+ }
+}
+
+// TreeFS returns a new filesystem view rooted at root, which may be any
+// tree-ish object accepted by PeelToTreeID.
+//
+// Labels: Deps-Borrowed, Life-Parent.
+func (fetcher *Fetcher) TreeFS(root oid.ObjectID) (*TreeFS, error) {
+ rootTree, err := fetcher.PeelToTreeID(root)
+ if err != nil {
+ return nil, err
+ }
+
+ return &TreeFS{
+ fetcher: fetcher,
+ rootTree: rootTree,
+ }, nil
+}
+
+type treeFSOp uint8
+
+const (
+ treeFSOpOpen treeFSOp = iota
+ treeFSOpReadFile
+ treeFSOpReadDir
+ treeFSOpStat
+ treeFSOpSub
+)
+
+func (op treeFSOp) pathErrorOp() string {
+ switch op {
+ case treeFSOpOpen:
+ return "open"
+ case treeFSOpReadFile:
+ return "readfile"
+ case treeFSOpReadDir:
+ return "readdir"
+ case treeFSOpStat:
+ return "stat"
+ case treeFSOpSub:
+ return "sub"
+ default:
+ return "treefs"
+ }
+}
+
+// Open opens name for reading.
+//
+// Directories are returned as fs.ReadDirFile values. Gitlink entries are not
+// readable through TreeFS.
+func (treeFS *TreeFS) Open(name string) (fs.File, error) {
+ entry, err := treeFS.resolvePath(treeFSOpOpen, name)
+ if err != nil {
+ return nil, err
+ }
+
+ info, err := treeFS.statEntry(entry)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpOpen, name, err)
+ }
+
+ if entry.isDir() {
+ treeID, err := entry.subtreeID()
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpOpen, name, err)
+ }
+
+ tree, err := treeFS.fetcher.ExactTree(treeID)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpOpen, name, err)
+ }
+
+ entries := make([]fs.DirEntry, 0, len(tree.Object().Entries()))
+ for _, child := range tree.Object().Entries() {
+ childEntry := treeEntryValue{
+ name: string(child.Name),
+ mode: child.Mode,
+ objectID: child.ID,
+ treeEntry: &child,
+ }
+
+ childInfo, err := treeFS.statEntry(childEntry)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpOpen, name, err)
+ }
+
+ entries = append(entries, childInfo)
+ }
+
+ return &treeFSDir{
+ info: info,
+ entries: entries,
+ }, nil
+ }
+
+ if entry.mode == mode.Gitlink {
+ return nil, treeFSPathError(treeFSOpOpen, name, ErrGitlinkNotFile)
+ }
+
+ reader, _, err := treeFS.fetcher.ExactBlobReader(entry.objectID)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpOpen, name, err)
+ }
+
+ return &treeFSBlob{
+ info: info,
+ reader: reader,
+ }, nil
+}
+
+type treeFSBlob struct {
+ info *treeFSInfo
+ reader io.ReadCloser
+}
+
+var _ fs.File = (*treeFSBlob)(nil)
+
+func (file *treeFSBlob) Stat() (fs.FileInfo, error) { return file.info, nil }
+func (file *treeFSBlob) Read(p []byte) (int, error) { return file.reader.Read(p) }
+func (file *treeFSBlob) Close() error { return file.reader.Close() }
+
+type treeFSDir struct {
+ info *treeFSInfo
+ entries []fs.DirEntry
+ offset int
+}
+
+var (
+ _ fs.File = (*treeFSDir)(nil)
+ _ fs.ReadDirFile = (*treeFSDir)(nil)
+)
+
+func (dir *treeFSDir) Stat() (fs.FileInfo, error) { return dir.info, nil }
+func (dir *treeFSDir) Close() error { return nil }
+
+func (dir *treeFSDir) Read(_ []byte) (int, error) {
+ return 0, fs.ErrInvalid
+}
+
+func (dir *treeFSDir) ReadDir(n int) ([]fs.DirEntry, error) {
+ if dir.offset >= len(dir.entries) && n > 0 {
+ return nil, io.EOF
+ }
+
+ if n <= 0 {
+ out := append([]fs.DirEntry(nil), dir.entries[dir.offset:]...)
+ dir.offset = len(dir.entries)
+
+ return out, nil
+ }
+
+ end := min(dir.offset+n, len(dir.entries))
+
+ out := append([]fs.DirEntry(nil), dir.entries[dir.offset:end]...)
+ dir.offset = end
+
+ return out, nil
+}
+
+func treeFSValidPath(name string) bool {
+ return name == "." || fs.ValidPath(name)
+}
+
+func treeFSPathError(op treeFSOp, path string, err error) error {
+ return &fs.PathError{Op: op.pathErrorOp(), Path: path, Err: err}
+}
+
+// ReadDir reads and returns all directory entries for name.
+func (treeFS *TreeFS) ReadDir(name string) ([]fs.DirEntry, error) {
+ file, err := treeFS.Open(name)
+ if err != nil {
+ return nil, err
+ }
+
+ defer func() { _ = file.Close() }()
+
+ readDirFile, ok := file.(fs.ReadDirFile)
+ if !ok {
+ return nil, treeFSPathError(treeFSOpReadDir, name, fs.ErrInvalid)
+ }
+
+ entries, err := readDirFile.ReadDir(-1)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpReadDir, name, err)
+ }
+
+ return entries, nil
+}
+
+// ReadFile reads the blob contents at name.
+//
+// Directories and gitlink entries are not readable through TreeFS.
+func (treeFS *TreeFS) ReadFile(name string) ([]byte, error) {
+ entry, err := treeFS.resolvePath(treeFSOpReadFile, name)
+ if err != nil {
+ return nil, err
+ }
+
+ if entry.isDir() {
+ return nil, treeFSPathError(treeFSOpReadFile, name, ErrIsDirectory)
+ }
+
+ if entry.mode == mode.Gitlink {
+ return nil, treeFSPathError(treeFSOpReadFile, name, ErrGitlinkNotFile)
+ }
+
+ reader, _, err := treeFS.fetcher.ExactBlobReader(entry.objectID)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpReadFile, name, err)
+ }
+
+ defer func() { _ = reader.Close() }()
+
+ data, err := io.ReadAll(reader)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpReadFile, name, err)
+ }
+
+ return data, nil
+}
+
+// Stat returns synthetic file metadata for name.
+//
+// TreeFS metadata reflects Git tree entry mode and blob size where applicable.
+// It does not represent filesystem stat metadata: ModTime is zero, ownership is
+// unavailable, and Sys returns the underlying tree.Entry when one exists.
+func (treeFS *TreeFS) Stat(name string) (fs.FileInfo, error) {
+ entry, err := treeFS.resolvePath(treeFSOpStat, name)
+ if err != nil {
+ return nil, err
+ }
+
+ info, err := treeFS.statEntry(entry)
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpStat, name, err)
+ }
+
+ return info, nil
+}
+
+// Sub returns a new TreeFS rooted at dir.
+func (treeFS *TreeFS) Sub(dir string) (fs.FS, error) {
+ entry, err := treeFS.resolvePath(treeFSOpSub, dir)
+ if err != nil {
+ return nil, err
+ }
+
+ treeID, err := entry.subtreeID()
+ if err != nil {
+ return nil, treeFSPathError(treeFSOpSub, dir, fs.ErrInvalid)
+ }
+
+ return &TreeFS{
+ fetcher: treeFS.fetcher,
+ rootTree: treeID,
+ rootEntry: entry.treeEntry,
+ }, nil
+}
+
+func (treeFS *TreeFS) resolvePath(op treeFSOp, name string) (treeEntryValue, error) {
+ if !treeFSValidPath(name) {
+ return treeEntryValue{}, treeFSPathError(op, name, fs.ErrInvalid)
+ }
+
+ if name == "." {
+ return treeEntryValue{
+ name: ".",
+ mode: mode.Directory,
+ treeID: treeFS.rootTree,
+ treeEntry: treeFS.rootEntry,
+ }, nil
+ }
+
+ entry, err := treeFS.fetcher.Path(treeFS.rootTree, splitPath(name))
+ if err != nil {
+ return treeEntryValue{}, treeFS.pathResolveError(op, name, err)
+ }
+
+ return treeEntryValue{
+ name: string(entry.Name),
+ mode: entry.Mode,
+ objectID: entry.ID,
+ treeEntry: &entry,
+ }, nil
+}
+
+func (treeFS *TreeFS) pathResolveError(op treeFSOp, name string, err error) error {
+ if _, ok := errors.AsType[*PathNotFoundError](err); ok {
+ return treeFSPathError(op, name, fs.ErrNotExist)
+ }
+
+ if _, ok := errors.AsType[*PathNotTreeError](err); ok {
+ return treeFSPathError(op, name, fs.ErrInvalid)
+ }
+
+ if errors.Is(err, ErrPathInvalid) {
+ return treeFSPathError(op, name, fs.ErrInvalid)
+ }
+
+ return treeFSPathError(op, name, err)
+}
+
+func (treeFS *TreeFS) statEntry(entry treeEntryValue) (*treeFSInfo, error) {
+ size := int64(0)
+
+ if entry.mode == mode.Regular || entry.mode == mode.Executable || entry.mode == mode.Symlink {
+ sz, err := entry.blobSize(treeFS.fetcher)
+ if err != nil {
+ return nil, err
+ }
+
+ size = int64(sz)
+ }
+
+ var sys any
+ if entry.treeEntry != nil {
+ sys = *entry.treeEntry
+ }
+
+ return &treeFSInfo{
+ name: entry.name,
+ mode: treeFSEntryMode(entry.mode),
+ size: size,
+ sys: sys,
+ isDir: entry.isDir(),
+ }, nil
+}
diff --git a/object/fetch/treefs_test.go b/object/fetch/treefs_test.go
new file mode 100644
index 00000000..05240823
--- /dev/null
+++ b/object/fetch/treefs_test.go
@@ -0,0 +1,172 @@
+package fetch_test
+
+import (
+ "errors"
+ "io/fs"
+ "testing"
+
+ "lindenii.org/go/furgit/object/commit"
+ "lindenii.org/go/furgit/object/fetch"
+ "lindenii.org/go/furgit/object/id"
+ "lindenii.org/go/furgit/object/signature"
+ "lindenii.org/go/furgit/object/store/memory"
+ "lindenii.org/go/furgit/object/tree"
+ "lindenii.org/go/furgit/object/tree/mode"
+ "lindenii.org/go/furgit/object/typ"
+)
+
+func TestTreeFS(t *testing.T) {
+ t.Parallel()
+
+ for _, objectFormat := range id.SupportedObjectFormats() {
+ t.Run(objectFormat.String(), func(t *testing.T) {
+ t.Parallel()
+
+ store := memory.New(objectFormat)
+
+ plainID, err := store.WriteBytesContent(typ.Blob, []byte("plain\n"))
+ if err != nil {
+ t.Fatalf("WriteBytesContent(plain.txt): %v", err)
+ }
+
+ execID, err := store.WriteBytesContent(typ.Blob, []byte("#!/bin/sh\nexit 0\n"))
+ if err != nil {
+ t.Fatalf("WriteBytesContent(exec.sh): %v", err)
+ }
+
+ subTreeID := writeTree(t, store, []tree.Entry{
+ {Mode: mode.Executable, Name: []byte("exec.sh"), ID: execID},
+ })
+
+ rootTreeID := writeTree(t, store, []tree.Entry{
+ {Mode: mode.Regular, Name: []byte("plain.txt"), ID: plainID},
+ {Mode: mode.Directory, Name: []byte("dir"), ID: subTreeID},
+ })
+
+ commitID := writeCommit(t, store, rootTreeID)
+
+ fetcher := fetch.New(store)
+
+ treeFS, err := fetcher.TreeFS(commitID)
+ if err != nil {
+ t.Fatalf("fetcher.TreeFS: %v", err)
+ }
+
+ content, err := treeFS.ReadFile("plain.txt")
+ if err != nil {
+ t.Fatalf("ReadFile(plain.txt): %v", err)
+ }
+
+ if string(content) != "plain\n" {
+ t.Fatalf("ReadFile(plain.txt) = %q, want %q", string(content), "plain\n")
+ }
+
+ entries, err := treeFS.ReadDir(".")
+ if err != nil {
+ t.Fatalf("ReadDir(.): %v", err)
+ }
+
+ if len(entries) != 2 {
+ t.Fatalf("len(ReadDir(.)) = %d, want 2", len(entries))
+ }
+
+ info, err := treeFS.Stat("plain.txt")
+ if err != nil {
+ t.Fatalf("Stat(plain.txt): %v", err)
+ }
+
+ entry, ok := info.Sys().(tree.Entry)
+ if !ok {
+ t.Fatalf("Stat(plain.txt).Sys() type = %T, want tree.Entry", info.Sys())
+ }
+
+ if entry.Mode != mode.Regular {
+ t.Fatalf("Stat(plain.txt).Sys().Mode = %o, want %o", entry.Mode, mode.Regular)
+ }
+
+ subFS, err := treeFS.Sub("dir")
+ if err != nil {
+ t.Fatalf("Sub(dir): %v", err)
+ }
+
+ subReadFileFS, ok := subFS.(fs.ReadFileFS)
+ if !ok {
+ t.Fatalf("Sub(dir) type does not implement fs.ReadFileFS")
+ }
+
+ subContent, err := subReadFileFS.ReadFile("exec.sh")
+ if err != nil {
+ t.Fatalf("Sub(dir).ReadFile(exec.sh): %v", err)
+ }
+
+ if string(subContent) != "#!/bin/sh\nexit 0\n" {
+ t.Fatalf("Sub(dir).ReadFile(exec.sh) = %q", string(subContent))
+ }
+
+ _, err = treeFS.ReadFile("dir")
+ if err == nil {
+ t.Fatal("ReadFile(dir) unexpectedly succeeded")
+ }
+
+ if _, ok := errors.AsType[*fs.PathError](err); !ok {
+ t.Fatalf("ReadFile(dir) err type = %T, want *fs.PathError", err)
+ }
+ })
+ }
+}
+
+// writeTree builds a tree object from entries, writes it to store,
+// and returns its object ID.
+func writeTree(t *testing.T, store *memory.Memory, entries []tree.Entry) id.ObjectID {
+ t.Helper()
+
+ tr := new(tree.Tree)
+ for _, entry := range entries {
+ err := tr.Insert(entry)
+ if err != nil {
+ t.Fatalf("tree.Insert(%q): %v", entry.Name, err)
+ }
+ }
+
+ body, err := tr.AppendWithoutHeader(nil)
+ if err != nil {
+ t.Fatalf("tree.AppendWithoutHeader: %v", err)
+ }
+
+ treeID, err := store.WriteBytesContent(typ.Tree, body)
+ if err != nil {
+ t.Fatalf("WriteBytesContent(tree): %v", err)
+ }
+
+ return treeID
+}
+
+// writeCommit builds a commit object pointing at tree, writes it to store,
+// and returns its object ID.
+func writeCommit(t *testing.T, store *memory.Memory, tree id.ObjectID) id.ObjectID {
+ t.Helper()
+
+ who := signature.Signature{
+ Name: []byte("Test Author"),
+ Email: []byte("author@example.org"),
+ WhenUnix: 1234567890,
+ OffsetMinutes: 0,
+ }
+
+ body, err := (&commit.Commit{
+ Tree: tree,
+ Author: who,
+ Committer: who,
+ Message: []byte("treefs\n"),
+ }).AppendWithoutHeader(nil)
+ if err != nil {
+ t.Fatalf("commit.AppendWithoutHeader: %v", err)
+ }
+
+ commitID, err := store.WriteBytesContent(typ.Commit, body)
+ if err != nil {
+ t.Fatalf("WriteBytesContent(commit): %v", err)
+ }
+
+ return commitID
+}
generated by cgit v1.3.1-10-gc9f91 (git 2.54.0) at 2026-06-20 06:34:25 +0000