diff options
Diffstat (limited to 'vendor/github.com/libgit2/git2go/rebase.go')
-rw-r--r-- | vendor/github.com/libgit2/git2go/rebase.go | 274 |
1 files changed, 274 insertions, 0 deletions
diff --git a/vendor/github.com/libgit2/git2go/rebase.go b/vendor/github.com/libgit2/git2go/rebase.go new file mode 100644 index 000000000..5206fcae7 --- /dev/null +++ b/vendor/github.com/libgit2/git2go/rebase.go @@ -0,0 +1,274 @@ +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 +) + +// Special value indicating that there is no currently active operation +var RebaseNoOperation uint = ^uint(0) + +// Error returned if there is no current rebase operation +var ErrRebaseNoOperation = errors.New("no current rebase operation") + +// 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 + r *Repository +} + +// 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()) + runtime.KeepAlive(branch) + runtime.KeepAlive(upstream) + runtime.KeepAlive(onto) + 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()) + runtime.KeepAlive(r) + 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. There is also an error returned for API +// compatibility. +func (rebase *Rebase) CurrentOperationIndex() (uint, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var err error + operationIndex := uint(C.git_rebase_operation_current(rebase.ptr)) + runtime.KeepAlive(rebase) + if operationIndex == RebaseNoOperation { + err = ErrRebaseNoOperation + } + + return uint(operationIndex), err +} + +// OperationCount gets the count of rebase operations that are to be applied. +func (rebase *Rebase) OperationCount() uint { + ret := uint(C.git_rebase_operation_entrycount(rebase.ptr)) + runtime.KeepAlive(rebase) + return ret +} + +// 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) + runtime.KeepAlive(rebase) + 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) + runtime.KeepAlive(ID) + runtime.KeepAlive(rebase) + 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) + runtime.KeepAlive(rebase) + 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) + runtime.KeepAlive(rebase) + 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 +} |