Update to libgit2 d675982a153

There's been some changes to the checkout strategy, especially the
SAFE_CREATE mode, which is now the RECREATE_MISSING flag, though that
shouldn't be necessary to use in the general case.

The largest changes come from the removal of the signture from
ref-modifying functions/methods and the removal of the reflog string in
all but those directly related to moving references.

12 files changed, 48 insertions, 172 deletions

diff --git a/branch.go b/branch.go
index 22b767e..0daa99d 100644
--- a/branch.go
+++ b/branch.go
@@ -90,30 +90,16 @@ func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, er
 	return newBranchIteratorFromC(repo, ptr), nil
 }
 
-func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Branch, error) {
+func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool) (*Branch, error) {
 
 	ref := new(Reference)
 	cBranchName := C.CString(branchName)
 	cForce := cbool(force)
 
-	cSignature, err := signature.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.git_signature_free(cSignature)
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.cast_ptr, cForce, cSignature, cmsg)
+	ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.cast_ptr, cForce)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -131,29 +117,15 @@ func (b *Branch) Delete() error {
 	return nil
 }
 
-func (b *Branch) Move(newBranchName string, force bool, signature *Signature, msg string) (*Branch, error) {
+func (b *Branch) Move(newBranchName string, force bool) (*Branch, error) {
 	var ptr *C.git_reference
 	cNewBranchName := C.CString(newBranchName)
 	cForce := cbool(force)
 
-	cSignature, err := signature.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.git_signature_free(cSignature)
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce, cSignature, cmsg)
+	ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
diff --git a/checkout.go b/checkout.go
index 6eb6098..98c1ee6 100644
--- a/checkout.go
+++ b/checkout.go
@@ -15,18 +15,23 @@ type CheckoutStrategy uint
 const (
 	CheckoutNone                      CheckoutStrategy = C.GIT_CHECKOUT_NONE                         // Dry run, no actual updates
 	CheckoutSafe                      CheckoutStrategy = C.GIT_CHECKOUT_SAFE                         // Allow safe updates that cannot overwrite uncommitted data
-	CheckoutSafeCreate                CheckoutStrategy = C.GIT_CHECKOUT_SAFE_CREATE                  // Allow safe updates plus creation of missing files
-	CheckoutForce                     CheckoutStrategy = C.GIT_CHECKOUT_FORCE                        // Allow all updates to force working directory to look like index
+	CheckoutRecreateMissing           CheckoutStrategy = C.GIT_CHECKOUT_RECREATE_MISSING             // Allow checkout to recreate missing files
 	CheckoutAllowConflicts            CheckoutStrategy = C.GIT_CHECKOUT_ALLOW_CONFLICTS              // Allow checkout to make safe updates even if conflicts are found
 	CheckoutRemoveUntracked           CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_UNTRACKED             // Remove untracked files not in index (that are not ignored)
 	CheckoutRemoveIgnored             CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_IGNORED               // Remove ignored files not in index
 	CheckoutUpdateOnly                CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_ONLY                  // Only update existing files, don't create new ones
 	CheckoutDontUpdateIndex           CheckoutStrategy = C.GIT_CHECKOUT_DONT_UPDATE_INDEX            // Normally checkout updates index entries as it goes; this stops that
 	CheckoutNoRefresh                 CheckoutStrategy = C.GIT_CHECKOUT_NO_REFRESH                   // Don't refresh index/config/etc before doing checkout
+	CheckoutSkipUnmerged              CheckoutStrategy = C.GIT_CHECKOUT_SKIP_UNMERGED                // Allow checkout to skip unmerged files
+	CheckoutUserOurs                  CheckoutStrategy = C.GIT_CHECKOUT_USE_OURS                     // For unmerged files, checkout stage 2 from index
+	CheckoutUseTheirs                 CheckoutStrategy = C.GIT_CHECKOUT_USE_THEIRS                   // For unmerged files, checkout stage 3 from index
 	CheckoutDisablePathspecMatch      CheckoutStrategy = C.GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH       // Treat pathspec as simple list of exact match file paths
-	CheckoutSkipUnmerged              CheckoutStrategy = C.GIT_CHECKOUT_SKIP_UNMERGED                // Allow checkout to skip unmerged files (NOT IMPLEMENTED)
-	CheckoutUserOurs                  CheckoutStrategy = C.GIT_CHECKOUT_USE_OURS                     // For unmerged files, checkout stage 2 from index (NOT IMPLEMENTED)
-	CheckoutUseTheirs                 CheckoutStrategy = C.GIT_CHECKOUT_USE_THEIRS                   // For unmerged files, checkout stage 3 from index (NOT IMPLEMENTED)
+	CheckoutSkipLockedDirectories     CheckoutStrategy = C.GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES      // Ignore directories in use, they will be left empty
+	CheckoutDontOverwriteIgnored      CheckoutStrategy = C.GIT_CHECKOUT_DONT_OVERWRITE_IGNORED       // Don't overwrite ignored files that exist in the checkout target
+	CheckoutConflictStyleMerge        CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_MERGE         // Write normal merge files for conflicts
+	CheckoutConflictStyleDiff3        CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_DIFF3         // Include common ancestor data in diff3 format files for conflicts
+	CheckoutDontRemoveExisting        CheckoutStrategy = C.GIT_CHECKOUT_DONT_REMOVE_EXISTING         // Don't overwrite existing files or folders
+	CheckoutDontWriteIndex            CheckoutStrategy = C.GIT_CHECKOUT_DONT_WRITE_INDEX             // Normally checkout writes the index upon completion; this prevents that
 	CheckoutUpdateSubmodules          CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES            // Recursively checkout submodules with same options (NOT IMPLEMENTED)
 	CheckoutUpdateSubmodulesIfChanged CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED // Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED)
 )
diff --git a/cherrypick_test.go b/cherrypick_test.go
index f06dbdd..141a55d 100644
--- a/cherrypick_test.go
+++ b/cherrypick_test.go
@@ -16,7 +16,7 @@ func checkout(t *testing.T, repo *Repository, commit *Commit) {
 		t.Fatal(err)
 	}
 
-	err = repo.SetHeadDetached(commit.Id(), commit.Author(), "checkout")
+	err = repo.SetHeadDetached(commit.Id())
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/push_test.go b/push_test.go
index cd708c6..ad72e4d 100644
--- a/push_test.go
+++ b/push_test.go
@@ -16,7 +16,7 @@ func TestRemotePush(t *testing.T) {
 
 	seedTestRepo(t, localRepo)
 
-	err = remote.Push([]string{"refs/heads/master"}, nil, nil, "")
+	err = remote.Push([]string{"refs/heads/master"}, nil)
 	checkFatal(t, err)
 
 	_, err = localRepo.LookupReference("refs/remotes/test_push/master")
diff --git a/reference.go b/reference.go
index ef12d0b..61e2b26 100644
--- a/reference.go
+++ b/reference.go
@@ -27,7 +27,7 @@ func newReferenceFromC(ptr *C.git_reference, repo *Repository) *Reference {
 	return ref
 }
 
-func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string) (*Reference, error) {
+func (v *Reference) SetSymbolicTarget(target string, msg string) (*Reference, error) {
 	var ptr *C.git_reference
 
 	ctarget := C.CString(target)
@@ -36,12 +36,6 @@ func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string)
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	csig, err := sig.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
 	var cmsg *C.char
 	if msg == "" {
 		cmsg = nil
@@ -50,7 +44,7 @@ func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string)
 		defer C.free(unsafe.Pointer(cmsg))
 	}
 
-	ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, csig, cmsg)
+	ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, cmsg)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -58,18 +52,12 @@ func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string)
 	return newReferenceFromC(ptr, v.repo), nil
 }
 
-func (v *Reference) SetTarget(target *Oid, sig *Signature, msg string) (*Reference, error) {
+func (v *Reference) SetTarget(target *Oid, msg string) (*Reference, error) {
 	var ptr *C.git_reference
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	csig, err := sig.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
 	var cmsg *C.char
 	if msg == "" {
 		cmsg = nil
@@ -78,7 +66,7 @@ func (v *Reference) SetTarget(target *Oid, sig *Signature, msg string) (*Referen
 		defer C.free(unsafe.Pointer(cmsg))
 	}
 
-	ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), csig, cmsg)
+	ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), cmsg)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -100,17 +88,11 @@ func (v *Reference) Resolve() (*Reference, error) {
 	return newReferenceFromC(ptr, v.repo), nil
 }
 
-func (v *Reference) Rename(name string, force bool, sig *Signature, msg string) (*Reference, error) {
+func (v *Reference) Rename(name string, force bool, msg string) (*Reference, error) {
 	var ptr *C.git_reference
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
-	csig, err := sig.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
 	var cmsg *C.char
 	if msg == "" {
 		cmsg = nil
@@ -122,7 +104,7 @@ func (v *Reference) Rename(name string, force bool, sig *Signature, msg string)
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force), csig, cmsg)
+	ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force), cmsg)
 
 	if ret < 0 {
 		return nil, MakeGitError(ret)
diff --git a/reference_test.go b/reference_test.go
index c7d52fb..562e276 100644
--- a/reference_test.go
+++ b/reference_test.go
@@ -14,14 +14,7 @@ func TestRefModification(t *testing.T) {
 
 	commitId, treeId := seedTestRepo(t, repo)
 
-	loc, err := time.LoadLocation("Europe/Berlin")
-	checkFatal(t, err)
-	sig := &Signature{
-		Name:  "Rand Om Hacker",
-		Email: "[email protected]",
-		When:  time.Date(2013, 03, 06, 14, 30, 0, 0, loc),
-	}
-	_, err = repo.CreateReference("refs/tags/tree", treeId, true, sig, "testTreeTag")
+	_, err := repo.CreateReference("refs/tags/tree", treeId, true, "testTreeTag")
 	checkFatal(t, err)
 
 	tag, err := repo.LookupReference("refs/tags/tree")
@@ -52,7 +45,7 @@ func TestRefModification(t *testing.T) {
 		t.Fatalf("Wrong ref target")
 	}
 
-	_, err = tag.Rename("refs/tags/renamed", false, nil, "")
+	_, err = tag.Rename("refs/tags/renamed", false, "")
 	checkFatal(t, err)
 	tag, err = repo.LookupReference("refs/tags/renamed")
 	checkFatal(t, err)
@@ -85,13 +78,13 @@ func TestReferenceIterator(t *testing.T) {
 	commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree)
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/one", commitId, true, sig, "headOne")
+	_, err = repo.CreateReference("refs/heads/one", commitId, true, "headOne")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/two", commitId, true, sig, "headTwo")
+	_, err = repo.CreateReference("refs/heads/two", commitId, true, "headTwo")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/three", commitId, true, sig, "headThree")
+	_, err = repo.CreateReference("refs/heads/three", commitId, true, "headThree")
 	checkFatal(t, err)
 
 	iter, err := repo.NewReferenceIterator()
@@ -143,7 +136,7 @@ func TestReferenceOwner(t *testing.T) {
 	defer os.RemoveAll(repo.Workdir())
 	commitId, _ := seedTestRepo(t, repo)
 
-	ref, err := repo.CreateReference("refs/heads/foo", commitId, true, nil, "")
+	ref, err := repo.CreateReference("refs/heads/foo", commitId, true, "")
 	checkFatal(t, err)
 
 	owner := ref.Owner()
@@ -162,7 +155,7 @@ func TestUtil(t *testing.T) {
 
 	commitId, _ := seedTestRepo(t, repo)
 
-	ref, err := repo.CreateReference("refs/heads/foo", commitId, true, nil, "")
+	ref, err := repo.CreateReference("refs/heads/foo", commitId, true, "")
 	checkFatal(t, err)
 
 	ref2, err := repo.DwimReference("foo")
diff --git a/remote.go b/remote.go
index 84750d3..72d3934 100644
--- a/remote.go
+++ b/remote.go
@@ -598,18 +598,9 @@ func (o *Remote) UpdateFetchHead() bool {
 
 // Fetch performs a fetch operation. refspecs specifies which refspecs
 // to use for this fetch, use an empty list to use the refspecs from
-// the configuration; sig and msg specify what to use for the reflog
-// entries. Leave nil and "" to use defaults.
-func (o *Remote) Fetch(refspecs []string, sig *Signature, msg string) error {
-
-	var csig *C.git_signature = nil
-	if sig != nil {
-		csig, err := sig.toC()
-		if err != nil {
-			return err
-		}
-		defer C.free(unsafe.Pointer(csig))
-	}
+// the configuration; msg specifies what to use for the reflog
+// entries. Leave "" to use defaults.
+func (o *Remote) Fetch(refspecs []string, msg string) error {
 
 	var cmsg *C.char = nil
 	if msg != "" {
@@ -625,7 +616,7 @@ func (o *Remote) Fetch(refspecs []string, sig *Signature, msg string) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_fetch(o.ptr, &crefspecs, csig, cmsg)
+	ret := C.git_remote_fetch(o.ptr, &crefspecs, cmsg)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
@@ -696,24 +687,7 @@ func (o *Remote) Ls(filterRefs ...string) ([]RemoteHead, error) {
 	return heads, nil
 }
 
-func (o *Remote) Push(refspecs []string, opts *PushOptions, sig *Signature, msg string) error {
-	var csig *C.git_signature = nil
-	if sig != nil {
-		csig, err := sig.toC()
-		if err != nil {
-			return err
-		}
-		defer C.free(unsafe.Pointer(csig))
-	}
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
+func (o *Remote) Push(refspecs []string, opts *PushOptions) error {
 	var copts C.git_push_options
 	C.git_push_init_options(&copts, C.GIT_PUSH_OPTIONS_VERSION)
 	if opts != nil {
@@ -728,7 +702,7 @@ func (o *Remote) Push(refspecs []string, opts *PushOptions, sig *Signature, msg
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_push(o.ptr, &crefspecs, &copts, csig, cmsg)
+	ret := C.git_remote_push(o.ptr, &crefspecs, &copts)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
diff --git a/remote_test.go b/remote_test.go
index 54a66ed..bbbdeb9 100644
--- a/remote_test.go
+++ b/remote_test.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"testing"
-	"time"
 )
 
 func TestRefspecs(t *testing.T) {
@@ -73,7 +72,7 @@ func TestCertificateCheck(t *testing.T) {
 
 	err = remote.SetCallbacks(&callbacks)
 	checkFatal(t, err)
-	err = remote.Fetch([]string{}, nil, "")
+	err = remote.Fetch([]string{}, "")
 	checkFatal(t, err)
 }
 
@@ -168,13 +167,7 @@ func TestRemotePrune(t *testing.T) {
 	checkFatal(t, err)
 	defer commit.Free()
 
-	sig := &Signature{
-		Name:  "Rand Om Hacker",
-		Email: "[email protected]",
-		When:  time.Now(),
-	}
-
-	remoteRef, err := remoteRepo.CreateBranch("test-prune", commit, true, sig, "branch test-prune")
+	remoteRef, err := remoteRepo.CreateBranch("test-prune", commit, true)
 	checkFatal(t, err)
 
 	repo := createTestRepo(t)
@@ -189,10 +182,10 @@ func TestRemotePrune(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", remoteUrl)
 	checkFatal(t, err)
 
-	err = remote.Fetch([]string{"test-prune"}, sig, "")
+	err = remote.Fetch([]string{"test-prune"}, "")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/remotes/origin/test-prune", head, true, sig, "remote reference")
+	_, err = repo.CreateReference("refs/remotes/origin/test-prune", head, true, "remote reference")
 	checkFatal(t, err)
 
 	err = remoteRef.Delete()
diff --git a/repository.go b/repository.go
index 7fac277..b65867b 100644
--- a/repository.go
+++ b/repository.go
@@ -206,65 +206,35 @@ func (v *Repository) Head() (*Reference, error) {
 	return newReferenceFromC(ptr, v), nil
 }
 
-func (v *Repository) SetHead(refname string, sig *Signature, msg string) error {
+func (v *Repository) SetHead(refname string) error {
 	cname := C.CString(refname)
 	defer C.free(unsafe.Pointer(cname))
 
-	csig, err := sig.toC()
-	if err != nil {
-		return err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
-	var cmsg *C.char
-	if msg != "" {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_repository_set_head(v.ptr, cname, csig, cmsg)
+	ecode := C.git_repository_set_head(v.ptr, cname)
 	if ecode != 0 {
 		return MakeGitError(ecode)
 	}
 	return nil
 }
 
-func (v *Repository) SetHeadDetached(id *Oid, sig *Signature, msg string) error {
-	csig, err := sig.toC()
-	if err != nil {
-		return err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
-	var cmsg *C.char
-	if msg != "" {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
+func (v *Repository) SetHeadDetached(id *Oid) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_repository_set_head_detached(v.ptr, id.toC(), csig, cmsg)
+	ecode := C.git_repository_set_head_detached(v.ptr, id.toC())
 	if ecode != 0 {
 		return MakeGitError(ecode)
 	}
 	return nil
 }
 
-func (v *Repository) CreateReference(name string, id *Oid, force bool, sig *Signature, msg string) (*Reference, error) {
+func (v *Repository) CreateReference(name string, id *Oid, force bool, msg string) (*Reference, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
-	csig, err := sig.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
 	var cmsg *C.char
 	if msg == "" {
 		cmsg = nil
@@ -278,7 +248,7 @@ func (v *Repository) CreateReference(name string, id *Oid, force bool, sig *Sign
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_reference_create(&ptr, v.ptr, cname, id.toC(), cbool(force), csig, cmsg)
+	ecode := C.git_reference_create(&ptr, v.ptr, cname, id.toC(), cbool(force), cmsg)
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
@@ -286,19 +256,13 @@ func (v *Repository) CreateReference(name string, id *Oid, force bool, sig *Sign
 	return newReferenceFromC(ptr, v), nil
 }
 
-func (v *Repository) CreateSymbolicReference(name, target string, force bool, sig *Signature, msg string) (*Reference, error) {
+func (v *Repository) CreateSymbolicReference(name, target string, force bool, msg string) (*Reference, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
 	ctarget := C.CString(target)
 	defer C.free(unsafe.Pointer(ctarget))
 
-	csig, err := sig.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.free(unsafe.Pointer(csig))
-
 	var cmsg *C.char
 	if msg == "" {
 		cmsg = nil
@@ -312,7 +276,7 @@ func (v *Repository) CreateSymbolicReference(name, target string, force bool, si
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), csig, cmsg)
+	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), cmsg)
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
diff --git a/revparse_test.go b/revparse_test.go
index c046a20..8c3a352 100644
--- a/revparse_test.go
+++ b/revparse_test.go
@@ -35,7 +35,7 @@ func TestRevparseExt(t *testing.T) {
 
 	_, treeId := seedTestRepo(t, repo)
 
-	ref, err := repo.CreateReference("refs/heads/master", treeId, true, nil, "")
+	ref, err := repo.CreateReference("refs/heads/master", treeId, true, "")
 	checkFatal(t, err)
 
 	obj, ref, err := repo.RevparseExt("master")
diff --git a/submodule.go b/submodule.go
index 7c6c922..fdd38cc 100644
--- a/submodule.go
+++ b/submodule.go
@@ -16,7 +16,6 @@ type SubmoduleUpdateOptions struct {
 	*CheckoutOpts
 	*RemoteCallbacks
 	CloneCheckoutStrategy CheckoutStrategy
-	Signature             *Signature
 }
 
 // Submodule
@@ -345,11 +344,5 @@ func populateSubmoduleUpdateOptions(ptr *C.git_submodule_update_options, opts *S
 	populateRemoteCallbacks(&ptr.remote_callbacks, opts.RemoteCallbacks)
 	ptr.clone_checkout_strategy = C.uint(opts.CloneCheckoutStrategy)
 
-	sig, err := opts.Signature.toC()
-	if err != nil {
-		return err
-	}
-	ptr.signature = sig
-
 	return nil
 }
diff --git a/vendor/libgit2 b/vendor/libgit2
-Subproject 04bdd97f2b63793a8720fd19007911e946ba3c5
+Subproject d675982a15388d8c413acda139b4662062cf328