From 298f2e2111905388e3d10cd0db0221a22dc7a62f Mon Sep 17 00:00:00 2001 From: Mirko Nosenzo Date: Sun, 29 May 2016 13:13:58 +0200 Subject: [PATCH 01/18] BranchAll maps GIT_BRANCH_ALL Added support to All Branch Iteration and Lookup --- branch.go | 1 + 1 file changed, 1 insertion(+) diff --git a/branch.go b/branch.go index df72dba..a869054 100644 --- a/branch.go +++ b/branch.go @@ -13,6 +13,7 @@ import ( type BranchType uint const ( + BranchAll BranchType = C.GIT_BRANCH_ALL BranchLocal BranchType = C.GIT_BRANCH_LOCAL BranchRemote BranchType = C.GIT_BRANCH_REMOTE ) -- 2.45.2 From 82f86f2f13213cfadfafc07a033c269095386dbc Mon Sep 17 00:00:00 2001 From: Mirko Nosenzo Date: Sun, 29 May 2016 14:37:37 +0200 Subject: [PATCH 02/18] StatusConflicted maps GIT_STATUS_CONFLICTED Added support for file in conflicted status --- status.go | 1 + 1 file changed, 1 insertion(+) diff --git a/status.go b/status.go index 068a474..e68e6e9 100644 --- a/status.go +++ b/status.go @@ -25,6 +25,7 @@ const ( StatusWtTypeChange Status = C.GIT_STATUS_WT_TYPECHANGE StatusWtRenamed Status = C.GIT_STATUS_WT_RENAMED StatusIgnored Status = C.GIT_STATUS_IGNORED + StatusConflicted Status = C.GIT_STATUS_CONFLICTED ) type StatusEntry struct { -- 2.45.2 From 981538924c7607980dd8328564cad6c0aedd6154 Mon Sep 17 00:00:00 2001 From: Travis Lane Date: Thu, 7 Apr 2016 21:51:00 -0700 Subject: [PATCH 03/18] diff: Add DiffStats String This implements git_diff_stats_to_buf which provides the output for git diff --stats. --- diff.go | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/diff.go b/diff.go index 9a7ac78..8ae0512 100644 --- a/diff.go +++ b/diff.go @@ -217,6 +217,33 @@ func (stats *DiffStats) FilesChanged() int { return int(C.git_diff_stats_files_changed(stats.ptr)) } +type DiffStatsFormat int + +const ( + DiffStatsNone DiffStatsFormat = C.GIT_DIFF_STATS_NONE + DiffStatsFull DiffStatsFormat = C.GIT_DIFF_STATS_FULL + DiffStatsShort DiffStatsFormat = C.GIT_DIFF_STATS_SHORT + DiffStatsNumber DiffStatsFormat = C.GIT_DIFF_STATS_NUMBER + DiffStatsIncludeSummary DiffStatsFormat = C.GIT_DIFF_STATS_INCLUDE_SUMMARY +) + +func (stats *DiffStats) String(format DiffStatsFormat, + width uint) (string, error) { + buf := C.git_buf{} + defer C.git_buf_free(&buf) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C.git_diff_stats_to_buf(&buf, + stats.ptr, C.git_diff_stats_format_t(format), C.size_t(width)) + if ret < 0 { + return "", MakeGitError(ret) + } + + return C.GoString(buf.ptr), nil +} + func (diff *Diff) Stats() (*DiffStats, error) { stats := new(DiffStats) -- 2.45.2 From b1a9de8037e4260dcd840db38e2e16473cdddcb6 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Sun, 7 Aug 2016 14:40:59 +1000 Subject: [PATCH 04/18] Initial rebase wrapper version --- rebase.go | 152 ++++++++++++++++++++++++++++++++++++++++++++ rebase_test.go | 167 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 319 insertions(+) create mode 100644 rebase.go create mode 100644 rebase_test.go diff --git a/rebase.go b/rebase.go new file mode 100644 index 0000000..3e7da53 --- /dev/null +++ b/rebase.go @@ -0,0 +1,152 @@ +package git + +/* +#include +*/ +import "C" +import ( + "errors" + "runtime" + "unsafe" +) + +// RebaseOperationType is the type of rebase operation +type RebaseOperationType uint + +const ( + // RebaseOperationPick The given commit is to be cherry-picked. The client should commit the changes and continue if there are no conflicts. + RebaseOperationPick RebaseOperationType = C.GIT_REBASE_OPERATION_PICK + // RebaseOperationEdit The given commit is to be cherry-picked, but the client should stop to allow the user to edit the changes before committing them. + RebaseOperationEdit RebaseOperationType = C.GIT_REBASE_OPERATION_EDIT + // RebaseOperationSquash The given commit is to be squashed into the previous commit. The commit message will be merged with the previous message. + RebaseOperationSquash RebaseOperationType = C.GIT_REBASE_OPERATION_SQUASH + // RebaseOperationFixup No commit will be cherry-picked. The client should run the given command and (if successful) continue. + RebaseOperationFixup RebaseOperationType = C.GIT_REBASE_OPERATION_FIXUP + // RebaseOperationExec No commit will be cherry-picked. The client should run the given command and (if successful) continue. + RebaseOperationExec RebaseOperationType = C.GIT_REBASE_OPERATION_EXEC +) + +// RebaseOperation describes a single instruction/operation to be performed during the rebase. +type RebaseOperation struct { + Type RebaseOperationType + ID *Oid + Exec string +} + +func rebaseOperationFromC(c *C.git_rebase_operation) *RebaseOperation { + operation := &RebaseOperation{} + operation.Type = RebaseOperationType(c._type) + operation.ID = newOidFromC(&c.id) + operation.Exec = C.GoString(c.exec) + + return operation +} + +// RebaseOptions are used to tell the rebase machinery how to operate +type RebaseOptions struct{} + +// Rebase object wrapper for C pointer +type Rebase struct { + ptr *C.git_rebase +} + +//RebaseInit initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch. +func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + //TODO : use real rebase_options + if opts != nil { + return nil, errors.New("RebaseOptions Not implemented yet") + } + + if branch == nil { + branch = &AnnotatedCommit{ptr: nil} + } + + if upstream == nil { + upstream = &AnnotatedCommit{ptr: nil} + } + + if onto == nil { + onto = &AnnotatedCommit{ptr: nil} + } + + var ptr *C.git_rebase + err := C.git_rebase_init(&ptr, r.ptr, branch.ptr, upstream.ptr, onto.ptr, nil) + if err < 0 { + return nil, MakeGitError(err) + } + + return newRebaseFromC(ptr), nil +} + +// Next performs the next rebase operation and returns the information about it. +// If the operation is one that applies a patch (which is any operation except GIT_REBASE_OPERATION_EXEC) +// then the patch will be applied and the index and working directory will be updated with the changes. +// If there are conflicts, you will need to address those before committing the changes. +func (rebase *Rebase) Next() (*RebaseOperation, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var ptr *C.git_rebase_operation + err := C.git_rebase_next(&ptr, rebase.ptr) + if err < 0 { + return nil, MakeGitError(err) + } + + return rebaseOperationFromC(ptr), nil +} + +// Commit commits the current patch. +// You must have resolved any conflicts that were introduced during the patch application from the git_rebase_next invocation. +func (rebase *Rebase) Commit(ID *Oid, author, committer *Signature, message string) error { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + authorSig, err := author.toC() + if err != nil { + return err + } + defer C.git_signature_free(authorSig) + + committerSig, err := committer.toC() + if err != nil { + return err + } + + cmsg := C.CString(message) + defer C.free(unsafe.Pointer(cmsg)) + + cerr := C.git_rebase_commit(ID.toC(), rebase.ptr, authorSig, committerSig, nil, cmsg) + if cerr < 0 { + return MakeGitError(cerr) + } + + return nil +} + +// Finish finishes a rebase that is currently in progress once all patches have been applied. +func (rebase *Rebase) Finish() error { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + err := C.git_rebase_finish(rebase.ptr, nil) + if err < 0 { + return MakeGitError(err) + } + + return nil +} + +//Free frees the Rebase object and underlying git_rebase C pointer. +func (rebase *Rebase) Free() { + runtime.SetFinalizer(rebase, nil) + C.git_reference_free(rebase.ptr) +} + +func newRebaseFromC(ptr *C.git_rebase) *Rebase { + rebase := &Rebase{ptr: ptr} + runtime.SetFinalizer(rebase, (*Rebase).Free) + return rebase +} diff --git a/rebase_test.go b/rebase_test.go new file mode 100644 index 0000000..d4b4251 --- /dev/null +++ b/rebase_test.go @@ -0,0 +1,167 @@ +package git + +import ( + "testing" + "time" +) + +func createBranch(repo *Repository, branch string) error { + head, err := repo.Head() + if err != nil { + return err + } + commit, err := repo.LookupCommit(head.Target()) + if err != nil { + return err + } + _, err = repo.CreateBranch(branch, commit, false) + if err != nil { + return err + } + + return nil +} + +func signature() *Signature { + return &Signature{ + Name: "Emile", + Email: "emile@emile.com", + When: time.Now(), + } +} + +func commitSomething(repo *Repository, something string) (*Oid, error) { + head, err := repo.Head() + if err != nil { + return nil, err + } + + headCommit, err := repo.LookupCommit(head.Target()) + if err != nil { + return nil, err + } + + index, err := NewIndex() + if err != nil { + return nil, err + } + defer index.Free() + + blobOID, err := repo.CreateBlobFromBuffer([]byte("fou")) + if err != nil { + return nil, err + } + + entry := &IndexEntry{ + Mode: FilemodeBlob, + Id: blobOID, + Path: something, + } + + if err := index.Add(entry); err != nil { + return nil, err + } + + newTreeOID, err := index.WriteTreeTo(repo) + if err != nil { + return nil, err + } + + newTree, err := repo.LookupTree(newTreeOID) + if err != nil { + return nil, err + } + + if err != nil { + return nil, err + } + commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase onto, Baby! "+something, newTree, headCommit) + if err != nil { + return nil, err + } + + opts := &CheckoutOpts{ + Strategy: CheckoutRemoveUntracked | CheckoutForce, + } + err = repo.CheckoutIndex(index, opts) + if err != nil { + return nil, err + } + + return commit, nil +} + +func entryExists(repo *Repository, file string) bool { + head, err := repo.Head() + if err != nil { + return false + } + headCommit, err := repo.LookupCommit(head.Target()) + if err != nil { + return false + } + headTree, err := headCommit.Tree() + if err != nil { + return false + } + _, err = headTree.EntryByPath(file) + + return err == nil +} + +func TestRebaseOnto(t *testing.T) { + repo := createTestRepo(t) + defer cleanupTestRepo(t, repo) + + fileInMaster := "something" + fileInEmile := "something else" + + // Seed master + seedTestRepo(t, repo) + + // Create a new branch from master + err := createBranch(repo, "emile") + checkFatal(t, err) + + // Create a commit in master + _, err = commitSomething(repo, fileInMaster) + checkFatal(t, err) + + // Switch to this emile + err = repo.SetHead("refs/heads/emile") + checkFatal(t, err) + + // Check master commit is not in emile branch + if entryExists(repo, fileInMaster) { + t.Fatal("something entry should not exist in emile branch") + } + + // Create a commit in emile + _, err = commitSomething(repo, fileInEmile) + checkFatal(t, err) + + // Rebase onto master + master, err := repo.LookupBranch("master", BranchLocal) + branch, err := repo.AnnotatedCommitFromRef(master.Reference) + checkFatal(t, err) + + rebase, err := repo.RebaseInit(nil, nil, branch, nil) + checkFatal(t, err) + defer rebase.Free() + + operation, err := rebase.Next() + checkFatal(t, err) + + commit, err := repo.LookupCommit(operation.ID) + checkFatal(t, err) + + err = rebase.Commit(operation.ID, signature(), signature(), commit.Message()) + checkFatal(t, err) + + rebase.Finish() + + // Check master commit is now also in emile branch + if !entryExists(repo, fileInMaster) { + t.Fatal("something entry should now exist in emile branch") + } +} -- 2.45.2 From a62a8c3b92eeb14055d30608ac7d3243bcfba701 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Sun, 7 Aug 2016 16:33:06 +1000 Subject: [PATCH 05/18] Add operation OperationCount() service and enrich UTs --- rebase.go | 15 +++ rebase_test.go | 251 ++++++++++++++++++++++++++++++++++++------------- 2 files changed, 201 insertions(+), 65 deletions(-) diff --git a/rebase.go b/rebase.go index 3e7da53..fb3d612 100644 --- a/rebase.go +++ b/rebase.go @@ -139,6 +139,11 @@ func (rebase *Rebase) Finish() error { return nil } +// OperationCount gets the count of rebase operations that are to be applied. +func (rebase *Rebase) OperationCount() uint { + return uint(C.git_rebase_operation_entrycount(rebase.ptr)) +} + //Free frees the Rebase object and underlying git_rebase C pointer. func (rebase *Rebase) Free() { runtime.SetFinalizer(rebase, nil) @@ -150,3 +155,13 @@ func newRebaseFromC(ptr *C.git_rebase) *Rebase { runtime.SetFinalizer(rebase, (*Rebase).Free) return rebase } + +/* TODO -- Add last wrapper services and manage rebase_options + +int git_rebase_abort(git_rebase *rebase); +int git_rebase_init_options(git_rebase_options *opts, unsigned int version); +int git_rebase_open(git_rebase **out, git_repository *repo, const git_rebase_options *opts); +git_rebase_operation * git_rebase_operation_byindex(git_rebase *rebase, size_t idx); +size_t git_rebase_operation_current(git_rebase *rebase); + +*/ diff --git a/rebase_test.go b/rebase_test.go index d4b4251..7106e7f 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -1,19 +1,142 @@ package git import ( + "errors" + "strconv" "testing" "time" ) +// Tests + +func TestRebaseNoConflicts(t *testing.T) { + // TEST DATA + + // Inputs + branchName := "emile" + masterCommit := "something" + emileCommits := []string{ + "fou", + "barre", + "ouich", + } + + // Outputs + expectedHistory := []string{ + "Test rebase onto, Baby! " + emileCommits[2], + "Test rebase onto, Baby! " + emileCommits[1], + "Test rebase onto, Baby! " + emileCommits[0], + "Test rebase onto, Baby! " + masterCommit, + "This is a commit\n", + } + + // TEST + repo := createTestRepo(t) + seedTestRepo(t, repo) + + // Setup a repo with 2 branches and a different tree + err := setupRepoForRebase(repo, masterCommit, branchName) + checkFatal(t, err) + defer cleanupTestRepo(t, repo) + + // Create several commits in emile + for _, commit := range emileCommits { + _, err = commitSomething(repo, commit, commit) + checkFatal(t, err) + } + + // Rebase onto master + err = performRebaseOnto(repo, "master") + checkFatal(t, err) + + // Check history is in correct order + actualHistory, err := commitMsgsList(repo) + checkFatal(t, err) + assertStringList(t, expectedHistory, actualHistory) + +} + +// Utils +func setupRepoForRebase(repo *Repository, masterCommit, branchName string) error { + // Create a new branch from master + err := createBranch(repo, branchName) + if err != nil { + return err + } + + // Create a commit in master + _, err = commitSomething(repo, masterCommit, masterCommit) + if err != nil { + return err + } + + // Switch to emile + err = repo.SetHead("refs/heads/" + branchName) + if err != nil { + return err + } + + // Check master commit is not in emile branch + if entryExists(repo, masterCommit) { + return errors.New(masterCommit + " entry should not exist in " + branchName + " branch.") + } + + return nil +} + +func performRebaseOnto(repo *Repository, branch string) error { + master, err := repo.LookupBranch(branch, BranchLocal) + if err != nil { + return err + } + defer master.Free() + + onto, err := repo.AnnotatedCommitFromRef(master.Reference) + if err != nil { + return err + } + defer onto.Free() + + rebase, err := repo.RebaseInit(nil, nil, onto, nil) + if err != nil { + return err + } + defer rebase.Free() + + opCount := int(rebase.OperationCount()) + + for op := 0; op < opCount; op++ { + operation, err := rebase.Next() + if err != nil { + return err + } + + commit, err := repo.LookupCommit(operation.ID) + if err != nil { + return err + } + defer commit.Free() + + err = rebase.Commit(operation.ID, signature(), signature(), commit.Message()) + if err != nil { + return err + } + } + + err = rebase.Finish() + if err != nil { + return err + } + + return nil +} + func createBranch(repo *Repository, branch string) error { - head, err := repo.Head() - if err != nil { - return err - } - commit, err := repo.LookupCommit(head.Target()) + commit, err := headCommit(repo) if err != nil { return err } + defer commit.Free() _, err = repo.CreateBranch(branch, commit, false) if err != nil { return err @@ -30,24 +153,50 @@ func signature() *Signature { } } -func commitSomething(repo *Repository, something string) (*Oid, error) { +func headCommit(repo *Repository) (*Commit, error) { head, err := repo.Head() if err != nil { return nil, err } + defer head.Free() - headCommit, err := repo.LookupCommit(head.Target()) + commit, err := repo.LookupCommit(head.Target()) if err != nil { return nil, err } + return commit, nil +} + +func headTree(repo *Repository) (*Tree, error) { + headCommit, err := headCommit(repo) + if err != nil { + return nil, err + } + defer headCommit.Free() + + tree, err := headCommit.Tree() + if err != nil { + return nil, err + } + + return tree, nil +} + +func commitSomething(repo *Repository, something, content string) (*Oid, error) { + headCommit, err := headCommit(repo) + if err != nil { + return nil, err + } + defer headCommit.Free() + index, err := NewIndex() if err != nil { return nil, err } defer index.Free() - blobOID, err := repo.CreateBlobFromBuffer([]byte("fou")) + blobOID, err := repo.CreateBlobFromBuffer([]byte(content)) if err != nil { return nil, err } @@ -71,6 +220,7 @@ func commitSomething(repo *Repository, something string) (*Oid, error) { if err != nil { return nil, err } + defer newTree.Free() if err != nil { return nil, err @@ -92,76 +242,47 @@ func commitSomething(repo *Repository, something string) (*Oid, error) { } func entryExists(repo *Repository, file string) bool { - head, err := repo.Head() - if err != nil { - return false - } - headCommit, err := repo.LookupCommit(head.Target()) - if err != nil { - return false - } - headTree, err := headCommit.Tree() + headTree, err := headTree(repo) if err != nil { return false } + defer headTree.Free() + _, err = headTree.EntryByPath(file) return err == nil } -func TestRebaseOnto(t *testing.T) { - repo := createTestRepo(t) - defer cleanupTestRepo(t, repo) +func commitMsgsList(repo *Repository) ([]string, error) { + head, err := headCommit(repo) + if err != nil { + return nil, err + } + defer head.Free() - fileInMaster := "something" - fileInEmile := "something else" + var commits []string - // Seed master - seedTestRepo(t, repo) + parent := head.Parent(0) + defer parent.Free() + commits = append(commits, head.Message(), parent.Message()) - // Create a new branch from master - err := createBranch(repo, "emile") - checkFatal(t, err) - - // Create a commit in master - _, err = commitSomething(repo, fileInMaster) - checkFatal(t, err) - - // Switch to this emile - err = repo.SetHead("refs/heads/emile") - checkFatal(t, err) - - // Check master commit is not in emile branch - if entryExists(repo, fileInMaster) { - t.Fatal("something entry should not exist in emile branch") + for parent.ParentCount() != 0 { + parent = parent.Parent(0) + defer parent.Free() + commits = append(commits, parent.Message()) } - // Create a commit in emile - _, err = commitSomething(repo, fileInEmile) - checkFatal(t, err) + return commits, nil +} - // Rebase onto master - master, err := repo.LookupBranch("master", BranchLocal) - branch, err := repo.AnnotatedCommitFromRef(master.Reference) - checkFatal(t, err) - - rebase, err := repo.RebaseInit(nil, nil, branch, nil) - checkFatal(t, err) - defer rebase.Free() - - operation, err := rebase.Next() - checkFatal(t, err) - - commit, err := repo.LookupCommit(operation.ID) - checkFatal(t, err) - - err = rebase.Commit(operation.ID, signature(), signature(), commit.Message()) - checkFatal(t, err) - - rebase.Finish() - - // Check master commit is now also in emile branch - if !entryExists(repo, fileInMaster) { - t.Fatal("something entry should now exist in emile branch") +func assertStringList(t *testing.T, expected, actual []string) { + if len(expected) != len(actual) { + t.Fatal("Lists are not the same size, expected " + strconv.Itoa(len(expected)) + + ", got " + strconv.Itoa(len(actual))) + } + for index, element := range expected { + if element != actual[index] { + t.Error("Expected element " + strconv.Itoa(index) + " to be " + element + ", got " + actual[index]) + } } } -- 2.45.2 From e1f09497409bb8dea59d8312f1049267cee37544 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Sun, 7 Aug 2016 17:00:14 +1000 Subject: [PATCH 06/18] Add Abort() service to wrapper --- rebase.go | 10 +++++- rebase_test.go | 91 +++++++++++++++++++++++++++++++++++++++----------- 2 files changed, 80 insertions(+), 21 deletions(-) diff --git a/rebase.go b/rebase.go index fb3d612..ee409df 100644 --- a/rebase.go +++ b/rebase.go @@ -50,6 +50,15 @@ type Rebase struct { ptr *C.git_rebase } +// Abort aborts a rebase that is currently in progress, resetting the repository and working directory to their state before rebase began. +func (rebase *Rebase) Abort() error { + err := C.git_rebase_abort(rebase.ptr) + if err < 0 { + return MakeGitError(err) + } + return nil +} + //RebaseInit initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch. func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) { runtime.LockOSThread() @@ -158,7 +167,6 @@ func newRebaseFromC(ptr *C.git_rebase) *Rebase { /* TODO -- Add last wrapper services and manage rebase_options -int git_rebase_abort(git_rebase *rebase); int git_rebase_init_options(git_rebase_options *opts, unsigned int version); int git_rebase_open(git_rebase **out, git_repository *repo, const git_rebase_options *opts); git_rebase_operation * git_rebase_operation_byindex(git_rebase *rebase, size_t idx); diff --git a/rebase_test.go b/rebase_test.go index 7106e7f..dc5aeb3 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -9,6 +9,58 @@ import ( // Tests +func TestRebaseAbort(t *testing.T) { + // TEST DATA + + // Inputs + branchName := "emile" + masterCommit := "something" + emileCommits := []string{ + "fou", + "barre", + } + + // Outputs + expectedHistory := []string{ + "Test rebase, Baby! " + emileCommits[1], + "Test rebase, Baby! " + emileCommits[0], + "This is a commit\n", + } + + // TEST + repo := createTestRepo(t) + seedTestRepo(t, repo) + + // Setup a repo with 2 branches and a different tree + err := setupRepoForRebase(repo, masterCommit, branchName) + checkFatal(t, err) + defer cleanupTestRepo(t, repo) + + // Create several commits in emile + for _, commit := range emileCommits { + _, err = commitSomething(repo, commit, commit) + checkFatal(t, err) + } + + // Check history + actualHistory, err := commitMsgsList(repo) + checkFatal(t, err) + assertStringList(t, expectedHistory, actualHistory) + + // Rebase onto master + rebase, err := performRebaseOnto(repo, "master") + checkFatal(t, err) + defer rebase.Free() + + // Abort rebase + rebase.Abort() + + // Check history is still the same + actualHistory, err = commitMsgsList(repo) + checkFatal(t, err) + assertStringList(t, expectedHistory, actualHistory) +} + func TestRebaseNoConflicts(t *testing.T) { // TEST DATA @@ -23,10 +75,10 @@ func TestRebaseNoConflicts(t *testing.T) { // Outputs expectedHistory := []string{ - "Test rebase onto, Baby! " + emileCommits[2], - "Test rebase onto, Baby! " + emileCommits[1], - "Test rebase onto, Baby! " + emileCommits[0], - "Test rebase onto, Baby! " + masterCommit, + "Test rebase, Baby! " + emileCommits[2], + "Test rebase, Baby! " + emileCommits[1], + "Test rebase, Baby! " + emileCommits[0], + "Test rebase, Baby! " + masterCommit, "This is a commit\n", } @@ -46,7 +98,12 @@ func TestRebaseNoConflicts(t *testing.T) { } // Rebase onto master - err = performRebaseOnto(repo, "master") + rebase, err := performRebaseOnto(repo, "master") + checkFatal(t, err) + defer rebase.Free() + + // Finish the rebase properly + err = rebase.Finish() checkFatal(t, err) // Check history is in correct order @@ -84,51 +141,45 @@ func setupRepoForRebase(repo *Repository, masterCommit, branchName string) error return nil } -func performRebaseOnto(repo *Repository, branch string) error { +func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { master, err := repo.LookupBranch(branch, BranchLocal) if err != nil { - return err + return nil, err } defer master.Free() onto, err := repo.AnnotatedCommitFromRef(master.Reference) if err != nil { - return err + return nil, err } defer onto.Free() rebase, err := repo.RebaseInit(nil, nil, onto, nil) if err != nil { - return err + return nil, err } - defer rebase.Free() opCount := int(rebase.OperationCount()) for op := 0; op < opCount; op++ { operation, err := rebase.Next() if err != nil { - return err + return nil, err } commit, err := repo.LookupCommit(operation.ID) if err != nil { - return err + return nil, err } defer commit.Free() err = rebase.Commit(operation.ID, signature(), signature(), commit.Message()) if err != nil { - return err + return nil, err } } - err = rebase.Finish() - if err != nil { - return err - } - - return nil + return rebase, nil } func createBranch(repo *Repository, branch string) error { @@ -225,7 +276,7 @@ func commitSomething(repo *Repository, something, content string) (*Oid, error) if err != nil { return nil, err } - commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase onto, Baby! "+something, newTree, headCommit) + commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase, Baby! "+something, newTree, headCommit) if err != nil { return nil, err } -- 2.45.2 From 193b21398b76d602daabfef4d2462531c9aec410 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Sun, 7 Aug 2016 17:31:42 +1000 Subject: [PATCH 07/18] Add CurrentOperationIndex() and OperationAt(index uint) services to wrapper --- rebase.go | 47 ++++++++++++++++++++++++++++++----------------- rebase_test.go | 26 +++++++++++++++++++++++--- 2 files changed, 53 insertions(+), 20 deletions(-) diff --git a/rebase.go b/rebase.go index ee409df..2218295 100644 --- a/rebase.go +++ b/rebase.go @@ -33,7 +33,7 @@ type RebaseOperation struct { Exec string } -func rebaseOperationFromC(c *C.git_rebase_operation) *RebaseOperation { +func newRebaseOperationFromC(c *C.git_rebase_operation) *RebaseOperation { operation := &RebaseOperation{} operation.Type = RebaseOperationType(c._type) operation.ID = newOidFromC(&c.id) @@ -50,15 +50,6 @@ type Rebase struct { ptr *C.git_rebase } -// Abort aborts a rebase that is currently in progress, resetting the repository and working directory to their state before rebase began. -func (rebase *Rebase) Abort() error { - err := C.git_rebase_abort(rebase.ptr) - if err < 0 { - return MakeGitError(err) - } - return nil -} - //RebaseInit initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch. func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) { runtime.LockOSThread() @@ -66,7 +57,7 @@ func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedComm //TODO : use real rebase_options if opts != nil { - return nil, errors.New("RebaseOptions Not implemented yet") + return nil, errors.New("RebaseOptions Not implemented yet, use nil for default opts") } if branch == nil { @@ -90,6 +81,23 @@ func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedComm return newRebaseFromC(ptr), nil } +// OperationAt gets the rebase operation specified by the given index. +func (rebase *Rebase) OperationAt(index uint) *RebaseOperation { + operation := C.git_rebase_operation_byindex(rebase.ptr, C.size_t(index)) + return newRebaseOperationFromC(operation) +} + +// CurrentOperationIndex gets the index of the rebase operation that is currently being applied. +// If the first operation has not yet been applied then this returns -1 (C.GIT_REBASE_NO_OPERATION). +func (rebase *Rebase) CurrentOperationIndex() int { + return int(C.git_rebase_operation_current(rebase.ptr)) +} + +// OperationCount gets the count of rebase operations that are to be applied. +func (rebase *Rebase) OperationCount() uint { + return uint(C.git_rebase_operation_entrycount(rebase.ptr)) +} + // Next performs the next rebase operation and returns the information about it. // If the operation is one that applies a patch (which is any operation except GIT_REBASE_OPERATION_EXEC) // then the patch will be applied and the index and working directory will be updated with the changes. @@ -104,7 +112,7 @@ func (rebase *Rebase) Next() (*RebaseOperation, error) { return nil, MakeGitError(err) } - return rebaseOperationFromC(ptr), nil + return newRebaseOperationFromC(ptr), nil } // Commit commits the current patch. @@ -148,9 +156,16 @@ func (rebase *Rebase) Finish() error { return nil } -// OperationCount gets the count of rebase operations that are to be applied. -func (rebase *Rebase) OperationCount() uint { - return uint(C.git_rebase_operation_entrycount(rebase.ptr)) +// Abort aborts a rebase that is currently in progress, resetting the repository and working directory to their state before rebase began. +func (rebase *Rebase) Abort() error { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + err := C.git_rebase_abort(rebase.ptr) + if err < 0 { + return MakeGitError(err) + } + return nil } //Free frees the Rebase object and underlying git_rebase C pointer. @@ -169,7 +184,5 @@ func newRebaseFromC(ptr *C.git_rebase) *Rebase { int git_rebase_init_options(git_rebase_options *opts, unsigned int version); int git_rebase_open(git_rebase **out, git_repository *repo, const git_rebase_options *opts); -git_rebase_operation * git_rebase_operation_byindex(git_rebase *rebase, size_t idx); -size_t git_rebase_operation_current(git_rebase *rebase); */ diff --git a/rebase_test.go b/rebase_test.go index dc5aeb3..e97a1a7 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -29,12 +29,12 @@ func TestRebaseAbort(t *testing.T) { // TEST repo := createTestRepo(t) + defer cleanupTestRepo(t, repo) seedTestRepo(t, repo) // Setup a repo with 2 branches and a different tree err := setupRepoForRebase(repo, masterCommit, branchName) checkFatal(t, err) - defer cleanupTestRepo(t, repo) // Create several commits in emile for _, commit := range emileCommits { @@ -84,12 +84,12 @@ func TestRebaseNoConflicts(t *testing.T) { // TEST repo := createTestRepo(t) + defer cleanupTestRepo(t, repo) seedTestRepo(t, repo) // Setup a repo with 2 branches and a different tree err := setupRepoForRebase(repo, masterCommit, branchName) checkFatal(t, err) - defer cleanupTestRepo(t, repo) // Create several commits in emile for _, commit := range emileCommits { @@ -154,25 +154,41 @@ func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { } defer onto.Free() + // Init rebase rebase, err := repo.RebaseInit(nil, nil, onto, nil) if err != nil { return nil, err } - opCount := int(rebase.OperationCount()) + // Check no operation has been started yet + if rebase.CurrentOperationIndex() != -1 { // -1 == GIT_REBASE_NO_OPERATION + return nil, errors.New("No operation should have been started yet") + } + // Iterate in rebase operations regarding operation count + opCount := int(rebase.OperationCount()) for op := 0; op < opCount; op++ { operation, err := rebase.Next() if err != nil { return nil, err } + // Check operation index is correct + if rebase.CurrentOperationIndex() != op { + return nil, errors.New("Bad operation index") + } + if !operationsAreEqual(rebase.OperationAt(uint(op)), operation) { + return nil, errors.New("Rebase operations should be equal") + } + + // Get current rebase operation created commit commit, err := repo.LookupCommit(operation.ID) if err != nil { return nil, err } defer commit.Free() + // Apply commit err = rebase.Commit(operation.ID, signature(), signature(), commit.Message()) if err != nil { return nil, err @@ -182,6 +198,10 @@ func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { return rebase, nil } +func operationsAreEqual(l, r *RebaseOperation) bool { + return l.Exec == r.Exec && l.Type == r.Type && l.ID.String() == r.ID.String() +} + func createBranch(repo *Repository, branch string) error { commit, err := headCommit(repo) if err != nil { -- 2.45.2 From b2d71f4fbc4bf6d0d1e5b29e38270f4760db3f04 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Mon, 8 Aug 2016 10:49:40 +1000 Subject: [PATCH 08/18] Fix Free() service in Rebase wrapper --- rebase.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rebase.go b/rebase.go index 2218295..ab112c0 100644 --- a/rebase.go +++ b/rebase.go @@ -171,7 +171,7 @@ func (rebase *Rebase) Abort() error { //Free frees the Rebase object and underlying git_rebase C pointer. func (rebase *Rebase) Free() { runtime.SetFinalizer(rebase, nil) - C.git_reference_free(rebase.ptr) + C.git_rebase_free(rebase.ptr) } func newRebaseFromC(ptr *C.git_rebase) *Rebase { -- 2.45.2 From e55c00eca7e70e2d02860cda3cdc9169a88ece36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sat, 27 Aug 2016 19:21:05 +0200 Subject: [PATCH 09/18] Run the tests in parallel This saves about 1s, or 1/3 of the test runtime. The linking is still much slower, but this we can control. --- blame_test.go | 1 + blob_test.go | 1 + branch_test.go | 2 ++ cherrypick_test.go | 1 + clone_test.go | 2 ++ config_test.go | 1 + describe_test.go | 1 + diff_test.go | 4 +++- git_test.go | 2 ++ index_test.go | 7 +++++++ merge_test.go | 5 +++++ note_test.go | 4 ++++ object_test.go | 3 +++ odb_test.go | 5 ++++- patch_test.go | 1 + push_test.go | 1 + reference_test.go | 6 ++++++ remote_test.go | 7 +++++++ reset_test.go | 1 + revparse_test.go | 3 +++ status_test.go | 2 ++ submodule_test.go | 1 + tag_test.go | 5 +++++ tree_test.go | 2 ++ 24 files changed, 66 insertions(+), 2 deletions(-) diff --git a/blame_test.go b/blame_test.go index a2a4d38..ec96af7 100644 --- a/blame_test.go +++ b/blame_test.go @@ -6,6 +6,7 @@ import ( ) func TestBlame(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/blob_test.go b/blob_test.go index 2b5ec4f..719d185 100644 --- a/blob_test.go +++ b/blob_test.go @@ -5,6 +5,7 @@ import ( ) func TestCreateBlobFromBuffer(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/branch_test.go b/branch_test.go index a0834a8..01a2e28 100644 --- a/branch_test.go +++ b/branch_test.go @@ -5,6 +5,7 @@ import ( ) func TestBranchIterator(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -27,6 +28,7 @@ func TestBranchIterator(t *testing.T) { } func TestBranchIteratorEach(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/cherrypick_test.go b/cherrypick_test.go index a3246bd..bfa5ca8 100644 --- a/cherrypick_test.go +++ b/cherrypick_test.go @@ -33,6 +33,7 @@ func readReadme(t *testing.T, repo *Repository) string { } func TestCherrypick(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/clone_test.go b/clone_test.go index a6bbf94..24c3a09 100644 --- a/clone_test.go +++ b/clone_test.go @@ -10,6 +10,7 @@ const ( ) func TestClone(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -35,6 +36,7 @@ func TestClone(t *testing.T) { } func TestCloneWithCallback(t *testing.T) { + t.Parallel() testPayload := 0 repo := createTestRepo(t) diff --git a/config_test.go b/config_test.go index fea8d8a..f31e73e 100644 --- a/config_test.go +++ b/config_test.go @@ -88,6 +88,7 @@ var tests = []TestRunner{ } func TestConfigLookups(t *testing.T) { + t.Parallel() var ( err error c *Config diff --git a/describe_test.go b/describe_test.go index 25af107..f0a45f4 100644 --- a/describe_test.go +++ b/describe_test.go @@ -8,6 +8,7 @@ import ( ) func TestDescribeCommit(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/diff_test.go b/diff_test.go index 850ed8e..6fbad51 100644 --- a/diff_test.go +++ b/diff_test.go @@ -7,6 +7,7 @@ import ( ) func TestFindSimilar(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -61,7 +62,7 @@ func TestFindSimilar(t *testing.T) { } func TestDiffTreeToTree(t *testing.T) { - + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -189,6 +190,7 @@ func createTestTrees(t *testing.T, repo *Repository) (originalTree *Tree, newTre } func TestDiffBlobs(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/git_test.go b/git_test.go index 58caf71..bdb6837 100644 --- a/git_test.go +++ b/git_test.go @@ -109,6 +109,7 @@ func updateReadme(t *testing.T, repo *Repository, content string) (*Oid, *Oid) { } func TestOidZero(t *testing.T) { + t.Parallel() var zeroId Oid if !zeroId.IsZero() { @@ -117,6 +118,7 @@ func TestOidZero(t *testing.T) { } func TestEmptyOid(t *testing.T) { + t.Parallel() _, err := NewOid("") if err == nil || !IsErrorCode(err, ErrGeneric) { t.Fatal("Should have returned invalid error") diff --git a/index_test.go b/index_test.go index 5f6b375..600b8b1 100644 --- a/index_test.go +++ b/index_test.go @@ -8,6 +8,7 @@ import ( ) func TestCreateRepoAndStage(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -24,6 +25,7 @@ func TestCreateRepoAndStage(t *testing.T) { } func TestIndexReadTree(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -53,6 +55,7 @@ func TestIndexReadTree(t *testing.T) { } func TestIndexWriteTreeTo(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -72,6 +75,7 @@ func TestIndexWriteTreeTo(t *testing.T) { } func TestIndexAddAndWriteTreeTo(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -106,6 +110,7 @@ func TestIndexAddAndWriteTreeTo(t *testing.T) { } func TestIndexAddAllNoCallback(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -127,6 +132,7 @@ func TestIndexAddAllNoCallback(t *testing.T) { } func TestIndexAddAllCallback(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -155,6 +161,7 @@ func TestIndexAddAllCallback(t *testing.T) { } func TestIndexOpen(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/merge_test.go b/merge_test.go index 8059727..f2c84bc 100644 --- a/merge_test.go +++ b/merge_test.go @@ -6,6 +6,7 @@ import ( ) func TestMergeWithSelf(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -24,6 +25,7 @@ func TestMergeWithSelf(t *testing.T) { } func TestMergeAnalysisWithSelf(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -46,6 +48,7 @@ func TestMergeAnalysisWithSelf(t *testing.T) { } func TestMergeSameFile(t *testing.T) { + t.Parallel() file := MergeFileInput{ Path: "test", Mode: 33188, @@ -68,6 +71,7 @@ func TestMergeSameFile(t *testing.T) { } func TestMergeTreesWithoutAncestor(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -125,6 +129,7 @@ func appendCommit(t *testing.T, repo *Repository) (*Oid, *Oid) { } func TestMergeBase(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/note_test.go b/note_test.go index 27e04be..9f64eb8 100644 --- a/note_test.go +++ b/note_test.go @@ -8,6 +8,7 @@ import ( ) func TestCreateNote(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -27,6 +28,7 @@ func TestCreateNote(t *testing.T) { } func TestNoteIterator(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -63,6 +65,7 @@ func TestNoteIterator(t *testing.T) { } func TestRemoveNote(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -86,6 +89,7 @@ func TestRemoveNote(t *testing.T) { } func TestDefaultNoteRef(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/object_test.go b/object_test.go index 2ae2a6a..cb262de 100644 --- a/object_test.go +++ b/object_test.go @@ -5,6 +5,7 @@ import ( ) func TestObjectPoymorphism(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -88,6 +89,7 @@ func checkOwner(t *testing.T, repo *Repository, obj Object) { } func TestObjectOwner(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -104,6 +106,7 @@ func TestObjectOwner(t *testing.T) { } func TestObjectPeel(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/odb_test.go b/odb_test.go index dfd2ad0..3d22fc9 100644 --- a/odb_test.go +++ b/odb_test.go @@ -7,6 +7,7 @@ import ( ) func TestOdbReadHeader(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -35,6 +36,7 @@ func TestOdbReadHeader(t *testing.T) { } func TestOdbStream(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -64,7 +66,7 @@ func TestOdbStream(t *testing.T) { } func TestOdbHash(t *testing.T) { - + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -92,6 +94,7 @@ Initial commit.` } func TestOdbForeach(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/patch_test.go b/patch_test.go index 2d52fb4..291c705 100644 --- a/patch_test.go +++ b/patch_test.go @@ -6,6 +6,7 @@ import ( ) func TestPatch(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/push_test.go b/push_test.go index 8f6e806..f372882 100644 --- a/push_test.go +++ b/push_test.go @@ -5,6 +5,7 @@ import ( ) func TestRemotePush(t *testing.T) { + t.Parallel() repo := createBareTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/reference_test.go b/reference_test.go index 761daf8..b6721e1 100644 --- a/reference_test.go +++ b/reference_test.go @@ -8,6 +8,7 @@ import ( ) func TestRefModification(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -53,6 +54,7 @@ func TestRefModification(t *testing.T) { } func TestReferenceIterator(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -131,6 +133,7 @@ func TestReferenceIterator(t *testing.T) { } func TestReferenceOwner(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -150,6 +153,7 @@ func TestReferenceOwner(t *testing.T) { } func TestUtil(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -177,6 +181,7 @@ func TestUtil(t *testing.T) { } func TestIsNote(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -210,6 +215,7 @@ func TestIsNote(t *testing.T) { } func TestReferenceIsValidName(t *testing.T) { + t.Parallel() if !ReferenceIsValidName("HEAD") { t.Errorf("HEAD should be a valid reference name") } diff --git a/remote_test.go b/remote_test.go index 978b803..3d00640 100644 --- a/remote_test.go +++ b/remote_test.go @@ -6,6 +6,7 @@ import ( ) func TestListRemotes(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -33,6 +34,7 @@ func assertHostname(cert *Certificate, valid bool, hostname string, t *testing.T } func TestCertificateCheck(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -52,6 +54,7 @@ func TestCertificateCheck(t *testing.T) { } func TestRemoteConnect(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -63,6 +66,7 @@ func TestRemoteConnect(t *testing.T) { } func TestRemoteLs(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -81,6 +85,7 @@ func TestRemoteLs(t *testing.T) { } func TestRemoteLsFiltering(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -107,6 +112,7 @@ func TestRemoteLsFiltering(t *testing.T) { } func TestRemotePruneRefs(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -129,6 +135,7 @@ func TestRemotePruneRefs(t *testing.T) { } func TestRemotePrune(t *testing.T) { + t.Parallel() remoteRepo := createTestRepo(t) defer cleanupTestRepo(t, remoteRepo) diff --git a/reset_test.go b/reset_test.go index ec578bd..45777e4 100644 --- a/reset_test.go +++ b/reset_test.go @@ -6,6 +6,7 @@ import ( ) func TestResetToCommit(t *testing.T) { + t.Parallel() repo := createTestRepo(t) seedTestRepo(t, repo) // create commit to reset to diff --git a/revparse_test.go b/revparse_test.go index 75e9ffd..2835434 100644 --- a/revparse_test.go +++ b/revparse_test.go @@ -5,6 +5,7 @@ import ( ) func TestRevparse(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -17,6 +18,7 @@ func TestRevparse(t *testing.T) { } func TestRevparseSingle(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -29,6 +31,7 @@ func TestRevparseSingle(t *testing.T) { } func TestRevparseExt(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/status_test.go b/status_test.go index 5b97b00..17ed94f 100644 --- a/status_test.go +++ b/status_test.go @@ -7,6 +7,7 @@ import ( ) func TestStatusFile(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -27,6 +28,7 @@ func TestStatusFile(t *testing.T) { } func TestStatusList(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/submodule_test.go b/submodule_test.go index 43c890a..fa2e98c 100644 --- a/submodule_test.go +++ b/submodule_test.go @@ -5,6 +5,7 @@ import ( ) func TestSubmoduleForeach(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/tag_test.go b/tag_test.go index 2fdfe00..3404923 100644 --- a/tag_test.go +++ b/tag_test.go @@ -7,6 +7,7 @@ import ( ) func TestCreateTag(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -26,6 +27,7 @@ func TestCreateTag(t *testing.T) { } func TestCreateTagLightweight(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -50,6 +52,7 @@ func TestCreateTagLightweight(t *testing.T) { } func TestListTags(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -79,6 +82,7 @@ func TestListTags(t *testing.T) { } func TestListTagsWithMatch(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -116,6 +120,7 @@ func TestListTagsWithMatch(t *testing.T) { } func TestTagForeach(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) diff --git a/tree_test.go b/tree_test.go index fae395a..f5b6822 100644 --- a/tree_test.go +++ b/tree_test.go @@ -3,6 +3,7 @@ package git import "testing" func TestTreeEntryById(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -22,6 +23,7 @@ func TestTreeEntryById(t *testing.T) { } func TestTreeBuilderInsert(t *testing.T) { + t.Parallel() repo := createTestRepo(t) defer cleanupTestRepo(t, repo) -- 2.45.2 From 3c1ba8c40e4d654bfca8b535c861a63c41b16f27 Mon Sep 17 00:00:00 2001 From: Itamar Turner-Trauring Date: Sat, 27 Aug 2016 20:44:46 +0200 Subject: [PATCH 10/18] Add test for slice-to-slice and GCo pointer detection --- .travis.yml | 1 + blob_test.go | 26 ++++++++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/.travis.yml b/.travis.yml index f796389..016cf2d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,6 +10,7 @@ go: - 1.3 - 1.4 - 1.5 + - 1.6 - tip matrix: diff --git a/blob_test.go b/blob_test.go index 2b5ec4f..652c50c 100644 --- a/blob_test.go +++ b/blob_test.go @@ -1,9 +1,21 @@ package git import ( + "bytes" "testing" ) +type bufWrapper struct { + buf [64]byte + pointer []byte +} + +func doublePointerBytes() []byte { + o := &bufWrapper{} + o.pointer = o.buf[0:10] + return o.pointer[0:1] +} + func TestCreateBlobFromBuffer(t *testing.T) { repo := createTestRepo(t) defer cleanupTestRepo(t, repo) @@ -14,4 +26,18 @@ func TestCreateBlobFromBuffer(t *testing.T) { if id.String() != "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" { t.Fatal("Empty buffer did not deliver empty blob id") } + + for _, data := range []([]byte){[]byte("hello there"), doublePointerBytes()} { + expected := make([]byte, len(data)) + copy(expected, data) + id, err = repo.CreateBlobFromBuffer(data) + checkFatal(t, err) + + blob, err := repo.LookupBlob(id) + checkFatal(t, err) + if !bytes.Equal(blob.Contents(), expected) { + t.Fatal("Loaded bytes don't match original bytes:", + blob.Contents(), "!=", expected) + } + } } -- 2.45.2 From b5d213c2c1229ea5de524ee24a9d9635a9cf303f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sat, 27 Aug 2016 20:47:41 +0200 Subject: [PATCH 11/18] Remove unecessary copy --- blob_test.go | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/blob_test.go b/blob_test.go index 652c50c..6b7cd49 100644 --- a/blob_test.go +++ b/blob_test.go @@ -28,16 +28,14 @@ func TestCreateBlobFromBuffer(t *testing.T) { } for _, data := range []([]byte){[]byte("hello there"), doublePointerBytes()} { - expected := make([]byte, len(data)) - copy(expected, data) id, err = repo.CreateBlobFromBuffer(data) checkFatal(t, err) blob, err := repo.LookupBlob(id) checkFatal(t, err) - if !bytes.Equal(blob.Contents(), expected) { + if !bytes.Equal(blob.Contents(), data) { t.Fatal("Loaded bytes don't match original bytes:", - blob.Contents(), "!=", expected) + blob.Contents(), "!=", data) } } } -- 2.45.2 From b41e4c4ac7c7ec4d45ec5d8903077bd01264549f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sat, 27 Aug 2016 20:51:13 +0200 Subject: [PATCH 12/18] Work around Go 1.6's CGo pointer check It depends heavily on the expression at the call site an whether it can figure out whether we're using a slice or not, so provid an incantation that does this. --- blob.go | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/blob.go b/blob.go index 1a86e60..8b3e94f 100644 --- a/blob.go +++ b/blob.go @@ -37,15 +37,24 @@ func (repo *Repository) CreateBlobFromBuffer(data []byte) (*Oid, error) { defer runtime.UnlockOSThread() var id C.git_oid - var ptr unsafe.Pointer + var size C.size_t + // Go 1.6 added some increased checking of passing pointer to + // C, but its check depends on its expectations of waht we + // pass to the C function, so unless we take the address of + // its contents at the call site itself, it can fail when + // 'data' is a slice of a slice. + // + // When we're given an empty slice, create a dummy one where 0 + // isn't out of bounds. if len(data) > 0 { - ptr = unsafe.Pointer(&data[0]) + size = C.size_t(len(data)) } else { - ptr = unsafe.Pointer(nil) + data = []byte{0} + size = C.size_t(0) } - ecode := C.git_blob_create_frombuffer(&id, repo.ptr, ptr, C.size_t(len(data))) + ecode := C.git_blob_create_frombuffer(&id, repo.ptr, unsafe.Pointer(&data[0]), size) if ecode < 0 { return nil, MakeGitError(ecode) } -- 2.45.2 From 5c678353faa4f180ee4ad8a5e58ca71e093cf757 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sat, 27 Aug 2016 20:52:07 +0200 Subject: [PATCH 13/18] Add Go 1.7 to the build list --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 016cf2d..79ad168 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,6 +11,7 @@ go: - 1.4 - 1.5 - 1.6 + - 1.7 - tip matrix: -- 2.45.2 From e00b0831aaefeceab320c8d2fdc23fffcca58168 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Tue, 6 Sep 2016 14:15:10 +1000 Subject: [PATCH 14/18] Add RebaseOpen() service to wrapper --- rebase.go | 20 +++++++++++++++++++- rebase_test.go | 16 +++++++++++++++- 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/rebase.go b/rebase.go index ab112c0..a51b7ce 100644 --- a/rebase.go +++ b/rebase.go @@ -81,6 +81,25 @@ func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedComm return newRebaseFromC(ptr), nil } +//RebaseOpen opens an existing rebase that was previously started by either an invocation of git_rebase_init or by another client. +func (r *Repository) RebaseOpen(opts *RebaseOptions) (*Rebase, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + //TODO : use real rebase_options + if opts != nil { + return nil, errors.New("RebaseOptions Not implemented yet, use nil for default opts") + } + + var ptr *C.git_rebase + err := C.git_rebase_open(&ptr, r.ptr, nil) + if err < 0 { + return nil, MakeGitError(err) + } + + return newRebaseFromC(ptr), nil +} + // OperationAt gets the rebase operation specified by the given index. func (rebase *Rebase) OperationAt(index uint) *RebaseOperation { operation := C.git_rebase_operation_byindex(rebase.ptr, C.size_t(index)) @@ -183,6 +202,5 @@ func newRebaseFromC(ptr *C.git_rebase) *Rebase { /* TODO -- Add last wrapper services and manage rebase_options int git_rebase_init_options(git_rebase_options *opts, unsigned int version); -int git_rebase_open(git_rebase **out, git_repository *repo, const git_rebase_options *opts); */ diff --git a/rebase_test.go b/rebase_test.go index e97a1a7..745297e 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -87,8 +87,14 @@ func TestRebaseNoConflicts(t *testing.T) { defer cleanupTestRepo(t, repo) seedTestRepo(t, repo) + // Try to open existing rebase + oRebase, err := repo.RebaseOpen(nil) + if err == nil { + t.Fatal("Did not expect to find a rebase in progress") + } + // Setup a repo with 2 branches and a different tree - err := setupRepoForRebase(repo, masterCommit, branchName) + err = setupRepoForRebase(repo, masterCommit, branchName) checkFatal(t, err) // Create several commits in emile @@ -102,6 +108,14 @@ func TestRebaseNoConflicts(t *testing.T) { checkFatal(t, err) defer rebase.Free() + // Open existing rebase + oRebase, err = repo.RebaseOpen(nil) + checkFatal(t, err) + defer oRebase.Free() + if oRebase == nil { + t.Fatal("Expected to find an existing rebase in progress") + } + // Finish the rebase properly err = rebase.Finish() checkFatal(t, err) -- 2.45.2 From adc3a4bd89723785b5f04dd14691472300a03bdb Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Tue, 13 Sep 2016 16:03:16 +1000 Subject: [PATCH 15/18] Add DefaultRebaseOptions() [git_rebase_init_options(GIT_REBASE_OPTIONS_VERSION)] service to wrapper --- rebase.go | 69 +++++++++++++++++++++++++++++++++++--------------- rebase_test.go | 23 +++++++++++++++++ 2 files changed, 72 insertions(+), 20 deletions(-) diff --git a/rebase.go b/rebase.go index a51b7ce..464840b 100644 --- a/rebase.go +++ b/rebase.go @@ -5,7 +5,6 @@ package git */ import "C" import ( - "errors" "runtime" "unsafe" ) @@ -43,7 +42,53 @@ func newRebaseOperationFromC(c *C.git_rebase_operation) *RebaseOperation { } // RebaseOptions are used to tell the rebase machinery how to operate -type RebaseOptions struct{} +type RebaseOptions struct { + Version uint + Quiet int + InMemory int + RewriteNotesRef string + MergeOptions MergeOptions + CheckoutOptions CheckoutOpts +} + +// DefaultRebaseOptions returns a RebaseOptions with default values. +func DefaultRebaseOptions() (RebaseOptions, error) { + opts := C.git_rebase_options{} + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ecode := C.git_rebase_init_options(&opts, C.GIT_REBASE_OPTIONS_VERSION) + if ecode < 0 { + return RebaseOptions{}, MakeGitError(ecode) + } + return rebaseOptionsFromC(&opts), nil +} + +func rebaseOptionsFromC(opts *C.git_rebase_options) RebaseOptions { + return RebaseOptions{ + Version: uint(opts.version), + Quiet: int(opts.quiet), + InMemory: int(opts.inmemory), + RewriteNotesRef: C.GoString(opts.rewrite_notes_ref), + MergeOptions: mergeOptionsFromC(&opts.merge_options), + CheckoutOptions: checkoutOptionsFromC(&opts.checkout_options), + } +} + +func (ro *RebaseOptions) toC() *C.git_rebase_options { + if ro == nil { + return nil + } + return &C.git_rebase_options{ + version: C.uint(ro.Version), + quiet: C.int(ro.Quiet), + inmemory: C.int(ro.InMemory), + rewrite_notes_ref: C.CString(ro.RewriteNotesRef), + merge_options: *ro.MergeOptions.toC(), + checkout_options: *ro.CheckoutOptions.toC(), + } +} // Rebase object wrapper for C pointer type Rebase struct { @@ -55,11 +100,6 @@ func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedComm runtime.LockOSThread() defer runtime.UnlockOSThread() - //TODO : use real rebase_options - if opts != nil { - return nil, errors.New("RebaseOptions Not implemented yet, use nil for default opts") - } - if branch == nil { branch = &AnnotatedCommit{ptr: nil} } @@ -73,7 +113,7 @@ func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedComm } var ptr *C.git_rebase - err := C.git_rebase_init(&ptr, r.ptr, branch.ptr, upstream.ptr, onto.ptr, nil) + err := C.git_rebase_init(&ptr, r.ptr, branch.ptr, upstream.ptr, onto.ptr, opts.toC()) if err < 0 { return nil, MakeGitError(err) } @@ -86,13 +126,8 @@ func (r *Repository) RebaseOpen(opts *RebaseOptions) (*Rebase, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() - //TODO : use real rebase_options - if opts != nil { - return nil, errors.New("RebaseOptions Not implemented yet, use nil for default opts") - } - var ptr *C.git_rebase - err := C.git_rebase_open(&ptr, r.ptr, nil) + err := C.git_rebase_open(&ptr, r.ptr, opts.toC()) if err < 0 { return nil, MakeGitError(err) } @@ -198,9 +233,3 @@ func newRebaseFromC(ptr *C.git_rebase) *Rebase { runtime.SetFinalizer(rebase, (*Rebase).Free) return rebase } - -/* TODO -- Add last wrapper services and manage rebase_options - -int git_rebase_init_options(git_rebase_options *opts, unsigned int version); - -*/ diff --git a/rebase_test.go b/rebase_test.go index 745297e..f76baed 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -9,6 +9,29 @@ import ( // Tests +func TestDefaultRebaseOptions(t *testing.T) { + opts, err := DefaultRebaseOptions() + checkFatal(t, err) + + if opts.Version != 1 { + t.Error("Expected opts Version to equal 1, got ", opts.Version) + } + if opts.Quiet != 0 { + t.Error("Expected opts Quiet to equal 1, got ", opts.Quiet) + } + if opts.InMemory != 0 { + t.Error("Expected opts InMemory to equal 1, got ", opts.InMemory) + } + if opts.RewriteNotesRef != "" { + t.Error("Expected opts RewriteNotesRef to equal 1, got ", opts.RewriteNotesRef) + } + + copts := opts.toC() + if copts == nil { + t.Error("Copts should not be nil") + } +} + func TestRebaseAbort(t *testing.T) { // TEST DATA -- 2.45.2 From 03e10c56391b1d7ca7e2c4e59417500bea2bd242 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Wed, 14 Sep 2016 14:42:58 +1000 Subject: [PATCH 16/18] Fix reference bug introduced with RebaseOptions implementation --- rebase.go | 9 ++++++++- rebase_test.go | 6 ++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/rebase.go b/rebase.go index 464840b..f28c7f6 100644 --- a/rebase.go +++ b/rebase.go @@ -84,12 +84,19 @@ func (ro *RebaseOptions) toC() *C.git_rebase_options { version: C.uint(ro.Version), quiet: C.int(ro.Quiet), inmemory: C.int(ro.InMemory), - rewrite_notes_ref: C.CString(ro.RewriteNotesRef), + rewrite_notes_ref: rewriteNotesRefToC(ro.RewriteNotesRef), merge_options: *ro.MergeOptions.toC(), checkout_options: *ro.CheckoutOptions.toC(), } } +func rewriteNotesRefToC(ref string) *C.char { + if ref == "" { + return nil + } + return C.CString(ref) +} + // Rebase object wrapper for C pointer type Rebase struct { ptr *C.git_rebase diff --git a/rebase_test.go b/rebase_test.go index f76baed..38d6868 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -143,6 +143,12 @@ func TestRebaseNoConflicts(t *testing.T) { err = rebase.Finish() checkFatal(t, err) + // Check no more rebase is in progress + oRebase, err = repo.RebaseOpen(nil) + if err == nil { + t.Fatal("Did not expect to find a rebase in progress") + } + // Check history is in correct order actualHistory, err := commitMsgsList(repo) checkFatal(t, err) -- 2.45.2 From a671e67ee884c0c69b6216ac0bff01dfde4dd622 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Tue, 1 Nov 2016 10:57:23 +1100 Subject: [PATCH 17/18] Took @carlosmn PR review into account --- git.go | 1 + rebase.go | 35 ++++++++++++++++++++--------------- rebase_test.go | 20 +++++++++++--------- 3 files changed, 32 insertions(+), 24 deletions(-) diff --git a/git.go b/git.go index ed891e6..e272389 100644 --- a/git.go +++ b/git.go @@ -50,6 +50,7 @@ const ( ErrClassFilter ErrorClass = C.GITERR_FILTER ErrClassRevert ErrorClass = C.GITERR_REVERT ErrClassCallback ErrorClass = C.GITERR_CALLBACK + ErrClassRebase ErrorClass = C.GITERR_REBASE ) type ErrorCode int diff --git a/rebase.go b/rebase.go index f28c7f6..8384d68 100644 --- a/rebase.go +++ b/rebase.go @@ -28,14 +28,14 @@ const ( // RebaseOperation describes a single instruction/operation to be performed during the rebase. type RebaseOperation struct { Type RebaseOperationType - ID *Oid + Id *Oid Exec string } func newRebaseOperationFromC(c *C.git_rebase_operation) *RebaseOperation { operation := &RebaseOperation{} operation.Type = RebaseOperationType(c._type) - operation.ID = newOidFromC(&c.id) + operation.Id = newOidFromC(&c.id) operation.Exec = C.GoString(c.exec) return operation @@ -84,26 +84,26 @@ func (ro *RebaseOptions) toC() *C.git_rebase_options { version: C.uint(ro.Version), quiet: C.int(ro.Quiet), inmemory: C.int(ro.InMemory), - rewrite_notes_ref: rewriteNotesRefToC(ro.RewriteNotesRef), + rewrite_notes_ref: mapEmptyStringToNull(ro.RewriteNotesRef), merge_options: *ro.MergeOptions.toC(), checkout_options: *ro.CheckoutOptions.toC(), } } -func rewriteNotesRefToC(ref string) *C.char { +func mapEmptyStringToNull(ref string) *C.char { if ref == "" { return nil } return C.CString(ref) } -// Rebase object wrapper for C pointer +// Rebase is the struct representing a Rebase object. type Rebase struct { ptr *C.git_rebase } -//RebaseInit initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch. -func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) { +// InitRebase initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch. +func (r *Repository) InitRebase(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() @@ -128,8 +128,8 @@ func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedComm return newRebaseFromC(ptr), nil } -//RebaseOpen opens an existing rebase that was previously started by either an invocation of git_rebase_init or by another client. -func (r *Repository) RebaseOpen(opts *RebaseOptions) (*Rebase, error) { +// OpenRebase opens an existing rebase that was previously started by either an invocation of InitRebase or by another client. +func (r *Repository) OpenRebase(opts *RebaseOptions) (*Rebase, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() @@ -149,9 +149,13 @@ func (rebase *Rebase) OperationAt(index uint) *RebaseOperation { } // CurrentOperationIndex gets the index of the rebase operation that is currently being applied. -// If the first operation has not yet been applied then this returns -1 (C.GIT_REBASE_NO_OPERATION). -func (rebase *Rebase) CurrentOperationIndex() int { - return int(C.git_rebase_operation_current(rebase.ptr)) +// Returns an error if no rebase operation is currently applied. +func (rebase *Rebase) CurrentOperationIndex() (uint, error) { + operationIndex := int(C.git_rebase_operation_current(rebase.ptr)) + if operationIndex == C.GIT_REBASE_NO_OPERATION { + return 0, MakeGitError(C.GIT_REBASE_NO_OPERATION) + } + return uint(operationIndex), nil } // OperationCount gets the count of rebase operations that are to be applied. @@ -160,7 +164,7 @@ func (rebase *Rebase) OperationCount() uint { } // Next performs the next rebase operation and returns the information about it. -// If the operation is one that applies a patch (which is any operation except GIT_REBASE_OPERATION_EXEC) +// If the operation is one that applies a patch (which is any operation except RebaseOperationExec) // then the patch will be applied and the index and working directory will be updated with the changes. // If there are conflicts, you will need to address those before committing the changes. func (rebase *Rebase) Next() (*RebaseOperation, error) { @@ -177,7 +181,7 @@ func (rebase *Rebase) Next() (*RebaseOperation, error) { } // Commit commits the current patch. -// You must have resolved any conflicts that were introduced during the patch application from the git_rebase_next invocation. +// You must have resolved any conflicts that were introduced during the patch application from the Next() invocation. func (rebase *Rebase) Commit(ID *Oid, author, committer *Signature, message string) error { runtime.LockOSThread() defer runtime.UnlockOSThread() @@ -192,6 +196,7 @@ func (rebase *Rebase) Commit(ID *Oid, author, committer *Signature, message stri if err != nil { return err } + defer C.git_signature_free(committerSig) cmsg := C.CString(message) defer C.free(unsafe.Pointer(cmsg)) @@ -229,7 +234,7 @@ func (rebase *Rebase) Abort() error { return nil } -//Free frees the Rebase object and underlying git_rebase C pointer. +// Free frees the Rebase object. func (rebase *Rebase) Free() { runtime.SetFinalizer(rebase, nil) C.git_rebase_free(rebase.ptr) diff --git a/rebase_test.go b/rebase_test.go index 38d6868..9c8e0c2 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -111,7 +111,7 @@ func TestRebaseNoConflicts(t *testing.T) { seedTestRepo(t, repo) // Try to open existing rebase - oRebase, err := repo.RebaseOpen(nil) + oRebase, err := repo.OpenRebase(nil) if err == nil { t.Fatal("Did not expect to find a rebase in progress") } @@ -132,7 +132,7 @@ func TestRebaseNoConflicts(t *testing.T) { defer rebase.Free() // Open existing rebase - oRebase, err = repo.RebaseOpen(nil) + oRebase, err = repo.OpenRebase(nil) checkFatal(t, err) defer oRebase.Free() if oRebase == nil { @@ -144,7 +144,7 @@ func TestRebaseNoConflicts(t *testing.T) { checkFatal(t, err) // Check no more rebase is in progress - oRebase, err = repo.RebaseOpen(nil) + oRebase, err = repo.OpenRebase(nil) if err == nil { t.Fatal("Did not expect to find a rebase in progress") } @@ -198,13 +198,14 @@ func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { defer onto.Free() // Init rebase - rebase, err := repo.RebaseInit(nil, nil, onto, nil) + rebase, err := repo.InitRebase(nil, nil, onto, nil) if err != nil { return nil, err } // Check no operation has been started yet - if rebase.CurrentOperationIndex() != -1 { // -1 == GIT_REBASE_NO_OPERATION + rebaseOperationIndex, err := rebase.CurrentOperationIndex() + if err == nil { return nil, errors.New("No operation should have been started yet") } @@ -217,7 +218,8 @@ func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { } // Check operation index is correct - if rebase.CurrentOperationIndex() != op { + rebaseOperationIndex, err = rebase.CurrentOperationIndex() + if int(rebaseOperationIndex) != op { return nil, errors.New("Bad operation index") } if !operationsAreEqual(rebase.OperationAt(uint(op)), operation) { @@ -225,14 +227,14 @@ func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { } // Get current rebase operation created commit - commit, err := repo.LookupCommit(operation.ID) + commit, err := repo.LookupCommit(operation.Id) if err != nil { return nil, err } defer commit.Free() // Apply commit - err = rebase.Commit(operation.ID, signature(), signature(), commit.Message()) + err = rebase.Commit(operation.Id, signature(), signature(), commit.Message()) if err != nil { return nil, err } @@ -242,7 +244,7 @@ func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) { } func operationsAreEqual(l, r *RebaseOperation) bool { - return l.Exec == r.Exec && l.Type == r.Type && l.ID.String() == r.ID.String() + return l.Exec == r.Exec && l.Type == r.Type && l.Id.String() == r.Id.String() } func createBranch(repo *Repository, branch string) error { -- 2.45.2 From 6118c9ba37f494cbb892aa686416280ae6ee6593 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Wed, 23 Nov 2016 17:10:59 +1100 Subject: [PATCH 18/18] LockOSThread in CurrentOperationIndex for git error creation --- rebase.go | 5 +++++ rebase_test.go | 23 ----------------------- 2 files changed, 5 insertions(+), 23 deletions(-) diff --git a/rebase.go b/rebase.go index 8384d68..8553e25 100644 --- a/rebase.go +++ b/rebase.go @@ -145,16 +145,21 @@ func (r *Repository) OpenRebase(opts *RebaseOptions) (*Rebase, error) { // OperationAt gets the rebase operation specified by the given index. func (rebase *Rebase) OperationAt(index uint) *RebaseOperation { operation := C.git_rebase_operation_byindex(rebase.ptr, C.size_t(index)) + return newRebaseOperationFromC(operation) } // CurrentOperationIndex gets the index of the rebase operation that is currently being applied. // Returns an error if no rebase operation is currently applied. func (rebase *Rebase) CurrentOperationIndex() (uint, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + operationIndex := int(C.git_rebase_operation_current(rebase.ptr)) if operationIndex == C.GIT_REBASE_NO_OPERATION { return 0, MakeGitError(C.GIT_REBASE_NO_OPERATION) } + return uint(operationIndex), nil } diff --git a/rebase_test.go b/rebase_test.go index 9c8e0c2..fb88a4e 100644 --- a/rebase_test.go +++ b/rebase_test.go @@ -9,29 +9,6 @@ import ( // Tests -func TestDefaultRebaseOptions(t *testing.T) { - opts, err := DefaultRebaseOptions() - checkFatal(t, err) - - if opts.Version != 1 { - t.Error("Expected opts Version to equal 1, got ", opts.Version) - } - if opts.Quiet != 0 { - t.Error("Expected opts Quiet to equal 1, got ", opts.Quiet) - } - if opts.InMemory != 0 { - t.Error("Expected opts InMemory to equal 1, got ", opts.InMemory) - } - if opts.RewriteNotesRef != "" { - t.Error("Expected opts RewriteNotesRef to equal 1, got ", opts.RewriteNotesRef) - } - - copts := opts.toC() - if copts == nil { - t.Error("Copts should not be nil") - } -} - func TestRebaseAbort(t *testing.T) { // TEST DATA -- 2.45.2