ref: 0fe27421c7f37ba38445ead185580ca4e73b2664
parent: ce22af5eb8c94f2a817fca326efc6bea680e63cc
author: Runxi Yu <runxiyu@umich.edu>
date: Mon Mar 30 09:10:28 EDT 2026
object/store/memory: I guess implement the ObjectWriter interface
--- a/object/store/memory/add.go
+++ b/object/store/memory/add.go
@@ -1,21 +1,18 @@
package memory
import (
- objectheader "codeberg.org/lindenii/furgit/object/header"
objectid "codeberg.org/lindenii/furgit/object/id"
objecttype "codeberg.org/lindenii/furgit/object/type"
)
// AddObject stores one object body and returns its object ID.
+//
+//go:fix inline
func (store *Store) AddObject(ty objecttype.Type, body []byte) objectid.ObjectID {- header, ok := objectheader.Encode(ty, int64(len(body)))
- if !ok {- panic("failed to encode object header")+ id, err := store.WriteBytesContent(ty, body)
+ if err != nil {+ panic(err)
}
-
- raw := append(append([]byte(nil), header...), body...)
- id := store.algo.Sum(raw)
- store.objects[id] = storedObject{ty: ty, content: append([]byte(nil), body...)}return id
}
--- /dev/null
+++ b/object/store/memory/write_bytes.go
@@ -1,0 +1,35 @@
+package memory
+
+import (
+ "bytes"
+
+ objectheader "codeberg.org/lindenii/furgit/object/header"
+ objectid "codeberg.org/lindenii/furgit/object/id"
+ objecttype "codeberg.org/lindenii/furgit/object/type"
+)
+
+// WriteBytesContent writes one typed object content byte slice.
+func (store *Store) WriteBytesContent(ty objecttype.Type, content []byte) (objectid.ObjectID, error) {+ id := store.algo.Sum(buildRawObject(ty, content))
+ store.objects[id] = storedObject{ty: ty, content: append([]byte(nil), content...)}+
+ return id, nil
+}
+
+// WriteBytesFull writes one full serialized object byte slice as "type size\0content".
+func (store *Store) WriteBytesFull(raw []byte) (objectid.ObjectID, error) {+ return store.WriteReaderFull(bytes.NewReader(raw))
+}
+
+func buildRawObject(ty objecttype.Type, body []byte) []byte {+ header, ok := objectheader.Encode(ty, int64(len(body)))
+ if !ok {+ panic("failed to encode object header")+ }
+
+ raw := make([]byte, len(header)+len(body))
+ copy(raw, header)
+ copy(raw[len(header):], body)
+
+ return raw
+}
--- /dev/null
+++ b/object/store/memory/write_reader.go
@@ -1,0 +1,55 @@
+package memory
+
+import (
+ "errors"
+ "fmt"
+ "io"
+
+ objectheader "codeberg.org/lindenii/furgit/object/header"
+ objectid "codeberg.org/lindenii/furgit/object/id"
+ objecttype "codeberg.org/lindenii/furgit/object/type"
+)
+
+// WriteReaderContent writes one typed object content stream.
+func (store *Store) WriteReaderContent(ty objecttype.Type, size int64, src io.Reader) (objectid.ObjectID, error) {+ if size < 0 {+ return objectid.ObjectID{}, fmt.Errorf("objectstore/memory: negative content size: %d", size)+ }
+
+ content, err := io.ReadAll(io.LimitReader(src, size+1))
+ if err != nil {+ return objectid.ObjectID{}, err+ }
+
+ switch {+ case int64(len(content)) > size:
+ return objectid.ObjectID{}, errors.New("objectstore/memory: object content longer than declared size")+ case int64(len(content)) < size:
+ return objectid.ObjectID{}, errors.New("objectstore/memory: object content shorter than declared size")+ }
+
+ return store.WriteBytesContent(ty, content)
+}
+
+// WriteReaderFull writes one full serialized object stream as "type size\0content".
+func (store *Store) WriteReaderFull(src io.Reader) (objectid.ObjectID, error) {+ raw, err := io.ReadAll(src)
+ if err != nil {+ return objectid.ObjectID{}, err+ }
+
+ ty, size, headerLen, ok := objectheader.Parse(raw)
+ if !ok {+ return objectid.ObjectID{}, errors.New("objectstore/memory: malformed object header")+ }
+
+ content := raw[headerLen:]
+ if int64(len(content)) != size {+ return objectid.ObjectID{}, errors.New("objectstore/memory: object header size/content mismatch")+ }
+
+ id := store.algo.Sum(raw)
+ store.objects[id] = storedObject{ty: ty, content: append([]byte(nil), content...)}+
+ return id, nil
+}
--- /dev/null
+++ b/object/store/memory/write_test.go
@@ -1,0 +1,170 @@
+package memory
+
+import (
+ "bytes"
+ "testing"
+
+ "codeberg.org/lindenii/furgit/internal/testgit"
+ objectheader "codeberg.org/lindenii/furgit/object/header"
+ objectid "codeberg.org/lindenii/furgit/object/id"
+ objecttype "codeberg.org/lindenii/furgit/object/type"
+)
+
+func TestStoreWriteReaderContent(t *testing.T) {+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper+ store := New(algo)
+ content := []byte("memory-content\n")+
+ gotID, err := store.WriteReaderContent(objecttype.TypeBlob, int64(len(content)), bytes.NewReader(content))
+ if err != nil {+ t.Fatalf("WriteReaderContent: %v", err)+ }
+
+ wantID := algo.Sum(buildRawObject(objecttype.TypeBlob, content))
+ if gotID != wantID {+ t.Fatalf("WriteReaderContent id = %s, want %s", gotID, wantID)+ }
+
+ gotType, gotContent, err := store.ReadBytesContent(gotID)
+ if err != nil {+ t.Fatalf("ReadBytesContent: %v", err)+ }
+
+ if gotType != objecttype.TypeBlob {+ t.Fatalf("ReadBytesContent type = %v, want %v", gotType, objecttype.TypeBlob)+ }
+
+ if !bytes.Equal(gotContent, content) {+ t.Fatalf("ReadBytesContent content mismatch")+ }
+ })
+}
+
+func TestStoreWriteReaderFull(t *testing.T) {+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper+ store := New(algo)
+ content := []byte("memory-full\n")+ raw := buildRawObject(objecttype.TypeBlob, content)
+
+ gotID, err := store.WriteReaderFull(bytes.NewReader(raw))
+ if err != nil {+ t.Fatalf("WriteReaderFull: %v", err)+ }
+
+ wantID := algo.Sum(raw)
+ if gotID != wantID {+ t.Fatalf("WriteReaderFull id = %s, want %s", gotID, wantID)+ }
+
+ gotRaw, err := store.ReadBytesFull(gotID)
+ if err != nil {+ t.Fatalf("ReadBytesFull: %v", err)+ }
+
+ if !bytes.Equal(gotRaw, raw) {+ t.Fatalf("ReadBytesFull mismatch")+ }
+ })
+}
+
+func TestStoreWriteBytes(t *testing.T) {+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper+ store := New(algo)
+ content := []byte("memory-bytes\n")+
+ gotID, err := store.WriteBytesContent(objecttype.TypeBlob, content)
+ if err != nil {+ t.Fatalf("WriteBytesContent: %v", err)+ }
+
+ wantID := algo.Sum(buildRawObject(objecttype.TypeBlob, content))
+ if gotID != wantID {+ t.Fatalf("WriteBytesContent id = %s, want %s", gotID, wantID)+ }
+
+ raw := buildRawObject(objecttype.TypeBlob, content)
+
+ gotID2, err := store.WriteBytesFull(raw)
+ if err != nil {+ t.Fatalf("WriteBytesFull: %v", err)+ }
+
+ if gotID2 != wantID {+ t.Fatalf("WriteBytesFull id = %s, want %s", gotID2, wantID)+ }
+ })
+}
+
+func TestStoreWriteReaderValidationErrors(t *testing.T) {+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper+ t.Run("content overflow", func(t *testing.T) {+ t.Parallel()
+ store := New(algo)
+
+ _, err := store.WriteReaderContent(objecttype.TypeBlob, 1, bytes.NewReader([]byte("hello")))+ if err == nil {+ t.Fatalf("expected error after overflow")+ }
+ })
+
+ t.Run("content short", func(t *testing.T) {+ t.Parallel()
+ store := New(algo)
+
+ _, err := store.WriteReaderContent(objecttype.TypeBlob, 5, bytes.NewReader([]byte("x")))+ if err == nil {+ t.Fatalf("expected error for short content")+ }
+ })
+
+ t.Run("full malformed header", func(t *testing.T) {+ t.Parallel()
+ store := New(algo)
+
+ _, err := store.WriteReaderFull(bytes.NewReader([]byte("not-a-header")))+ if err == nil {+ t.Fatalf("expected error for malformed header")+ }
+ })
+
+ t.Run("full size mismatch", func(t *testing.T) {+ t.Parallel()
+ store := New(algo)
+
+ _, err := store.WriteReaderFull(bytes.NewReader([]byte("blob 1\x00hello")))+ if err == nil {+ t.Fatalf("expected error after mismatch")+ }
+ })
+
+ t.Run("bytes malformed header", func(t *testing.T) {+ t.Parallel()
+ store := New(algo)
+
+ _, err := store.WriteBytesFull([]byte("not-a-header"))+ if err == nil {+ t.Fatalf("expected error for malformed byte header")+ }
+ })
+ })
+}
+
+func TestBuildRawObjectMatchesObjectHeaderEncode(t *testing.T) {+ t.Parallel()
+
+ content := []byte("body")+ raw := buildRawObject(objecttype.TypeBlob, content)
+ header, ok := objectheader.Encode(objecttype.TypeBlob, int64(len(content)))
+ if !ok {+ t.Fatalf("objectheader.Encode failed")+ }
+
+ want := append(append([]byte(nil), header...), content...)
+ if !bytes.Equal(raw, want) {+ t.Fatalf("buildRawObject mismatch")+ }
+}
--
⑨