add branch iterator / remove useless repo from reference iterator

3 files changed, 86 insertions, 4 deletions

diff --git a/branch.go b/branch.go
index aee23e4..a11f948 100644
--- a/branch.go
+++ b/branch.go
@@ -23,6 +23,61 @@ type Branch struct {
 	Reference
 }
 
+type BranchIterator struct {
+	ptr *C.git_branch_iterator
+}
+
+func newBranchIteratorFromC(ptr *C.git_branch_iterator) *BranchIterator {
+	i := &BranchIterator{ptr: ptr}
+	runtime.SetFinalizer(i, (*BranchIterator).Free)
+	return i
+}
+
+func (i *BranchIterator) Next() (*Reference, error) {
+	ref, _, err := i.NextWithType()
+	return ref, err
+}
+
+func (i *BranchIterator) NextWithType() (*Reference, BranchType, error) {
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var refPtr *C.git_reference
+	var refType C.git_branch_t
+
+	ecode := C.git_branch_next(&refPtr, &refType, i.ptr)
+
+	if ecode == C.GIT_ITEROVER {
+		return nil, BranchLocal, ErrIterOver
+	} else if ecode < 0 {
+		return nil, BranchLocal, MakeGitError(ecode)
+	}
+
+	return newReferenceFromC(refPtr), BranchType(refType), nil
+}
+
+func (i *BranchIterator) Free() {
+	runtime.SetFinalizer(i, nil)
+	C.git_branch_iterator_free(i.ptr)
+}
+
+func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, error) {
+
+	refType := C.git_branch_t(flags)
+	var ptr *C.git_branch_iterator
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ecode := C.git_branch_iterator_new(&ptr, repo.ptr, refType)
+	if ecode < 0 {
+		return nil, MakeGitError(ecode)
+	}
+
+	return newBranchIteratorFromC(ptr), nil
+}
+
 func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Reference, error) {
 
 	ref := new(Reference)
diff --git a/branch_test.go b/branch_test.go
new file mode 100644
index 0000000..e95c877
--- /dev/null
+++ b/branch_test.go
@@ -0,0 +1,28 @@
+package git
+
+import (
+	"testing"
+)
+
+func Test_List_Branches(t *testing.T) {
+
+	repo := createTestRepo(t)
+	seedTestRepo(t, repo)
+
+	i, err := repo.NewBranchIterator(BranchLocal)
+	checkFatal(t, err)
+
+	ref, err := i.Next()
+	checkFatal(t, err)
+	if ref.Name() != "refs/heads/master" {
+		t.Fatalf("expected refs/heads/master, not %v", ref.Name())
+	}
+	ref, err = i.Next()
+	if ref != nil {
+		t.Fatal("expected nil")
+	}
+
+	if err != ErrIterOver {
+		t.Fatal("expected iterover")
+	}
+}
diff --git a/reference.go b/reference.go
index d246c55..5722db2 100644
--- a/reference.go
+++ b/reference.go
@@ -186,8 +186,7 @@ func (v *Reference) Free() {
 }
 
 type ReferenceIterator struct {
-	ptr  *C.git_reference_iterator
-	repo *Repository
+	ptr *C.git_reference_iterator
 }
 
 // NewReferenceIterator creates a new iterator over reference names
@@ -202,7 +201,7 @@ func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
 		return nil, MakeGitError(ret)
 	}
 
-	iter := &ReferenceIterator{repo: repo, ptr: ptr}
+	iter := &ReferenceIterator{ptr: ptr}
 	runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
 	return iter, nil
 }
@@ -223,7 +222,7 @@ func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterato
 		return nil, MakeGitError(ret)
 	}
 
-	iter := &ReferenceIterator{repo: repo, ptr: ptr}
+	iter := &ReferenceIterator{ptr: ptr}
 	runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
 	return iter, nil
 }