merge.go

package git

/*
#include <git2.h>

extern git_annotated_commit** _go_git_make_merge_head_array(size_t len);
extern void _go_git_annotated_commit_array_set(git_annotated_commit** array, git_annotated_commit* ptr, size_t n);
extern git_annotated_commit* _go_git_annotated_commit_array_get(git_annotated_commit** array, size_t n);
extern int _go_git_merge_file(git_merge_file_result*, char*, size_t, char*, unsigned int, char*, size_t, char*, unsigned int, char*, size_t, char*, unsigned int, git_merge_file_options*);

*/
import"C"
import (
"reflect"
"runtime"
"unsafe"
)

typeAnnotatedCommitstruct {
doNotCompare
ptr*C.git_annotated_commit
r*Repository
}

funcnewAnnotatedCommitFromC(ptr*C.git_annotated_commit, r*Repository) *AnnotatedCommit {
mh:=&AnnotatedCommit{ptr: ptr, r: r}
runtime.SetFinalizer(mh, (*AnnotatedCommit).Free)
returnmh
}

func (mh*AnnotatedCommit) Id() *Oid {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

ret:=newOidFromC(C.git_annotated_commit_id(mh.ptr))
runtime.KeepAlive(mh)
returnret
}

func (mh*AnnotatedCommit) Free() {
runtime.SetFinalizer(mh, nil)
C.git_annotated_commit_free(mh.ptr)
}

func (r*Repository) AnnotatedCommitFromFetchHead(branchNamestring, remoteURLstring, oid*Oid) (*AnnotatedCommit, error) {
cbranchName:=C.CString(branchName)
deferC.free(unsafe.Pointer(cbranchName))

cremoteURL:=C.CString(remoteURL)
deferC.free(unsafe.Pointer(cremoteURL))

runtime.LockOSThread()
deferruntime.UnlockOSThread()

varptr*C.git_annotated_commit
ret:=C.git_annotated_commit_from_fetchhead(&ptr, r.ptr, cbranchName, cremoteURL, oid.toC())
runtime.KeepAlive(oid)
ifret<0 {
returnnil, MakeGitError(ret)
 }

annotatedCommit:=newAnnotatedCommitFromC(ptr, r)
runtime.KeepAlive(r)
returnannotatedCommit, nil
}

func (r*Repository) LookupAnnotatedCommit(oid*Oid) (*AnnotatedCommit, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

varptr*C.git_annotated_commit
ret:=C.git_annotated_commit_lookup(&ptr, r.ptr, oid.toC())
runtime.KeepAlive(oid)
ifret<0 {
returnnil, MakeGitError(ret)
 }

annotatedCommit:=newAnnotatedCommitFromC(ptr, r)
runtime.KeepAlive(r)
returnannotatedCommit, nil
}

func (r*Repository) AnnotatedCommitFromRef(ref*Reference) (*AnnotatedCommit, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

varptr*C.git_annotated_commit
ret:=C.git_annotated_commit_from_ref(&ptr, r.ptr, ref.ptr)
runtime.KeepAlive(r)
runtime.KeepAlive(ref)
ifret<0 {
returnnil, MakeGitError(ret)
 }

annotatedCommit:=newAnnotatedCommitFromC(ptr, r)
runtime.KeepAlive(r)
returnannotatedCommit, nil
}

func (r*Repository) AnnotatedCommitFromRevspec(specstring) (*AnnotatedCommit, error) {
crevspec:=C.CString(spec)
deferC.free(unsafe.Pointer(crevspec))

runtime.LockOSThread()
deferruntime.UnlockOSThread()

varptr*C.git_annotated_commit
ret:=C.git_annotated_commit_from_revspec(&ptr, r.ptr, crevspec)
runtime.KeepAlive(r)
ifret<0 {
returnnil, MakeGitError(ret)
 }

annotatedCommit:=newAnnotatedCommitFromC(ptr, r)
runtime.KeepAlive(r)
returnannotatedCommit, nil
}

typeMergeTreeFlagint

const (
// Detect renames that occur between the common ancestor and the "ours"
// side or the common ancestor and the "theirs" side. This will enable
// the ability to merge between a modified and renamed file.
MergeTreeFindRenamesMergeTreeFlag=C.GIT_MERGE_FIND_RENAMES
// If a conflict occurs, exit immediately instead of attempting to
// continue resolving conflicts. The merge operation will fail with
// GIT_EMERGECONFLICT and no index will be returned.
MergeTreeFailOnConflictMergeTreeFlag=C.GIT_MERGE_FAIL_ON_CONFLICT
// MergeTreeSkipREUC specifies not to write the REUC extension on the
// generated index.
MergeTreeSkipREUCMergeTreeFlag=C.GIT_MERGE_SKIP_REUC
// MergeTreeNoRecursive specifies not to build a recursive merge base (by
// merging the multiple merge bases) if the commits being merged have
// multiple merge bases. Instead, the first base is used.
// This flag provides a similar merge base to `git-merge-resolve`.
MergeTreeNoRecursiveMergeTreeFlag=C.GIT_MERGE_NO_RECURSIVE
)

typeMergeOptionsstruct {
TreeFlagsMergeTreeFlag

RenameThresholduint
TargetLimituint
RecursionLimituint
FileFavorMergeFileFavor

//TODO: Diff similarity metric
}

funcmergeOptionsFromC(opts*C.git_merge_options) MergeOptions {
returnMergeOptions{
TreeFlags: MergeTreeFlag(opts.flags),
RenameThreshold: uint(opts.rename_threshold),
TargetLimit: uint(opts.target_limit),
RecursionLimit: uint(opts.recursion_limit),
FileFavor: MergeFileFavor(opts.file_favor),
 }
}

funcDefaultMergeOptions() (MergeOptions, error) {
opts:= C.git_merge_options{}

runtime.LockOSThread()
deferruntime.UnlockOSThread()

ecode:=C.git_merge_options_init(&opts, C.GIT_MERGE_OPTIONS_VERSION)
ifecode<0 {
returnMergeOptions{}, MakeGitError(ecode)
 }
returnmergeOptionsFromC(&opts), nil
}

funcpopulateMergeOptions(copts*C.git_merge_options, opts*MergeOptions) *C.git_merge_options {
C.git_merge_options_init(copts, C.GIT_MERGE_OPTIONS_VERSION)
ifopts==nil {
returnnil
 }
copts.flags=C.uint32_t(opts.TreeFlags)
copts.rename_threshold=C.uint(opts.RenameThreshold)
copts.target_limit=C.uint(opts.TargetLimit)
copts.recursion_limit=C.uint(opts.RecursionLimit)
copts.file_favor=C.git_merge_file_favor_t(opts.FileFavor)
returncopts
}

funcfreeMergeOptions(copts*C.git_merge_options) {
}

typeMergeFileFavorint

const (
MergeFileFavorNormalMergeFileFavor=C.GIT_MERGE_FILE_FAVOR_NORMAL
MergeFileFavorOursMergeFileFavor=C.GIT_MERGE_FILE_FAVOR_OURS
MergeFileFavorTheirsMergeFileFavor=C.GIT_MERGE_FILE_FAVOR_THEIRS
MergeFileFavorUnionMergeFileFavor=C.GIT_MERGE_FILE_FAVOR_UNION
)

func (r*Repository) Merge(theirHeads []*AnnotatedCommit, mergeOptions*MergeOptions, checkoutOptions*CheckoutOptions) error {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

varerrerror
cMergeOpts:=populateMergeOptions(&C.git_merge_options{}, mergeOptions)
deferfreeMergeOptions(cMergeOpts)
cCheckoutOptions:=populateCheckoutOptions(&C.git_checkout_options{}, checkoutOptions, &err)
deferfreeCheckoutOptions(cCheckoutOptions)

gmerge_head_array:=make([]*C.git_annotated_commit, len(theirHeads))
fori:=0; i<len(theirHeads); i++ {
gmerge_head_array[i] =theirHeads[i].ptr
 }
ptr:=unsafe.Pointer(&gmerge_head_array[0])
ret:=C.git_merge(r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)), cMergeOpts, cCheckoutOptions)
runtime.KeepAlive(theirHeads)
ifret==C.int(ErrorCodeUser) &&err!=nil {
returnerr
 }
ifret<0 {
returnMakeGitError(ret)
 }
returnnil
}

typeMergeAnalysisint

const (
MergeAnalysisNoneMergeAnalysis=C.GIT_MERGE_ANALYSIS_NONE
MergeAnalysisNormalMergeAnalysis=C.GIT_MERGE_ANALYSIS_NORMAL
MergeAnalysisUpToDateMergeAnalysis=C.GIT_MERGE_ANALYSIS_UP_TO_DATE
MergeAnalysisFastForwardMergeAnalysis=C.GIT_MERGE_ANALYSIS_FASTFORWARD
MergeAnalysisUnbornMergeAnalysis=C.GIT_MERGE_ANALYSIS_UNBORN
)

typeMergePreferenceint

const (
MergePreferenceNoneMergePreference=C.GIT_MERGE_PREFERENCE_NONE
MergePreferenceNoFastForwardMergePreference=C.GIT_MERGE_PREFERENCE_NO_FASTFORWARD
MergePreferenceFastForwardOnlyMergePreference=C.GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY
)

// MergeAnalysis returns the possible actions which could be taken by
// a 'git-merge' command. There may be multiple answers, so the first
// return value is a bitmask of MergeAnalysis values.
func (r*Repository) MergeAnalysis(theirHeads []*AnnotatedCommit) (MergeAnalysis, MergePreference, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

gmerge_head_array:=make([]*C.git_annotated_commit, len(theirHeads))
fori:=0; i<len(theirHeads); i++ {
gmerge_head_array[i] =theirHeads[i].ptr
 }
ptr:=unsafe.Pointer(&gmerge_head_array[0])
varanalysis C.git_merge_analysis_t
varpreference C.git_merge_preference_t
err:=C.git_merge_analysis(&analysis, &preference, r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)))
runtime.KeepAlive(theirHeads)
iferr<0 {
returnMergeAnalysisNone, MergePreferenceNone, MakeGitError(err)
 }
returnMergeAnalysis(analysis), MergePreference(preference), nil

}

func (r*Repository) MergeCommits(ours*Commit, theirs*Commit, options*MergeOptions) (*Index, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

copts:=populateMergeOptions(&C.git_merge_options{}, options)
deferfreeMergeOptions(copts)

varptr*C.git_index
ret:=C.git_merge_commits(&ptr, r.ptr, ours.cast_ptr, theirs.cast_ptr, copts)
runtime.KeepAlive(ours)
runtime.KeepAlive(theirs)
ifret<0 {
returnnil, MakeGitError(ret)
 }

returnnewIndexFromC(ptr, r), nil
}

func (r*Repository) MergeTrees(ancestor*Tree, ours*Tree, theirs*Tree, options*MergeOptions) (*Index, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

copts:=populateMergeOptions(&C.git_merge_options{}, options)
deferfreeMergeOptions(copts)

varancestor_ptr*C.git_tree
ifancestor!=nil {
ancestor_ptr=ancestor.cast_ptr
 }
varptr*C.git_index
ret:=C.git_merge_trees(&ptr, r.ptr, ancestor_ptr, ours.cast_ptr, theirs.cast_ptr, copts)
runtime.KeepAlive(ancestor)
runtime.KeepAlive(ours)
runtime.KeepAlive(theirs)
ifret<0 {
returnnil, MakeGitError(ret)
 }

returnnewIndexFromC(ptr, r), nil
}

func (r*Repository) MergeBase(one*Oid, two*Oid) (*Oid, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

varoid C.git_oid
ret:=C.git_merge_base(&oid, r.ptr, one.toC(), two.toC())
runtime.KeepAlive(one)
runtime.KeepAlive(two)
runtime.KeepAlive(r)
ifret<0 {
returnnil, MakeGitError(ret)
 }
returnnewOidFromC(&oid), nil
}

// MergeBases retrieves the list of merge bases between two commits.
//
// If none are found, an empty slice is returned and the error is set
// approprately
func (r*Repository) MergeBases(one, two*Oid) ([]*Oid, error) {
runtime.LockOSThread()
deferruntime.UnlockOSThread()

varcoids C.git_oidarray
ret:=C.git_merge_bases(&coids, r.ptr, one.toC(), two.toC())
runtime.KeepAlive(one)
runtime.KeepAlive(two)
ifret<0 {
returnnil, MakeGitError(ret)
 }

oids:=make([]*Oid, coids.count)
hdr:= reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(coids.ids)),
Len: int(coids.count),
Cap: int(coids.count),
 }

goSlice:=*(*[]C.git_oid)(unsafe.Pointer(&hdr))

fori, cid:=rangegoSlice {
oids[i] =newOidFromC(&cid)
 }

returnoids, nil
}

// MergeBaseMany finds a merge base given a list of commits.
func (r*Repository) MergeBaseMany(oids []*Oid) (*Oid, error) {
coids:=make([]C.git_oid, len(oids))
fori:=0; i<len(oids); i++ {
coids[i] =*oids[i].toC()
 }

runtime.LockOSThread()
deferruntime.UnlockOSThread()

varoid C.git_oid
ret:=C.git_merge_base_many(&oid, r.ptr, C.size_t(len(oids)), &coids[0])
runtime.KeepAlive(r)
runtime.KeepAlive(coids)
ifret<0 {
returnnil, MakeGitError(ret)
 }
returnnewOidFromC(&oid), nil
}

// MergeBasesMany finds all merge bases given a list of commits.
func (r*Repository) MergeBasesMany(oids []*Oid) ([]*Oid, error) {
inCoids:=make([]C.git_oid, len(oids))
fori:=0; i<len(oids); i++ {
inCoids[i] =*oids[i].toC()
 }

runtime.LockOSThread()
deferruntime.UnlockOSThread()

varoutCoids C.git_oidarray
ret:=C.git_merge_bases_many(&outCoids, r.ptr, C.size_t(len(oids)), &inCoids[0])
runtime.KeepAlive(r)
runtime.KeepAlive(inCoids)
ifret<0 {
returnnil, MakeGitError(ret)
 }

outOids:=make([]*Oid, outCoids.count)
hdr:= reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(outCoids.ids)),
Len: int(outCoids.count),
Cap: int(outCoids.count),
 }
goSlice:=*(*[]C.git_oid)(unsafe.Pointer(&hdr))

fori, cid:=rangegoSlice {
outOids[i] =newOidFromC(&cid)
 }

returnoutOids, nil
}

// MergeBaseOctopus finds a merge base in preparation for an octopus merge.
func (r*Repository) MergeBaseOctopus(oids []*Oid) (*Oid, error) {
coids:=make([]C.git_oid, len(oids))
fori:=0; i<len(oids); i++ {
coids[i] =*oids[i].toC()
 }

runtime.LockOSThread()
deferruntime.UnlockOSThread()

varoid C.git_oid
ret:=C.git_merge_base_octopus(&oid, r.ptr, C.size_t(len(oids)), &coids[0])
runtime.KeepAlive(r)
runtime.KeepAlive(coids)
ifret<0 {
returnnil, MakeGitError(ret)
 }
returnnewOidFromC(&oid), nil
}

typeMergeFileResultstruct {
doNotCompare
ptr*C.git_merge_file_result
Automergeablebool
Pathstring
Modeuint
Contents []byte
}

funcnewMergeFileResultFromC(c*C.git_merge_file_result) *MergeFileResult {
varpathstring
ifc.path!=nil {
path=C.GoString(c.path)
 }

originalBytes:=C.GoBytes(unsafe.Pointer(c.ptr), C.int(c.len))
gobytes:=make([]byte, len(originalBytes))
copy(gobytes, originalBytes)
r:=&MergeFileResult{
Automergeable: c.automergeable!=0,
Path: path,
Mode: uint(c.mode),
Contents: gobytes,
ptr: c,
 }

runtime.SetFinalizer(r, (*MergeFileResult).Free)
returnr
}

func (r*MergeFileResult) Free() {
runtime.SetFinalizer(r, nil)
C.git_merge_file_result_free(r.ptr)
}

typeMergeFileInputstruct {
Pathstring
Modeuint
Contents []byte
}

typeMergeFileFlagsint

const (
MergeFileDefaultMergeFileFlags=C.GIT_MERGE_FILE_DEFAULT

// Create standard conflicted merge files
MergeFileStyleMergeMergeFileFlags=C.GIT_MERGE_FILE_STYLE_MERGE

// Create diff3-style files
MergeFileStyleDiffMergeFileFlags=C.GIT_MERGE_FILE_STYLE_DIFF3

// Condense non-alphanumeric regions for simplified diff file
MergeFileStyleSimplifyAlnumMergeFileFlags=C.GIT_MERGE_FILE_SIMPLIFY_ALNUM

// Ignore all whitespace
MergeFileIgnoreWhitespaceMergeFileFlags=C.GIT_MERGE_FILE_IGNORE_WHITESPACE

// Ignore changes in amount of whitespace
MergeFileIgnoreWhitespaceChangeMergeFileFlags=C.GIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE

// Ignore whitespace at end of line
MergeFileIgnoreWhitespaceEOLMergeFileFlags=C.GIT_MERGE_FILE_IGNORE_WHITESPACE_EOL

// Use the "patience diff" algorithm
MergeFileDiffPatienceMergeFileFlags=C.GIT_MERGE_FILE_DIFF_PATIENCE

// Take extra time to find minimal diff
MergeFileDiffMinimalMergeFileFlags=C.GIT_MERGE_FILE_DIFF_MINIMAL
)

typeMergeFileOptionsstruct {
AncestorLabelstring
OurLabelstring
TheirLabelstring
FavorMergeFileFavor
FlagsMergeFileFlags
MarkerSizeuint16
}

funcmergeFileOptionsFromC(c C.git_merge_file_options) MergeFileOptions {
returnMergeFileOptions{
AncestorLabel: C.GoString(c.ancestor_label),
OurLabel: C.GoString(c.our_label),
TheirLabel: C.GoString(c.their_label),
Favor: MergeFileFavor(c.favor),
Flags: MergeFileFlags(c.flags),
MarkerSize: uint16(c.marker_size),
 }
}

funcpopulateMergeFileOptions(copts*C.git_merge_file_options, opts*MergeFileOptions) *C.git_merge_file_options {
C.git_merge_file_options_init(copts, C.GIT_MERGE_FILE_OPTIONS_VERSION)
ifopts==nil {
returnnil
 }

copts.ancestor_label=C.CString(opts.AncestorLabel)
copts.our_label=C.CString(opts.OurLabel)
copts.their_label=C.CString(opts.TheirLabel)
copts.favor=C.git_merge_file_favor_t(opts.Favor)
copts.flags=C.uint32_t(opts.Flags)
copts.marker_size=C.ushort(opts.MarkerSize)
returncopts
}

funcfreeMergeFileOptions(copts*C.git_merge_file_options) {
ifcopts==nil {
return
 }
C.free(unsafe.Pointer(copts.ancestor_label))
C.free(unsafe.Pointer(copts.our_label))
C.free(unsafe.Pointer(copts.their_label))
}

funcMergeFile(ancestorMergeFileInput, oursMergeFileInput, theirsMergeFileInput, options*MergeFileOptions) (*MergeFileResult, error) {

ancestorPath:=C.CString(ancestor.Path)
deferC.free(unsafe.Pointer(ancestorPath))
varancestorContents*byte
iflen(ancestor.Contents) >0 {
ancestorContents=&ancestor.Contents[0]
 }

oursPath:=C.CString(ours.Path)
deferC.free(unsafe.Pointer(oursPath))
varoursContents*byte
iflen(ours.Contents) >0 {
oursContents=&ours.Contents[0]
 }

theirsPath:=C.CString(theirs.Path)
deferC.free(unsafe.Pointer(theirsPath))
vartheirsContents*byte
iflen(theirs.Contents) >0 {
theirsContents=&theirs.Contents[0]
 }

varcopts*C.git_merge_file_options
ifoptions!=nil {
copts=&C.git_merge_file_options{}
ecode:=C.git_merge_file_options_init(copts, C.GIT_MERGE_FILE_OPTIONS_VERSION)
ifecode<0 {
returnnil, MakeGitError(ecode)
 }
populateMergeFileOptions(copts, options)
deferfreeMergeFileOptions(copts)
 }

runtime.LockOSThread()
deferruntime.UnlockOSThread()

varresult C.git_merge_file_result
ecode:=C._go_git_merge_file(&result,
 (*C.char)(unsafe.Pointer(ancestorContents)), C.size_t(len(ancestor.Contents)), ancestorPath, C.uint(ancestor.Mode),
 (*C.char)(unsafe.Pointer(oursContents)), C.size_t(len(ours.Contents)), oursPath, C.uint(ours.Mode),
 (*C.char)(unsafe.Pointer(theirsContents)), C.size_t(len(theirs.Contents)), theirsPath, C.uint(theirs.Mode),
copts)
runtime.KeepAlive(ancestor)
runtime.KeepAlive(ours)
runtime.KeepAlive(theirs)
ifecode<0 {
returnnil, MakeGitError(ecode)
 }

returnnewMergeFileResultFromC(&result), nil

}

// TODO: GIT_EXTERN(int) git_merge_file_from_index(git_merge_file_result *out,git_repository *repo,const git_index_entry *ancestor, const git_index_entry *ours, const git_index_entry *theirs, const git_merge_file_options *opts);