Merge remote-tracking branch 'anulman/catchupTo66af84' into working-with-libgit2-at-2dc49ea

Conflicts:
	git.go
	reference.go
	reference_test.go
	repository.go
	submodule.go

git.go

@@ -168,7 +168,7 @@ func Discover(start string, across_fs bool, ceiling_dirs []string) (string, erro
 	defer C.free(unsafe.Pointer(cstart))
 
 	retpath := (*C.git_buf)(C.malloc(C.GIT_PATH_MAX))
-	defer C.free(unsafe.Pointer(retpath))
+	defer C.git_buf_free(retpath)
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()

reference.go

@@ -28,18 +28,22 @@ func newReferenceFromC(ptr *C.git_reference) *Reference {
 	return ref
 }
 
-func (v *Reference) SetSymbolicTarget(target, logMsg string) (*Reference, error) {
+func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string) (*Reference, error) {
 	var ptr *C.git_reference
+
 	ctarget := C.CString(target)
 	defer C.free(unsafe.Pointer(ctarget))
 
-	cLogMsg := C.CString(logMsg)
+	csig := sig.toC()
-	defer C.free(unsafe.Pointer(cLogMsg))
+	defer C.free(unsafe.Pointer(csig))
+
+	cmsg := C.CString(msg)
+	defer C.free(unsafe.Pointer(cmsg))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, nil, cLogMsg)
+	ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, csig, cmsg)
 	if ret < 0 {
 		return nil, LastError()
 	}
@@ -47,16 +51,16 @@ func (v *Reference) SetSymbolicTarget(target, logMsg string) (*Reference, error)
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Reference) SetTarget(target *Oid, logMsg string) (*Reference, error) {
+func (v *Reference) SetTarget(target *Oid, sig *Signature, msg string) (*Reference, error) {
 	var ptr *C.git_reference
 
-	cLogMsg := C.CString(logMsg)
+	csig := sig.toC()
-	defer C.free(unsafe.Pointer(cLogMsg))
+	defer C.free(unsafe.Pointer(csig))
 
-	runtime.LockOSThread()
+	cmsg := C.CString(msg)
-	defer runtime.UnlockOSThread()
+	defer C.free(unsafe.Pointer(cmsg))
 
-	ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), nil, cLogMsg)
+	ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), csig, cmsg)
 	if ret < 0 {
 		return nil, LastError()
 	}

reference_test.go

@@ -14,7 +14,14 @@ func TestRefModification(t *testing.T) {
 
 	commitId, treeId := seedTestRepo(t, repo)
 
-	_, err := repo.CreateReference("refs/tags/tree", treeId, true, "")
+	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),
+	}
+	_, err = repo.CreateReference("refs/tags/tree", treeId, true, sig, "testTreeTag")
 	checkFatal(t, err)
 
 	tag, err := repo.LookupReference("refs/tags/tree")
@@ -78,13 +85,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, sig, "headOne")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/two", commitId, true, "")
+	_, err = repo.CreateReference("refs/heads/two", commitId, true, sig, "headTwo")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/three", commitId, true, "")
+	_, err = repo.CreateReference("refs/heads/three", commitId, true, sig, "headThree")
 	checkFatal(t, err)
 
 	iter, err := repo.NewReferenceIterator()

repository.go

@@ -146,18 +146,22 @@ func (v *Repository) LookupReference(name string) (*Reference, error) {
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Repository) CreateReference(name string, oid *Oid, force bool, logMsg string) (*Reference, error) {
+func (v *Repository) CreateReference(name string, oid *Oid, force bool, sig *Signature, msg string) (*Reference, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
-	var ptr *C.git_reference
 
-	cLogMsg := C.CString(logMsg)
+	csig := sig.toC()
-	defer C.free(unsafe.Pointer(cLogMsg))
+	defer C.free(unsafe.Pointer(csig))
+
+	cmsg := C.CString(msg)
+	defer C.free(unsafe.Pointer(cmsg))
+
+	var ptr *C.git_reference
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_reference_create(&ptr, v.ptr, cname, oid.toC(), cbool(force), nil, cLogMsg)
+	ecode := C.git_reference_create(&ptr, v.ptr, cname, oid.toC(), cbool(force), csig, cmsg)
 	if ecode < 0 {
 		return nil, LastError()
 	}
@@ -165,19 +169,25 @@ func (v *Repository) CreateReference(name string, oid *Oid, force bool, logMsg s
 	return newReferenceFromC(ptr), nil
 }
 
-func (v *Repository) CreateSymbolicReference(name, target string, force bool, logMsg string) (*Reference, error) {
+func (v *Repository) CreateSymbolicReference(name, target string, force bool, sig *Signature, msg 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))
+	csig := sig.toC()
-	var ptr *C.git_reference
+	defer C.free(unsafe.Pointer(csig))
+
+	cmsg := C.CString(msg)
+	defer C.free(unsafe.Pointer(cmsg))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), nil, cLogMsg)
+	var ptr *C.git_reference
+
+	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), csig, cmsg)
 	if ecode < 0 {
 		return nil, LastError()
 	}

submodule.go

@@ -56,6 +56,14 @@ const (
 	SubmoduleStatusWdUntracked                     = C.GIT_SUBMODULE_STATUS_WD_UNTRACKED
 )
 
+type SubmoduleRecurse int
+
+const (
+	SubmoduleRecurseNo       SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_NO
+	SubmoduleRecurseYes                       = C.GIT_SUBMODULE_RECURSE_YES
+	SubmoduleRecurseOndemand                  = C.GIT_SUBMODULE_RECURSE_ONDEMAND
+)
+
 func SubmoduleStatusIsUnmodified(status int) bool {
 	o := SubmoduleStatus(status) & ^(SubmoduleStatusInHead | SubmoduleStatusInIndex |
 		SubmoduleStatusInConfig | SubmoduleStatusInWd)
@@ -236,15 +244,7 @@ func (sub *Submodule) FetchRecurseSubmodules() bool {
 	return true
 }
 
-func (sub *Submodule) SetFetchRecurseSubmodules(v bool) error {
+func (sub *Submodule) SetFetchRecurseSubmodules(recurse SubmoduleRecurse) error {
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	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()