object: Use objectheader

9 files changed, 57 insertions, 52 deletions

diff --git a/object/blob_serialize.go b/object/blob_serialize.go
index b06242a0..d14ae56c 100644
--- a/object/blob_serialize.go
+++ b/object/blob_serialize.go
@@ -1,15 +1,27 @@
 package object
 
-import "codeberg.org/lindenii/furgit/objecttype"
+import (
+	"codeberg.org/lindenii/furgit/internal/objectheader"
+	"codeberg.org/lindenii/furgit/objecttype"
+)
 
-// Serialize renders the raw object (header + body).
-func (blob *Blob) Serialize() ([]byte, error) {
-	header, err := headerForType(objecttype.TypeBlob, blob.Data)
+// SerializeWithoutHeader renders the raw blob body bytes.
+func (blob *Blob) SerializeWithoutHeader() ([]byte, error) {
+	return append([]byte(nil), blob.Data...), nil
+}
+
+// SerializeWithHeader renders the raw object (header + body).
+func (blob *Blob) SerializeWithHeader() ([]byte, error) {
+	body, err := blob.SerializeWithoutHeader()
 	if err != nil {
 		return nil, err
 	}
-	raw := make([]byte, len(header)+len(blob.Data))
+	header, ok := objectheader.Encode(objecttype.TypeBlob, int64(len(body)))
+	if !ok {
+		return nil, ErrInvalidObject
+	}
+	raw := make([]byte, len(header)+len(body))
 	copy(raw, header)
-	copy(raw[len(header):], blob.Data)
+	copy(raw[len(header):], body)
 	return raw, nil
 }
diff --git a/object/blob_serialize_test.go b/object/blob_serialize_test.go
index f0895556..79fbc1b9 100644
--- a/object/blob_serialize_test.go
+++ b/object/blob_serialize_test.go
@@ -15,9 +15,9 @@ func TestBlobSerialize(t *testing.T) {
 		wantID := repo.HashObject(t, "blob", body)
 
 		blob := &object.Blob{Data: body}
-		rawObj, err := blob.Serialize()
+		rawObj, err := blob.SerializeWithHeader()
 		if err != nil {
-			t.Fatalf("Serialize: %v", err)
+			t.Fatalf("SerializeWithHeader: %v", err)
 		}
 		gotID := algo.Sum(rawObj)
 		if gotID != wantID {
diff --git a/object/commit_serialize.go b/object/commit_serialize.go
index 0d775f18..b7c058a3 100644
--- a/object/commit_serialize.go
+++ b/object/commit_serialize.go
@@ -4,10 +4,12 @@ import (
 	"bytes"
 	"fmt"
 
+	"codeberg.org/lindenii/furgit/internal/objectheader"
 	"codeberg.org/lindenii/furgit/objecttype"
 )
 
-func (commit *Commit) serialize() ([]byte, error) {
+// SerializeWithoutHeader renders the raw commit body bytes.
+func (commit *Commit) SerializeWithoutHeader() ([]byte, error) {
 	var buf bytes.Buffer
 
 	if commit.Tree.Size() == 0 {
@@ -54,15 +56,15 @@ func (commit *Commit) serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-// Serialize renders the raw object (header + body).
-func (commit *Commit) Serialize() ([]byte, error) {
-	body, err := commit.serialize()
+// SerializeWithHeader renders the raw object (header + body).
+func (commit *Commit) SerializeWithHeader() ([]byte, error) {
+	body, err := commit.SerializeWithoutHeader()
 	if err != nil {
 		return nil, err
 	}
-	header, err := headerForType(objecttype.TypeCommit, body)
-	if err != nil {
-		return nil, err
+	header, ok := objectheader.Encode(objecttype.TypeCommit, int64(len(body)))
+	if !ok {
+		return nil, ErrInvalidObject
 	}
 	raw := make([]byte, len(header)+len(body))
 	copy(raw, header)
diff --git a/object/commit_serialize_test.go b/object/commit_serialize_test.go
index 3f6eb4aa..2061495d 100644
--- a/object/commit_serialize_test.go
+++ b/object/commit_serialize_test.go
@@ -19,9 +19,9 @@ func TestCommitSerialize(t *testing.T) {
 			t.Fatalf("ParseCommit: %v", err)
 		}
 
-		rawObj, err := commit.Serialize()
+		rawObj, err := commit.SerializeWithHeader()
 		if err != nil {
-			t.Fatalf("Serialize: %v", err)
+			t.Fatalf("SerializeWithHeader: %v", err)
 		}
 		gotID := algo.Sum(rawObj)
 		if gotID != commitID {
diff --git a/object/object.go b/object/object.go
index ee75b903..53fb0a58 100644
--- a/object/object.go
+++ b/object/object.go
@@ -2,9 +2,7 @@
 package object
 
 import (
-	"bytes"
 	"errors"
-	"strconv"
 
 	"codeberg.org/lindenii/furgit/objecttype"
 )
@@ -19,20 +17,6 @@ var (
 // Object is a Git object that can serialize itself.
 type Object interface {
 	ObjectType() objecttype.Type
-	Serialize() ([]byte, error)
-}
-
-func headerForType(ty objecttype.Type, body []byte) ([]byte, error) {
-	tyStr, ok := objecttype.Name(ty)
-	if !ok {
-		return nil, ErrInvalidObject
-	}
-	size := strconv.Itoa(len(body))
-	var buf bytes.Buffer
-	buf.Grow(len(tyStr) + len(size) + 2)
-	buf.WriteString(tyStr)
-	buf.WriteByte(' ')
-	buf.WriteString(size)
-	buf.WriteByte(0)
-	return buf.Bytes(), nil
+	SerializeWithoutHeader() ([]byte, error)
+	SerializeWithHeader() ([]byte, error)
 }
diff --git a/object/tag_serialize.go b/object/tag_serialize.go
index bbc229c1..f9d754cf 100644
--- a/object/tag_serialize.go
+++ b/object/tag_serialize.go
@@ -4,10 +4,12 @@ import (
 	"bytes"
 	"fmt"
 
+	"codeberg.org/lindenii/furgit/internal/objectheader"
 	"codeberg.org/lindenii/furgit/objecttype"
 )
 
-func (tag *Tag) serialize() ([]byte, error) {
+// SerializeWithoutHeader renders the raw tag body bytes.
+func (tag *Tag) SerializeWithoutHeader() ([]byte, error) {
 	if tag.Target.Size() == 0 {
 		return nil, ErrInvalidObject
 	}
@@ -42,15 +44,15 @@ func (tag *Tag) serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-// Serialize renders the raw object (header + body).
-func (tag *Tag) Serialize() ([]byte, error) {
-	body, err := tag.serialize()
+// SerializeWithHeader renders the raw object (header + body).
+func (tag *Tag) SerializeWithHeader() ([]byte, error) {
+	body, err := tag.SerializeWithoutHeader()
 	if err != nil {
 		return nil, err
 	}
-	header, err := headerForType(objecttype.TypeTag, body)
-	if err != nil {
-		return nil, err
+	header, ok := objectheader.Encode(objecttype.TypeTag, int64(len(body)))
+	if !ok {
+		return nil, ErrInvalidObject
 	}
 	raw := make([]byte, len(header)+len(body))
 	copy(raw, header)
diff --git a/object/tag_serialize_test.go b/object/tag_serialize_test.go
index 40e346f8..4585bc16 100644
--- a/object/tag_serialize_test.go
+++ b/object/tag_serialize_test.go
@@ -20,9 +20,9 @@ func TestTagSerialize(t *testing.T) {
 			t.Fatalf("ParseTag: %v", err)
 		}
 
-		rawObj, err := tag.Serialize()
+		rawObj, err := tag.SerializeWithHeader()
 		if err != nil {
-			t.Fatalf("Serialize: %v", err)
+			t.Fatalf("SerializeWithHeader: %v", err)
 		}
 		gotID := algo.Sum(rawObj)
 		if gotID != tagID {
diff --git a/object/tree_serialize.go b/object/tree_serialize.go
index 79b1c79a..2ef0ebbb 100644
--- a/object/tree_serialize.go
+++ b/object/tree_serialize.go
@@ -3,10 +3,12 @@ package object
 import (
 	"strconv"
 
+	"codeberg.org/lindenii/furgit/internal/objectheader"
 	"codeberg.org/lindenii/furgit/objecttype"
 )
 
-func (tree *Tree) serialize() []byte {
+// SerializeWithoutHeader renders the raw tree body bytes.
+func (tree *Tree) SerializeWithoutHeader() ([]byte, error) {
 	var bodyLen int
 	for _, entry := range tree.Entries {
 		mode := strconv.FormatUint(uint64(entry.Mode), 8)
@@ -27,16 +29,19 @@ func (tree *Tree) serialize() []byte {
 		pos += copy(body[pos:], id)
 	}
 
-	return body
+	return body, nil
 }
 
-// Serialize renders the raw object (header + body).
-func (tree *Tree) Serialize() ([]byte, error) {
-	body := tree.serialize()
-	header, err := headerForType(objecttype.TypeTree, body)
+// SerializeWithHeader renders the raw object (header + body).
+func (tree *Tree) SerializeWithHeader() ([]byte, error) {
+	body, err := tree.SerializeWithoutHeader()
 	if err != nil {
 		return nil, err
 	}
+	header, ok := objectheader.Encode(objecttype.TypeTree, int64(len(body)))
+	if !ok {
+		return nil, ErrInvalidObject
+	}
 	raw := make([]byte, len(header)+len(body))
 	copy(raw, header)
 	copy(raw[len(header):], body)
diff --git a/object/tree_serialize_test.go b/object/tree_serialize_test.go
index a0da877c..c04c1d92 100644
--- a/object/tree_serialize_test.go
+++ b/object/tree_serialize_test.go
@@ -48,9 +48,9 @@ func TestTreeSerialize(t *testing.T) {
 
 		wantTreeID := repo.Mktree(t, buildGitMktreeInput(tree.Entries))
 
-		rawObj, err := tree.Serialize()
+		rawObj, err := tree.SerializeWithHeader()
 		if err != nil {
-			t.Fatalf("Serialize: %v", err)
+			t.Fatalf("SerializeWithHeader: %v", err)
 		}
 		gotTreeID := algo.Sum(rawObj)
 		if gotTreeID != wantTreeID {