summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--branch.go95
-rw-r--r--branch_test.go26
-rw-r--r--git.go121
-rw-r--r--git_test.go7
-rw-r--r--index.go4
-rw-r--r--push_test.go2
-rw-r--r--reference.go74
-rw-r--r--reference_test.go33
-rw-r--r--remote.go32
-rw-r--r--repository.go2
-rw-r--r--walk.go5
-rw-r--r--wrapper.c3
12 files changed, 280 insertions, 124 deletions
diff --git a/branch.go b/branch.go
index bd7312b..af21140 100644
--- a/branch.go
+++ b/branch.go
@@ -20,10 +20,70 @@ const (
)
type Branch struct {
- Reference
+ *Reference
}
-func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Reference, error) {
+func (r *Reference) Branch() *Branch {
+ return &Branch{Reference: r}
+}
+
+type BranchIterator struct {
+ ptr *C.git_branch_iterator
+ repo *Repository
+}
+
+type BranchInfo struct {
+ Branch *Branch
+ Type BranchType
+}
+
+func newBranchIteratorFromC(repo *Repository, ptr *C.git_branch_iterator) *BranchIterator {
+ i := &BranchIterator{repo: repo, ptr: ptr}
+ runtime.SetFinalizer(i, (*BranchIterator).Free)
+ return i
+}
+
+func (i *BranchIterator) Next() (*Branch, BranchType, error) {
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var refPtr *C.git_reference
+ var refType C.git_branch_t
+
+ ecode := C.git_branch_next(&refPtr, &refType, i.ptr)
+
+ if ecode < 0 {
+ return nil, BranchLocal, MakeGitError(ecode)
+ }
+
+ branch := newReferenceFromC(refPtr).Branch()
+
+ return branch, BranchType(refType), nil
+}
+
+func (i *BranchIterator) Free() {
+ runtime.SetFinalizer(i, nil)
+ C.git_branch_iterator_free(i.ptr)
+}
+
+func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, error) {
+
+ refType := C.git_branch_t(flags)
+ var ptr *C.git_branch_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_branch_iterator_new(&ptr, repo.ptr, refType)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newBranchIteratorFromC(repo, ptr), nil
+}
+
+func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Branch, error) {
ref := new(Reference)
cBranchName := C.CString(branchName)
@@ -47,14 +107,14 @@ func (repo *Repository) CreateBranch(branchName string, target *Commit, force bo
if ret < 0 {
return nil, MakeGitError(ret)
}
- return ref, nil
+ return ref.Branch(), nil
}
func (b *Branch) Delete() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_delete(b.ptr)
+ ret := C.git_branch_delete(b.Reference.ptr)
if ret < 0 {
return MakeGitError(ret)
}
@@ -62,7 +122,7 @@ func (b *Branch) Delete() error {
}
func (b *Branch) Move(newBranchName string, force bool, signature *Signature, msg string) (*Branch, error) {
- newBranch := new(Branch)
+ var ptr *C.git_reference
cNewBranchName := C.CString(newBranchName)
cForce := cbool(force)
@@ -80,11 +140,11 @@ func (b *Branch) Move(newBranchName string, force bool, signature *Signature, ms
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_move(&newBranch.ptr, b.ptr, cNewBranchName, cForce, cSignature, cmsg)
+ ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce, cSignature, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
- return newBranch, nil
+ return newReferenceFromC(ptr).Branch(), nil
}
func (b *Branch) IsHead() (bool, error) {
@@ -92,7 +152,7 @@ func (b *Branch) IsHead() (bool, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_is_head(b.ptr)
+ ret := C.git_branch_is_head(b.Reference.ptr)
switch ret {
case 1:
return true, nil
@@ -104,17 +164,18 @@ func (b *Branch) IsHead() (bool, error) {
}
func (repo *Repository) LookupBranch(branchName string, bt BranchType) (*Branch, error) {
- branch := new(Branch)
+ var ptr *C.git_reference
+
cName := C.CString(branchName)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_lookup(&branch.ptr, repo.ptr, cName, C.git_branch_t(bt))
+ ret := C.git_branch_lookup(&ptr, repo.ptr, cName, C.git_branch_t(bt))
if ret < 0 {
return nil, MakeGitError(ret)
}
- return branch, nil
+ return newReferenceFromC(ptr).Branch(), nil
}
func (b *Branch) Name() (string, error) {
@@ -124,7 +185,7 @@ func (b *Branch) Name() (string, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_name(&cName, b.ptr)
+ ret := C.git_branch_name(&cName, b.Reference.ptr)
if ret < 0 {
return "", MakeGitError(ret)
}
@@ -155,24 +216,24 @@ func (b *Branch) SetUpstream(upstreamName string) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_set_upstream(b.ptr, cName)
+ ret := C.git_branch_set_upstream(b.Reference.ptr, cName)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
-func (b *Branch) Upstream() (*Branch, error) {
- upstream := new(Branch)
+func (b *Branch) Upstream() (*Reference, error) {
+ var ptr *C.git_reference
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_branch_upstream(&upstream.ptr, b.ptr)
+ ret := C.git_branch_upstream(&ptr, b.Reference.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
- return upstream, nil
+ return newReferenceFromC(ptr), nil
}
func (repo *Repository) UpstreamName(canonicalBranchName string) (string, error) {
diff --git a/branch_test.go b/branch_test.go
new file mode 100644
index 0000000..44f6338
--- /dev/null
+++ b/branch_test.go
@@ -0,0 +1,26 @@
+package git
+
+import (
+ "testing"
+)
+
+func TestBranchIterator(t *testing.T) {
+
+ repo := createTestRepo(t)
+ seedTestRepo(t, repo)
+
+ i, err := repo.NewBranchIterator(BranchLocal)
+ checkFatal(t, err)
+
+ b, bt, err := i.Next()
+ checkFatal(t, err)
+ if name, _ := b.Name(); name != "master" {
+ t.Fatalf("expected master")
+ } else if bt != BranchLocal {
+ t.Fatalf("expected BranchLocal, not %v", t)
+ }
+ b, bt, err = i.Next()
+ if !IsErrorCode(err, ErrIterOver) {
+ t.Fatal("expected iterover")
+ }
+}
diff --git a/git.go b/git.go
index 8159244..2afbfaa 100644
--- a/git.go
+++ b/git.go
@@ -15,14 +15,78 @@ import (
"unsafe"
)
+type ErrorClass int
+
const (
- ITEROVER = C.GIT_ITEROVER
- EEXISTS = C.GIT_EEXISTS
- ENOTFOUND = C.GIT_ENOTFOUND
+ ErrClassNone ErrorClass = C.GITERR_NONE
+ ErrClassNoMemory = C.GITERR_NOMEMORY
+ ErrClassOs = C.GITERR_OS
+ ErrClassInvalid = C.GITERR_INVALID
+ ErrClassReference = C.GITERR_REFERENCE
+ ErrClassZlib = C.GITERR_ZLIB
+ ErrClassRepository = C.GITERR_REPOSITORY
+ ErrClassConfig = C.GITERR_CONFIG
+ ErrClassRegex = C.GITERR_REGEX
+ ErrClassOdb = C.GITERR_ODB
+ ErrClassIndex = C.GITERR_INDEX
+ ErrClassObject = C.GITERR_OBJECT
+ ErrClassNet = C.GITERR_NET
+ ErrClassTag = C.GITERR_TAG
+ ErrClassTree = C.GITERR_TREE
+ ErrClassIndexer = C.GITERR_INDEXER
+ ErrClassSSL = C.GITERR_SSL
+ ErrClassSubmodule = C.GITERR_SUBMODULE
+ ErrClassThread = C.GITERR_THREAD
+ ErrClassStash = C.GITERR_STASH
+ ErrClassCheckout = C.GITERR_CHECKOUT
+ ErrClassFetchHead = C.GITERR_FETCHHEAD
+ ErrClassMerge = C.GITERR_MERGE
+ ErrClassSsh = C.GITERR_SSH
+ ErrClassFilter = C.GITERR_FILTER
+ ErrClassRevert = C.GITERR_REVERT
+ ErrClassCallback = C.GITERR_CALLBACK
)
-var (
- ErrIterOver = errors.New("Iteration is over")
+type ErrorCode int
+
+const (
+
+ // No error
+ ErrOk ErrorCode = C.GIT_OK
+ // Generic error
+ ErrGeneric = C.GIT_ERROR
+ // Requested object could not be found
+ ErrNotFound = C.GIT_ENOTFOUND
+ // Object exists preventing operation
+ ErrExists = C.GIT_EEXISTS
+ // More than one object matches
+ ErrAmbigious = C.GIT_EAMBIGUOUS
+ // Output buffer too short to hold data
+ ErrBuffs = C.GIT_EBUFS
+ // GIT_EUSER 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 = C.GIT_EUSER
+ // Operation not allowed on bare repository
+ ErrBareRepo = C.GIT_EBAREREPO
+ // HEAD refers to branch with no commits
+ ErrUnbornBranch = C.GIT_EUNBORNBRANCH
+ // Merge in progress prevented operation
+ ErrUnmerged = C.GIT_EUNMERGED
+ // Reference was not fast-forwardable
+ ErrNonFastForward = C.GIT_ENONFASTFORWARD
+ // Name/ref spec was not in a valid format
+ ErrInvalidSpec = C.GIT_EINVALIDSPEC
+ // Merge conflicts prevented operation
+ ErrMergeConflict = C.GIT_EMERGECONFLICT
+ // Lock file prevented operation
+ ErrLocked = C.GIT_ELOCKED
+ // Reference value does not match expected
+ ErrModified = C.GIT_EMODIFIED
+ // Internal only
+ ErrPassthrough = C.GIT_PASSTHROUGH
+ // Signals end of iteration with iterator
+ ErrIterOver = C.GIT_ITEROVER
)
func init() {
@@ -64,6 +128,10 @@ func NewOid(s string) (*Oid, error) {
return nil, error
}
+ if len(slice) != 20 {
+ return nil, &GitError{"Invalid Oid", ErrClassNone, ErrGeneric}
+ }
+
copy(o[:], slice[:20])
return o, nil
}
@@ -124,29 +192,50 @@ func ShortenOids(ids []*Oid, minlen int) (int, error) {
}
type GitError struct {
- Message string
- Class int
- ErrorCode int
+ Message string
+ Class ErrorClass
+ Code ErrorCode
}
func (e GitError) Error() string {
return e.Message
}
-func IsNotExist(err error) bool {
- return err.(*GitError).ErrorCode == C.GIT_ENOTFOUND
+func IsErrorClass(err error, c ErrorClass) bool {
+
+ if err == nil {
+ return false
+ }
+ if gitError, ok := err.(*GitError); ok {
+ return gitError.Class == c
+ }
+ return false
}
-func IsExist(err error) bool {
- return err.(*GitError).ErrorCode == C.GIT_EEXISTS
+func IsErrorCode(err error, c ErrorCode) bool {
+ if err == nil {
+ return false
+ }
+ if gitError, ok := err.(*GitError); ok {
+ return gitError.Code == c
+ }
+ return false
}
func MakeGitError(errorCode C.int) error {
- err := C.giterr_last()
- if err == nil {
- return &GitError{"No message", C.GITERR_INVALID, C.GIT_ERROR}
+
+ var errMessage string
+ var errClass ErrorClass
+ if errorCode != ErrIterOver {
+ err := C.giterr_last()
+ if err != nil {
+ errMessage = C.GoString(err.message)
+ errClass = ErrorClass(err.klass)
+ } else {
+ errClass = ErrClassInvalid
+ }
}
- return &GitError{C.GoString(err.message), int(err.klass), int(errorCode)}
+ return &GitError{errMessage, errClass, ErrorCode(errorCode)}
}
func MakeGitError2(err int) error {
diff --git a/git_test.go b/git_test.go
index 6542ca0..f4515a6 100644
--- a/git_test.go
+++ b/git_test.go
@@ -62,3 +62,10 @@ func TestOidZero(t *testing.T) {
t.Error("Zero Oid is not zero")
}
}
+
+func TestEmptyOid(t *testing.T) {
+ _, err := NewOid("")
+ if err == nil || !IsErrorCode(err, ErrGeneric) {
+ t.Fatal("Should have returned invalid error")
+ }
+}
diff --git a/index.go b/index.go
index d3178a2..f20dc31 100644
--- a/index.go
+++ b/index.go
@@ -266,10 +266,6 @@ func (v *IndexConflictIterator) Next() (IndexConflict, error) {
defer runtime.UnlockOSThread()
ecode := C.git_index_conflict_next(&cancestor, &cour, &ctheir, v.ptr)
- if ecode == C.GIT_ITEROVER {
- return IndexConflict{}, ErrIterOver
- }
-
if ecode < 0 {
return IndexConflict{}, MakeGitError(ecode)
}
diff --git a/push_test.go b/push_test.go
index c1e6a22..65f4dd2 100644
--- a/push_test.go
+++ b/push_test.go
@@ -1,7 +1,6 @@
package git
import (
- "log"
"os"
"testing"
"time"
@@ -45,7 +44,6 @@ func Test_Push_ToRemote(t *testing.T) {
checkFatal(t, err)
err = push.StatusForeach(func(ref string, msg string) int {
- log.Printf("%s -> %s", ref, msg)
return 0
})
checkFatal(t, err)
diff --git a/reference.go b/reference.go
index d246c55..98facc2 100644
--- a/reference.go
+++ b/reference.go
@@ -22,9 +22,8 @@ type Reference struct {
}
func newReferenceFromC(ptr *C.git_reference) *Reference {
- ref := &Reference{ptr}
+ ref := &Reference{ptr: ptr}
runtime.SetFinalizer(ref, (*Reference).Free)
-
return ref
}
@@ -190,6 +189,10 @@ type ReferenceIterator struct {
repo *Repository
}
+type ReferenceNameIterator struct {
+ *ReferenceIterator
+}
+
// NewReferenceIterator creates a new iterator over reference names
func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
var ptr *C.git_reference_iterator
@@ -202,11 +205,28 @@ func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
return nil, MakeGitError(ret)
}
- iter := &ReferenceIterator{repo: repo, ptr: ptr}
+ iter := &ReferenceIterator{ptr: ptr, repo: repo}
runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
return iter, nil
}
+// NewReferenceIterator creates a new branch iterator over reference names
+func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error) {
+ var ptr *C.git_reference_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_iterator_new(&ptr, repo.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ iter := &ReferenceIterator{ptr: ptr, repo: repo}
+ runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
+ return iter.Names(), nil
+}
+
// NewReferenceIteratorGlob creates an iterator over reference names
// that match the speicified glob. The glob is of the usual fnmatch
// type.
@@ -223,23 +243,24 @@ func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterato
return nil, MakeGitError(ret)
}
- iter := &ReferenceIterator{repo: repo, ptr: ptr}
+ iter := &ReferenceIterator{ptr: ptr}
runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
return iter, nil
}
+func (i *ReferenceIterator) Names() *ReferenceNameIterator {
+ return &ReferenceNameIterator{i}
+}
+
// NextName retrieves the next reference name. If the iteration is over,
// the returned error is git.ErrIterOver
-func (v *ReferenceIterator) NextName() (string, error) {
+func (v *ReferenceNameIterator) Next() (string, error) {
var ptr *C.char
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_next_name(&ptr, v.ptr)
- if ret == ITEROVER {
- return "", ErrIterOver
- }
if ret < 0 {
return "", MakeGitError(ret)
}
@@ -247,31 +268,11 @@ func (v *ReferenceIterator) NextName() (string, error) {
return C.GoString(ptr), nil
}
-// Create a channel from the iterator. You can use range on the
-// returned channel to iterate over all the references names. The channel
-// will be closed in case any error is found.
-func (v *ReferenceIterator) NameIter() <-chan string {
- ch := make(chan string)
- go func() {
- defer close(ch)
- name, err := v.NextName()
- for err == nil {
- ch <- name
- name, err = v.NextName()
- }
- }()
-
- return ch
-}
-
// Next retrieves the next reference. If the iterationis over, the
// returned error is git.ErrIterOver
func (v *ReferenceIterator) Next() (*Reference, error) {
var ptr *C.git_reference
ret := C.git_reference_next(&ptr, v.ptr)
- if ret == ITEROVER {
- return nil, ErrIterOver
- }
if ret < 0 {
return nil, MakeGitError(ret)
}
@@ -279,23 +280,6 @@ func (v *ReferenceIterator) Next() (*Reference, error) {
return newReferenceFromC(ptr), nil
}
-// Create a channel from the iterator. You can use range on the
-// returned channel to iterate over all the references names. The channel
-// will be closed in case any error is found.
-func (v *ReferenceIterator) Iter() <-chan *Reference {
- ch := make(chan *Reference)
- go func() {
- defer close(ch)
- name, err := v.Next()
- for err == nil {
- ch <- name
- name, err = v.Next()
- }
- }()
-
- return ch
-}
-
// Free the reference iterator
func (v *ReferenceIterator) Free() {
runtime.SetFinalizer(v, nil)
diff --git a/reference_test.go b/reference_test.go
index ffa9f35..3e72ae7 100644
--- a/reference_test.go
+++ b/reference_test.go
@@ -60,7 +60,7 @@ func TestRefModification(t *testing.T) {
}
-func TestIterator(t *testing.T) {
+func TestReferenceIterator(t *testing.T) {
repo := createTestRepo(t)
defer os.RemoveAll(repo.Workdir())
@@ -106,12 +106,13 @@ func TestIterator(t *testing.T) {
}
// test some manual iteration
- name, err := iter.NextName()
+ nameIter := iter.Names()
+ name, err := nameIter.Next()
for err == nil {
list = append(list, name)
- name, err = iter.NextName()
+ name, err = nameIter.Next()
}
- if err != ErrIterOver {
+ if !IsErrorCode(err, ErrIterOver) {
t.Fatal("Iteration not over")
}
@@ -127,7 +128,7 @@ func TestIterator(t *testing.T) {
count++
_, err = iter.Next()
}
- if err != ErrIterOver {
+ if !IsErrorCode(err, ErrIterOver) {
t.Fatal("Iteration not over")
}
@@ -135,28 +136,6 @@ func TestIterator(t *testing.T) {
t.Fatalf("Wrong number of references returned %v", count)
}
- // test the channel iteration
- list = []string{}
- iter, err = repo.NewReferenceIterator()
- for name := range iter.NameIter() {
- list = append(list, name)
- }
-
- sort.Strings(list)
- compareStringList(t, expected, list)
-
- iter, err = repo.NewReferenceIteratorGlob("refs/heads/t*")
- expected = []string{
- "refs/heads/three",
- "refs/heads/two",
- }
-
- list = []string{}
- for name := range iter.NameIter() {
- list = append(list, name)
- }
-
- compareStringList(t, expected, list)
}
func TestUtil(t *testing.T) {
diff --git a/remote.go b/remote.go
index eb5d7a7..74ebe27 100644
--- a/remote.go
+++ b/remote.go
@@ -38,14 +38,14 @@ const (
RemoteCompletionError = C.GIT_REMOTE_COMPLETION_ERROR
)
-type ProgressCallback func(str string) int
+type TransportMessageCallback func(str string) int
type CompletionCallback func(RemoteCompletion) int
type CredentialsCallback func(url string, username_from_url string, allowed_types CredType) (int, *Cred)
type TransferProgressCallback func(stats TransferProgress) int
type UpdateTipsCallback func(refname string, a *Oid, b *Oid) int
type RemoteCallbacks struct {
- ProgressCallback
+ SidebandProgressCallback TransportMessageCallback
CompletionCallback
CredentialsCallback
TransferProgressCallback
@@ -65,14 +65,14 @@ func populateRemoteCallbacks(ptr *C.git_remote_callbacks, callbacks *RemoteCallb
ptr.payload = unsafe.Pointer(callbacks)
}
-//export progressCallback
-func progressCallback(_str *C.char, _len C.int, data unsafe.Pointer) int {
+//export sidebandProgressCallback
+func sidebandProgressCallback(_str *C.char, _len C.int, data unsafe.Pointer) int {
callbacks := (*RemoteCallbacks)(data)
- if callbacks.ProgressCallback == nil {
+ if callbacks.SidebandProgressCallback == nil {
return 0
}
str := C.GoStringN(_str, _len)
- return callbacks.ProgressCallback(str)
+ return callbacks.SidebandProgressCallback(str)
}
//export completionCallback
@@ -127,6 +127,26 @@ func RemoteIsValidName(name string) bool {
return false
}
+func (r *Remote) SetCheckCert(check bool) {
+ C.git_remote_check_cert(r.ptr, cbool(check))
+}
+
+func (r *Remote) SetCallbacks(callbacks *RemoteCallbacks) error {
+ var ccallbacks C.git_remote_callbacks
+
+ populateRemoteCallbacks(&ccallbacks, callbacks)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_remote_set_callbacks(r.ptr, &ccallbacks)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+
+ return nil
+}
+
func (r *Remote) Free() {
runtime.SetFinalizer(r, nil)
C.git_remote_free(r.ptr)
diff --git a/repository.go b/repository.go
index e694bb6..ffd1bcc 100644
--- a/repository.go
+++ b/repository.go
@@ -2,7 +2,7 @@ package git
/*
#include <git2.h>
-#include <git2/errors.h>
+#include <git2/sys/repository.h>
*/
import "C"
import (
diff --git a/walk.go b/walk.go
index f7c147d..9e07411 100644
--- a/walk.go
+++ b/walk.go
@@ -7,7 +7,6 @@ package git
import "C"
import (
- "io"
"runtime"
"unsafe"
)
@@ -158,8 +157,6 @@ func (v *RevWalk) Next(id *Oid) (err error) {
ret := C.git_revwalk_next(id.toC(), v.ptr)
switch {
- case ret == ITEROVER:
- err = io.EOF
case ret < 0:
err = MakeGitError(ret)
}
@@ -173,7 +170,7 @@ func (v *RevWalk) Iterate(fun RevWalkIterator) (err error) {
oid := new(Oid)
for {
err = v.Next(oid)
- if err == io.EOF {
+ if IsErrorCode(err, ErrIterOver) {
return nil
}
if err != nil {
diff --git a/wrapper.c b/wrapper.c
index f2232e4..2a475d0 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -44,12 +44,11 @@ void _go_git_refdb_backend_free(git_refdb_backend *backend)
}
void _go_git_setup_callbacks(git_remote_callbacks *callbacks) {
- typedef int (*progress_cb)(const char *str, int len, void *data);
typedef int (*completion_cb)(git_remote_completion_type type, void *data);
typedef int (*credentials_cb)(git_cred **cred, const char *url, const char *username_from_url, unsigned int allowed_types, void *data);
typedef int (*transfer_progress_cb)(const git_transfer_progress *stats, void *data);
typedef int (*update_tips_cb)(const char *refname, const git_oid *a, const git_oid *b, void *data);
- callbacks->progress = (progress_cb)progressCallback;
+ callbacks->sideband_progress = (git_transport_message_cb)sidebandProgressCallback;
callbacks->completion = (completion_cb)completionCallback;
callbacks->credentials = (credentials_cb)credentialsCallback;
callbacks->transfer_progress = (transfer_progress_cb)transferProgressCallback;
generated by cgit v1.2.3 (git 2.51.0) at 2025-11-06 18:30:55 +0000