object/typ: Remove Type prefix from object/typ.Type literals

9 files changed, 22 insertions, 22 deletions

diff --git a/object/tree/append.go b/object/tree/append.go
index 9985e668..5fe040f1 100644
--- a/object/tree/append.go
+++ b/object/tree/append.go
@@ -39,7 +39,7 @@ func (tree *Tree) AppendWithHeader(dst []byte) ([]byte, error) {
 		return dst, err
 	}
 
-	dst = header.Append(dst, typ.TypeTree, uint64(len(body)))
+	dst = header.Append(dst, typ.Tree, uint64(len(body)))
 
 	return append(dst, body...), nil
 }
diff --git a/object/tree/append_test.go b/object/tree/append_test.go
index babcd03b..174f50bf 100644
--- a/object/tree/append_test.go
+++ b/object/tree/append_test.go
@@ -29,7 +29,7 @@ func TestAppend(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			treeID, err := repo.HashObject(t, typ.TypeTree, bytes.NewReader(rawBody))
+			treeID, err := repo.HashObject(t, typ.Tree, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(tree): %v", err)
 			}
diff --git a/object/tree/helpers_test.go b/object/tree/helpers_test.go
index c71f0117..d6cfddb6 100644
--- a/object/tree/helpers_test.go
+++ b/object/tree/helpers_test.go
@@ -15,23 +15,23 @@ import (
 func mixedEntries(tb testing.TB, repo *testgit.Repo) []tree.Entry {
 	tb.Helper()
 
-	blobA, err := repo.HashObject(tb, typ.TypeBlob, strings.NewReader("blob-A\n"))
+	blobA, err := repo.HashObject(tb, typ.Blob, strings.NewReader("blob-A\n"))
 	if err != nil {
 		tb.Fatalf("HashObject(blob-A): %v", err)
 	}
 
-	blobB, err := repo.HashObject(tb, typ.TypeBlob, strings.NewReader("blob-B\n"))
+	blobB, err := repo.HashObject(tb, typ.Blob, strings.NewReader("blob-B\n"))
 	if err != nil {
 		tb.Fatalf("HashObject(blob-B): %v", err)
 	}
 
-	blobC, err := repo.HashObject(tb, typ.TypeBlob, strings.NewReader("blob-C\n"))
+	blobC, err := repo.HashObject(tb, typ.Blob, strings.NewReader("blob-C\n"))
 	if err != nil {
 		tb.Fatalf("HashObject(blob-C): %v", err)
 	}
 
 	subTree, err := repo.MkTree(tb, []testgit.TreeEntry{
-		{Mode: "100644", Type: typ.TypeBlob, OID: blobA, Name: "leaf"},
+		{Mode: "100644", Type: typ.Blob, OID: blobA, Name: "leaf"},
 	})
 	if err != nil {
 		tb.Fatalf("MkTree(subtree): %v", err)
diff --git a/object/tree/mode/details.go b/object/tree/mode/details.go
index 90ead2ed..32ea6768 100644
--- a/object/tree/mode/details.go
+++ b/object/tree/mode/details.go
@@ -19,30 +19,30 @@ var modeTable = map[Mode]modeDetails{
 		valid:         true,
 		isBlobLike:    false,
 		isRegularFile: false,
-		objectType:    typ.TypeTree,
+		objectType:    typ.Tree,
 	},
 	Regular: {
 		valid:         true,
 		isBlobLike:    true,
 		isRegularFile: true,
-		objectType:    typ.TypeBlob,
+		objectType:    typ.Blob,
 	},
 	Executable: {
 		valid:         true,
 		isBlobLike:    true,
 		isRegularFile: true,
-		objectType:    typ.TypeBlob,
+		objectType:    typ.Blob,
 	},
 	Symlink: {
 		valid:         true,
 		isBlobLike:    true,
 		isRegularFile: false,
-		objectType:    typ.TypeBlob,
+		objectType:    typ.Blob,
 	},
 	Gitlink: {
 		valid:         true,
 		isBlobLike:    false,
 		isRegularFile: false,
-		objectType:    typ.TypeCommit,
+		objectType:    typ.Commit,
 	},
 }
diff --git a/object/tree/mode/mode_test.go b/object/tree/mode/mode_test.go
index 0e2cc2aa..2ce6c8ea 100644
--- a/object/tree/mode/mode_test.go
+++ b/object/tree/mode/mode_test.go
@@ -14,12 +14,12 @@ func TestObjectType(t *testing.T) {
 		mode mode.Mode
 		want typ.Type
 	}{
-		{mode: mode.Directory, want: typ.TypeTree},
-		{mode: mode.Regular, want: typ.TypeBlob},
-		{mode: mode.Executable, want: typ.TypeBlob},
-		{mode: mode.Symlink, want: typ.TypeBlob},
-		{mode: mode.Gitlink, want: typ.TypeCommit},
-		{mode: mode.Mode(0), want: typ.TypeUnknown},
+		{mode: mode.Directory, want: typ.Tree},
+		{mode: mode.Regular, want: typ.Blob},
+		{mode: mode.Executable, want: typ.Blob},
+		{mode: mode.Symlink, want: typ.Blob},
+		{mode: mode.Gitlink, want: typ.Commit},
+		{mode: mode.Mode(0), want: typ.Unknown},
 	} {
 		if got := tc.mode.ObjectType(); got != tc.want {
 			t.Fatalf("Mode(%o).ObjectType() = %v, want %v", tc.mode, got, tc.want)
diff --git a/object/tree/mode/ops.go b/object/tree/mode/ops.go
index 149d95db..5f161d0b 100644
--- a/object/tree/mode/ops.go
+++ b/object/tree/mode/ops.go
@@ -32,7 +32,7 @@ func (mode Mode) HasSameType(other Mode) bool {
 
 // ObjectType returns the type of object that an entry with this mode targets.
 //
-// It returns [typ.TypeUnknown] for invalid modes.
+// It returns [typ.Unknown] for invalid modes.
 func (mode Mode) ObjectType() typ.Type {
 	return mode.details().objectType
 }
diff --git a/object/tree/parse_test.go b/object/tree/parse_test.go
index 8d32b136..0f5a8b30 100644
--- a/object/tree/parse_test.go
+++ b/object/tree/parse_test.go
@@ -28,7 +28,7 @@ func TestParse(t *testing.T) {
 				t.Fatalf("MkTree: %v", err)
 			}
 
-			rawBody, err := repo.CatFile(t, typ.TypeTree, treeID)
+			rawBody, err := repo.CatFile(t, typ.Tree, treeID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
diff --git a/object/tree/roundtrip_test.go b/object/tree/roundtrip_test.go
index 7fdc4140..3e82c79a 100644
--- a/object/tree/roundtrip_test.go
+++ b/object/tree/roundtrip_test.go
@@ -30,7 +30,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			treeID, err := repo.HashObject(t, typ.TypeTree, bytes.NewReader(rawBody))
+			treeID, err := repo.HashObject(t, typ.Tree, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(tree): %v", err)
 			}
@@ -43,7 +43,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("Fsck: %v", err)
 			}
 
-			gitBody, err := repo.CatFile(t, typ.TypeTree, treeID)
+			gitBody, err := repo.CatFile(t, typ.Tree, treeID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
diff --git a/object/tree/type.go b/object/tree/type.go
index 125e0bcc..aa433e82 100644
--- a/object/tree/type.go
+++ b/object/tree/type.go
@@ -6,5 +6,5 @@ import "lindenii.org/go/furgit/object/typ"
 func (tree *Tree) ObjectType() typ.Type {
 	_ = tree
 
-	return typ.TypeTree
+	return typ.Tree
 }