Merge pull request #366 from LinuxBozo/repository-open-flags
Add new repository open flags
diff --git a/git.go b/git.go
index cb973ee..c032b0a 100644
--- a/git.go
+++ b/git.go
@@ -53,6 +53,7 @@
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/patch.go b/patch.go
index 45e14ac..0d0df7f 100644
--- a/patch.go
+++ b/patch.go
@@ -40,15 +40,18 @@
if patch.ptr == nil {
return "", ErrInvalid
}
- var buf C.git_buf
runtime.LockOSThread()
defer runtime.UnlockOSThread()
+ var buf C.git_buf
+
ecode := C.git_patch_to_buf(&buf, patch.ptr)
if ecode < 0 {
return "", MakeGitError(ecode)
}
+ defer C.git_buf_free(&buf)
+
return C.GoString(buf.ptr), nil
}
diff --git a/rebase.go b/rebase.go
new file mode 100644
index 0000000..8553e25
--- /dev/null
+++ b/rebase.go
@@ -0,0 +1,252 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "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 newRebaseOperationFromC(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 {
+ 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: mapEmptyStringToNull(ro.RewriteNotesRef),
+ merge_options: *ro.MergeOptions.toC(),
+ checkout_options: *ro.CheckoutOptions.toC(),
+ }
+}
+
+func mapEmptyStringToNull(ref string) *C.char {
+ if ref == "" {
+ return nil
+ }
+ return C.CString(ref)
+}
+
+// Rebase is the struct representing a Rebase object.
+type Rebase struct {
+ ptr *C.git_rebase
+}
+
+// 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()
+
+ 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, opts.toC())
+ if err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return newRebaseFromC(ptr), nil
+}
+
+// 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()
+
+ var ptr *C.git_rebase
+ err := C.git_rebase_open(&ptr, r.ptr, opts.toC())
+ 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))
+
+ 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
+}
+
+// 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 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) {
+ 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 newRebaseOperationFromC(ptr), nil
+}
+
+// Commit commits the current patch.
+// 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()
+
+ authorSig, err := author.toC()
+ if err != nil {
+ return err
+ }
+ defer C.git_signature_free(authorSig)
+
+ committerSig, err := committer.toC()
+ if err != nil {
+ return err
+ }
+ defer C.git_signature_free(committerSig)
+
+ 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
+}
+
+// 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.
+func (rebase *Rebase) Free() {
+ runtime.SetFinalizer(rebase, nil)
+ C.git_rebase_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..fb88a4e
--- /dev/null
+++ b/rebase_test.go
@@ -0,0 +1,381 @@
+package git
+
+import (
+ "errors"
+ "strconv"
+ "testing"
+ "time"
+)
+
+// 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)
+ 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)
+
+ // 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
+
+ // Inputs
+ branchName := "emile"
+ masterCommit := "something"
+ emileCommits := []string{
+ "fou",
+ "barre",
+ "ouich",
+ }
+
+ // Outputs
+ expectedHistory := []string{
+ "Test rebase, Baby! " + emileCommits[2],
+ "Test rebase, Baby! " + emileCommits[1],
+ "Test rebase, Baby! " + emileCommits[0],
+ "Test rebase, Baby! " + masterCommit,
+ "This is a commit\n",
+ }
+
+ // TEST
+ repo := createTestRepo(t)
+ defer cleanupTestRepo(t, repo)
+ seedTestRepo(t, repo)
+
+ // Try to open existing rebase
+ oRebase, err := repo.OpenRebase(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)
+ checkFatal(t, err)
+
+ // Create several commits in emile
+ for _, commit := range emileCommits {
+ _, err = commitSomething(repo, commit, commit)
+ checkFatal(t, err)
+ }
+
+ // Rebase onto master
+ rebase, err := performRebaseOnto(repo, "master")
+ checkFatal(t, err)
+ defer rebase.Free()
+
+ // Open existing rebase
+ oRebase, err = repo.OpenRebase(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)
+
+ // Check no more rebase is in progress
+ oRebase, err = repo.OpenRebase(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)
+ 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) (*Rebase, error) {
+ master, err := repo.LookupBranch(branch, BranchLocal)
+ if err != nil {
+ return nil, err
+ }
+ defer master.Free()
+
+ onto, err := repo.AnnotatedCommitFromRef(master.Reference)
+ if err != nil {
+ return nil, err
+ }
+ defer onto.Free()
+
+ // Init rebase
+ rebase, err := repo.InitRebase(nil, nil, onto, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ // Check no operation has been started yet
+ rebaseOperationIndex, err := rebase.CurrentOperationIndex()
+ if err == nil {
+ 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
+ rebaseOperationIndex, err = rebase.CurrentOperationIndex()
+ if int(rebaseOperationIndex) != 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
+ }
+ }
+
+ 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 {
+ return err
+ }
+ defer commit.Free()
+ _, 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 headCommit(repo *Repository) (*Commit, error) {
+ head, err := repo.Head()
+ if err != nil {
+ return nil, err
+ }
+ defer head.Free()
+
+ 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(content))
+ 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
+ }
+ defer newTree.Free()
+
+ if err != nil {
+ return nil, err
+ }
+ commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase, 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 {
+ headTree, err := headTree(repo)
+ if err != nil {
+ return false
+ }
+ defer headTree.Free()
+
+ _, err = headTree.EntryByPath(file)
+
+ return err == nil
+}
+
+func commitMsgsList(repo *Repository) ([]string, error) {
+ head, err := headCommit(repo)
+ if err != nil {
+ return nil, err
+ }
+ defer head.Free()
+
+ var commits []string
+
+ parent := head.Parent(0)
+ defer parent.Free()
+ commits = append(commits, head.Message(), parent.Message())
+
+ for parent.ParentCount() != 0 {
+ parent = parent.Parent(0)
+ defer parent.Free()
+ commits = append(commits, parent.Message())
+ }
+
+ return commits, nil
+}
+
+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])
+ }
+ }
+}
diff --git a/tree.go b/tree.go
index eba9f3d..27dd63d 100644
--- a/tree.go
+++ b/tree.go
@@ -87,6 +87,7 @@
if ret < 0 {
return nil, MakeGitError(ret)
}
+ defer C.git_tree_entry_free(entry)
return newTreeEntry(entry), nil
}
