blob.go

@@ -22,4 +22,3 @@ func (v Blob) Contents() []byte {
 	buffer := unsafe.Pointer(C.git_blob_rawcontent(v.ptr))
 	return C.GoBytes(buffer, size)
 }
-

checkout.go

@@ -9,8 +9,8 @@ git_checkout_opts git_checkout_opts_init() {
 */
 import "C"
 import (
-	"runtime"
 	"os"
+	"runtime"
 )
 
 type CheckoutStrategy uint

git.go

@@ -10,8 +10,8 @@ import (
 	"bytes"
 	"errors"
 	"runtime"
-	"unsafe"
 	"strings"
+	"unsafe"
 )
 
 const (
@@ -93,7 +93,7 @@ func (oid *Oid) Equal(oid2 *Oid) bool {
 }
 
 func (oid *Oid) IsZero() bool {
-	for _, a := range(oid.bytes) {
+	for _, a := range oid.bytes {
 		if a != '0' {
 			return false
 		}
@@ -147,14 +147,14 @@ func LastError() error {
 }
 
 func cbool(b bool) C.int {
-	if (b) {
+	if b {
 		return C.int(1)
 	}
 	return C.int(0)
 }
 
 func ucbool(b bool) C.uint {
-	if (b) {
+	if b {
 		return C.uint(1)
 	}
 	return C.uint(0)
@@ -167,16 +167,16 @@ func Discover(start string, across_fs bool, ceiling_dirs []string) (string, erro
 	cstart := C.CString(start)
 	defer C.free(unsafe.Pointer(cstart))
 
-	retpath := (*C.char)(C.malloc(C.GIT_PATH_MAX))
+	retpath := (*C.git_buf)(C.malloc(C.GIT_PATH_MAX))
 	defer C.free(unsafe.Pointer(retpath))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	r := C.git_repository_discover(retpath, C.GIT_PATH_MAX, cstart, cbool(across_fs), ceildirs)
+	r := C.git_repository_discover(retpath, cstart, cbool(across_fs), ceildirs)
 
 	if r == 0 {
-		return C.GoString(retpath), nil
+		return C.GoString(retpath.ptr), nil
 	}
 
 	return "", LastError()

git_test.go

@@ -1,8 +1,8 @@
 package git
 
 import (
-	"testing"
 	"io/ioutil"
+	"testing"
 	"time"
 )
 
@@ -44,4 +44,3 @@ func seedTestRepo(t *testing.T, repo *Repository) (*Oid, *Oid) {
 
 	return commitId, treeId
 }
-

object.go

@@ -28,8 +28,8 @@ type gitObject struct {
 	ptr *C.git_object
 }
 
-func (t ObjectType) String() (string) {
+func (t ObjectType) String() string {
-	switch (t) {
+	switch t {
 	case ObjectAny:
 		return "Any"
 	case ObjectBad:

odb.go

@@ -8,9 +8,9 @@ extern int _go_git_odb_foreach(git_odb *db, void *payload);
 */
 import "C"
 import (
-	"unsafe"
 	"reflect"
 	"runtime"
+	"unsafe"
 )
 
 type Odb struct {
@@ -65,7 +65,7 @@ func odbForEachCb(id *C.git_oid, payload unsafe.Pointer) int {
 	case <-ch:
 		return -1
 	}
-	return 0;
+	return 0
 }
 
 func (v *Odb) forEachWrap(ch chan *Oid) {

reference.go

@@ -11,6 +11,7 @@ import (
 )
 
 type ReferenceType int
+
 const (
 	ReferenceSymbolic ReferenceType = C.GIT_REF_SYMBOLIC
 	ReferenceOid                    = C.GIT_REF_OID
@@ -27,15 +28,18 @@ func newReferenceFromC(ptr *C.git_reference) *Reference {
 	return ref
 }
 
-func (v *Reference) SetSymbolicTarget(target string) (*Reference, error) {
+func (v *Reference) SetSymbolicTarget(target, logMsg string) (*Reference, error) {
 	var ptr *C.git_reference
 	ctarget := C.CString(target)
 	defer C.free(unsafe.Pointer(ctarget))
 
+	cLogMsg := C.CString(logMsg)
+	defer C.free(unsafe.Pointer(cLogMsg))
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget)
+	ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, nil, cLogMsg)
 	if ret < 0 {
 		return nil, LastError()
 	}
@@ -43,13 +47,16 @@ func (v *Reference) SetSymbolicTarget(target string) (*Reference, error) {
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Reference) SetTarget(target *Oid) (*Reference, error) {
+func (v *Reference) SetTarget(target *Oid, logMsg string) (*Reference, error) {
 	var ptr *C.git_reference
 
+	cLogMsg := C.CString(logMsg)
+	defer C.free(unsafe.Pointer(cLogMsg))
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_reference_set_target(&ptr, v.ptr, target.toC())
+	ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), nil, cLogMsg)
 	if ret < 0 {
 		return nil, LastError()
 	}
@@ -71,15 +78,18 @@ func (v *Reference) Resolve() (*Reference, error) {
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Reference) Rename(name string, force bool) (*Reference, error) {
+func (v *Reference) Rename(name string, force bool, logMsg string) (*Reference, error) {
 	var ptr *C.git_reference
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
+	cLogMsg := C.CString(logMsg)
+	defer C.free(unsafe.Pointer(cLogMsg))
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force))
+	ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force), nil, cLogMsg)
 
 	if ret < 0 {
 		return nil, LastError()

reference_test.go

@@ -14,7 +14,7 @@ func TestRefModification(t *testing.T) {
 
 	commitId, treeId := seedTestRepo(t, repo)
 
-	_, 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")
@@ -45,7 +45,7 @@ func TestRefModification(t *testing.T) {
 		t.Fatalf("Wrong ref target")
 	}
 
-	_, err = tag.Rename("refs/tags/renamed", false)
+	_, err = tag.Rename("refs/tags/renamed", false, "")
 	checkFatal(t, err)
 	tag, err = repo.LookupReference("refs/tags/renamed")
 	checkFatal(t, err)
@@ -78,13 +78,13 @@ func TestIterator(t *testing.T) {
 	commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree)
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/one", commitId, true)
+	_, err = repo.CreateReference("refs/heads/one", commitId, true, "")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/two", commitId, true)
+	_, err = repo.CreateReference("refs/heads/two", commitId, true, "")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/three", commitId, true)
+	_, err = repo.CreateReference("refs/heads/three", commitId, true, "")
 	checkFatal(t, err)
 
 	iter, err := repo.NewReferenceIterator()
@@ -108,7 +108,6 @@ func TestIterator(t *testing.T) {
 		t.Fatal("Iteration not over")
 	}
 
-
 	sort.Strings(list)
 	compareStringList(t, expected, list)
 
@@ -129,7 +128,6 @@ func TestIterator(t *testing.T) {
 		t.Fatalf("Wrong number of references returned %v", count)
 	}
 
-
 	// test the channel iteration
 	list = []string{}
 	iter, err = repo.NewReferenceIterator()

repository.go

@@ -146,15 +146,18 @@ func (v *Repository) LookupReference(name string) (*Reference, error) {
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Repository) CreateReference(name string, oid *Oid, force bool) (*Reference, error) {
+func (v *Repository) CreateReference(name string, oid *Oid, force bool, logMsg string) (*Reference, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 	var ptr *C.git_reference
 
+	cLogMsg := C.CString(logMsg)
+	defer C.free(unsafe.Pointer(cLogMsg))
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_reference_create(&ptr, v.ptr, cname, oid.toC(), cbool(force))
+	ecode := C.git_reference_create(&ptr, v.ptr, cname, oid.toC(), cbool(force), nil, cLogMsg)
 	if ecode < 0 {
 		return nil, LastError()
 	}
@@ -162,17 +165,19 @@ func (v *Repository) CreateReference(name string, oid *Oid, force bool) (*Refere
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Repository) CreateSymbolicReference(name, target string, force bool) (*Reference, error) {
+func (v *Repository) CreateSymbolicReference(name, target string, force bool, logMsg string) (*Reference, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 	ctarget := C.CString(target)
 	defer C.free(unsafe.Pointer(ctarget))
+	cLogMsg := C.CString(logMsg)
+	defer C.free(unsafe.Pointer(cLogMsg))
 	var ptr *C.git_reference
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force))
+	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), nil, cLogMsg)
 	if ecode < 0 {
 		return nil, LastError()
 	}
@@ -232,7 +237,7 @@ func (v *Repository) CreateCommit(
 	ret := C.git_commit_create(
 		oid.toC(), v.ptr, cref,
 		authorSig, committerSig,
-		nil, cmsg, tree.ptr, C.int(nparents), parentsarg)
+		nil, cmsg, tree.ptr, C.size_t(nparents), parentsarg)
 
 	if ret < 0 {
 		return nil, LastError()

submodule.go

@@ -240,7 +240,12 @@ func (sub *Submodule) SetFetchRecurseSubmodules(v bool) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_submodule_set_fetch_recurse_submodules(sub.ptr, cbool(v))
+	recurse := 0
+	if v {
+		recurse = 1
+	}
+
+	ret := C.git_submodule_set_fetch_recurse_submodules(sub.ptr, C.git_submodule_recurse_t(recurse))
 	if ret < 0 {
 		return LastError()
 	}

tree.go

@@ -14,6 +14,7 @@ import (
 )
 
 type Filemode int
+
 const (
 	FilemodeNew            Filemode = C.GIT_FILEMODE_NEW
 	FilemodeTree                    = C.GIT_FILEMODE_TREE
@@ -125,7 +126,7 @@ func (v *TreeBuilder) Free() {
 	C.git_treebuilder_free(v.ptr)
 }
 
-func (v *TreeBuilder) Insert(filename string, id *Oid, filemode int) (error) {
+func (v *TreeBuilder) Insert(filename string, id *Oid, filemode int) error {
 	cfilename := C.CString(filename)
 	defer C.free(unsafe.Pointer(cfilename))
 

walk.go

@@ -14,6 +14,7 @@ import (
 // RevWalk
 
 type SortType uint
+
 const (
 	SortNone        SortType = C.GIT_SORT_NONE
 	SortTopological          = C.GIT_SORT_TOPOLOGICAL