From d190d8a6b3717402744902d060be57195f27d604 Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 16 Apr 2013 23:04:35 +0200 Subject: [PATCH 1/6] Take 2 on polymorphism --- blob.go | 18 +++++++++++++----- commit.go | 20 ++++++++++++++------ object.go | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ odb.go | 9 --------- repository.go | 40 +++++++++++++++++++++++----------------- tree.go | 29 +++++++++++++---------------- 6 files changed, 112 insertions(+), 53 deletions(-) create mode 100644 object.go diff --git a/blob.go b/blob.go index 73e3ab3..ee50a15 100644 --- a/blob.go +++ b/blob.go @@ -7,17 +7,25 @@ package git */ import "C" import ( - "runtime" "unsafe" + "runtime" ) type Blob struct { - ptr *C.git_object + ptr *C.git_blob } -func (v *Blob) Free() { - runtime.SetFinalizer(v, nil) - C.git_object_free(v.ptr) +func (o *Blob) Id() *Oid { + return newOidFromC(C.git_blob_id(o.ptr)) +} + +func (o *Blob) Type() ObjectType { + return OBJ_BLOB +} + +func (o *Blob) Free() { + runtime.SetFinalizer(o, nil) + C.git_blob_free(o.ptr) } func (v *Blob) Size() int64 { diff --git a/commit.go b/commit.go index d31f684..b1ca6c4 100644 --- a/commit.go +++ b/commit.go @@ -19,8 +19,17 @@ type Commit struct { ptr *C.git_commit } -func (c *Commit) Id() *Oid { - return newOidFromC(C.git_commit_id(c.ptr)) +func (o *Commit) Id() *Oid { + return newOidFromC(C.git_commit_id(o.ptr)) +} + +func (o *Commit) Type() ObjectType { + return OBJ_COMMIT +} + +func (o *Commit) Free() { + runtime.SetFinalizer(o, nil) + C.git_commit_free(o.ptr) } func (c *Commit) Message() string { @@ -28,15 +37,14 @@ func (c *Commit) Message() string { } func (c *Commit) Tree() (*Tree, error) { - tree := new(Tree) + var ptr *C.git_object - err := C.git_commit_tree(&tree.ptr, c.ptr) + err := C.git_commit_tree(&ptr, c.ptr) if err < 0 { return nil, LastError() } - runtime.SetFinalizer(tree, (*Tree).Free) - return tree, nil + return allocObject(ptr).(*Tree), nil } func (c *Commit) TreeId() *Oid { diff --git a/object.go b/object.go new file mode 100644 index 0000000..0d55409 --- /dev/null +++ b/object.go @@ -0,0 +1,49 @@ +package git + +/* +#cgo pkg-config: libgit2 +#include +#include +*/ +import "C" +import "runtime" + +type ObjectType int + +var ( + OBJ_ANY ObjectType = C.GIT_OBJ_ANY + OBJ_BAD ObjectType = C.GIT_OBJ_BAD + OBJ_COMMIT ObjectType = C.GIT_OBJ_COMMIT + OBJ_TREE ObjectType = C.GIT_OBJ_TREE + OBJ_BLOB ObjectType = C.GIT_OBJ_BLOB + OBJ_TAG ObjectType = C.GIT_OBJ_TAG +) + +type Object interface { + Free() + Id() *Oid + Type() ObjectType +} + +func allocObject(cobj *C.git_object) Object { + var object Object + + switch ObjectType(C.git_object_type(cobj)) { + case OBJ_COMMIT: + object = &Commit{cobj} + runtime.SetFinalizer(object, (*Commit).Free) + + case OBJ_TREE: + object = &Tree{cobj} + runtime.SetFinalizer(object, (*Tree).Free) + + case OBJ_BLOB: + object = &Blob{cobj} + runtime.SetFinalizer(object, (*Blob).Free) + + default: + return nil + } + + return object +} diff --git a/odb.go b/odb.go index bf17171..37d9fcd 100644 --- a/odb.go +++ b/odb.go @@ -12,15 +12,6 @@ import ( "runtime" ) -var ( - OBJ_ANY = C.GIT_OBJ_ANY - OBJ_BAD = C.GIT_OBJ_BAD - OBJ_COMMIT = C.GIT_OBJ_COMMIT - OBJ_TREE = C.GIT_OBJ_TREE - OBJ_BLOB = C.GIT_OBJ_BLOB - OBJ_TAG = C.GIT_OBJ_TAG -) - type Odb struct { ptr *C.git_odb } diff --git a/repository.go b/repository.go index 3de4974..015e5bf 100644 --- a/repository.go +++ b/repository.go @@ -72,35 +72,41 @@ func (v *Repository) Index() (*Index, error) { return newIndexFromC(ptr), nil } -func (v *Repository) LookupTree(oid *Oid) (*Tree, error) { - tree := new(Tree) - ret := C.git_tree_lookup(&tree.ptr, v.ptr, oid.toC()) +func (v *Repository) Lookup(oid *Oid, t ObjectType) (Object, error) { + var ptr *C.git_object + ret := C.git_object_lookup(&ptr, v.ptr, oid.toC(), C.git_otype(t)) if ret < 0 { return nil, LastError() } - return tree, nil + return allocObject(ptr), nil } -func (v *Repository) LookupCommit(o *Oid) (*Commit, error) { - commit := new(Commit) - ecode := C.git_commit_lookup(&commit.ptr, v.ptr, o.toC()) - if ecode < 0 { - return nil, LastError() +func (v *Repository) LookupTree(oid *Oid) (*Tree, error) { + obj, err := v.Lookup(oid, OBJ_TREE) + if err != nil { + return nil, err } - return commit, nil + return obj.(*Tree), nil } -func (v *Repository) LookupBlob(o *Oid) (*Blob, error) { - blob := new(Blob) - ecode := C.git_blob_lookup(&blob.ptr, v.ptr, o.toC()) - if ecode < 0 { - return nil, LastError() +func (v *Repository) LookupCommit(oid *Oid) (*Commit, error) { + obj, err := v.Lookup(oid, OBJ_COMMIT) + if err != nil { + return nil, err } - runtime.SetFinalizer(blob, (*Blob).Free) - return blob, nil + return obj.(*Commit), nil +} + +func (v *Repository) LookupBlob(oid *Oid) (*Blob, error) { + obj, err := v.Lookup(oid, OBJ_BLOB) + if err != nil { + return nil, err + } + + return obj.(*Blob), nil } func (v *Repository) LookupReference(name string) (*Reference, error) { diff --git a/tree.go b/tree.go index dc82929..d8a639c 100644 --- a/tree.go +++ b/tree.go @@ -17,6 +17,19 @@ type Tree struct { ptr *C.git_tree } +func (o *Tree) Id() *Oid { + return newOidFromC(C.git_tree_id(o.ptr)) +} + +func (o *Tree) Type() ObjectType { + return OBJ_TREE +} + +func (o *Tree) Free() { + runtime.SetFinalizer(o, nil) + C.git_tree_free(o.ptr) +} + type TreeEntry struct { Name string Id *Oid @@ -31,22 +44,6 @@ func newTreeEntry(entry *C.git_tree_entry) *TreeEntry { } } -func (t *Tree) Free() { - runtime.SetFinalizer(t, nil) - C.git_tree_free(t.ptr) -} - -func TreeLookup(repo *Repository, oid *Oid) (*Tree, error) { - tree := new(Tree) - err := C.git_tree_lookup(&tree.ptr, repo.ptr, oid.toC()) - if err < 0 { - return nil, LastError() - } - - runtime.SetFinalizer(tree, (*Tree).Free) - return tree, nil -} - func (t *Tree) EntryByName(filename string) *TreeEntry { cname := C.CString(filename) defer C.free(unsafe.Pointer(cname)) -- 2.45.2 From 7292cafac2d2c4462f3bc0b850e702d6d87f629e Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 16 Apr 2013 23:18:35 +0200 Subject: [PATCH 2/6] Add @carlosmn's tests --- git_test.go | 47 ++++++++++++++++++++++++++++++++ index_test.go | 15 ----------- object_test.go | 68 +++++++++++++++++++++++++++++++++++++++++++++++ reference_test.go | 24 ++--------------- repository.go | 24 ++++++++++++++--- 5 files changed, 137 insertions(+), 41 deletions(-) create mode 100644 git_test.go create mode 100644 object_test.go diff --git a/git_test.go b/git_test.go new file mode 100644 index 0000000..52aea1d --- /dev/null +++ b/git_test.go @@ -0,0 +1,47 @@ +package git + +import ( + "testing" + "io/ioutil" + "time" +) + +func createTestRepo(t *testing.T) *Repository { + // figure out where we can create the test repo + path, err := ioutil.TempDir("", "git2go") + checkFatal(t, err) + repo, err := InitRepository(path, false) + checkFatal(t, err) + + tmpfile := "README" + err = ioutil.WriteFile(path + "/" + tmpfile, []byte("foo\n"), 0644) + checkFatal(t, err) + + return repo +} + +func seedTestRepo(t *testing.T, repo *Repository) (*Oid, *Oid) { + loc, err := time.LoadLocation("Europe/Berlin") + checkFatal(t, err) + sig := &Signature{ + Name: "Rand Om Hacker", + Email: "random@hacker.com", + When: time.Date(2013, 03, 06, 14, 30, 0, 0, loc), + } + + idx, err := repo.Index() + checkFatal(t, err) + err = idx.AddByPath("README") + checkFatal(t, err) + treeId, err := idx.WriteTree() + checkFatal(t, err) + + message := "This is a commit\n" + tree, err := repo.LookupTree(treeId) + checkFatal(t, err) + commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree) + checkFatal(t, err) + + return commitId, treeId +} + diff --git a/index_test.go b/index_test.go index fe6fb87..9828d0f 100644 --- a/index_test.go +++ b/index_test.go @@ -4,23 +4,8 @@ import ( "os" "runtime" "testing" - "io/ioutil" ) -func createTestRepo(t *testing.T) *Repository { - // figure out where we can create the test repo - path, err := ioutil.TempDir("", "git2go") - checkFatal(t, err) - repo, err := InitRepository(path, false) - checkFatal(t, err) - - tmpfile := "README" - err = ioutil.WriteFile(path + "/" + tmpfile, []byte("foo\n"), 0644) - checkFatal(t, err) - - return repo -} - func TestCreateRepoAndStage(t *testing.T) { repo := createTestRepo(t) defer os.RemoveAll(repo.Workdir()) diff --git a/object_test.go b/object_test.go new file mode 100644 index 0000000..82dce98 --- /dev/null +++ b/object_test.go @@ -0,0 +1,68 @@ +package git + +import ( + "os" + "testing" +) + +func TestObjectPoymorphism(t *testing.T) { + repo := createTestRepo(t) + defer os.RemoveAll(repo.Workdir()) + commitId, treeId := seedTestRepo(t, repo) + + var obj Object + + commit, err := repo.LookupCommit(commitId) + checkFatal(t, err) + + obj = commit + if obj.Type() != OBJ_COMMIT { + t.Fatalf("Wrong object type, expected commit, have %v", obj.Type()) + } + + tree, err := repo.LookupTree(treeId) + checkFatal(t, err) + + obj = tree + if obj.Type() != OBJ_TREE { + t.Fatalf("Wrong object type, expected tree, have %v", obj.Type()) + } + + tree2, ok := obj.(*Tree) + if !ok { + t.Fatalf("Converting back to *Tree is not ok") + } + + if tree2.EntryByName("README") == nil { + t.Fatalf("Tree did not have expected \"README\" entry") + } + + _, ok = obj.(*Commit) + if ok { + t.Fatalf("*Tree is somehow the same as *Commit") + } + + obj, err = repo.Lookup(tree.Id()) + checkFatal(t, err) + + _, ok = obj.(*Tree) + if !ok { + t.Fatalf("Lookup creates the wrong type") + } + + if obj.Type() != OBJ_TREE { + t.Fatalf("Type() doesn't agree with dynamic type") + } + + obj, err = repo.RevparseSingle("HEAD") + checkFatal(t, err) + if obj.Type() != OBJ_COMMIT || obj.Id().String() != commit.Id().String() { + t.Fatalf("Failed to parse the right revision") + } + + obj, err = repo.RevparseSingle("HEAD^{tree}") + checkFatal(t, err) + if obj.Type() != OBJ_TREE || obj.Id().String() != tree.Id().String() { + t.Fatalf("Failed to parse the right revision") + } +} diff --git a/reference_test.go b/reference_test.go index 8043833..3ea421d 100644 --- a/reference_test.go +++ b/reference_test.go @@ -4,35 +4,15 @@ import ( "os" "runtime" "testing" - "time" ) func TestRefModification(t *testing.T) { repo := createTestRepo(t) defer os.RemoveAll(repo.Workdir()) - loc, err := time.LoadLocation("Europe/Berlin") - checkFatal(t, err) - sig := &Signature{ - Name: "Rand Om Hacker", - Email: "random@hacker.com", - When: time.Date(2013, 03, 06, 14, 30, 0, 0, loc), - } + commitId, treeId := seedTestRepo(t, repo) - idx, err := repo.Index() - checkFatal(t, err) - err = idx.AddByPath("README") - checkFatal(t, err) - treeId, err := idx.WriteTree() - checkFatal(t, err) - - message := "This is a commit\n" - tree, err := repo.LookupTree(treeId) - checkFatal(t, err) - commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree) - checkFatal(t, err) - - _, err = repo.CreateReference("refs/tags/tree", treeId, true) + _, err := repo.CreateReference("refs/tags/tree", treeId, true) checkFatal(t, err) tag, err := repo.LookupReference("refs/tags/tree") diff --git a/repository.go b/repository.go index 015e5bf..0a07dc3 100644 --- a/repository.go +++ b/repository.go @@ -72,7 +72,7 @@ func (v *Repository) Index() (*Index, error) { return newIndexFromC(ptr), nil } -func (v *Repository) Lookup(oid *Oid, t ObjectType) (Object, error) { +func (v *Repository) lookupType(oid *Oid, t ObjectType) (Object, error) { var ptr *C.git_object ret := C.git_object_lookup(&ptr, v.ptr, oid.toC(), C.git_otype(t)) if ret < 0 { @@ -82,8 +82,12 @@ func (v *Repository) Lookup(oid *Oid, t ObjectType) (Object, error) { return allocObject(ptr), nil } +func (v *Repository) Lookup(oid *Oid) (Object, error) { + return v.lookupType(oid, OBJ_ANY) +} + func (v *Repository) LookupTree(oid *Oid) (*Tree, error) { - obj, err := v.Lookup(oid, OBJ_TREE) + obj, err := v.lookupType(oid, OBJ_TREE) if err != nil { return nil, err } @@ -92,7 +96,7 @@ func (v *Repository) LookupTree(oid *Oid) (*Tree, error) { } func (v *Repository) LookupCommit(oid *Oid) (*Commit, error) { - obj, err := v.Lookup(oid, OBJ_COMMIT) + obj, err := v.lookupType(oid, OBJ_COMMIT) if err != nil { return nil, err } @@ -101,7 +105,7 @@ func (v *Repository) LookupCommit(oid *Oid) (*Commit, error) { } func (v *Repository) LookupBlob(oid *Oid) (*Blob, error) { - obj, err := v.Lookup(oid, OBJ_BLOB) + obj, err := v.lookupType(oid, OBJ_BLOB) if err != nil { return nil, err } @@ -247,3 +251,15 @@ func (v *Repository) TreeBuilder() (*TreeBuilder, error) { return bld, nil } +func (v *Repository) RevparseSingle(spec string) (Object, error) { + cspec := C.CString(spec) + defer C.free(unsafe.Pointer(cspec)) + + var ptr *C.git_object + ecode := C.git_revparse_single(&ptr, v.ptr, cspec) + if ecode < 0 { + return nil, LastError() + } + + return allocObject(ptr), nil +} -- 2.45.2 From 2bf17ba2f18ad3ae3068568e5754046544b159b7 Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Thu, 18 Apr 2013 00:54:46 +0200 Subject: [PATCH 3/6] Ok, now with shared base object --- blob.go | 20 +++----------------- commit.go | 26 ++++++-------------------- object.go | 38 +++++++++++++++++++++++++++----------- tree.go | 23 +++++------------------ 4 files changed, 41 insertions(+), 66 deletions(-) diff --git a/blob.go b/blob.go index ee50a15..cc26c92 100644 --- a/blob.go +++ b/blob.go @@ -8,31 +8,17 @@ package git import "C" import ( "unsafe" - "runtime" ) type Blob struct { - ptr *C.git_blob + gitObject } -func (o *Blob) Id() *Oid { - return newOidFromC(C.git_blob_id(o.ptr)) -} - -func (o *Blob) Type() ObjectType { - return OBJ_BLOB -} - -func (o *Blob) Free() { - runtime.SetFinalizer(o, nil) - C.git_blob_free(o.ptr) -} - -func (v *Blob) Size() int64 { +func (v Blob) Size() int64 { return int64(C.git_blob_rawsize(v.ptr)) } -func (v *Blob) Contents() []byte { +func (v Blob) Contents() []byte { size := C.int(C.git_blob_rawsize(v.ptr)) buffer := unsafe.Pointer(C.git_blob_rawcontent(v.ptr)) return C.GoBytes(buffer, size) diff --git a/commit.go b/commit.go index b1ca6c4..9730a70 100644 --- a/commit.go +++ b/commit.go @@ -9,34 +9,20 @@ extern int _go_git_treewalk(git_tree *tree, git_treewalk_mode mode, void *ptr); import "C" import ( - "runtime" "unsafe" "time" ) // Commit type Commit struct { - ptr *C.git_commit + gitObject } -func (o *Commit) Id() *Oid { - return newOidFromC(C.git_commit_id(o.ptr)) -} - -func (o *Commit) Type() ObjectType { - return OBJ_COMMIT -} - -func (o *Commit) Free() { - runtime.SetFinalizer(o, nil) - C.git_commit_free(o.ptr) -} - -func (c *Commit) Message() string { +func (c Commit) Message() string { return C.GoString(C.git_commit_message(c.ptr)) } -func (c *Commit) Tree() (*Tree, error) { +func (c Commit) Tree() (*Tree, error) { var ptr *C.git_object err := C.git_commit_tree(&ptr, c.ptr) @@ -47,16 +33,16 @@ func (c *Commit) Tree() (*Tree, error) { return allocObject(ptr).(*Tree), nil } -func (c *Commit) TreeId() *Oid { +func (c Commit) TreeId() *Oid { return newOidFromC(C.git_commit_tree_id(c.ptr)) } -func (c *Commit) Author() *Signature { +func (c Commit) Author() *Signature { ptr := C.git_commit_author(c.ptr) return newSignatureFromC(ptr) } -func (c *Commit) Committer() *Signature { +func (c Commit) Committer() *Signature { ptr := C.git_commit_committer(c.ptr) return newSignatureFromC(ptr) } diff --git a/object.go b/object.go index 0d55409..a346234 100644 --- a/object.go +++ b/object.go @@ -25,25 +25,41 @@ type Object interface { Type() ObjectType } +type gitObject struct { + ptr *C.git_object +} + +func (o gitObject) Id() *Oid { + return newOidFromC(C.git_commit_id(o.ptr)) +} + +func (o gitObject) Type() ObjectType { + return ObjectType(C.git_object_type(o.ptr)) +} + +func (o gitObject) Free() { + runtime.SetFinalizer(o, nil) + C.git_commit_free(o.ptr) +} + func allocObject(cobj *C.git_object) Object { - var object Object switch ObjectType(C.git_object_type(cobj)) { case OBJ_COMMIT: - object = &Commit{cobj} - runtime.SetFinalizer(object, (*Commit).Free) + commit := &Commit{gitObject{cobj}} + runtime.SetFinalizer(commit, (*Commit).Free) + return commit case OBJ_TREE: - object = &Tree{cobj} - runtime.SetFinalizer(object, (*Tree).Free) + tree := &Tree{gitObject{cobj}} + runtime.SetFinalizer(tree, (*Tree).Free) + return tree case OBJ_BLOB: - object = &Blob{cobj} - runtime.SetFinalizer(object, (*Blob).Free) - - default: - return nil + blob := &Blob{gitObject{cobj}} + runtime.SetFinalizer(blob, (*Blob).Free) + return blob } - return object + return nil } diff --git a/tree.go b/tree.go index d8a639c..3bc8999 100644 --- a/tree.go +++ b/tree.go @@ -14,20 +14,7 @@ import ( ) type Tree struct { - ptr *C.git_tree -} - -func (o *Tree) Id() *Oid { - return newOidFromC(C.git_tree_id(o.ptr)) -} - -func (o *Tree) Type() ObjectType { - return OBJ_TREE -} - -func (o *Tree) Free() { - runtime.SetFinalizer(o, nil) - C.git_tree_free(o.ptr) + gitObject } type TreeEntry struct { @@ -44,7 +31,7 @@ func newTreeEntry(entry *C.git_tree_entry) *TreeEntry { } } -func (t *Tree) EntryByName(filename string) *TreeEntry { +func (t Tree) EntryByName(filename string) *TreeEntry { cname := C.CString(filename) defer C.free(unsafe.Pointer(cname)) @@ -56,7 +43,7 @@ func (t *Tree) EntryByName(filename string) *TreeEntry { return newTreeEntry(entry) } -func (t *Tree) EntryByIndex(index uint64) *TreeEntry { +func (t Tree) EntryByIndex(index uint64) *TreeEntry { entry := C.git_tree_entry_byindex(t.ptr, C.size_t(index)) if entry == nil { return nil @@ -65,7 +52,7 @@ func (t *Tree) EntryByIndex(index uint64) *TreeEntry { return newTreeEntry(entry) } -func (t *Tree) EntryCount() uint64 { +func (t Tree) EntryCount() uint64 { num := C.git_tree_entrycount(t.ptr) return uint64(num) } @@ -81,7 +68,7 @@ func CallbackGitTreeWalk(_root unsafe.Pointer, _entry unsafe.Pointer, ptr unsafe return C.int(callback(root, newTreeEntry(entry))) } -func (t *Tree) Walk(callback TreeWalkCallback) error { +func (t Tree) Walk(callback TreeWalkCallback) error { err := C._go_git_treewalk( t.ptr, C.GIT_TREEWALK_PRE, -- 2.45.2 From ac6ea9aa754dde141c778f862263de26add8afe1 Mon Sep 17 00:00:00 2001 From: Axel Wagner Date: Fri, 26 Apr 2013 02:06:47 +0200 Subject: [PATCH 4/6] Add String() Method to ObjectType --- object.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/object.go b/object.go index a346234..a98c681 100644 --- a/object.go +++ b/object.go @@ -29,6 +29,25 @@ type gitObject struct { ptr *C.git_object } +func (t ObjectType) String() (string) { + switch (t) { + case OBJ_ANY: + return "Any" + case OBJ_BAD: + return "Bad" + case OBJ_COMMIT: + return "Commit" + case OBJ_TREE: + return "Tree" + case OBJ_BLOB: + return "Blob" + case OBJ_TAG: + return "tag" + } + // Never reached + return "" +} + func (o gitObject) Id() *Oid { return newOidFromC(C.git_commit_id(o.ptr)) } -- 2.45.2 From 289d84e1f7e7618dce387c53034deee55fab0a44 Mon Sep 17 00:00:00 2001 From: Axel Wagner Date: Fri, 26 Apr 2013 02:32:41 +0200 Subject: [PATCH 5/6] Give gitObject.Free a pointer-receiver This is needed to get runtime.SetFinalizer to work, which expects a pointer-receiver. Without it the runtime will crash, when it tries to garbage-collect an object. --- object.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/object.go b/object.go index a346234..ec1e468 100644 --- a/object.go +++ b/object.go @@ -37,7 +37,7 @@ func (o gitObject) Type() ObjectType { return ObjectType(C.git_object_type(o.ptr)) } -func (o gitObject) Free() { +func (o *gitObject) Free() { runtime.SetFinalizer(o, nil) C.git_commit_free(o.ptr) } -- 2.45.2 From 28b5284389ebbc47c974e2412c1d1464e18bf983 Mon Sep 17 00:00:00 2001 From: Axel Wagner Date: Fri, 26 Apr 2013 23:28:32 +0200 Subject: [PATCH 6/6] Use ObjectType in TreeEntry --- tree.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tree.go b/tree.go index 3bc8999..9a9fd63 100644 --- a/tree.go +++ b/tree.go @@ -20,14 +20,14 @@ type Tree struct { type TreeEntry struct { Name string Id *Oid - Type int + Type ObjectType } func newTreeEntry(entry *C.git_tree_entry) *TreeEntry { return &TreeEntry{ C.GoString(C.git_tree_entry_name(entry)), newOidFromC(C.git_tree_entry_id(entry)), - int(C.git_tree_entry_type(entry)), + ObjectType(C.git_tree_entry_type(entry)), } } -- 2.45.2