object: Use objecttype instead of doing object types ourself

11 files changed, 50 insertions, 80 deletions

diff --git a/object/blob.go b/object/blob.go
index 03d17df6..8f094405 100644
--- a/object/blob.go
+++ b/object/blob.go
@@ -1,12 +1,14 @@
 package object
 
+import "codeberg.org/lindenii/furgit/objecttype"
+
 // Blob represents a Git blob object.
 type Blob struct {
 	Data []byte
 }
 
 // ObjectType returns TypeBlob.
-func (blob *Blob) ObjectType() Type {
+func (blob *Blob) ObjectType() objecttype.Type {
 	_ = blob
-	return TypeBlob
+	return objecttype.TypeBlob
 }
diff --git a/object/blob_serialize.go b/object/blob_serialize.go
index c1818c20..b06242a0 100644
--- a/object/blob_serialize.go
+++ b/object/blob_serialize.go
@@ -1,8 +1,10 @@
 package object
 
+import "codeberg.org/lindenii/furgit/objecttype"
+
 // Serialize renders the raw object (header + body).
 func (blob *Blob) Serialize() ([]byte, error) {
-	header, err := headerForType(TypeBlob, blob.Data)
+	header, err := headerForType(objecttype.TypeBlob, blob.Data)
 	if err != nil {
 		return nil, err
 	}
diff --git a/object/commit.go b/object/commit.go
index 0183ff02..92b7fcdc 100644
--- a/object/commit.go
+++ b/object/commit.go
@@ -1,6 +1,9 @@
 package object
 
-import "codeberg.org/lindenii/furgit/oid"
+import (
+	"codeberg.org/lindenii/furgit/objecttype"
+	"codeberg.org/lindenii/furgit/oid"
+)
 
 // Commit represents a Git commit object.
 type Commit struct {
@@ -14,7 +17,7 @@ type Commit struct {
 }
 
 // ObjectType returns TypeCommit.
-func (commit *Commit) ObjectType() Type {
+func (commit *Commit) ObjectType() objecttype.Type {
 	_ = commit
-	return TypeCommit
+	return objecttype.TypeCommit
 }
diff --git a/object/commit_serialize.go b/object/commit_serialize.go
index b06e597c..0d775f18 100644
--- a/object/commit_serialize.go
+++ b/object/commit_serialize.go
@@ -3,6 +3,8 @@ package object
 import (
 	"bytes"
 	"fmt"
+
+	"codeberg.org/lindenii/furgit/objecttype"
 )
 
 func (commit *Commit) serialize() ([]byte, error) {
@@ -58,7 +60,7 @@ func (commit *Commit) Serialize() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	header, err := headerForType(TypeCommit, body)
+	header, err := headerForType(objecttype.TypeCommit, body)
 	if err != nil {
 		return nil, err
 	}
diff --git a/object/object.go b/object/object.go
index c40769a7..ee75b903 100644
--- a/object/object.go
+++ b/object/object.go
@@ -4,8 +4,9 @@ package object
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"strconv"
+
+	"codeberg.org/lindenii/furgit/objecttype"
 )
 
 var (
@@ -15,68 +16,16 @@ var (
 	ErrNotFound = errors.New("object: not found")
 )
 
-// Type mirrors Git object type tags.
-type Type uint8
-
-const (
-	TypeInvalid  Type = 0
-	TypeCommit   Type = 1
-	TypeTree     Type = 2
-	TypeBlob     Type = 3
-	TypeTag      Type = 4
-	TypeFuture   Type = 5
-	TypeOfsDelta Type = 6
-	TypeRefDelta Type = 7
-)
-
-const (
-	typeNameBlob   = "blob"
-	typeNameTree   = "tree"
-	typeNameCommit = "commit"
-	typeNameTag    = "tag"
-)
-
 // Object is a Git object that can serialize itself.
 type Object interface {
-	ObjectType() Type
+	ObjectType() objecttype.Type
 	Serialize() ([]byte, error)
 }
 
-// ParseTypeName parses a canonical Git object type name.
-func ParseTypeName(name string) (Type, error) {
-	switch name {
-	case typeNameBlob:
-		return TypeBlob, nil
-	case typeNameTree:
-		return TypeTree, nil
-	case typeNameCommit:
-		return TypeCommit, nil
-	case typeNameTag:
-		return TypeTag, nil
-	default:
-		return TypeInvalid, ErrInvalidObject
-	}
-}
-
-func typeName(ty Type) (string, error) {
-	switch ty {
-	case TypeBlob:
-		return typeNameBlob, nil
-	case TypeTree:
-		return typeNameTree, nil
-	case TypeCommit:
-		return typeNameCommit, nil
-	case TypeTag:
-		return typeNameTag, nil
-	default:
-		return "", fmt.Errorf("object: unsupported type %d", ty)
-	}
-}
-
-func headerForType(ty Type, body []byte) ([]byte, error) {
-	tyStr, err := typeName(ty)
-	if err != nil {
-		return nil, err
+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
diff --git a/object/tag.go b/object/tag.go
index ec91ffde..4e150ba2 100644
--- a/object/tag.go
+++ b/object/tag.go
@@ -1,18 +1,21 @@
 package object
 
-import "codeberg.org/lindenii/furgit/oid"
+import (
+	"codeberg.org/lindenii/furgit/objecttype"
+	"codeberg.org/lindenii/furgit/oid"
+)
 
 // Tag represents a Git annotated tag object.
 type Tag struct {
 	Target     oid.ObjectID
-	TargetType Type
+	TargetType objecttype.Type
 	Name       []byte
 	Tagger     *Ident
 	Message    []byte
 }
 
 // ObjectType returns TypeTag.
-func (tag *Tag) ObjectType() Type {
+func (tag *Tag) ObjectType() objecttype.Type {
 	_ = tag
-	return TypeTag
+	return objecttype.TypeTag
 }
diff --git a/object/tag_parse.go b/object/tag_parse.go
index 565b9f89..b9b3cac8 100644
--- a/object/tag_parse.go
+++ b/object/tag_parse.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 
+	"codeberg.org/lindenii/furgit/objecttype"
 	"codeberg.org/lindenii/furgit/oid"
 )
 
@@ -43,8 +44,8 @@ func ParseTag(body []byte, algo oid.Algorithm) (*Tag, error) {
 			t.Target = id
 			haveTarget = true
 		case "type":
-			ty, err := ParseTypeName(string(value))
-			if err != nil {
+			ty, ok := objecttype.ParseName(string(value))
+			if !ok {
 				return nil, errors.New("object: tag: unknown target type")
 			}
 			t.TargetType = ty
diff --git a/object/tag_parse_test.go b/object/tag_parse_test.go
index 818ea309..b8628bb3 100644
--- a/object/tag_parse_test.go
+++ b/object/tag_parse_test.go
@@ -6,6 +6,7 @@ import (
 
 	"codeberg.org/lindenii/furgit/internal/testgit"
 	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/objecttype"
 	"codeberg.org/lindenii/furgit/oid"
 )
 
@@ -23,8 +24,8 @@ func TestTagParseFromGit(t *testing.T) {
 		if tag.Target != commitID {
 			t.Fatalf("tag target mismatch: got %s want %s", tag.Target, commitID)
 		}
-		if tag.TargetType != object.TypeCommit {
-			t.Fatalf("tag target type = %v, want %v", tag.TargetType, object.TypeCommit)
+		if tag.TargetType != objecttype.TypeCommit {
+			t.Fatalf("tag target type = %v, want %v", tag.TargetType, objecttype.TypeCommit)
 		}
 		if !bytes.Equal(tag.Name, []byte("v1")) {
 			t.Fatalf("tag name = %q, want %q", tag.Name, "v1")
diff --git a/object/tag_serialize.go b/object/tag_serialize.go
index 9600b81f..bbc229c1 100644
--- a/object/tag_serialize.go
+++ b/object/tag_serialize.go
@@ -3,6 +3,8 @@ package object
 import (
 	"bytes"
 	"fmt"
+
+	"codeberg.org/lindenii/furgit/objecttype"
 )
 
 func (tag *Tag) serialize() ([]byte, error) {
@@ -13,8 +15,8 @@ func (tag *Tag) serialize() ([]byte, error) {
 	var buf bytes.Buffer
 	fmt.Fprintf(&buf, "object %s\n", tag.Target.String())
 
-	tyName, err := typeName(tag.TargetType)
-	if err != nil {
+	tyName, ok := objecttype.Name(tag.TargetType)
+	if !ok {
 		return nil, fmt.Errorf("object: tag: invalid target type %d", tag.TargetType)
 	}
 	buf.WriteString("type ")
@@ -46,7 +48,7 @@ func (tag *Tag) Serialize() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	header, err := headerForType(TypeTag, body)
+	header, err := headerForType(objecttype.TypeTag, body)
 	if err != nil {
 		return nil, err
 	}
diff --git a/object/tree.go b/object/tree.go
index a922f2ab..9ccea4a2 100644
--- a/object/tree.go
+++ b/object/tree.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"sort"
 
+	"codeberg.org/lindenii/furgit/objecttype"
 	"codeberg.org/lindenii/furgit/oid"
 )
 
@@ -32,9 +33,9 @@ type Tree struct {
 }
 
 // ObjectType returns TypeTree.
-func (tree *Tree) ObjectType() Type {
+func (tree *Tree) ObjectType() objecttype.Type {
 	_ = tree
-	return TypeTree
+	return objecttype.TypeTree
 }
 
 // Entry looks up a tree entry by name.
diff --git a/object/tree_serialize.go b/object/tree_serialize.go
index b6182a03..79b1c79a 100644
--- a/object/tree_serialize.go
+++ b/object/tree_serialize.go
@@ -1,6 +1,10 @@
 package object
 
-import "strconv"
+import (
+	"strconv"
+
+	"codeberg.org/lindenii/furgit/objecttype"
+)
 
 func (tree *Tree) serialize() []byte {
 	var bodyLen int
@@ -29,7 +33,7 @@ func (tree *Tree) serialize() []byte {
 // Serialize renders the raw object (header + body).
 func (tree *Tree) Serialize() ([]byte, error) {
 	body := tree.serialize()
-	header, err := headerForType(TypeTree, body)
+	header, err := headerForType(objecttype.TypeTree, body)
 	if err != nil {
 		return nil, err
 	}