git/odb/pack: introduce PackedObjectType to classify packed objects

git/odb/pack/type.go

@@ -0,0 +1,58 @@
+package pack
+
+import (
+	"errors"
+	"fmt"
+)
+
+// PackedObjectType is a constant type that is defined for all valid object
+// types that a packed object can represent.
+type PackedObjectType uint8
+
+const (
+	// TypeNone is the zero-value for PackedObjectType, and represents the
+	// absence of a type.
+	TypeNone PackedObjectType = iota
+	// TypeCommit is the PackedObjectType for commit objects.
+	TypeCommit
+	// TypeTree is the PackedObjectType for tree objects.
+	TypeTree
+	// Typeblob is the PackedObjectType for blob objects.
+	TypeBlob
+	// TypeTag is the PackedObjectType for tag objects.
+	TypeTag
+
+	// TypeObjectOffsetDelta is the type for OBJ_OFS_DELTA-typed objects.
+	TypeObjectOffsetDelta PackedObjectType = 6
+	// TypeObjectReferenceDelta is the type for OBJ_REF_DELTA-typed objects.
+	TypeObjectReferenceDelta PackedObjectType = 7
+)
+
+// String implements fmt.Stringer and returns an encoding of the type valid for
+// use in the loose object format protocol (see: package 'git/odb' for more).
+//
+// If the receiving instance is not defined, String() will panic().
+func (t PackedObjectType) String() string {
+	switch t {
+	case TypeNone:
+		return "<none>"
+	case TypeCommit:
+		return "commit"
+	case TypeTree:
+		return "tree"
+	case TypeBlob:
+		return "blob"
+	case TypeTag:
+		return "tag"
+	case TypeObjectOffsetDelta:
+		return "obj_ofs_delta"
+	case TypeObjectReferenceDelta:
+		return "obj_ref_delta"
+	}
+
+	panic(fmt.Sprintf("git/odb/pack: unknown object type: %d", t))
+}
+
+var (
+	errUnrecognizedObjectType = errors.New("git/odb/pack: unrecognized object type")
+)

git/odb/pack/type_test.go

@@ -0,0 +1,52 @@
+package pack
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type PackedObjectStringTestCase struct {
+	T PackedObjectType
+
+	Expected string
+	Panic    bool
+}
+
+func (c *PackedObjectStringTestCase) Assert(t *testing.T) {
+	if c.Panic {
+		defer func() {
+			err := recover()
+
+			if err == nil {
+				t.Fatalf("git/odb/pack: expected panic()")
+			}
+
+			assert.Equal(t, c.Expected, fmt.Sprintf("%s", err))
+		}()
+	}
+
+	assert.Equal(t, c.Expected, c.T.String())
+}
+
+func TestPackedObjectTypeString(t *testing.T) {
+	for desc, c := range map[string]*PackedObjectStringTestCase{
+		"TypeNone": {T: TypeNone, Expected: "<none>"},
+
+		"TypeCommit": {T: TypeCommit, Expected: "commit"},
+		"TypeTree":   {T: TypeTree, Expected: "tree"},
+		"TypeBlob":   {T: TypeBlob, Expected: "blob"},
+		"TypeTag":    {T: TypeTag, Expected: "tag"},
+
+		"TypeObjectOffsetDelta": {T: TypeObjectOffsetDelta,
+			Expected: "obj_ofs_delta"},
+		"TypeObjectReferenceDelta": {T: TypeObjectReferenceDelta,
+			Expected: "obj_ref_delta"},
+
+		"unknown type": {T: PackedObjectType(5), Panic: true,
+			Expected: "git/odb/pack: unknown object type: 5"},
+	} {
+		t.Run(desc, c.Assert)
+	}
+}