Rename ObjType enum

10 files changed, 132 insertions, 132 deletions

diff --git a/loose.go b/loose.go
index b8e9b19e..60cdfbc9 100644
--- a/loose.go
+++ b/loose.go
@@ -32,32 +32,32 @@ func (repo *Repository) looseRead(id Hash) (Object, error) {
 func (repo *Repository) looseReadTyped(id Hash) (ObjectType, []byte, error) {
 	path, err := repo.loosePath(id)
 	if err != nil {
-		return ObjInvalid, nil, err
+		return ObjectTypeInvalid, nil, err
 	}
 	path = repo.repoPath(path)
 	f, err := os.Open(path)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return ObjInvalid, nil, ErrNotFound
+			return ObjectTypeInvalid, nil, ErrNotFound
 		}
-		return ObjInvalid, nil, err
+		return ObjectTypeInvalid, nil, err
 	}
 	defer func() { _ = f.Close() }()
 
 	zr, err := zlib.NewReader(f)
 	if err != nil {
-		return ObjInvalid, nil, err
+		return ObjectTypeInvalid, nil, err
 	}
 	defer func() { _ = zr.Close() }()
 
 	raw, err := io.ReadAll(zr)
 	if err != nil {
-		return ObjInvalid, nil, err
+		return ObjectTypeInvalid, nil, err
 	}
 
 	nul := bytes.IndexByte(raw, 0)
 	if nul < 0 {
-		return ObjInvalid, nil, ErrInvalidObject
+		return ObjectTypeInvalid, nil, ErrInvalidObject
 	}
 
 	header := raw[:nul]
@@ -65,13 +65,13 @@ func (repo *Repository) looseReadTyped(id Hash) (ObjectType, []byte, error) {
 
 	ty, declaredSize, err := parseLooseHeader(header)
 	if err != nil {
-		return ObjInvalid, nil, err
+		return ObjectTypeInvalid, nil, err
 	}
 	if declaredSize != int64(len(body)) {
-		return ObjInvalid, nil, ErrInvalidObject
+		return ObjectTypeInvalid, nil, ErrInvalidObject
 	}
 	if !repo.verifyRawObject(raw, id) {
-		return ObjInvalid, nil, ErrInvalidObject
+		return ObjectTypeInvalid, nil, ErrInvalidObject
 	}
 
 	out := append([]byte(nil), body...)
@@ -81,22 +81,22 @@ func (repo *Repository) looseReadTyped(id Hash) (ObjectType, []byte, error) {
 func (repo *Repository) looseTypeSize(id Hash) (ObjectType, int64, error) {
 	path, err := repo.loosePath(id)
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	path = repo.repoPath(path)
 	// #nosec G304
 	f, err := os.Open(path)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return ObjInvalid, 0, ErrNotFound
+			return ObjectTypeInvalid, 0, ErrNotFound
 		}
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	defer func() { _ = f.Close() }()
 
 	zr, err := zlib.NewReader(f)
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	defer func() { _ = zr.Close() }()
 
@@ -109,20 +109,20 @@ func (repo *Repository) looseTypeSize(id Hash) (ObjectType, int64, error) {
 			if nul := bytes.IndexByte(data, 0); nul >= 0 {
 				header = append(header, data[:nul]...)
 				if len(header) > looseHeaderLimit {
-					return ObjInvalid, 0, ErrInvalidObject
+					return ObjectTypeInvalid, 0, ErrInvalidObject
 				}
 				break
 			}
 			header = append(header, data...)
 			if len(header) > looseHeaderLimit {
-				return ObjInvalid, 0, ErrInvalidObject
+				return ObjectTypeInvalid, 0, ErrInvalidObject
 			}
 		}
 		if readErr != nil {
 			if readErr == io.EOF {
-				return ObjInvalid, 0, ErrInvalidObject
+				return ObjectTypeInvalid, 0, ErrInvalidObject
 			}
-			return ObjInvalid, 0, readErr
+			return ObjectTypeInvalid, 0, readErr
 		}
 	}
 	return parseLooseHeader(header)
@@ -131,38 +131,38 @@ func (repo *Repository) looseTypeSize(id Hash) (ObjectType, int64, error) {
 func parseLooseHeader(header []byte) (ObjectType, int64, error) {
 	space := bytes.IndexByte(header, ' ')
 	if space < 0 {
-		return ObjInvalid, 0, ErrInvalidObject
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	}
 	ty, err := objTypeFromName(string(header[:space]))
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	expect := header[space+1:]
 	if len(expect) == 0 {
-		return ObjInvalid, 0, ErrInvalidObject
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	}
 	size, err := strconv.ParseInt(string(expect), 10, 64)
 	if err != nil {
-		return ObjInvalid, 0, fmt.Errorf("furgit: loose: size parse: %w", err)
+		return ObjectTypeInvalid, 0, fmt.Errorf("furgit: loose: size parse: %w", err)
 	}
 	if size < 0 {
-		return ObjInvalid, 0, ErrInvalidObject
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	}
 	return ty, size, nil
 }
 
 func objTypeFromName(name string) (ObjectType, error) {
 	switch name {
-	case objNameBlob:
-		return ObjBlob, nil
-	case objNameTree:
-		return ObjTree, nil
-	case objNameCommit:
-		return ObjCommit, nil
-	case objNameTag:
-		return ObjTag, nil
+	case objectTypeNameBlob:
+		return ObjectTypeBlob, nil
+	case objectTypeNameTree:
+		return ObjectTypeTree, nil
+	case objectTypeNameCommit:
+		return ObjectTypeCommit, nil
+	case objectTypeNameTag:
+		return ObjectTypeTag, nil
 	default:
-		return ObjInvalid, ErrInvalidObject
+		return ObjectTypeInvalid, ErrInvalidObject
 	}
 }
 
diff --git a/obj.go b/obj.go
index ab37c570..de847607 100644
--- a/obj.go
+++ b/obj.go
@@ -11,21 +11,21 @@ import (
 type ObjectType uint8
 
 const (
-	ObjInvalid  ObjectType = 0
-	ObjCommit   ObjectType = 1
-	ObjTree     ObjectType = 2
-	ObjBlob     ObjectType = 3
-	ObjTag      ObjectType = 4
-	ObjFuture   ObjectType = 5
-	ObjOfsDelta ObjectType = 6
-	ObjRefDelta ObjectType = 7
+	ObjectTypeInvalid  ObjectType = 0
+	ObjectTypeCommit   ObjectType = 1
+	ObjectTypeTree     ObjectType = 2
+	ObjectTypeBlob     ObjectType = 3
+	ObjectTypeTag      ObjectType = 4
+	ObjectTypeFuture   ObjectType = 5
+	ObjectTypeOfsDelta ObjectType = 6
+	ObjectTypeRefDelta ObjectType = 7
 )
 
 const (
-	objNameBlob   = "blob"
-	objNameTree   = "tree"
-	objNameCommit = "commit"
-	objNameTag    = "tag"
+	objectTypeNameBlob   = "blob"
+	objectTypeNameTree   = "tree"
+	objectTypeNameCommit = "commit"
+	objectTypeNameTag    = "tag"
 )
 
 // Object describes any Git object variant.
@@ -36,15 +36,15 @@ type Object interface {
 func headerForType(ty ObjectType, body []byte) ([]byte, error) {
 	var tyStr string
 	switch ty {
-	case ObjBlob:
-		tyStr = objNameBlob
-	case ObjTree:
-		tyStr = objNameTree
-	case ObjCommit:
-		tyStr = objNameCommit
-	case ObjTag:
-		tyStr = objNameTag
-	case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta:
+	case ObjectTypeBlob:
+		tyStr = objectTypeNameBlob
+	case ObjectTypeTree:
+		tyStr = objectTypeNameTree
+	case ObjectTypeCommit:
+		tyStr = objectTypeNameCommit
+	case ObjectTypeTag:
+		tyStr = objectTypeNameTag
+	case ObjectTypeInvalid, ObjectTypeFuture, ObjectTypeOfsDelta, ObjectTypeRefDelta:
 		return nil, fmt.Errorf("furgit: object: unsupported type %d", ty)
 	default:
 		return nil, fmt.Errorf("furgit: object: unsupported type %d", ty)
@@ -61,15 +61,15 @@ func headerForType(ty ObjectType, body []byte) ([]byte, error) {
 
 func parseObjectBody(ty ObjectType, id Hash, body []byte, repo *Repository) (Object, error) {
 	switch ty {
-	case ObjBlob:
+	case ObjectTypeBlob:
 		return parseBlob(id, body)
-	case ObjTree:
+	case ObjectTypeTree:
 		return parseTree(id, body, repo)
-	case ObjCommit:
+	case ObjectTypeCommit:
 		return parseCommit(id, body, repo)
-	case ObjTag:
+	case ObjectTypeTag:
 		return parseTag(id, body, repo)
-	case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta:
+	case ObjectTypeInvalid, ObjectTypeFuture, ObjectTypeOfsDelta, ObjectTypeRefDelta:
 		return nil, fmt.Errorf("furgit: object: unsupported type %d", ty)
 	default:
 		return nil, fmt.Errorf("furgit: object: unknown type %d", ty)
@@ -99,14 +99,14 @@ func (repo *Repository) ReadObjectTypeSize(id Hash) (ObjectType, int64, error) {
 		return ty, size, nil
 	}
 	if !errors.Is(err, ErrNotFound) {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	loc, err := repo.packIndexFind(id)
 	if err != nil {
 		if errors.Is(err, ErrNotFound) {
-			return ObjInvalid, 0, ErrInvalidObject
+			return ObjectTypeInvalid, 0, ErrInvalidObject
 		}
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	return repo.packTypeSizeAtLocation(loc, nil)
 }
diff --git a/obj_blob.go b/obj_blob.go
index d3be2f23..c25f88eb 100644
--- a/obj_blob.go
+++ b/obj_blob.go
@@ -10,7 +10,7 @@ type Blob struct {
 // ObjectType allows Blob to satisfy the Object interface.
 func (blob *Blob) ObjectType() ObjectType {
 	_ = blob
-	return ObjBlob
+	return ObjectTypeBlob
 }
 
 func parseBlob(id Hash, body []byte) (*Blob, error) {
@@ -23,7 +23,7 @@ func parseBlob(id Hash, body []byte) (*Blob, error) {
 
 // Serialize renders the full "blob size\\0body" representation.
 func (blob *Blob) Serialize() ([]byte, error) {
-	header, err := headerForType(ObjBlob, blob.Data)
+	header, err := headerForType(ObjectTypeBlob, blob.Data)
 	if err != nil {
 		return nil, err
 	}
diff --git a/obj_commit.go b/obj_commit.go
index 628a188a..f1616fba 100644
--- a/obj_commit.go
+++ b/obj_commit.go
@@ -20,7 +20,7 @@ type Commit struct {
 // ObjectType allows Commit to satisfy the Object interface.
 func (commit *Commit) ObjectType() ObjectType {
 	_ = commit
-	return ObjCommit
+	return ObjectTypeCommit
 }
 
 func parseCommit(id Hash, body []byte, repo *Repository) (*Commit, error) {
@@ -124,7 +124,7 @@ func (commit *Commit) Serialize() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	header, err := headerForType(ObjCommit, body)
+	header, err := headerForType(ObjectTypeCommit, body)
 	if err != nil {
 		return nil, err
 	}
diff --git a/obj_tag.go b/obj_tag.go
index 8c5981e9..20088f17 100644
--- a/obj_tag.go
+++ b/obj_tag.go
@@ -19,7 +19,7 @@ type Tag struct {
 // ObjectType allows Tag to satisfy the Object interface.
 func (tag *Tag) ObjectType() ObjectType {
 	_ = tag
-	return ObjTag
+	return ObjectTypeTag
 }
 
 // parseTag parses a tag object body.
@@ -51,15 +51,15 @@ func parseTag(id Hash, body []byte, repo *Repository) (*Tag, error) {
 		case bytes.HasPrefix(line, []byte("type ")):
 			switch string(line[5:]) {
 			case "commit":
-				t.TargetType = ObjCommit
+				t.TargetType = ObjectTypeCommit
 			case "tree":
-				t.TargetType = ObjTree
+				t.TargetType = ObjectTypeTree
 			case "blob":
-				t.TargetType = ObjBlob
+				t.TargetType = ObjectTypeBlob
 			case "tag":
-				t.TargetType = ObjTag
+				t.TargetType = ObjectTypeTag
 			default:
-				t.TargetType = ObjInvalid
+				t.TargetType = ObjectTypeInvalid
 				return nil, errors.New("furgit: tag: unknown target type")
 			}
 			haveType = true
@@ -100,15 +100,15 @@ func tagBody(t *Tag) ([]byte, error) {
 	fmt.Fprintf(&buf, "object %s\n", t.Target.String())
 	buf.WriteString("type ")
 	switch t.TargetType {
-	case ObjCommit:
+	case ObjectTypeCommit:
 		buf.WriteString("commit")
-	case ObjTree:
+	case ObjectTypeTree:
 		buf.WriteString("tree")
-	case ObjBlob:
+	case ObjectTypeBlob:
 		buf.WriteString("blob")
-	case ObjTag:
+	case ObjectTypeTag:
 		buf.WriteString("tag")
-	case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta:
+	case ObjectTypeInvalid, ObjectTypeFuture, ObjectTypeOfsDelta, ObjectTypeRefDelta:
 		return nil, fmt.Errorf("furgit: tag: invalid target type %d", t.TargetType)
 	default:
 		return nil, fmt.Errorf("furgit: tag: invalid target type %d", t.TargetType)
@@ -138,7 +138,7 @@ func (tag *Tag) Serialize() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	header, err := headerForType(ObjTag, body)
+	header, err := headerForType(ObjectTypeTag, body)
 	if err != nil {
 		return nil, err
 	}
diff --git a/obj_tree.go b/obj_tree.go
index 8ba1e26f..36c98950 100644
--- a/obj_tree.go
+++ b/obj_tree.go
@@ -23,7 +23,7 @@ type TreeEntry struct {
 // ObjectType allows Tree to satisfy the Object interface.
 func (tree *Tree) ObjectType() ObjectType {
 	_ = tree
-	return ObjTree
+	return ObjectTypeTree
 }
 
 // parseTree decodes a tree body.
@@ -99,7 +99,7 @@ func treeBody(t *Tree) []byte {
 // Serialize renders a Tree into canonical Git format.
 func (tree *Tree) Serialize() ([]byte, error) {
 	body := treeBody(tree)
-	header, err := headerForType(ObjTree, body)
+	header, err := headerForType(ObjectTypeTree, body)
 	if err != nil {
 		return nil, err
 	}
diff --git a/objects_test.go b/objects_test.go
index 8836515c..141ba1d7 100644
--- a/objects_test.go
+++ b/objects_test.go
@@ -65,7 +65,7 @@ func TestParseBlobAndSerialize(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Serialize error: %v", err)
 	}
-	header, err := headerForType(ObjBlob, data)
+	header, err := headerForType(ObjectTypeBlob, data)
 	if err != nil {
 		t.Fatalf("headerForType: %v", err)
 	}
@@ -99,7 +99,7 @@ func TestParseTreeAndSerialize(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Serialize error: %v", err)
 	}
-	header, _ := headerForType(ObjTree, body)
+	header, _ := headerForType(ObjectTypeTree, body)
 	want := append(append([]byte(nil), header...), body...)
 	if !bytes.Equal(serialized, want) {
 		t.Fatalf("serialized tree mismatch")
@@ -190,7 +190,7 @@ func TestParseTagAndSerialize(t *testing.T) {
 	if err != nil {
 		t.Fatalf("parseTag error: %v", err)
 	}
-	if tag.Target != target || tag.TargetType != ObjCommit {
+	if tag.Target != target || tag.TargetType != ObjectTypeCommit {
 		t.Fatalf("tag target mismatch")
 	}
 	if tag.Tagger == nil {
diff --git a/pack_pack.go b/pack_pack.go
index 3ab935cd..1569cf57 100644
--- a/pack_pack.go
+++ b/pack_pack.go
@@ -81,7 +81,7 @@ func (repo *Repository) packReadAt(loc packlocation, want Hash) (Object, error)
 func (repo *Repository) packBodyResolveAtLocation(loc packlocation) (ObjectType, borrowedBody, error) {
 	pf, err := repo.packFile(loc.PackPath)
 	if err != nil {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	return repo.packBodyResolveWithin(pf, loc.Offset)
 }
@@ -89,7 +89,7 @@ func (repo *Repository) packBodyResolveAtLocation(loc packlocation) (ObjectType,
 func (repo *Repository) packTypeSizeAtLocation(loc packlocation, seen map[packKey]struct{}) (ObjectType, int64, error) {
 	pf, err := repo.packFile(loc.PackPath)
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	return repo.packTypeSizeWithin(pf, loc.Offset, seen)
 }
@@ -100,7 +100,7 @@ func (repo *Repository) packTypeSizeByID(id Hash, seen map[packKey]struct{}) (Ob
 		return repo.packTypeSizeAtLocation(loc, seen)
 	}
 	if !errors.Is(err, ErrNotFound) {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	return repo.looseTypeSize(id)
 }
@@ -109,7 +109,7 @@ func packHeaderRead(r io.Reader) (ObjectType, int, error) {
 	var b [1]byte
 	_, err := io.ReadFull(r, b[:])
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	ty := ObjectType((b[0] >> 4) & 0x07)
 	size := int(b[0] & 0x0f)
@@ -117,7 +117,7 @@ func packHeaderRead(r io.Reader) (ObjectType, int, error) {
 	for (b[0] & 0x80) != 0 {
 		_, err = io.ReadFull(r, b[:])
 		if err != nil {
-			return ObjInvalid, 0, err
+			return ObjectTypeInvalid, 0, err
 		}
 		size |= int(b[0]&0x7f) << shift
 		shift += 7
@@ -175,30 +175,30 @@ func packSectionInflate(r io.Reader, sizeHint int) (borrowedBody, error) {
 func (repo *Repository) packDeltaResolveOfs(pf *packFile, deltaOffset uint64, r io.Reader) (ObjectType, borrowedBody, error) {
 	dist, err := packDeltaReadOfsDistance(r)
 	if err != nil {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	var baseOfs uint64
 	if deltaOffset > dist {
 		baseOfs = deltaOffset - dist
 	}
 	if baseOfs == 0 {
-		return ObjInvalid, borrowedBody{}, ErrInvalidObject
+		return ObjectTypeInvalid, borrowedBody{}, ErrInvalidObject
 	}
 	ty, body, err := repo.packBodyResolveWithin(pf, baseOfs)
 	if err != nil {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	delta, err := packSectionInflate(r, 0)
 	if err != nil {
 		body.Release()
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	out, err := packDeltaApply(body, delta)
 	delta.Release()
 	body.Release()
 	if err != nil {
 		out.Release()
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	return ty, out, nil
 }
@@ -226,11 +226,11 @@ func (repo *Repository) packBodyResolveByID(id Hash) (ObjectType, borrowedBody,
 		return repo.packBodyResolveAtLocation(loc)
 	}
 	if !errors.Is(err, ErrNotFound) {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	ty, body, err := repo.looseReadTyped(id)
 	if err != nil {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	return ty, borrowedFromOwned(body), nil
 }
@@ -242,108 +242,108 @@ type packKey struct {
 
 func (repo *Repository) packTypeSizeWithin(pf *packFile, ofs uint64, seen map[packKey]struct{}) (ObjectType, int64, error) {
 	if pf == nil {
-		return ObjInvalid, 0, ErrInvalidObject
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	}
 	if seen == nil {
 		seen = make(map[packKey]struct{})
 	}
 	key := packKey{path: pf.relPath, ofs: ofs}
 	if _, dup := seen[key]; dup {
-		return ObjInvalid, 0, ErrInvalidObject
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	}
 	seen[key] = struct{}{}
 	defer delete(seen, key)
 
 	r, err := pf.cursor(ofs)
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	ty, size, err := packHeaderRead(r)
 	if err != nil {
-		return ObjInvalid, 0, err
+		return ObjectTypeInvalid, 0, err
 	}
 	declaredSize := int64(size)
 
 	switch ty {
-	case ObjCommit, ObjTree, ObjBlob, ObjTag:
+	case ObjectTypeCommit, ObjectTypeTree, ObjectTypeBlob, ObjectTypeTag:
 		return ty, declaredSize, nil
-	case ObjRefDelta:
+	case ObjectTypeRefDelta:
 		var base Hash
 		_, err := io.ReadFull(r, base.data[:repo.hashSize])
 		if err != nil {
-			return ObjInvalid, 0, err
+			return ObjectTypeInvalid, 0, err
 		}
 		base.size = repo.hashSize
 		baseTy, _, err := repo.packTypeSizeByID(base, seen)
 		if err != nil {
-			return ObjInvalid, 0, err
+			return ObjectTypeInvalid, 0, err
 		}
 		return baseTy, declaredSize, nil
-	case ObjOfsDelta:
+	case ObjectTypeOfsDelta:
 		dist, err := packDeltaReadOfsDistance(r)
 		if err != nil {
-			return ObjInvalid, 0, err
+			return ObjectTypeInvalid, 0, err
 		}
 		if ofs <= dist {
-			return ObjInvalid, 0, ErrInvalidObject
+			return ObjectTypeInvalid, 0, ErrInvalidObject
 		}
 		baseOfs := ofs - dist
 		baseTy, _, err := repo.packTypeSizeWithin(pf, baseOfs, seen)
 		if err != nil {
-			return ObjInvalid, 0, err
+			return ObjectTypeInvalid, 0, err
 		}
 		return baseTy, declaredSize, nil
-	case ObjInvalid, ObjFuture:
-		return ObjInvalid, 0, ErrInvalidObject
+	case ObjectTypeInvalid, ObjectTypeFuture:
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	default:
-		return ObjInvalid, 0, ErrInvalidObject
+		return ObjectTypeInvalid, 0, ErrInvalidObject
 	}
 }
 
 func (repo *Repository) packBodyResolveWithin(pf *packFile, ofs uint64) (ObjectType, borrowedBody, error) {
 	r, err := pf.cursor(ofs)
 	if err != nil {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 	ty, size, err := packHeaderRead(r)
 	if err != nil {
-		return ObjInvalid, borrowedBody{}, err
+		return ObjectTypeInvalid, borrowedBody{}, err
 	}
 
 	switch ty {
-	case ObjCommit, ObjTree, ObjBlob, ObjTag:
+	case ObjectTypeCommit, ObjectTypeTree, ObjectTypeBlob, ObjectTypeTag:
 		body, err := packSectionInflate(r, size)
 		return ty, body, err
-	case ObjRefDelta:
+	case ObjectTypeRefDelta:
 		var base Hash
 		_, err := io.ReadFull(r, base.data[:repo.hashSize])
 		if err != nil {
-			return ObjInvalid, borrowedBody{}, err
+			return ObjectTypeInvalid, borrowedBody{}, err
 		}
 		base.size = repo.hashSize
 		delta, err := packSectionInflate(r, 0)
 		if err != nil {
-			return ObjInvalid, borrowedBody{}, err
+			return ObjectTypeInvalid, borrowedBody{}, err
 		}
 		bt, body, err := repo.packBodyResolveByID(base)
 		if err != nil {
 			delta.Release()
-			return ObjInvalid, borrowedBody{}, err
+			return ObjectTypeInvalid, borrowedBody{}, err
 		}
 		out, err := packDeltaApply(body, delta)
 		delta.Release()
 		body.Release()
 		if err != nil {
 			out.Release()
-			return ObjInvalid, borrowedBody{}, err
+			return ObjectTypeInvalid, borrowedBody{}, err
 		}
 		return bt, out, nil
-	case ObjOfsDelta:
+	case ObjectTypeOfsDelta:
 		return repo.packDeltaResolveOfs(pf, ofs, r)
-	case ObjInvalid, ObjFuture:
-		return ObjInvalid, borrowedBody{}, ErrInvalidObject
+	case ObjectTypeInvalid, ObjectTypeFuture:
+		return ObjectTypeInvalid, borrowedBody{}, ErrInvalidObject
 	default:
-		return ObjInvalid, borrowedBody{}, ErrInvalidObject
+		return ObjectTypeInvalid, borrowedBody{}, ErrInvalidObject
 	}
 }
 
diff --git a/pack_test.go b/pack_test.go
index c2a3c573..82176ae1 100644
--- a/pack_test.go
+++ b/pack_test.go
@@ -62,12 +62,12 @@ func encodePackHeader(ty ObjectType, size int) []byte {
 }
 
 func TestPackHeaderRead(t *testing.T) {
-	buf := encodePackHeader(ObjTree, 0x1fff)
+	buf := encodePackHeader(ObjectTypeTree, 0x1fff)
 	ty, size, err := packHeaderRead(bytes.NewReader(buf))
 	if err != nil {
 		t.Fatalf("packHeaderRead error: %v", err)
 	}
-	if ty != ObjTree || size != 0x1fff {
+	if ty != ObjectTypeTree || size != 0x1fff {
 		t.Fatalf("unexpected header decode ty=%d size=%d", ty, size)
 	}
 	if _, _, err := packHeaderRead(bytes.NewReader([]byte{0x80})); err == nil {
diff --git a/repo_test.go b/repo_test.go
index c8eab26e..4f43f33d 100644
--- a/repo_test.go
+++ b/repo_test.go
@@ -128,7 +128,7 @@ func TestReadObjectTypeSizeLoose(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ReadObjectTypeSize loose error: %v", err)
 	}
-	if ty != ObjBlob || size != int64(len(data)) {
+	if ty != ObjectTypeBlob || size != int64(len(data)) {
 		t.Fatalf("unexpected loose metadata ty=%d size=%d", ty, size)
 	}
 }
@@ -139,9 +139,9 @@ func TestReadObjectTypeSizePackedObjects(t *testing.T) {
 	setupRepoConfig(t, root)
 
 	objs := []testPackObject{
-		{finalType: ObjBlob, body: []byte("packed base payload")},
+		{finalType: ObjectTypeBlob, body: []byte("packed base payload")},
 		{
-			finalType: ObjBlob,
+			finalType: ObjectTypeBlob,
 			body:      []byte("packed delta payload with extra bytes"),
 			encoding:  packEncodingOfsDelta,
 			baseIndex: 0,
@@ -159,7 +159,7 @@ func TestReadObjectTypeSizePackedObjects(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ReadObjectTypeSize base error: %v", err)
 	}
-	if ty != ObjBlob || size != int64(len(objs[0].body)) {
+	if ty != ObjectTypeBlob || size != int64(len(objs[0].body)) {
 		t.Fatalf("unexpected base metadata ty=%d size=%d", ty, size)
 	}
 
@@ -167,7 +167,7 @@ func TestReadObjectTypeSizePackedObjects(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ReadObjectTypeSize delta error: %v", err)
 	}
-	if ty != ObjBlob || size != int64(len(objs[1].body)) {
+	if ty != ObjectTypeBlob || size != int64(len(objs[1].body)) {
 		t.Fatalf("unexpected delta metadata ty=%d size=%d", ty, size)
 	}
 }
@@ -188,7 +188,7 @@ func TestReadObjectTypeSizePackRefDeltaLooseBase(t *testing.T) {
 
 	objs := []testPackObject{
 		{
-			finalType: ObjBlob,
+			finalType: ObjectTypeBlob,
 			body:      []byte("ref delta rewritten body"),
 			encoding:  packEncodingRefDelta,
 			baseHash:  baseID,
@@ -201,7 +201,7 @@ func TestReadObjectTypeSizePackRefDeltaLooseBase(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ReadObjectTypeSize ref delta error: %v", err)
 	}
-	if ty != ObjBlob || size != int64(len(objs[0].body)) {
+	if ty != ObjectTypeBlob || size != int64(len(objs[0].body)) {
 		t.Fatalf("unexpected ref delta metadata ty=%d size=%d", ty, size)
 	}
 }
@@ -285,7 +285,7 @@ func TestWriteLooseObjectAllTypes(t *testing.T) {
 	// Tag
 	tag := &Tag{
 		Target:     commitID,
-		TargetType: ObjCommit,
+		TargetType: ObjectTypeCommit,
 		Name:       []byte("v1.0.0"),
 		Tagger: &Ident{
 			Name:          []byte("Test Tagger"),
@@ -378,7 +378,7 @@ func writeTestPack(t *testing.T, root, name string, objs []testPackObject) []Has
 			if obj.baseIndex < 0 || obj.baseIndex >= i {
 				t.Fatalf("invalid base index %d for ofs delta %d", obj.baseIndex, i)
 			}
-			buf.Write(encodePackHeader(ObjOfsDelta, len(obj.body)))
+			buf.Write(encodePackHeader(ObjectTypeOfsDelta, len(obj.body)))
 			dist := offsets[i] - offsets[obj.baseIndex]
 			buf.Write(encodeOfsDistance(dist))
 			baseBody := objs[obj.baseIndex].body
@@ -392,7 +392,7 @@ func writeTestPack(t *testing.T, root, name string, objs []testPackObject) []Has
 			if len(baseBody) == 0 {
 				t.Fatalf("ref delta %d missing base body", i)
 			}
-			buf.Write(encodePackHeader(ObjRefDelta, len(obj.body)))
+			buf.Write(encodePackHeader(ObjectTypeRefDelta, len(obj.body)))
 			buf.Write(obj.baseHash.data[:testHashSize])
 			delta := buildInsertOnlyDelta(len(baseBody), obj.body)
 			buf.Write(compressBytes(t, delta))