blob.go

@@ -9,7 +9,6 @@ void _go_git_writestream_free(git_writestream *stream);
 */
 import "C"
 import (
-	"io"
 	"reflect"
 	"runtime"
 	"unsafe"
@@ -68,7 +67,7 @@ func (repo *Repository) CreateBlobFromBuffer(data []byte) (*Oid, error) {
 		size = C.size_t(0)
 	}
 
-	ecode := C.git_blob_create_frombuffer(&id, repo.ptr, unsafe.Pointer(&data[0]), size)
+	ecode := C.git_blob_create_from_buffer(&id, repo.ptr, unsafe.Pointer(&data[0]), size)
 	runtime.KeepAlive(repo)
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
@@ -76,32 +75,6 @@ func (repo *Repository) CreateBlobFromBuffer(data []byte) (*Oid, error) {
 	return newOidFromC(&id), nil
 }
 
-type BlobChunkCallback func(maxLen int) ([]byte, error)
-
-type BlobCallbackData struct {
-	Callback BlobChunkCallback
-	Error    error
-}
-
-//export blobChunkCb
-func blobChunkCb(buffer *C.char, maxLen C.size_t, handle unsafe.Pointer) int {
-	payload := pointerHandles.Get(handle)
-	data, ok := payload.(*BlobCallbackData)
-	if !ok {
-		panic("could not retrieve blob callback data")
-	}
-
-	goBuf, err := data.Callback(int(maxLen))
-	if err == io.EOF {
-		return 0
-	} else if err != nil {
-		data.Error = err
-		return -1
-	}
-	C.memcpy(unsafe.Pointer(buffer), unsafe.Pointer(&goBuf[0]), C.size_t(len(goBuf)))
-	return len(goBuf)
-}
-
 func (repo *Repository) CreateFromStream(hintPath string) (*BlobWriteStream, error) {
 	var chintPath *C.char = nil
 	var stream *C.git_writestream
@@ -114,7 +87,7 @@ func (repo *Repository) CreateFromStream(hintPath string) (*BlobWriteStream, err
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_blob_create_fromstream(&stream, repo.ptr, chintPath)
+	ecode := C.git_blob_create_from_stream(&stream, repo.ptr, chintPath)
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
@@ -166,7 +139,7 @@ func (stream *BlobWriteStream) Commit() (*Oid, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_blob_create_fromstream_commit(&oid, stream.ptr)
+	ecode := C.git_blob_create_from_stream_commit(&oid, stream.ptr)
 	runtime.KeepAlive(stream)
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)

branch.go

@@ -73,7 +73,7 @@ func (i *BranchIterator) ForEach(f BranchIteratorFunc) error {
 		}
 	}
 
-	if err != nil && IsErrorCode(err, ErrIterOver) {
+	if err != nil && IsErrorCode(err, ErrorCodeIterOver) {
 		return nil
 	}
 

branch_test.go

@@ -22,7 +22,7 @@ func TestBranchIterator(t *testing.T) {
 		t.Fatalf("expected BranchLocal, not %v", t)
 	}
 	b, bt, err = i.Next()
-	if !IsErrorCode(err, ErrIterOver) {
+	if !IsErrorCode(err, ErrorCodeIterOver) {
 		t.Fatal("expected iterover")
 	}
 }
@@ -49,7 +49,7 @@ func TestBranchIteratorEach(t *testing.T) {
 	}
 
 	err = i.ForEach(f)
-	if err != nil && !IsErrorCode(err, ErrIterOver) {
+	if err != nil && !IsErrorCode(err, ErrorCodeIterOver) {
 		t.Fatal(err)
 	}
 

checkout.go

@@ -51,7 +51,7 @@ const (
 type CheckoutNotifyCallback func(why CheckoutNotifyType, path string, baseline, target, workdir DiffFile) ErrorCode
 type CheckoutProgressCallback func(path string, completed, total uint) ErrorCode
 
-type CheckoutOpts struct {
+type CheckoutOptions struct {
 	Strategy         CheckoutStrategy   // Default will be a dry run
 	DisableFilters   bool               // Don't apply filters like CRLF conversion
 	DirMode          os.FileMode        // Default is 0755
@@ -65,19 +65,20 @@ type CheckoutOpts struct {
 	Baseline         *Tree
 }
 
-func checkoutOptionsFromC(c *C.git_checkout_options) CheckoutOpts {
-	opts := CheckoutOpts{}
-	opts.Strategy = CheckoutStrategy(c.checkout_strategy)
-	opts.DisableFilters = c.disable_filters != 0
-	opts.DirMode = os.FileMode(c.dir_mode)
-	opts.FileMode = os.FileMode(c.file_mode)
-	opts.FileOpenFlags = int(c.file_open_flags)
-	opts.NotifyFlags = CheckoutNotifyType(c.notify_flags)
+func checkoutOptionsFromC(c *C.git_checkout_options) CheckoutOptions {
+	opts := CheckoutOptions{
+		Strategy:       CheckoutStrategy(c.checkout_strategy),
+		DisableFilters: c.disable_filters != 0,
+		DirMode:        os.FileMode(c.dir_mode),
+		FileMode:       os.FileMode(c.file_mode),
+		FileOpenFlags:  int(c.file_open_flags),
+		NotifyFlags:    CheckoutNotifyType(c.notify_flags),
+	}
 	if c.notify_payload != nil {
-		opts.NotifyCallback = pointerHandles.Get(c.notify_payload).(*CheckoutOpts).NotifyCallback
+		opts.NotifyCallback = pointerHandles.Get(c.notify_payload).(*CheckoutOptions).NotifyCallback
 	}
 	if c.progress_payload != nil {
-		opts.ProgressCallback = pointerHandles.Get(c.progress_payload).(*CheckoutOpts).ProgressCallback
+		opts.ProgressCallback = pointerHandles.Get(c.progress_payload).(*CheckoutOptions).ProgressCallback
 	}
 	if c.target_directory != nil {
 		opts.TargetDirectory = C.GoString(c.target_directory)
@@ -85,12 +86,12 @@ func checkoutOptionsFromC(c *C.git_checkout_options) CheckoutOpts {
 	return opts
 }
 
-func (opts *CheckoutOpts) toC() *C.git_checkout_options {
+func (opts *CheckoutOptions) toC() *C.git_checkout_options {
 	if opts == nil {
 		return nil
 	}
 	c := C.git_checkout_options{}
-	populateCheckoutOpts(&c, opts)
+	populateCheckoutOptions(&c, opts)
 	return &c
 }
 
@@ -110,7 +111,7 @@ func checkoutNotifyCallback(why C.git_checkout_notify_t, cpath *C.char, cbaselin
 	if cworkdir != nil {
 		workdir = diffFileFromC((*C.git_diff_file)(cworkdir))
 	}
-	opts := pointerHandles.Get(data).(*CheckoutOpts)
+	opts := pointerHandles.Get(data).(*CheckoutOptions)
 	if opts.NotifyCallback == nil {
 		return 0
 	}
@@ -119,17 +120,17 @@ func checkoutNotifyCallback(why C.git_checkout_notify_t, cpath *C.char, cbaselin
 
 //export checkoutProgressCallback
 func checkoutProgressCallback(path *C.char, completed_steps, total_steps C.size_t, data unsafe.Pointer) int {
-	opts := pointerHandles.Get(data).(*CheckoutOpts)
+	opts := pointerHandles.Get(data).(*CheckoutOptions)
 	if opts.ProgressCallback == nil {
 		return 0
 	}
 	return int(opts.ProgressCallback(C.GoString(path), uint(completed_steps), uint(total_steps)))
 }
 
-// Convert the CheckoutOpts struct to the corresponding
+// Convert the CheckoutOptions struct to the corresponding
 // C-struct. Returns a pointer to ptr, or nil if opts is nil, in order
 // to help with what to pass.
-func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.git_checkout_options {
+func populateCheckoutOptions(ptr *C.git_checkout_options, opts *CheckoutOptions) *C.git_checkout_options {
 	if opts == nil {
 		return nil
 	}
@@ -165,7 +166,7 @@ func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.gi
 	return ptr
 }
 
-func freeCheckoutOpts(ptr *C.git_checkout_options) {
+func freeCheckoutOptions(ptr *C.git_checkout_options) {
 	if ptr == nil {
 		return
 	}
@@ -180,12 +181,12 @@ func freeCheckoutOpts(ptr *C.git_checkout_options) {
 
 // Updates files in the index and the working tree to match the content of
 // the commit pointed at by HEAD. opts may be nil.
-func (v *Repository) CheckoutHead(opts *CheckoutOpts) error {
+func (v *Repository) CheckoutHead(opts *CheckoutOptions) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
 	cOpts := opts.toC()
-	defer freeCheckoutOpts(cOpts)
+	defer freeCheckoutOptions(cOpts)
 
 	ret := C.git_checkout_head(v.ptr, cOpts)
 	runtime.KeepAlive(v)
@@ -199,7 +200,7 @@ func (v *Repository) CheckoutHead(opts *CheckoutOpts) error {
 // Updates files in the working tree to match the content of the given
 // index. If index is nil, the repository's index will be used. opts
 // may be nil.
-func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
+func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOptions) error {
 	var iptr *C.git_index = nil
 	if index != nil {
 		iptr = index.ptr
@@ -209,7 +210,7 @@ func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
 	defer runtime.UnlockOSThread()
 
 	cOpts := opts.toC()
-	defer freeCheckoutOpts(cOpts)
+	defer freeCheckoutOptions(cOpts)
 
 	ret := C.git_checkout_index(v.ptr, iptr, cOpts)
 	runtime.KeepAlive(v)
@@ -220,12 +221,12 @@ func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
 	return nil
 }
 
-func (v *Repository) CheckoutTree(tree *Tree, opts *CheckoutOpts) error {
+func (v *Repository) CheckoutTree(tree *Tree, opts *CheckoutOptions) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
 	cOpts := opts.toC()
-	defer freeCheckoutOpts(cOpts)
+	defer freeCheckoutOptions(cOpts)
 
 	ret := C.git_checkout_tree(v.ptr, tree.ptr, cOpts)
 	runtime.KeepAlive(v)

cherrypick.go

@@ -12,7 +12,7 @@ type CherrypickOptions struct {
 	Version      uint
 	Mainline     uint
 	MergeOpts    MergeOptions
-	CheckoutOpts CheckoutOpts
+	CheckoutOpts CheckoutOptions
 }
 
 func cherrypickOptionsFromC(c *C.git_cherrypick_options) CherrypickOptions {
@@ -41,7 +41,7 @@ func freeCherrypickOpts(ptr *C.git_cherrypick_options) {
 	if ptr == nil {
 		return
 	}
-	freeCheckoutOpts(&ptr.checkout_opts)
+	freeCheckoutOptions(&ptr.checkout_opts)
 }
 
 func DefaultCherrypickOptions() (CherrypickOptions, error) {

cherrypick_test.go

@@ -11,7 +11,7 @@ func checkout(t *testing.T, repo *Repository, commit *Commit) {
 		t.Fatal(err)
 	}
 
-	err = repo.CheckoutTree(tree, &CheckoutOpts{Strategy: CheckoutSafe})
+	err = repo.CheckoutTree(tree, &CheckoutOptions{Strategy: CheckoutSafe})
 	if err != nil {
 		t.Fatal(err)
 	}

clone.go

@@ -58,19 +58,19 @@ func remoteCreateCallback(cremote unsafe.Pointer, crepo unsafe.Pointer, cname, c
 	runtime.SetFinalizer(repo, nil)
 
 	if opts, ok := pointerHandles.Get(payload).(CloneOptions); ok {
-		remote, err := opts.RemoteCreateCallback(repo, name, url)
+		remote, errorCode := opts.RemoteCreateCallback(repo, name, url)
 		// clear finalizer as the calling C function will
 		// free the remote itself
 		runtime.SetFinalizer(remote, nil)
 
-		if err == ErrOk && remote != nil {
+		if errorCode == ErrorCodeOK && remote != nil {
 			cptr := (**C.git_remote)(cremote)
 			*cptr = remote.ptr
-		} else if err == ErrOk && remote == nil {
+		} else if errorCode == ErrorCodeOK && remote == nil {
 			panic("no remote created by callback")
 		}
 
-		return C.int(err)
+		return C.int(errorCode)
 	} else {
 		panic("invalid remote create callback")
 	}
@@ -82,7 +82,7 @@ func populateCloneOptions(ptr *C.git_clone_options, opts *CloneOptions) {
 	if opts == nil {
 		return
 	}
-	populateCheckoutOpts(&ptr.checkout_opts, opts.CheckoutOpts)
+	populateCheckoutOptions(&ptr.checkout_opts, opts.CheckoutOpts)
 	populateFetchOptions(&ptr.fetch_opts, opts.FetchOptions)
 	ptr.bare = cbool(opts.Bare)
 
@@ -98,7 +98,7 @@ func freeCloneOptions(ptr *C.git_clone_options) {
 		return
 	}
 
-	freeCheckoutOpts(&ptr.checkout_opts)
+	freeCheckoutOptions(&ptr.checkout_opts)
 
 	if ptr.remote_cb_payload != nil {
 		pointerHandles.Untrack(ptr.remote_cb_payload)

clone_test.go

@@ -54,10 +54,10 @@ func TestCloneWithCallback(t *testing.T) {
 
 			remote, err := r.Remotes.Create(REMOTENAME, url)
 			if err != nil {
-				return nil, ErrGeneric
+				return nil, ErrorCodeGeneric
 			}
 
-			return remote, ErrOk
+			return remote, ErrorCodeOK
 		},
 	}
 

credentials.go

@@ -2,62 +2,111 @@ package git
 
 /*
 #include <git2.h>
-#include <git2/sys/cred.h>
+#include <git2/credential.h>
 
-git_credtype_t _go_git_cred_credtype(git_cred *cred);
+git_credential_t _go_git_credential_credtype(git_credential *cred);
 */
 import "C"
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 )
 
-type CredType uint
+// CredentialType is a bitmask of supported credential types.
+//
+// This represents the various types of authentication methods supported by the
+// library.
+type CredentialType uint
 
 const (
-	CredTypeUserpassPlaintext CredType = C.GIT_CREDTYPE_USERPASS_PLAINTEXT
-	CredTypeSshKey            CredType = C.GIT_CREDTYPE_SSH_KEY
-	CredTypeSshCustom         CredType = C.GIT_CREDTYPE_SSH_CUSTOM
-	CredTypeDefault           CredType = C.GIT_CREDTYPE_DEFAULT
+	CredentialTypeUserpassPlaintext CredentialType = C.GIT_CREDENTIAL_USERPASS_PLAINTEXT
+	CredentialTypeSSHKey            CredentialType = C.GIT_CREDENTIAL_SSH_KEY
+	CredentialTypeSSHCustom         CredentialType = C.GIT_CREDENTIAL_SSH_CUSTOM
+	CredentialTypeDefault           CredentialType = C.GIT_CREDENTIAL_DEFAULT
+	CredentialTypeSSHInteractive    CredentialType = C.GIT_CREDENTIAL_SSH_INTERACTIVE
+	CredentialTypeUsername          CredentialType = C.GIT_CREDENTIAL_USERNAME
+	CredentialTypeSSHMemory         CredentialType = C.GIT_CREDENTIAL_SSH_MEMORY
 )
 
-type Cred struct {
-	ptr *C.git_cred
+func (t CredentialType) String() string {
+	if t == 0 {
+		return "CredentialType(0)"
 	}
 
-func newCred() *Cred {
-	cred := &Cred{}
-	runtime.SetFinalizer(cred, (*Cred).Free)
+	var parts []string
+
+	if (t & CredentialTypeUserpassPlaintext) != 0 {
+		parts = append(parts, "UserpassPlaintext")
+		t &= ^CredentialTypeUserpassPlaintext
+	}
+	if (t & CredentialTypeSSHKey) != 0 {
+		parts = append(parts, "SSHKey")
+		t &= ^CredentialTypeSSHKey
+	}
+	if (t & CredentialTypeSSHCustom) != 0 {
+		parts = append(parts, "SSHCustom")
+		t &= ^CredentialTypeSSHCustom
+	}
+	if (t & CredentialTypeDefault) != 0 {
+		parts = append(parts, "Default")
+		t &= ^CredentialTypeDefault
+	}
+	if (t & CredentialTypeSSHInteractive) != 0 {
+		parts = append(parts, "SSHInteractive")
+		t &= ^CredentialTypeSSHInteractive
+	}
+	if (t & CredentialTypeUsername) != 0 {
+		parts = append(parts, "Username")
+		t &= ^CredentialTypeUsername
+	}
+	if (t & CredentialTypeSSHMemory) != 0 {
+		parts = append(parts, "SSHMemory")
+		t &= ^CredentialTypeSSHMemory
+	}
+
+	if t != 0 {
+		parts = append(parts, fmt.Sprintf("CredentialType(%#x)", t))
+	}
+
+	return strings.Join(parts, "|")
+}
+
+type Credential struct {
+	ptr *C.git_credential
+}
+
+func newCredential() *Credential {
+	cred := &Credential{}
+	runtime.SetFinalizer(cred, (*Credential).Free)
 	return cred
 }
 
-func (o *Cred) HasUsername() bool {
-	if C.git_cred_has_username(o.ptr) == 1 {
+func (o *Credential) HasUsername() bool {
+	if C.git_credential_has_username(o.ptr) == 1 {
 		return true
 	}
 	return false
 }
 
-func (o *Cred) Type() CredType {
-	return (CredType)(C._go_git_cred_credtype(o.ptr))
+func (o *Credential) Type() CredentialType {
+	return (CredentialType)(C._go_git_credential_credtype(o.ptr))
 }
 
-func (o *Cred) Free() {
-	C.git_cred_free(o.ptr)
+func (o *Credential) Free() {
+	C.git_credential_free(o.ptr)
 	runtime.SetFinalizer(o, nil)
 	o.ptr = nil
 }
 
-func NewCredUserpassPlaintext(username string, password string) (*Cred, error) {
+func NewCredentialUsername(username string) (*Credential, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	cred := newCred()
+	cred := newCredential()
 	cusername := C.CString(username)
-	defer C.free(unsafe.Pointer(cusername))
-	cpassword := C.CString(password)
-	defer C.free(unsafe.Pointer(cpassword))
-	ret := C.git_cred_userpass_plaintext_new(&cred.ptr, cusername, cpassword)
+	ret := C.git_credential_username_new(&cred.ptr, cusername)
 	if ret != 0 {
 		cred.Free()
 		return nil, MakeGitError(ret)
@@ -65,13 +114,30 @@ func NewCredUserpassPlaintext(username string, password string) (*Cred, error) {
 	return cred, nil
 }
 
-// NewCredSshKey creates new ssh credentials reading the public and private keys
-// from the file system.
-func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (*Cred, error) {
+func NewCredentialUserpassPlaintext(username string, password string) (*Credential, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	cred := newCred()
+	cred := newCredential()
+	cusername := C.CString(username)
+	defer C.free(unsafe.Pointer(cusername))
+	cpassword := C.CString(password)
+	defer C.free(unsafe.Pointer(cpassword))
+	ret := C.git_credential_userpass_plaintext_new(&cred.ptr, cusername, cpassword)
+	if ret != 0 {
+		cred.Free()
+		return nil, MakeGitError(ret)
+	}
+	return cred, nil
+}
+
+// NewCredentialSSHKey creates new ssh credentials reading the public and private keys
+// from the file system.
+func NewCredentialSSHKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (*Credential, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	cred := newCredential()
 	cusername := C.CString(username)
 	defer C.free(unsafe.Pointer(cusername))
 	cpublickey := C.CString(publicKeyPath)
@@ -80,7 +146,7 @@ func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string,
 	defer C.free(unsafe.Pointer(cprivatekey))
 	cpassphrase := C.CString(passphrase)
 	defer C.free(unsafe.Pointer(cpassphrase))
-	ret := C.git_cred_ssh_key_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
+	ret := C.git_credential_ssh_key_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
 	if ret != 0 {
 		cred.Free()
 		return nil, MakeGitError(ret)
@@ -88,13 +154,13 @@ func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string,
 	return cred, nil
 }
 
-// NewCredSshKeyFromMemory creates new ssh credentials using the publicKey and privateKey
+// NewCredentialSSHKeyFromMemory creates new ssh credentials using the publicKey and privateKey
 // arguments as the values for the public and private keys.
-func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (*Cred, error) {
+func NewCredentialSSHKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (*Credential, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	cred := newCred()
+	cred := newCredential()
 	cusername := C.CString(username)
 	defer C.free(unsafe.Pointer(cusername))
 	cpublickey := C.CString(publicKey)
@@ -103,7 +169,7 @@ func NewCredSshKeyFromMemory(username string, publicKey string, privateKey strin
 	defer C.free(unsafe.Pointer(cprivatekey))
 	cpassphrase := C.CString(passphrase)
 	defer C.free(unsafe.Pointer(cpassphrase))
-	ret := C.git_cred_ssh_key_memory_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
+	ret := C.git_credential_ssh_key_memory_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
 	if ret != 0 {
 		cred.Free()
 		return nil, MakeGitError(ret)
@@ -111,14 +177,14 @@ func NewCredSshKeyFromMemory(username string, publicKey string, privateKey strin
 	return cred, nil
 }
 
-func NewCredSshKeyFromAgent(username string) (*Cred, error) {
+func NewCredentialSSHKeyFromAgent(username string) (*Credential, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	cred := newCred()
+	cred := newCredential()
 	cusername := C.CString(username)
 	defer C.free(unsafe.Pointer(cusername))
-	ret := C.git_cred_ssh_key_from_agent(&cred.ptr, cusername)
+	ret := C.git_credential_ssh_key_from_agent(&cred.ptr, cusername)
 	if ret != 0 {
 		cred.Free()
 		return nil, MakeGitError(ret)
@@ -126,12 +192,12 @@ func NewCredSshKeyFromAgent(username string) (*Cred, error) {
 	return cred, nil
 }
 
-func NewCredDefault() (*Cred, error) {
+func NewCredentialDefault() (*Credential, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	cred := newCred()
-	ret := C.git_cred_default_new(&cred.ptr)
+	cred := newCredential()
+	ret := C.git_credential_default_new(&cred.ptr)
 	if ret != 0 {
 		cred.Free()
 		return nil, MakeGitError(ret)

deprecated.go

@@ -0,0 +1,184 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+	"unsafe"
+)
+
+// The constants, functions, and types in this files are slated for deprecation
+// in the next major version.
+
+// blob.go
+
+// BlobChunkCallback is not used.
+type BlobChunkCallback func(maxLen int) ([]byte, error)
+
+// BlobCallbackData is not used.
+type BlobCallbackData struct {
+	Callback BlobChunkCallback
+	Error    error
+}
+
+// checkout.go
+
+// CheckoutOpts is a deprecated alias of CheckoutOptions.
+type CheckoutOpts = CheckoutOptions
+
+// credentials.go
+
+// CredType is a deprecated alias of CredentialType
+type CredType = CredentialType
+
+const (
+	CredTypeUserpassPlaintext = CredentialTypeUserpassPlaintext
+	CredTypeSshKey            = CredentialTypeSSHKey
+	CredTypeSshCustom         = CredentialTypeSSHCustom
+	CredTypeDefault           = CredentialTypeDefault
+)
+
+// Cred is a deprecated alias of Credential
+type Cred = Credential
+
+// NewCredUsername is a deprecated alias of NewCredentialUsername.
+func NewCredUsername(username string) (*Cred, error) {
+	return NewCredentialUsername(username)
+}
+
+// NewCredUserpassPlaintext is a deprecated alias of NewCredentialUserpassPlaintext.
+func NewCredUserpassPlaintext(username string, password string) (*Cred, error) {
+	return NewCredentialUserpassPlaintext(username, password)
+}
+
+// NewCredSshKey is a deprecated alias of NewCredentialSshKey.
+func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (*Cred, error) {
+	return NewCredentialSSHKey(username, publicKeyPath, privateKeyPath, passphrase)
+}
+
+// NewCredSshKeyFromMemory is a deprecated alias of NewCredentialSSHKeyFromMemory.
+func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (*Cred, error) {
+	return NewCredentialSSHKeyFromMemory(username, publicKey, privateKey, passphrase)
+}
+
+// NewCredSshKeyFromAgent is a deprecated alias of NewCredentialSSHFromAgent.
+func NewCredSshKeyFromAgent(username string) (*Cred, error) {
+	return NewCredentialSSHKeyFromAgent(username)
+}
+
+// NewCredDefault is a deprecated alias fof NewCredentialDefault.
+func NewCredDefault() (*Cred, error) {
+	return NewCredentialDefault()
+}
+
+// features.go
+
+const (
+	// FeatureHttps is a deprecated alias of FeatureHTTPS.
+	FeatureHttps = FeatureHTTPS
+
+	// FeatureSsh is a deprecated alias of FeatureSSH.
+	FeatureSsh = FeatureSSH
+)
+
+// git.go
+
+const (
+	ErrClassNone       = ErrorClassNone
+	ErrClassNoMemory   = ErrorClassNoMemory
+	ErrClassOs         = ErrorClassOS
+	ErrClassInvalid    = ErrorClassInvalid
+	ErrClassReference  = ErrorClassReference
+	ErrClassZlib       = ErrorClassZlib
+	ErrClassRepository = ErrorClassRepository
+	ErrClassConfig     = ErrorClassConfig
+	ErrClassRegex      = ErrorClassRegex
+	ErrClassOdb        = ErrorClassOdb
+	ErrClassIndex      = ErrorClassIndex
+	ErrClassObject     = ErrorClassObject
+	ErrClassNet        = ErrorClassNet
+	ErrClassTag        = ErrorClassTag
+	ErrClassTree       = ErrorClassTree
+	ErrClassIndexer    = ErrorClassIndexer
+	ErrClassSSL        = ErrorClassSSL
+	ErrClassSubmodule  = ErrorClassSubmodule
+	ErrClassThread     = ErrorClassThread
+	ErrClassStash      = ErrorClassStash
+	ErrClassCheckout   = ErrorClassCheckout
+	ErrClassFetchHead  = ErrorClassFetchHead
+	ErrClassMerge      = ErrorClassMerge
+	ErrClassSsh        = ErrorClassSSH
+	ErrClassFilter     = ErrorClassFilter
+	ErrClassRevert     = ErrorClassRevert
+	ErrClassCallback   = ErrorClassCallback
+	ErrClassRebase     = ErrorClassRebase
+	ErrClassPatch      = ErrorClassPatch
+)
+
+const (
+	ErrOk             = ErrorCodeOK
+	ErrGeneric        = ErrorCodeGeneric
+	ErrNotFound       = ErrorCodeNotFound
+	ErrExists         = ErrorCodeExists
+	ErrAmbiguous      = ErrorCodeAmbiguous
+	ErrAmbigious      = ErrorCodeAmbiguous
+	ErrBuffs          = ErrorCodeBuffs
+	ErrUser           = ErrorCodeUser
+	ErrBareRepo       = ErrorCodeBareRepo
+	ErrUnbornBranch   = ErrorCodeUnbornBranch
+	ErrUnmerged       = ErrorCodeUnmerged
+	ErrNonFastForward = ErrorCodeNonFastForward
+	ErrInvalidSpec    = ErrorCodeInvalidSpec
+	ErrConflict       = ErrorCodeConflict
+	ErrLocked         = ErrorCodeLocked
+	ErrModified       = ErrorCodeModified
+	ErrAuth           = ErrorCodeAuth
+	ErrCertificate    = ErrorCodeCertificate
+	ErrApplied        = ErrorCodeApplied
+	ErrPeel           = ErrorCodePeel
+	ErrEOF            = ErrorCodeEOF
+	ErrUncommitted    = ErrorCodeUncommitted
+	ErrDirectory      = ErrorCodeDirectory
+	ErrMergeConflict  = ErrorCodeMergeConflict
+	ErrPassthrough    = ErrorCodePassthrough
+	ErrIterOver       = ErrorCodeIterOver
+	ErrApplyFail      = ErrorCodeApplyFail
+)
+
+// index.go
+
+// IndexAddOpts is a deprecated alias of IndexAddOption.
+type IndexAddOpts = IndexAddOption
+
+// IndexStageOpts is a deprecated alias of IndexStageState.
+type IndexStageOpts = IndexStageState
+
+// submodule.go
+
+// SubmoduleCbk is a deprecated alias of SubmoduleCallback.
+type SubmoduleCbk = SubmoduleCallback
+
+// SubmoduleVisitor is not used.
+func SubmoduleVisitor(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer) C.int {
+	sub := &Submodule{(*C.git_submodule)(csub), nil}
+
+	callback, ok := pointerHandles.Get(handle).(SubmoduleCallback)
+	if !ok {
+		panic("invalid submodule visitor callback")
+	}
+	return (C.int)(callback(sub, C.GoString(name)))
+}
+
+// tree.go
+
+// CallbackGitTreeWalk is not used.
+func CallbackGitTreeWalk(_root *C.char, entry *C.git_tree_entry, ptr unsafe.Pointer) C.int {
+	root := C.GoString(_root)
+
+	if callback, ok := pointerHandles.Get(ptr).(TreeWalkCallback); ok {
+		return C.int(callback(root, newTreeEntry(entry)))
+	} else {
+		panic("invalid treewalk callback")
+	}
+}

diff.go

@@ -447,7 +447,7 @@ func (diff *Diff) ToBuf(format DiffFormat) ([]byte, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_buf_free(&diffBuf)
+	defer C.git_buf_dispose(&diffBuf)
 
 	return C.GoBytes(unsafe.Pointer(diffBuf.ptr), C.int(diffBuf.size)), nil
 }

diff_test.go

@@ -259,7 +259,7 @@ func TestApplyDiffAddfile(t *testing.T) {
 	defer diff.Free()
 
 	t.Run("check does not apply to current tree because file exists", func(t *testing.T) {
-		err = repo.ResetToCommit(addSecondFileCommit, ResetHard, &CheckoutOpts{})
+		err = repo.ResetToCommit(addSecondFileCommit, ResetHard, &CheckoutOptions{})
 		checkFatal(t, err)
 
 		err = repo.ApplyDiff(diff, ApplyLocationBoth, nil)
@@ -269,7 +269,7 @@ func TestApplyDiffAddfile(t *testing.T) {
 	})
 
 	t.Run("check apply to correct commit", func(t *testing.T) {
-		err = repo.ResetToCommit(addFirstFileCommit, ResetHard, &CheckoutOpts{})
+		err = repo.ResetToCommit(addFirstFileCommit, ResetHard, &CheckoutOptions{})
 		checkFatal(t, err)
 
 		err = repo.ApplyDiff(diff, ApplyLocationBoth, nil)
@@ -324,7 +324,7 @@ func TestApplyDiffAddfile(t *testing.T) {
 	})
 
 	t.Run("check convert to raw buffer and apply", func(t *testing.T) {
-		err = repo.ResetToCommit(addFirstFileCommit, ResetHard, &CheckoutOpts{})
+		err = repo.ResetToCommit(addFirstFileCommit, ResetHard, &CheckoutOptions{})
 		checkFatal(t, err)
 
 		raw, err := diff.ToBuf(DiffFormatPatch)
@@ -345,7 +345,7 @@ func TestApplyDiffAddfile(t *testing.T) {
 	t.Run("check apply callbacks work", func(t *testing.T) {
 		// reset the state and get new default options for test
 		resetAndGetOpts := func(t *testing.T) *ApplyOptions {
-			err = repo.ResetToCommit(addFirstFileCommit, ResetHard, &CheckoutOpts{})
+			err = repo.ResetToCommit(addFirstFileCommit, ResetHard, &CheckoutOptions{})
 			checkFatal(t, err)
 
 			opts, err := DefaultApplyOptions()
@@ -507,8 +507,8 @@ func TestApplyToTree(t *testing.T) {
 			diff: diffAC,
 			error: &GitError{
 				Message: "hunk at line 1 did not apply",
-				Code:    ErrApplyFail,
-				Class:   ErrClassPatch,
+				Code:    ErrorCodeApplyFail,
+				Class:   ErrorClassPatch,
 			},
 		},
 		{
@@ -531,8 +531,9 @@ func TestApplyToTree(t *testing.T) {
 			diff:              diffAB,
 			applyHunkCallback: func(*DiffHunk) (bool, error) { return true, errors.New("message dropped") },
 			error: &GitError{
-				Code:  ErrGeneric,
-				Class: ErrClassInvalid,
+				Message: "Generic",
+				Code:    ErrorCodeGeneric,
+				Class:   ErrorClassInvalid,
 			},
 		},
 		{
@@ -547,8 +548,9 @@ func TestApplyToTree(t *testing.T) {
 			diff:               diffAB,
 			applyDeltaCallback: func(*DiffDelta) (bool, error) { return true, errors.New("message dropped") },
 			error: &GitError{
-				Code:  ErrGeneric,
-				Class: ErrClassInvalid,
+				Message: "Generic",
+				Code:    ErrorCodeGeneric,
+				Class:   ErrorClassInvalid,
 			},
 		},
 	} {

errorclass_string.go

@@ -0,0 +1,63 @@
+// Code generated by "stringer -type ErrorClass -trimprefix ErrorClass -tags static"; DO NOT EDIT.
+
+package git
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[ErrorClassNone-0]
+	_ = x[ErrorClassNoMemory-1]
+	_ = x[ErrorClassOS-2]
+	_ = x[ErrorClassInvalid-3]
+	_ = x[ErrorClassReference-4]
+	_ = x[ErrorClassZlib-5]
+	_ = x[ErrorClassRepository-6]
+	_ = x[ErrorClassConfig-7]
+	_ = x[ErrorClassRegex-8]
+	_ = x[ErrorClassOdb-9]
+	_ = x[ErrorClassIndex-10]
+	_ = x[ErrorClassObject-11]
+	_ = x[ErrorClassNet-12]
+	_ = x[ErrorClassTag-13]
+	_ = x[ErrorClassTree-14]
+	_ = x[ErrorClassIndexer-15]
+	_ = x[ErrorClassSSL-16]
+	_ = x[ErrorClassSubmodule-17]
+	_ = x[ErrorClassThread-18]
+	_ = x[ErrorClassStash-19]
+	_ = x[ErrorClassCheckout-20]
+	_ = x[ErrorClassFetchHead-21]
+	_ = x[ErrorClassMerge-22]
+	_ = x[ErrorClassSSH-23]
+	_ = x[ErrorClassFilter-24]
+	_ = x[ErrorClassRevert-25]
+	_ = x[ErrorClassCallback-26]
+	_ = x[ErrorClassRebase-29]
+	_ = x[ErrorClassPatch-31]
+}
+
+const (
+	_ErrorClass_name_0 = "NoneNoMemoryOSInvalidReferenceZlibRepositoryConfigRegexOdbIndexObjectNetTagTreeIndexerSSLSubmoduleThreadStashCheckoutFetchHeadMergeSSHFilterRevertCallback"
+	_ErrorClass_name_1 = "Rebase"
+	_ErrorClass_name_2 = "Patch"
+)
+
+var (
+	_ErrorClass_index_0 = [...]uint8{0, 4, 12, 14, 21, 30, 34, 44, 50, 55, 58, 63, 69, 72, 75, 79, 86, 89, 98, 104, 109, 117, 126, 131, 134, 140, 146, 154}
+)
+
+func (i ErrorClass) String() string {
+	switch {
+	case 0 <= i && i <= 26:
+		return _ErrorClass_name_0[_ErrorClass_index_0[i]:_ErrorClass_index_0[i+1]]
+	case i == 29:
+		return _ErrorClass_name_1
+	case i == 31:
+		return _ErrorClass_name_2
+	default:
+		return "ErrorClass(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}

errorcode_string.go

@@ -0,0 +1,69 @@
+// Code generated by "stringer -type ErrorCode -trimprefix ErrorCode -tags static"; DO NOT EDIT.
+
+package git
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[ErrorCodeOK-0]
+	_ = x[ErrorCodeGeneric - -1]
+	_ = x[ErrorCodeNotFound - -3]
+	_ = x[ErrorCodeExists - -4]
+	_ = x[ErrorCodeAmbiguous - -5]
+	_ = x[ErrorCodeBuffs - -6]
+	_ = x[ErrorCodeUser - -7]
+	_ = x[ErrorCodeBareRepo - -8]
+	_ = x[ErrorCodeUnbornBranch - -9]
+	_ = x[ErrorCodeUnmerged - -10]
+	_ = x[ErrorCodeNonFastForward - -11]
+	_ = x[ErrorCodeInvalidSpec - -12]
+	_ = x[ErrorCodeConflict - -13]
+	_ = x[ErrorCodeLocked - -14]
+	_ = x[ErrorCodeModified - -15]
+	_ = x[ErrorCodeAuth - -16]
+	_ = x[ErrorCodeCertificate - -17]
+	_ = x[ErrorCodeApplied - -18]
+	_ = x[ErrorCodePeel - -19]
+	_ = x[ErrorCodeEOF - -20]
+	_ = x[ErrorCodeInvalid - -21]
+	_ = x[ErrorCodeUncommitted - -22]
+	_ = x[ErrorCodeDirectory - -23]
+	_ = x[ErrorCodeMergeConflict - -24]
+	_ = x[ErrorCodePassthrough - -30]
+	_ = x[ErrorCodeIterOver - -31]
+	_ = x[ErrorCodeRetry - -32]
+	_ = x[ErrorCodeMismatch - -33]
+	_ = x[ErrorCodeIndexDirty - -34]
+	_ = x[ErrorCodeApplyFail - -35]
+}
+
+const (
+	_ErrorCode_name_0 = "ApplyFailIndexDirtyMismatchRetryIterOverPassthrough"
+	_ErrorCode_name_1 = "MergeConflictDirectoryUncommittedInvalidEOFPeelAppliedCertificateAuthModifiedLockedConflictInvalidSpecNonFastForwardUnmergedUnbornBranchBareRepoUserBuffsAmbiguousExistsNotFound"
+	_ErrorCode_name_2 = "GenericOK"
+)
+
+var (
+	_ErrorCode_index_0 = [...]uint8{0, 9, 19, 27, 32, 40, 51}
+	_ErrorCode_index_1 = [...]uint8{0, 13, 22, 33, 40, 43, 47, 54, 65, 69, 77, 83, 91, 102, 116, 124, 136, 144, 148, 153, 162, 168, 176}
+	_ErrorCode_index_2 = [...]uint8{0, 7, 9}
+)
+
+func (i ErrorCode) String() string {
+	switch {
+	case -35 <= i && i <= -30:
+		i -= -35
+		return _ErrorCode_name_0[_ErrorCode_index_0[i]:_ErrorCode_index_0[i+1]]
+	case -24 <= i && i <= -3:
+		i -= -24
+		return _ErrorCode_name_1[_ErrorCode_index_1[i]:_ErrorCode_index_1[i+1]]
+	case -1 <= i && i <= 0:
+		i -= -1
+		return _ErrorCode_name_2[_ErrorCode_index_2[i]:_ErrorCode_index_2[i+1]]
+	default:
+		return "ErrorCode(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}

features.go

@@ -12,10 +12,10 @@ const (
 	FeatureThreads Feature = C.GIT_FEATURE_THREADS
 
 	// libgit2 was built with HTTPS support built-in
-	FeatureHttps Feature = C.GIT_FEATURE_HTTPS
+	FeatureHTTPS Feature = C.GIT_FEATURE_HTTPS
 
 	// libgit2 was build with SSH support built-in
-	FeatureSsh Feature = C.GIT_FEATURE_SSH
+	FeatureSSH Feature = C.GIT_FEATURE_SSH
 
 	// libgit2 was built with nanosecond support for files
 	FeatureNSec Feature = C.GIT_FEATURE_NSEC

git.go

@@ -17,101 +17,106 @@ import (
 type ErrorClass int
 
 const (
-	ErrClassNone       ErrorClass = C.GITERR_NONE
-	ErrClassNoMemory   ErrorClass = C.GITERR_NOMEMORY
-	ErrClassOs         ErrorClass = C.GITERR_OS
-	ErrClassInvalid    ErrorClass = C.GITERR_INVALID
-	ErrClassReference  ErrorClass = C.GITERR_REFERENCE
-	ErrClassZlib       ErrorClass = C.GITERR_ZLIB
-	ErrClassRepository ErrorClass = C.GITERR_REPOSITORY
-	ErrClassConfig     ErrorClass = C.GITERR_CONFIG
-	ErrClassRegex      ErrorClass = C.GITERR_REGEX
-	ErrClassOdb        ErrorClass = C.GITERR_ODB
-	ErrClassIndex      ErrorClass = C.GITERR_INDEX
-	ErrClassObject     ErrorClass = C.GITERR_OBJECT
-	ErrClassNet        ErrorClass = C.GITERR_NET
-	ErrClassTag        ErrorClass = C.GITERR_TAG
-	ErrClassTree       ErrorClass = C.GITERR_TREE
-	ErrClassIndexer    ErrorClass = C.GITERR_INDEXER
-	ErrClassSSL        ErrorClass = C.GITERR_SSL
-	ErrClassSubmodule  ErrorClass = C.GITERR_SUBMODULE
-	ErrClassThread     ErrorClass = C.GITERR_THREAD
-	ErrClassStash      ErrorClass = C.GITERR_STASH
-	ErrClassCheckout   ErrorClass = C.GITERR_CHECKOUT
-	ErrClassFetchHead  ErrorClass = C.GITERR_FETCHHEAD
-	ErrClassMerge      ErrorClass = C.GITERR_MERGE
-	ErrClassSsh        ErrorClass = C.GITERR_SSH
-	ErrClassFilter     ErrorClass = C.GITERR_FILTER
-	ErrClassRevert     ErrorClass = C.GITERR_REVERT
-	ErrClassCallback   ErrorClass = C.GITERR_CALLBACK
-	ErrClassRebase     ErrorClass = C.GITERR_REBASE
-	ErrClassPatch      ErrorClass = C.GITERR_PATCH
+	ErrorClassNone       ErrorClass = C.GIT_ERROR_NONE
+	ErrorClassNoMemory   ErrorClass = C.GIT_ERROR_NOMEMORY
+	ErrorClassOS         ErrorClass = C.GIT_ERROR_OS
+	ErrorClassInvalid    ErrorClass = C.GIT_ERROR_INVALID
+	ErrorClassReference  ErrorClass = C.GIT_ERROR_REFERENCE
+	ErrorClassZlib       ErrorClass = C.GIT_ERROR_ZLIB
+	ErrorClassRepository ErrorClass = C.GIT_ERROR_REPOSITORY
+	ErrorClassConfig     ErrorClass = C.GIT_ERROR_CONFIG
+	ErrorClassRegex      ErrorClass = C.GIT_ERROR_REGEX
+	ErrorClassOdb        ErrorClass = C.GIT_ERROR_ODB
+	ErrorClassIndex      ErrorClass = C.GIT_ERROR_INDEX
+	ErrorClassObject     ErrorClass = C.GIT_ERROR_OBJECT
+	ErrorClassNet        ErrorClass = C.GIT_ERROR_NET
+	ErrorClassTag        ErrorClass = C.GIT_ERROR_TAG
+	ErrorClassTree       ErrorClass = C.GIT_ERROR_TREE
+	ErrorClassIndexer    ErrorClass = C.GIT_ERROR_INDEXER
+	ErrorClassSSL        ErrorClass = C.GIT_ERROR_SSL
+	ErrorClassSubmodule  ErrorClass = C.GIT_ERROR_SUBMODULE
+	ErrorClassThread     ErrorClass = C.GIT_ERROR_THREAD
+	ErrorClassStash      ErrorClass = C.GIT_ERROR_STASH
+	ErrorClassCheckout   ErrorClass = C.GIT_ERROR_CHECKOUT
+	ErrorClassFetchHead  ErrorClass = C.GIT_ERROR_FETCHHEAD
+	ErrorClassMerge      ErrorClass = C.GIT_ERROR_MERGE
+	ErrorClassSSH        ErrorClass = C.GIT_ERROR_SSH
+	ErrorClassFilter     ErrorClass = C.GIT_ERROR_FILTER
+	ErrorClassRevert     ErrorClass = C.GIT_ERROR_REVERT
+	ErrorClassCallback   ErrorClass = C.GIT_ERROR_CALLBACK
+	ErrorClassRebase     ErrorClass = C.GIT_ERROR_REBASE
+	ErrorClassPatch      ErrorClass = C.GIT_ERROR_PATCH
 )
 
 type ErrorCode int
 
 const (
+	// ErrorCodeOK indicates that the operation completed successfully.
+	ErrorCodeOK ErrorCode = C.GIT_OK
 
-	// No error
-	ErrOk ErrorCode = C.GIT_OK
+	// ErrorCodeGeneric represents a generic error.
+	ErrorCodeGeneric ErrorCode = C.GIT_ERROR
+	// ErrorCodeNotFound represents that the requested object could not be found
+	ErrorCodeNotFound ErrorCode = C.GIT_ENOTFOUND
+	// ErrorCodeExists represents that the object exists preventing operation.
+	ErrorCodeExists ErrorCode = C.GIT_EEXISTS
+	// ErrorCodeAmbiguous represents that more than one object matches.
+	ErrorCodeAmbiguous ErrorCode = C.GIT_EAMBIGUOUS
+	// ErrorCodeBuffs represents that the output buffer is too short to hold data.
+	ErrorCodeBuffs ErrorCode = C.GIT_EBUFS
 
-	// Generic error
-	ErrGeneric ErrorCode = C.GIT_ERROR
-	// Requested object could not be found
-	ErrNotFound ErrorCode = C.GIT_ENOTFOUND
-	// Object exists preventing operation
-	ErrExists ErrorCode = C.GIT_EEXISTS
-	// More than one object matches
-	ErrAmbiguous ErrorCode = C.GIT_EAMBIGUOUS
-	// (backwards compatibility misspelling)
-	ErrAmbigious ErrorCode = C.GIT_EAMBIGUOUS
-	// Output buffer too short to hold data
-	ErrBuffs ErrorCode = C.GIT_EBUFS
-
-	// GIT_EUSER is a special error that is never generated by libgit2
+	// ErrorCodeUser is a special error that is never generated by libgit2
 	// code.  You can return it from a callback (e.g to stop an iteration)
 	// to know that it was generated by the callback and not by libgit2.
-	ErrUser ErrorCode = C.GIT_EUSER
+	ErrorCodeUser ErrorCode = C.GIT_EUSER
 
-	// Operation not allowed on bare repository
-	ErrBareRepo ErrorCode = C.GIT_EBAREREPO
-	// HEAD refers to branch with no commits
-	ErrUnbornBranch ErrorCode = C.GIT_EUNBORNBRANCH
-	// Merge in progress prevented operation
-	ErrUnmerged ErrorCode = C.GIT_EUNMERGED
-	// Reference was not fast-forwardable
-	ErrNonFastForward ErrorCode = C.GIT_ENONFASTFORWARD
-	// Name/ref spec was not in a valid format
-	ErrInvalidSpec ErrorCode = C.GIT_EINVALIDSPEC
-	// Checkout conflicts prevented operation
-	ErrConflict ErrorCode = C.GIT_ECONFLICT
-	// Lock file prevented operation
-	ErrLocked ErrorCode = C.GIT_ELOCKED
-	// Reference value does not match expected
-	ErrModified ErrorCode = C.GIT_EMODIFIED
-	// Authentication failed
-	ErrAuth ErrorCode = C.GIT_EAUTH
-	// Server certificate is invalid
-	ErrCertificate ErrorCode = C.GIT_ECERTIFICATE
-	// Patch/merge has already been applied
-	ErrApplied ErrorCode = C.GIT_EAPPLIED
-	// The requested peel operation is not possible
-	ErrPeel ErrorCode = C.GIT_EPEEL
-	// Unexpected EOF
-	ErrEOF ErrorCode = C.GIT_EEOF
-	// Uncommitted changes in index prevented operation
-	ErrUncommitted ErrorCode = C.GIT_EUNCOMMITTED
-	// The operation is not valid for a directory
-	ErrDirectory ErrorCode = C.GIT_EDIRECTORY
-	// A merge conflict exists and cannot continue
-	ErrMergeConflict ErrorCode = C.GIT_EMERGECONFLICT
+	// ErrorCodeBareRepo represents that the operation not allowed on bare repository
+	ErrorCodeBareRepo ErrorCode = C.GIT_EBAREREPO
+	// ErrorCodeUnbornBranch represents that HEAD refers to branch with no commits.
+	ErrorCodeUnbornBranch ErrorCode = C.GIT_EUNBORNBRANCH
+	// ErrorCodeUnmerged represents that a merge in progress prevented operation.
+	ErrorCodeUnmerged ErrorCode = C.GIT_EUNMERGED
+	// ErrorCodeNonFastForward represents that the reference was not fast-forwardable.
+	ErrorCodeNonFastForward ErrorCode = C.GIT_ENONFASTFORWARD
+	// ErrorCodeInvalidSpec represents that the name/ref spec was not in a valid format.
+	ErrorCodeInvalidSpec ErrorCode = C.GIT_EINVALIDSPEC
+	// ErrorCodeConflict represents that checkout conflicts prevented operation.
+	ErrorCodeConflict ErrorCode = C.GIT_ECONFLICT
+	// ErrorCodeLocked represents that lock file prevented operation.
+	ErrorCodeLocked ErrorCode = C.GIT_ELOCKED
+	// ErrorCodeModified represents that the reference value does not match expected.
+	ErrorCodeModified ErrorCode = C.GIT_EMODIFIED
+	// ErrorCodeAuth represents that the authentication failed.
+	ErrorCodeAuth ErrorCode = C.GIT_EAUTH
+	// ErrorCodeCertificate represents that the server certificate is invalid.
+	ErrorCodeCertificate ErrorCode = C.GIT_ECERTIFICATE
+	// ErrorCodeApplied represents that the patch/merge has already been applied.
+	ErrorCodeApplied ErrorCode = C.GIT_EAPPLIED
+	// ErrorCodePeel represents that the requested peel operation is not possible.
+	ErrorCodePeel ErrorCode = C.GIT_EPEEL
+	// ErrorCodeEOF represents an unexpected EOF.
+	ErrorCodeEOF ErrorCode = C.GIT_EEOF
+	// ErrorCodeInvalid represents an invalid operation or input.
+	ErrorCodeInvalid ErrorCode = C.GIT_EINVALID
+	// ErrorCodeUIncommitted represents that uncommitted changes in index prevented operation.
+	ErrorCodeUncommitted ErrorCode = C.GIT_EUNCOMMITTED
+	// ErrorCodeDirectory represents that the operation is not valid for a directory.
+	ErrorCodeDirectory ErrorCode = C.GIT_EDIRECTORY
+	// ErrorCodeMergeConflict represents that a merge conflict exists and cannot continue.
+	ErrorCodeMergeConflict ErrorCode = C.GIT_EMERGECONFLICT
 
-	// Internal only
-	ErrPassthrough ErrorCode = C.GIT_PASSTHROUGH
-	// Signals end of iteration with iterator
-	ErrIterOver ErrorCode = C.GIT_ITEROVER
-	// Patch application failed
-	ErrApplyFail ErrorCode = C.GIT_EAPPLYFAIL
+	// ErrorCodePassthrough represents that a user-configured callback refused to act.
+	ErrorCodePassthrough ErrorCode = C.GIT_PASSTHROUGH
+	// ErrorCodeIterOver signals end of iteration with iterator.
+	ErrorCodeIterOver ErrorCode = C.GIT_ITEROVER
+	// ErrorCodeRetry is an internal-only error code.
+	ErrorCodeRetry ErrorCode = C.GIT_RETRY
+	// ErrorCodeMismatch represents a hashsum mismatch in object.
+	ErrorCodeMismatch ErrorCode = C.GIT_EMISMATCH
+	// ErrorCodeIndexDirty represents that unsaved changes in the index would be overwritten.
+	ErrorCodeIndexDirty ErrorCode = C.GIT_EINDEXDIRTY
+	// ErrorCodeApplyFail represents that a patch application failed.
+	ErrorCodeApplyFail ErrorCode = C.GIT_EAPPLYFAIL
 )
 
 var (
@@ -201,7 +206,7 @@ func NewOid(s string) (*Oid, error) {
 	}
 
 	if len(slice) != 20 {
-		return nil, &GitError{"Invalid Oid", ErrClassNone, ErrGeneric}
+		return nil, &GitError{"Invalid Oid", ErrorClassNone, ErrGeneric}
 	}
 
 	copy(o[:], slice[:20])
@@ -269,7 +274,6 @@ func (e GitError) Error() string {
 }
 
 func IsErrorClass(err error, c ErrorClass) bool {
-
 	if err == nil {
 		return false
 	}
@@ -289,20 +293,23 @@ func IsErrorCode(err error, c ErrorCode) bool {
 	return false
 }
 
-func MakeGitError(errorCode C.int) error {
-
+func MakeGitError(c C.int) error {
 	var errMessage string
 	var errClass ErrorClass
-	if errorCode != C.GIT_ITEROVER {
-		err := C.giterr_last()
+	errorCode := ErrorCode(c)
+	if errorCode != ErrorCodeIterOver {
+		err := C.git_error_last()
 		if err != nil {
 			errMessage = C.GoString(err.message)
 			errClass = ErrorClass(err.klass)
 		} else {
-			errClass = ErrClassInvalid
+			errClass = ErrorClassInvalid
 		}
 	}
-	return &GitError{errMessage, errClass, ErrorCode(errorCode)}
+	if errMessage == "" {
+		errMessage = errorCode.String()
+	}
+	return &GitError{errMessage, errClass, errorCode}
 }
 
 func MakeGitError2(err int) error {

git_test.go

@@ -45,16 +45,16 @@ func createBareTestRepo(t *testing.T) *Repository {
 	return repo
 }
 
-// commitOpts contains any extra options for creating commits in the seed repo
-type commitOpts struct {
+// commitOptions contains any extra options for creating commits in the seed repo
+type commitOptions struct {
 	CommitSigningCallback
 }
 
 func seedTestRepo(t *testing.T, repo *Repository) (*Oid, *Oid) {
-	return seedTestRepoOpt(t, repo, commitOpts{})
+	return seedTestRepoOpt(t, repo, commitOptions{})
 }
 
-func seedTestRepoOpt(t *testing.T, repo *Repository, opts commitOpts) (*Oid, *Oid) {
+func seedTestRepoOpt(t *testing.T, repo *Repository, opts commitOptions) (*Oid, *Oid) {
 	loc, err := time.LoadLocation("Europe/Berlin")
 	checkFatal(t, err)
 	sig := &Signature{
@@ -155,7 +155,7 @@ func TestOidZero(t *testing.T) {
 func TestEmptyOid(t *testing.T) {
 	t.Parallel()
 	_, err := NewOid("")
-	if err == nil || !IsErrorCode(err, ErrGeneric) {
+	if err == nil || !IsErrorCode(err, ErrorCodeGeneric) {
 		t.Fatal("Should have returned invalid error")
 	}
 }

index.go

@@ -17,31 +17,33 @@ import (
 
 type IndexMatchedPathCallback func(string, string) int
 
-type IndexAddOpts uint
+// IndexAddOption is a set of flags for APIs that add files matching pathspec.
+type IndexAddOption uint
 
 const (
-	IndexAddDefault              IndexAddOpts = C.GIT_INDEX_ADD_DEFAULT
-	IndexAddForce                IndexAddOpts = C.GIT_INDEX_ADD_FORCE
-	IndexAddDisablePathspecMatch IndexAddOpts = C.GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH
-	IndexAddCheckPathspec        IndexAddOpts = C.GIT_INDEX_ADD_CHECK_PATHSPEC
+	IndexAddDefault              IndexAddOption = C.GIT_INDEX_ADD_DEFAULT
+	IndexAddForce                IndexAddOption = C.GIT_INDEX_ADD_FORCE
+	IndexAddDisablePathspecMatch IndexAddOption = C.GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH
+	IndexAddCheckPathspec        IndexAddOption = C.GIT_INDEX_ADD_CHECK_PATHSPEC
 )
 
-type IndexStageOpts int
+// IndexStageState indicates the state of the git index.
+type IndexStageState int
 
 const (
 	// IndexStageAny matches any index stage.
 	//
 	// Some index APIs take a stage to match; pass this value to match
 	// any entry matching the path regardless of stage.
-	IndexStageAny IndexStageOpts = C.GIT_INDEX_STAGE_ANY
+	IndexStageAny IndexStageState = C.GIT_INDEX_STAGE_ANY
 	// IndexStageNormal is a normal staged file in the index.
-	IndexStageNormal IndexStageOpts = C.GIT_INDEX_STAGE_NORMAL
+	IndexStageNormal IndexStageState = C.GIT_INDEX_STAGE_NORMAL
 	// IndexStageAncestor is the ancestor side of a conflict.
-	IndexStageAncestor IndexStageOpts = C.GIT_INDEX_STAGE_ANCESTOR
+	IndexStageAncestor IndexStageState = C.GIT_INDEX_STAGE_ANCESTOR
 	// IndexStageOurs is the "ours" side of a conflict.
-	IndexStageOurs IndexStageOpts = C.GIT_INDEX_STAGE_OURS
+	IndexStageOurs IndexStageState = C.GIT_INDEX_STAGE_OURS
 	// IndexStageTheirs is the "theirs" side of a conflict.
-	IndexStageTheirs IndexStageOpts = C.GIT_INDEX_STAGE_THEIRS
+	IndexStageTheirs IndexStageState = C.GIT_INDEX_STAGE_THEIRS
 )
 
 type Index struct {
@@ -219,7 +221,7 @@ func (v *Index) AddFromBuffer(entry *IndexEntry, buffer []byte) error {
 	return nil
 }
 
-func (v *Index) AddAll(pathspecs []string, flags IndexAddOpts, callback IndexMatchedPathCallback) error {
+func (v *Index) AddAll(pathspecs []string, flags IndexAddOption, callback IndexMatchedPathCallback) error {
 	cpathspecs := C.git_strarray{}
 	cpathspecs.count = C.size_t(len(pathspecs))
 	cpathspecs.strings = makeCStringsFromStrings(pathspecs)

indexer_test.go

@@ -35,7 +35,7 @@ func TestIndexerOutOfOrder(t *testing.T) {
 	var finalStats TransferProgress
 	idx, err := NewIndexer(tmpPath, nil, func(stats TransferProgress) ErrorCode {
 		finalStats = stats
-		return ErrOk
+		return ErrorCodeOK
 	})
 	checkFatal(t, err)
 	defer idx.Free()

mempack_test.go

@@ -53,7 +53,7 @@ func TestMempack(t *testing.T) {
 		if err == nil {
 			t.Errorf("object %s unexpectedly found", obj.Id().String())
 			obj.Free()
-		} else if !IsErrorCode(err, ErrNotFound) {
+		} else if !IsErrorCode(err, ErrorCodeNotFound) {
 			t.Errorf("unexpected error %v", err)
 		}
 	}

merge.go

@@ -195,20 +195,20 @@ const (
 	MergeFileFavorUnion  MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_UNION
 )
 
-func (r *Repository) Merge(theirHeads []*AnnotatedCommit, mergeOptions *MergeOptions, checkoutOptions *CheckoutOpts) error {
+func (r *Repository) Merge(theirHeads []*AnnotatedCommit, mergeOptions *MergeOptions, checkoutOptions *CheckoutOptions) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
 	cMergeOpts := mergeOptions.toC()
-	cCheckoutOpts := checkoutOptions.toC()
-	defer freeCheckoutOpts(cCheckoutOpts)
+	cCheckoutOptions := checkoutOptions.toC()
+	defer freeCheckoutOptions(cCheckoutOptions)
 
 	gmerge_head_array := make([]*C.git_annotated_commit, len(theirHeads))
 	for i := 0; i < len(theirHeads); i++ {
 		gmerge_head_array[i] = theirHeads[i].ptr
 	}
 	ptr := unsafe.Pointer(&gmerge_head_array[0])
-	err := C.git_merge(r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)), cMergeOpts, cCheckoutOpts)
+	err := C.git_merge(r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)), cMergeOpts, cCheckoutOptions)
 	runtime.KeepAlive(theirHeads)
 	if err < 0 {
 		return MakeGitError(err)

note_test.go

@@ -49,7 +49,7 @@ func TestNoteIterator(t *testing.T) {
 	for {
 		noteId, commitId, err := iter.Next()
 		if err != nil {
-			if !IsErrorCode(err, ErrIterOver) {
+			if !IsErrorCode(err, ErrorCodeIterOver) {
 				checkFatal(t, err)
 			}
 			break

object.go

@@ -201,13 +201,13 @@ func (o *Object) Free() {
 
 // Peel recursively peels an object until an object of the specified type is met.
 //
-// If the query cannot be satisfied due to the object model, ErrInvalidSpec
+// If the query cannot be satisfied due to the object model, ErrorCodeInvalidSpec
 // will be returned (e.g. trying to peel a blob to a tree).
 //
 // If you pass ObjectAny as the target type, then the object will be peeled
 // until the type changes. A tag will be peeled until the referenced object
 // is no longer a tag, and a commit will be peeled to a tree. Any other object
-// type will return ErrInvalidSpec.
+// type will return ErrorCodeInvalidSpec.
 //
 // If peeling a tag we discover an object which cannot be peeled to the target
 // type due to the object model, an error will be returned.

object_test.go

@@ -153,8 +153,8 @@ func TestObjectPeel(t *testing.T) {
 
 	obj, err = commit.Peel(ObjectTag)
 
-	if !IsErrorCode(err, ErrInvalidSpec) {
-		t.Fatalf("Wrong error when peeling a commit to a tag, expected ErrInvalidSpec, have %v", err)
+	if !IsErrorCode(err, ErrorCodeInvalidSpec) {
+		t.Fatalf("Wrong error when peeling a commit to a tag, expected ErrorCodeInvalidSpec, have %v", err)
 	}
 
 	tree, err := repo.LookupTree(treeID)
@@ -162,8 +162,8 @@ func TestObjectPeel(t *testing.T) {
 
 	obj, err = tree.Peel(ObjectAny)
 
-	if !IsErrorCode(err, ErrInvalidSpec) {
-		t.Fatalf("Wrong error when peeling a tree, expected ErrInvalidSpec, have %v", err)
+	if !IsErrorCode(err, ErrorCodeInvalidSpec) {
+		t.Fatalf("Wrong error when peeling a tree, expected ErrorCodeInvalidSpec, have %v", err)
 	}
 
 	entry := tree.EntryByName("README")
@@ -173,8 +173,8 @@ func TestObjectPeel(t *testing.T) {
 
 	obj, err = blob.Peel(ObjectAny)
 
-	if !IsErrorCode(err, ErrInvalidSpec) {
-		t.Fatalf("Wrong error when peeling a blob, expected ErrInvalidSpec, have %v", err)
+	if !IsErrorCode(err, ErrorCodeInvalidSpec) {
+		t.Fatalf("Wrong error when peeling a blob, expected ErrorCodeInvalidSpec, have %v", err)
 	}
 
 	tagID := createTestTag(t, repo, commit)

odb_test.go

@@ -169,7 +169,7 @@ func TestOdbWritepack(t *testing.T) {
 	var finalStats TransferProgress
 	writepack, err := odb.NewWritePack(func(stats TransferProgress) ErrorCode {
 		finalStats = stats
-		return ErrOk
+		return ErrorCodeOK
 	})
 	checkFatal(t, err)
 	defer writepack.Free()

rebase.go

@@ -129,7 +129,7 @@ type RebaseOptions struct {
 	InMemory              int
 	RewriteNotesRef       string
 	MergeOptions          MergeOptions
-	CheckoutOptions       CheckoutOpts
+	CheckoutOptions       CheckoutOptions
 	CommitSigningCallback CommitSigningCallback
 }
 

rebase_test.go

@@ -38,12 +38,12 @@ func TestRebaseAbort(t *testing.T) {
 	seedTestRepo(t, repo)
 
 	// Setup a repo with 2 branches and a different tree
-	err := setupRepoForRebase(repo, masterCommit, branchName, commitOpts{})
+	err := setupRepoForRebase(repo, masterCommit, branchName, commitOptions{})
 	checkFatal(t, err)
 
 	// Create several commits in emile
 	for _, commit := range emileCommits {
-		_, err = commitSomething(repo, commit, commit, commitOpts{})
+		_, err = commitSomething(repo, commit, commit, commitOptions{})
 		checkFatal(t, err)
 	}
 
@@ -99,12 +99,12 @@ func TestRebaseNoConflicts(t *testing.T) {
 	}
 
 	// Setup a repo with 2 branches and a different tree
-	err = setupRepoForRebase(repo, masterCommit, branchName, commitOpts{})
+	err = setupRepoForRebase(repo, masterCommit, branchName, commitOptions{})
 	checkFatal(t, err)
 
 	// Create several commits in emile
 	for _, commit := range emileCommits {
-		_, err = commitSomething(repo, commit, commit, commitOpts{})
+		_, err = commitSomething(repo, commit, commit, commitOptions{})
 		checkFatal(t, err)
 	}
 
@@ -143,7 +143,7 @@ func TestRebaseGpgSigned(t *testing.T) {
 	entity, err := openpgp.NewEntity("Namey mcnameface", "test comment", "test@example.com", nil)
 	checkFatal(t, err)
 
-	opts, err := DefaultRebaseOptions()
+	rebaseOpts, err := DefaultRebaseOptions()
 	checkFatal(t, err)
 
 	signCommitContent := func(commitContent string) (string, string, error) {
@@ -155,9 +155,9 @@ func TestRebaseGpgSigned(t *testing.T) {
 
 		return cipherText.String(), "", nil
 	}
-	opts.CommitSigningCallback = signCommitContent
+	rebaseOpts.CommitSigningCallback = signCommitContent
 
-	commitOpts := commitOpts{
+	commitOpts := commitOptions{
 		CommitSigningCallback: signCommitContent,
 	}
 
@@ -201,7 +201,7 @@ func TestRebaseGpgSigned(t *testing.T) {
 	}
 
 	// Rebase onto master
-	rebase, err := performRebaseOnto(repo, "master", &opts)
+	rebase, err := performRebaseOnto(repo, "master", &rebaseOpts)
 	checkFatal(t, err)
 	defer rebase.Free()
 
@@ -255,7 +255,7 @@ func checkCommitSigned(t *testing.T, entity *openpgp.Entity, commit *Commit) err
 }
 
 // Utils
-func setupRepoForRebase(repo *Repository, masterCommit, branchName string, opts commitOpts) error {
+func setupRepoForRebase(repo *Repository, masterCommit, branchName string, commitOpts commitOptions) error {
 	// Create a new branch from master
 	err := createBranch(repo, branchName)
 	if err != nil {
@@ -263,7 +263,7 @@ func setupRepoForRebase(repo *Repository, masterCommit, branchName string, opts
 	}
 
 	// Create a commit in master
-	_, err = commitSomething(repo, masterCommit, masterCommit, opts)
+	_, err = commitSomething(repo, masterCommit, masterCommit, commitOpts)
 	if err != nil {
 		return err
 	}
@@ -282,7 +282,7 @@ func setupRepoForRebase(repo *Repository, masterCommit, branchName string, opts
 	return nil
 }
 
-func performRebaseOnto(repo *Repository, branch string, opts *RebaseOptions) (*Rebase, error) {
+func performRebaseOnto(repo *Repository, branch string, rebaseOpts *RebaseOptions) (*Rebase, error) {
 	master, err := repo.LookupBranch(branch, BranchLocal)
 	if err != nil {
 		return nil, err
@@ -296,7 +296,7 @@ func performRebaseOnto(repo *Repository, branch string, opts *RebaseOptions) (*R
 	defer onto.Free()
 
 	// Init rebase
-	rebase, err := repo.InitRebase(nil, nil, onto, opts)
+	rebase, err := repo.InitRebase(nil, nil, onto, rebaseOpts)
 	if err != nil {
 		return nil, err
 	}
@@ -397,7 +397,7 @@ func headTree(repo *Repository) (*Tree, error) {
 	return tree, nil
 }
 
-func commitSomething(repo *Repository, something, content string, commitOpts commitOpts) (*Oid, error) {
+func commitSomething(repo *Repository, something, content string, commitOpts commitOptions) (*Oid, error) {
 	headCommit, err := headCommit(repo)
 	if err != nil {
 		return nil, err
@@ -470,10 +470,10 @@ func commitSomething(repo *Repository, something, content string, commitOpts com
 		}
 	}
 
-	opts := &CheckoutOpts{
+	checkoutOpts := &CheckoutOptions{
 		Strategy: CheckoutRemoveUntracked | CheckoutForce,
 	}
-	err = repo.CheckoutIndex(index, opts)
+	err = repo.CheckoutIndex(index, checkoutOpts)
 	if err != nil {
 		return nil, err
 	}

reference.go

@@ -424,7 +424,7 @@ func (i *ReferenceIterator) Names() *ReferenceNameIterator {
 }
 
 // NextName retrieves the next reference name. If the iteration is over,
-// the returned error is git.ErrIterOver
+// the returned error code is git.ErrorCodeIterOver
 func (v *ReferenceNameIterator) Next() (string, error) {
 	var ptr *C.char
 
@@ -440,7 +440,7 @@ func (v *ReferenceNameIterator) Next() (string, error) {
 }
 
 // Next retrieves the next reference. If the iterationis over, the
-// returned error is git.ErrIterOver
+// returned error code is git.ErrorCodeIterOver
 func (v *ReferenceIterator) Next() (*Reference, error) {
 	var ptr *C.git_reference
 
@@ -470,7 +470,7 @@ func (v *ReferenceIterator) Free() {
 	C.git_reference_iterator_free(v.ptr)
 }
 
-// ReferenceIsValidName ensures the reference name is well-formed.
+// ReferenceIsValidName returns whether the reference name is well-formed.
 //
 // Valid reference names must follow one of two patterns:
 //
@@ -483,10 +483,8 @@ func (v *ReferenceIterator) Free() {
 func ReferenceIsValidName(name string) bool {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
-	if C.git_reference_is_valid_name(cname) == 1 {
-		return true
-	}
-	return false
+
+	return C.git_reference_is_valid_name(cname) == 1
 }
 
 const (

reference_test.go

@@ -106,7 +106,7 @@ func TestReferenceIterator(t *testing.T) {
 		list = append(list, name)
 		name, err = nameIter.Next()
 	}
-	if !IsErrorCode(err, ErrIterOver) {
+	if !IsErrorCode(err, ErrorCodeIterOver) {
 		t.Fatal("Iteration not over")
 	}
 
@@ -122,7 +122,7 @@ func TestReferenceIterator(t *testing.T) {
 		count++
 		_, err = iter.Next()
 	}
-	if !IsErrorCode(err, ErrIterOver) {
+	if !IsErrorCode(err, ErrorCodeIterOver) {
 		t.Fatal("Iteration not over")
 	}
 
@@ -242,7 +242,7 @@ func TestReferenceNormalizeName(t *testing.T) {
 	}
 
 	ref, err = ReferenceNormalizeName("foo^", ReferenceFormatNormal)
-	if !IsErrorCode(err, ErrInvalidSpec) {
+	if !IsErrorCode(err, ErrorCodeInvalidSpec) {
 		t.Errorf("foo^ should be invalid")
 	}
 }

remote.go

@@ -51,7 +51,7 @@ const (
 
 type TransportMessageCallback func(str string) ErrorCode
 type CompletionCallback func(RemoteCompletion) ErrorCode
-type CredentialsCallback func(url string, username_from_url string, allowed_types CredType) (*Cred, error)
+type CredentialsCallback func(url string, username_from_url string, allowed_types CredentialType) (*Credential, error)
 type TransferProgressCallback func(stats TransferProgress) ErrorCode
 type UpdateTipsCallback func(refname string, a *Oid, b *Oid) ErrorCode
 type CertificateCheckCallback func(cert *Certificate, valid bool, hostname string) ErrorCode
@@ -243,14 +243,14 @@ func completionCallback(completion_type C.git_remote_completion_type, data unsaf
 }
 
 //export credentialsCallback
-func credentialsCallback(_cred **C.git_cred, _url *C.char, _username_from_url *C.char, allowed_types uint, data unsafe.Pointer) int {
+func credentialsCallback(_cred **C.git_credential, _url *C.char, _username_from_url *C.char, allowed_types uint, data unsafe.Pointer) int {
 	callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
 	if callbacks.CredentialsCallback == nil {
 		return C.GIT_PASSTHROUGH
 	}
 	url := C.GoString(_url)
 	username_from_url := C.GoString(_username_from_url)
-	cred, err := callbacks.CredentialsCallback(url, username_from_url, (CredType)(allowed_types))
+	cred, err := callbacks.CredentialsCallback(url, username_from_url, (CredentialType)(allowed_types))
 	if err != nil {
 		if gitError, ok := err.(*GitError); ok {
 			return int(gitError.Code)
@@ -322,7 +322,7 @@ func certificateCheckCallback(_cert *C.git_cert, _valid C.int, _host *C.char, da
 		C.memcpy(unsafe.Pointer(&cert.Hostkey.HashSHA256[0]), unsafe.Pointer(&ccert.hash_sha256[0]), C.size_t(len(cert.Hostkey.HashSHA256)))
 	} else {
 		cstr := C.CString("Unsupported certificate type")
-		C.giterr_set_str(C.GITERR_NET, cstr)
+		C.git_error_set_str(C.GITERR_NET, cstr)
 		C.free(unsafe.Pointer(cstr))
 		return -1 // we don't support anything else atm
 	}
@@ -376,13 +376,12 @@ func freeProxyOptions(ptr *C.git_proxy_options) {
 	C.free(unsafe.Pointer(ptr.url))
 }
 
+// RemoteIsValidName returns whether the remote name is well-formed.
 func RemoteIsValidName(name string) bool {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
-	if C.git_remote_is_valid_name(cname) == 1 {
-		return true
-	}
-	return false
+
+	return C.git_remote_is_valid_name(cname) == 1
 }
 
 func (r *Remote) Free() {
@@ -406,7 +405,7 @@ func (c *RemoteCollection) List() ([]string, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_strarray_free(&r)
+	defer C.git_strarray_dispose(&r)
 
 	remotes := makeStringsFromCStrings(r.strings, int(r.count))
 	return remotes, nil
@@ -640,7 +639,7 @@ func (o *Remote) FetchRefspecs() ([]string, error) {
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
-	defer C.git_strarray_free(&crefspecs)
+	defer C.git_strarray_dispose(&crefspecs)
 
 	refspecs := makeStringsFromCStrings(crefspecs.strings, int(crefspecs.count))
 	return refspecs, nil
@@ -673,7 +672,7 @@ func (o *Remote) PushRefspecs() ([]string, error) {
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
-	defer C.git_strarray_free(&crefspecs)
+	defer C.git_strarray_dispose(&crefspecs)
 	runtime.KeepAlive(o)
 
 	refspecs := makeStringsFromCStrings(crefspecs.strings, int(crefspecs.count))

remote_test.go

@@ -27,7 +27,7 @@ func TestListRemotes(t *testing.T) {
 func assertHostname(cert *Certificate, valid bool, hostname string, t *testing.T) ErrorCode {
 	if hostname != "github.com" {
 		t.Fatal("Hostname does not match")
-		return ErrUser
+		return ErrorCodeUser
 	}
 
 	return 0

reset.go

@@ -14,7 +14,7 @@ const (
 	ResetHard  ResetType = C.GIT_RESET_HARD
 )
 
-func (r *Repository) ResetToCommit(commit *Commit, resetType ResetType, opts *CheckoutOpts) error {
+func (r *Repository) ResetToCommit(commit *Commit, resetType ResetType, opts *CheckoutOptions) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 	ret := C.git_reset(r.ptr, commit.ptr, C.git_reset_t(resetType), opts.toC())

reset_test.go

@@ -37,7 +37,7 @@ func TestResetToCommit(t *testing.T) {
 	commitToResetTo, err := repo.LookupCommit(commitId)
 	checkFatal(t, err)
 
-	repo.ResetToCommit(commitToResetTo, ResetHard, &CheckoutOpts{})
+	repo.ResetToCommit(commitToResetTo, ResetHard, &CheckoutOptions{})
 
 	// check that the file now reads "testing reset" like it did before
 	bytes, err := ioutil.ReadFile(pathInRepo(repo, "README"))

revert.go

@@ -12,7 +12,7 @@ import (
 type RevertOptions struct {
 	Mainline     uint
 	MergeOpts    MergeOptions
-	CheckoutOpts CheckoutOpts
+	CheckoutOpts CheckoutOptions
 }
 
 func (opts *RevertOptions) toC() *C.git_revert_options {
@@ -33,7 +33,7 @@ func revertOptionsFromC(opts *C.git_revert_options) RevertOptions {
 }
 
 func freeRevertOptions(opts *C.git_revert_options) {
-	freeCheckoutOpts(&opts.checkout_opts)
+	freeCheckoutOptions(&opts.checkout_opts)
 }
 
 // DefaultRevertOptions initialises a RevertOptions struct with default values

script/build-libgit2.sh

@@ -68,6 +68,7 @@ cmake -DTHREADSAFE=ON \
       -DCMAKE_BUILD_TYPE="RelWithDebInfo" \
       -DCMAKE_INSTALL_PREFIX="${BUILD_INSTALL_PREFIX}" \
       -DCMAKE_INSTALL_LIBDIR="lib" \
+      -DDEPRECATE_HARD=ON \
       "${VENDORED_PATH}" &&
 
 exec cmake --build . --target install

stash.go

@@ -140,7 +140,7 @@ func stashApplyProgressCb(progress C.git_stash_apply_progress_t, handle unsafe.P
 // StashApplyOptions represents options to control the apply operation.
 type StashApplyOptions struct {
 	Flags            StashApplyFlag
-	CheckoutOptions  CheckoutOpts               // options to use when writing files to the working directory
+	CheckoutOptions  CheckoutOptions            // options to use when writing files to the working directory
 	ProgressCallback StashApplyProgressCallback // optional callback to notify the consumer of application progress
 }
 
@@ -173,7 +173,7 @@ func (opts *StashApplyOptions) toC() (
 			version: C.GIT_STASH_APPLY_OPTIONS_VERSION,
 			flags:   C.uint32_t(opts.Flags),
 		}
-		populateCheckoutOpts(&optsC.checkout_options, &opts.CheckoutOptions)
+		populateCheckoutOptions(&optsC.checkout_options, &opts.CheckoutOptions)
 		if opts.ProgressCallback != nil {
 			C._go_git_setup_stash_apply_progress_callbacks(optsC)
 			optsC.progress_payload = pointerHandles.Track(progressData)
@@ -191,21 +191,21 @@ func untrackStashApplyOptionsCallback(optsC *C.git_stash_apply_options) {
 
 func freeStashApplyOptions(optsC *C.git_stash_apply_options) {
 	if optsC != nil {
-		freeCheckoutOpts(&optsC.checkout_options)
+		freeCheckoutOptions(&optsC.checkout_options)
 	}
 }
 
 // Apply applies a single stashed state from the stash list.
 //
 // If local changes in the working directory conflict with changes in the
-// stash then ErrConflict will be returned.  In this case, the index
+// stash then ErrorCodeConflict will be returned.  In this case, the index
 // will always remain unmodified and all files in the working directory will
 // remain unmodified.  However, if you are restoring untracked files or
 // ignored files and there is a conflict when applying the modified files,
 // then those files will remain in the working directory.
 //
 // If passing the StashApplyReinstateIndex flag and there would be conflicts
-// when reinstating the index, the function will return ErrConflict
+// when reinstating the index, the function will return ErrorCodeConflict
 // and both the working directory and index will be left unmodified.
 //
 // Note that a minimum checkout strategy of 'CheckoutSafe' is implied.
@@ -213,12 +213,12 @@ func freeStashApplyOptions(optsC *C.git_stash_apply_options) {
 // 'index' is the position within the stash list. 0 points to the most
 // recent stashed state.
 //
-// Returns error code ErrNotFound if there's no stashed state for the given
-// index, error code ErrConflict if local changes in the working directory
+// Returns error code ErrorCodeNotFound if there's no stashed state for the given
+// index, error code ErrorCodeConflict if local changes in the working directory
 // conflict with changes in the stash, the user returned error from the
 // StashApplyProgressCallback, if any, or other error code.
 //
-// Error codes can be interogated with IsErrorCode(err, ErrNotFound).
+// Error codes can be interogated with IsErrorCode(err, ErrorCodeNotFound).
 func (c *StashCollection) Apply(index int, opts StashApplyOptions) error {
 	optsC, progressData := opts.toC()
 	defer untrackStashApplyOptionsCallback(optsC)
@@ -298,7 +298,7 @@ func (c *StashCollection) Foreach(callback StashCallback) error {
 // 'index' is the position within the stash list. 0 points
 // to the most recent stashed state.
 //
-// Returns error code ErrNotFound if there's no stashed
+// Returns error code ErrorCodeNotFound if there's no stashed
 // state for the given index.
 func (c *StashCollection) Drop(index int) error {
 	runtime.LockOSThread()
@@ -320,7 +320,7 @@ func (c *StashCollection) Drop(index int) error {
 //
 // 'opts' controls how stashes are applied.
 //
-// Returns error code ErrNotFound if there's no stashed
+// Returns error code ErrorCodeNotFound if there's no stashed
 // state for the given index.
 func (c *StashCollection) Pop(index int, opts StashApplyOptions) error {
 	optsC, progressData := opts.toC()

stash_test.go

@@ -56,8 +56,8 @@ func TestStash(t *testing.T) {
 	// Apply: no stash for the given index
 
 	err = repo.Stashes.Apply(1, opts)
-	if !IsErrorCode(err, ErrNotFound) {
-		t.Errorf("expecting GIT_ENOTFOUND error code %d, got %v", ErrNotFound, err)
+	if !IsErrorCode(err, ErrorCodeNotFound) {
+		t.Errorf("expecting GIT_ENOTFOUND error code %d, got %v", ErrorCodeNotFound, err)
 	}
 
 	// Apply: callback stopped

submodule.go

@@ -106,20 +106,21 @@ func (c *SubmoduleCollection) Lookup(name string) (*Submodule, error) {
 	return newSubmoduleFromC(ptr, c.repo), nil
 }
 
-type SubmoduleCbk func(sub *Submodule, name string) int
+// SubmoduleCallback is a function that is called for every submodule found in SubmoduleCollection.Foreach.
+type SubmoduleCallback func(sub *Submodule, name string) int
 
-//export SubmoduleVisitor
-func SubmoduleVisitor(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer) C.int {
+//export submoduleCallback
+func submoduleCallback(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer) C.int {
 	sub := &Submodule{(*C.git_submodule)(csub), nil}
 
-	if callback, ok := pointerHandles.Get(handle).(SubmoduleCbk); ok {
+	if callback, ok := pointerHandles.Get(handle).(SubmoduleCallback); ok {
 		return (C.int)(callback(sub, C.GoString(name)))
 	} else {
 		panic("invalid submodule visitor callback")
 	}
 }
 
-func (c *SubmoduleCollection) Foreach(cbk SubmoduleCbk) error {
+func (c *SubmoduleCollection) Foreach(cbk SubmoduleCallback) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
@@ -366,7 +367,7 @@ func populateSubmoduleUpdateOptions(ptr *C.git_submodule_update_options, opts *S
 		return nil
 	}
 
-	populateCheckoutOpts(&ptr.checkout_opts, opts.CheckoutOpts)
+	populateCheckoutOptions(&ptr.checkout_opts, opts.CheckoutOpts)
 	populateFetchOptions(&ptr.fetch_opts, opts.FetchOptions)
 
 	return nil

tag.go

@@ -159,7 +159,7 @@ func (c *TagsCollection) List() ([]string, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_strarray_free(&strC)
+	defer C.git_strarray_dispose(&strC)
 
 	tags := makeStringsFromCStrings(strC.strings, int(strC.count))
 	return tags, nil
@@ -183,7 +183,7 @@ func (c *TagsCollection) ListWithMatch(pattern string) ([]string, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_strarray_free(&strC)
+	defer C.git_strarray_dispose(&strC)
 
 	tags := makeStringsFromCStrings(strC.strings, int(strC.count))
 	return tags, nil

tree.go

@@ -121,8 +121,8 @@ func (t *Tree) EntryCount() uint64 {
 
 type TreeWalkCallback func(string, *TreeEntry) int
 
-//export CallbackGitTreeWalk
-func CallbackGitTreeWalk(_root *C.char, entry *C.git_tree_entry, ptr unsafe.Pointer) C.int {
+//export treeWalkCallback
+func treeWalkCallback(_root *C.char, entry *C.git_tree_entry, ptr unsafe.Pointer) C.int {
 	root := C.GoString(_root)
 
 	if callback, ok := pointerHandles.Get(ptr).(TreeWalkCallback); ok {

walk.go

@@ -182,7 +182,7 @@ func (v *RevWalk) Iterate(fun RevWalkIterator) (err error) {
 	oid := new(Oid)
 	for {
 		err = v.Next(oid)
-		if IsErrorCode(err, ErrIterOver) {
+		if IsErrorCode(err, ErrorCodeIterOver) {
 			return nil
 		}
 		if err != nil {

wrapper.c

@@ -30,12 +30,12 @@ void _go_git_populate_checkout_cb(git_checkout_options *opts)
 
 int _go_git_visit_submodule(git_repository *repo, void *fct)
 {
-	  return git_submodule_foreach(repo, (gogit_submodule_cbk)&SubmoduleVisitor, fct);
+	  return git_submodule_foreach(repo, (gogit_submodule_cbk)&submoduleCallback, fct);
 }
 
 int _go_git_treewalk(git_tree *tree, git_treewalk_mode mode, void *ptr)
 {
-	return git_tree_walk(tree, mode, (git_treewalk_cb)&CallbackGitTreeWalk, ptr);
+	return git_tree_walk(tree, mode, (git_treewalk_cb)&treeWalkCallback, ptr);
 }
 
 int _go_git_packbuilder_foreach(git_packbuilder *pb, void *payload)
@@ -117,7 +117,7 @@ void _go_git_setup_callbacks(git_remote_callbacks *callbacks) {
 
 	callbacks->sideband_progress = (git_transport_message_cb)sidebandProgressCallback;
 	callbacks->completion = (completion_cb)completionCallback;
-	callbacks->credentials = (git_cred_acquire_cb)credentialsCallback;
+	callbacks->credentials = (git_credential_acquire_cb)credentialsCallback;
 	callbacks->transfer_progress = (git_transfer_progress_cb)transferProgressCallback;
 	callbacks->update_tips = (update_tips_cb)updateTipsCallback;
 	callbacks->certificate_check = (git_transport_certificate_check_cb) certificateCheckCallback;
@@ -192,7 +192,7 @@ void _go_git_writestream_free(git_writestream *stream)
 	stream->free(stream);
 }
 
-git_credtype_t _go_git_cred_credtype(git_cred *cred) {
+git_credential_t _go_git_credential_credtype(git_credential *cred) {
 	return cred->credtype;
 }