From b1a9de8037e4260dcd840db38e2e16473cdddcb6 Mon Sep 17 00:00:00 2001 From: ezwiebel Date: Sun, 7 Aug 2016 14:40:59 +1000 Subject: [PATCH] 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") + } +}