Initial rebase wrapper version
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 <git2.h>
+*/
+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")
+ }
+}
