From 98e5a64ce72e81dcede7dbebc74e22576a1f5ab8 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Fri, 20 Feb 2026 22:22:56 +0800 Subject: object: Use objectheader --- object/blob_serialize.go | 24 ++++++++++++++++++------ object/blob_serialize_test.go | 4 ++-- object/commit_serialize.go | 16 +++++++++------- object/commit_serialize_test.go | 4 ++-- object/object.go | 20 ++------------------ object/tag_serialize.go | 16 +++++++++------- object/tag_serialize_test.go | 4 ++-- object/tree_serialize.go | 17 +++++++++++------ object/tree_serialize_test.go | 4 ++-- 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 { -- cgit v1.3.1-10-gc9f91