Commit 97f17222 authored by Carlos Martín Nieto's avatar Carlos Martín Nieto Committed by GitHub

Merge pull request #332 from ezwiebel/rebase-wrapper

Rebase wrapper
parents 4a142601 6118c9ba
......@@ -53,6 +53,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
......
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
}
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])
}
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment