checkout.go

@@ -5,8 +5,8 @@ package git
 */
 import "C"
 import (
-	"runtime"
 	"os"
+	"runtime"
 )
 
 type CheckoutStrategy uint
@@ -32,10 +32,19 @@ const (
 
 type CheckoutOpts struct {
 	Strategy       CheckoutStrategy // Default will be a dry run
-	DisableFilters bool				// Don't apply filters like CRLF conversion
+	DisableFilters bool             // Don't apply filters like CRLF conversion
-	DirMode        os.FileMode		// Default is 0755
+	DirMode        os.FileMode      // Default is 0755
-	FileMode       os.FileMode		// Default is 0644 or 0755 as dictated by blob
+	FileMode       os.FileMode      // Default is 0644 or 0755 as dictated by blob
-	FileOpenFlags  int				// Default is O_CREAT | O_TRUNC | O_WRONLY
+	FileOpenFlags  int              // Default is O_CREAT | O_TRUNC | O_WRONLY
+}
+
+func (opts *CheckoutOpts) toC() *C.git_checkout_options {
+	if opts == nil {
+		return nil
+	}
+	c := C.git_checkout_options{}
+	populateCheckoutOpts(&c, opts)
+	return &c
 }
 
 // Convert the CheckoutOpts struct to the corresponding

merge.go

@@ -0,0 +1,354 @@
+package git
+
+/*
+#include <git2.h>
+#include <git2/errors.h>
+
+extern git_merge_head** _go_git_make_merge_head_array(size_t len);
+extern void _go_git_merge_head_array_set(git_merge_head** array, git_merge_head* ptr, size_t n);
+extern git_merge_head* _go_git_merge_head_array_get(git_merge_head** array, size_t n);
+
+*/
+import "C"
+import (
+	"runtime"
+	"unsafe"
+)
+
+type MergeHead struct {
+	ptr *C.git_merge_head
+}
+
+func newMergeHeadFromC(c *C.git_merge_head) *MergeHead {
+	mh := &MergeHead{ptr: c}
+	runtime.SetFinalizer(mh, (*MergeHead).Free)
+	return mh
+}
+
+func (mh *MergeHead) Free() {
+	runtime.SetFinalizer(mh, nil)
+	C.git_merge_head_free(mh.ptr)
+}
+
+func (r *Repository) MergeHeadFromFetchHead(branchName string, remoteURL string, oid *Oid) (*MergeHead, error) {
+	mh := &MergeHead{}
+
+	cbranchName := C.CString(branchName)
+	defer C.free(unsafe.Pointer(cbranchName))
+
+	cremoteURL := C.CString(remoteURL)
+	defer C.free(unsafe.Pointer(cremoteURL))
+
+	ret := C.git_merge_head_from_fetchhead(&mh.ptr, r.ptr, cbranchName, cremoteURL, oid.toC())
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+	runtime.SetFinalizer(mh, (*MergeHead).Free)
+	return mh, nil
+}
+
+func (r *Repository) MergeHeadFromId(oid *Oid) (*MergeHead, error) {
+	mh := &MergeHead{}
+
+	ret := C.git_merge_head_from_id(&mh.ptr, r.ptr, oid.toC())
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+	runtime.SetFinalizer(mh, (*MergeHead).Free)
+	return mh, nil
+}
+
+func (r *Repository) MergeHeadFromRef(ref *Reference) (*MergeHead, error) {
+	mh := &MergeHead{}
+
+	ret := C.git_merge_head_from_ref(&mh.ptr, r.ptr, ref.ptr)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+	runtime.SetFinalizer(mh, (*MergeHead).Free)
+	return mh, nil
+}
+
+type MergeTreeFlag int
+
+const (
+	MergeTreeFindRenames MergeTreeFlag = C.GIT_MERGE_TREE_FIND_RENAMES
+)
+
+type MergeOptions struct {
+	Version uint
+	Flags   MergeTreeFlag
+
+	RenameThreshold uint
+	TargetLimit     uint
+	FileFavor       MergeFileFavor
+
+	//TODO: Diff similarity metric
+}
+
+func mergeOptionsFromC(opts *C.git_merge_options) MergeOptions {
+	return MergeOptions{
+		Version:         uint(opts.version),
+		Flags:           MergeTreeFlag(opts.flags),
+		RenameThreshold: uint(opts.rename_threshold),
+		TargetLimit:     uint(opts.target_limit),
+		FileFavor:       MergeFileFavor(opts.file_favor),
+	}
+}
+
+func DefaultMergeOptions() (MergeOptions, error) {
+	opts := C.git_merge_options{}
+	ecode := C.git_merge_init_options(&opts, C.GIT_MERGE_OPTIONS_VERSION)
+	if ecode < 0 {
+		return MergeOptions{}, MakeGitError(ecode)
+	}
+	return mergeOptionsFromC(&opts), nil
+}
+
+func (mo *MergeOptions) toC() *C.git_merge_options {
+	if mo == nil {
+		return nil
+	}
+	return &C.git_merge_options{
+		version:          C.uint(mo.Version),
+		flags:            C.git_merge_tree_flag_t(mo.Flags),
+		rename_threshold: C.uint(mo.RenameThreshold),
+		target_limit:     C.uint(mo.TargetLimit),
+		file_favor:       C.git_merge_file_favor_t(mo.FileFavor),
+	}
+}
+
+type MergeFileFavor int
+
+const (
+	MergeFileFavorNormal MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_NORMAL
+	MergeFileFavorOurs                  = C.GIT_MERGE_FILE_FAVOR_OURS
+	MergeFileFavorTheirs                = C.GIT_MERGE_FILE_FAVOR_THEIRS
+	MergeFileFavorUnion                 = C.GIT_MERGE_FILE_FAVOR_UNION
+)
+
+func (r *Repository) Merge(theirHeads []*MergeHead, mergeOptions *MergeOptions, checkoutOptions *CheckoutOpts) error {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	cMergeOpts := mergeOptions.toC()
+	cCheckoutOpts := checkoutOptions.toC()
+
+	gmerge_head_array := make([]*C.git_merge_head, len(theirHeads))
+	for i := 0; i < len(theirHeads); i++ {
+		gmerge_head_array[i] = theirHeads[i].ptr
+	}
+	ptr := unsafe.Pointer(&gmerge_head_array[0])
+	err := C.git_merge(r.ptr, (**C.git_merge_head)(ptr), C.size_t(len(theirHeads)), cMergeOpts, cCheckoutOpts)
+	if err < 0 {
+		return MakeGitError(err)
+	}
+	return nil
+}
+
+type MergeAnalysis int
+
+const (
+	MergeAnalysisNone        MergeAnalysis = C.GIT_MERGE_ANALYSIS_NONE
+	MergeAnalysisNormal                    = C.GIT_MERGE_ANALYSIS_NORMAL
+	MergeAnalysisUpToDate                  = C.GIT_MERGE_ANALYSIS_UP_TO_DATE
+	MergeAnalysisFastForward               = C.GIT_MERGE_ANALYSIS_FASTFORWARD
+	MergeAnalysisUnborn                    = C.GIT_MERGE_ANALYSIS_UNBORN
+)
+
+func (r *Repository) MergeAnalysis(theirHeads []*MergeHead) (MergeAnalysis, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	gmerge_head_array := make([]*C.git_merge_head, len(theirHeads))
+	for i := 0; i < len(theirHeads); i++ {
+		gmerge_head_array[i] = theirHeads[i].ptr
+	}
+	ptr := unsafe.Pointer(&gmerge_head_array[0])
+	var analysis C.git_merge_analysis_t
+	err := C.git_merge_analysis(&analysis, r.ptr, (**C.git_merge_head)(ptr), C.size_t(len(theirHeads)))
+	if err < 0 {
+		return MergeAnalysisNone, MakeGitError(err)
+	}
+	return MergeAnalysis(analysis), nil
+
+}
+
+func (r *Repository) MergeCommits(ours *Commit, theirs *Commit, options *MergeOptions) (*Index, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	copts := options.toC()
+
+	idx := &Index{}
+
+	ret := C.git_merge_commits(&idx.ptr, r.ptr, ours.cast_ptr, theirs.cast_ptr, copts)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+	runtime.SetFinalizer(idx, (*Index).Free)
+	return idx, nil
+}
+
+func (r *Repository) MergeTrees(ancestor *Tree, ours *Tree, theirs *Tree, options *MergeOptions) (*Index, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	copts := options.toC()
+
+	idx := &Index{}
+
+	ret := C.git_merge_trees(&idx.ptr, r.ptr, ancestor.cast_ptr, ours.cast_ptr, theirs.cast_ptr, copts)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+	runtime.SetFinalizer(idx, (*Index).Free)
+	return idx, nil
+}
+
+func (r *Repository) MergeBase(one *Oid, two *Oid) (*Oid, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var oid C.git_oid
+	ret := C.git_merge_base(&oid, r.ptr, one.toC(), two.toC())
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+	return newOidFromC(&oid), nil
+}
+
+//TODO: int git_merge_base_many(git_oid *out, git_repository *repo, size_t length, const git_oid input_array[]);
+//TODO: GIT_EXTERN(int) git_merge_base_octopus(git_oid *out,git_repository *repo,size_t length,const git_oid input_array[]);
+
+type MergeFileResult struct {
+	Automergeable bool
+	Path          string
+	Mode          uint
+	Contents      []byte
+	ptr           *C.git_merge_file_result
+}
+
+func newMergeFileResultFromC(c *C.git_merge_file_result) *MergeFileResult {
+	var path string
+	if c.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)
+	return r
+}
+
+func (r *MergeFileResult) Free() {
+	runtime.SetFinalizer(r, nil)
+	C.git_merge_file_result_free(r.ptr)
+}
+
+type MergeFileInput struct {
+	Path     string
+	Mode     uint
+	Contents []byte
+}
+
+// populate a C struct with merge file input, make sure to use freeMergeFileInput to clean up allocs
+func populateCMergeFileInput(c *C.git_merge_file_input, input MergeFileInput) {
+	c.path = C.CString(input.Path)
+	c.ptr = (*C.char)(unsafe.Pointer(&input.Contents[0]))
+	c.size = C.size_t(len(input.Contents))
+	c.mode = C.uint(input.Mode)
+}
+
+func freeCMergeFileInput(c *C.git_merge_file_input) {
+	C.free(unsafe.Pointer(c.path))
+}
+
+type MergeFileFlags int
+
+const (
+	MergeFileDefault MergeFileFlags = C.GIT_MERGE_FILE_DEFAULT
+
+	MergeFileStyleMerge         = C.GIT_MERGE_FILE_STYLE_MERGE
+	MergeFileStyleDiff          = C.GIT_MERGE_FILE_STYLE_DIFF3
+	MergeFileStyleSimplifyAlnum = C.GIT_MERGE_FILE_SIMPLIFY_ALNUM
+)
+
+type MergeFileOptions struct {
+	AncestorLabel string
+	OurLabel      string
+	TheirLabel    string
+	Favor         MergeFileFavor
+	Flags         MergeFileFlags
+}
+
+func mergeFileOptionsFromC(c C.git_merge_file_options) MergeFileOptions {
+	return MergeFileOptions{
+		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),
+	}
+}
+
+func populateCMergeFileOptions(c *C.git_merge_file_options, options MergeFileOptions) {
+	c.ancestor_label = C.CString(options.AncestorLabel)
+	c.our_label = C.CString(options.OurLabel)
+	c.their_label = C.CString(options.TheirLabel)
+	c.favor = C.git_merge_file_favor_t(options.Favor)
+	c.flags = C.git_merge_file_flags_t(options.Flags)
+}
+
+func freeCMergeFileOptions(c *C.git_merge_file_options) {
+	C.free(unsafe.Pointer(c.ancestor_label))
+	C.free(unsafe.Pointer(c.our_label))
+	C.free(unsafe.Pointer(c.their_label))
+}
+
+func MergeFile(ancestor MergeFileInput, ours MergeFileInput, theirs MergeFileInput, options *MergeFileOptions) (*MergeFileResult, error) {
+
+	var cancestor C.git_merge_file_input
+	var cours C.git_merge_file_input
+	var ctheirs C.git_merge_file_input
+
+	populateCMergeFileInput(&cancestor, ancestor)
+	defer freeCMergeFileInput(&cancestor)
+	populateCMergeFileInput(&cours, ours)
+	defer freeCMergeFileInput(&cours)
+	populateCMergeFileInput(&ctheirs, theirs)
+	defer freeCMergeFileInput(&ctheirs)
+
+	var copts *C.git_merge_file_options
+	if options != nil {
+		copts = &C.git_merge_file_options{}
+		ecode := C.git_merge_file_init_options(copts, C.GIT_MERGE_FILE_OPTIONS_VERSION)
+		if ecode < 0 {
+			return nil, MakeGitError(ecode)
+		}
+		populateCMergeFileOptions(copts, *options)
+	}
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var result C.git_merge_file_result
+	ecode := C.git_merge_file(&result, &cancestor, &cours, &ctheirs, copts)
+	if ecode < 0 {
+		return nil, MakeGitError(ecode)
+	}
+
+	return newMergeFileResultFromC(&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);

merge_test.go

@@ -0,0 +1,75 @@
+package git
+
+import (
+	"testing"
+)
+
+func TestMergeWithSelf(t *testing.T) {
+
+	repo := createTestRepo(t)
+	seedTestRepo(t, repo)
+
+	master, err := repo.LookupReference("refs/heads/master")
+	checkFatal(t, err)
+
+	mergeHead, err := repo.MergeHeadFromRef(master)
+	checkFatal(t, err)
+
+	mergeHeads := make([]*MergeHead, 1)
+	mergeHeads[0] = mergeHead
+	err = repo.Merge(mergeHeads, nil, nil)
+	checkFatal(t, err)
+}
+
+func TestMergeAnalysisWithSelf(t *testing.T) {
+
+	repo := createTestRepo(t)
+	seedTestRepo(t, repo)
+
+	master, err := repo.LookupReference("refs/heads/master")
+	checkFatal(t, err)
+
+	mergeHead, err := repo.MergeHeadFromRef(master)
+	checkFatal(t, err)
+
+	mergeHeads := make([]*MergeHead, 1)
+	mergeHeads[0] = mergeHead
+	a, err := repo.MergeAnalysis(mergeHeads)
+	checkFatal(t, err)
+
+	if a != MergeAnalysisUpToDate {
+		t.Fatalf("Expected up to date merge, not %v", a)
+	}
+}
+
+func TestMergeSameFile(t *testing.T) {
+
+	file := MergeFileInput{
+		Path:     "test",
+		Mode:     33188,
+		Contents: []byte("hello world"),
+	}
+
+	result, err := MergeFile(file, file, file, nil)
+	checkFatal(t, err)
+	if !result.Automergeable {
+		t.Fatal("expected automergeable")
+	}
+	if result.Path != file.Path {
+		t.Fatal("path was incorrect")
+	}
+	if result.Mode != file.Mode {
+		t.Fatal("mode was incorrect")
+	}
+
+	compareBytes(t, file.Contents, result.Contents)
+
+}
+
+func compareBytes(t *testing.T, expected, actual []byte) {
+	for i, v := range expected {
+		if actual[i] != v {
+			t.Fatalf("Bad bytes")
+		}
+	}
+}

push_test.go

@@ -1,7 +1,6 @@
 package git
 
 import (
-	"log"
 	"os"
 	"testing"
 	"time"
@@ -45,7 +44,6 @@ func Test_Push_ToRemote(t *testing.T) {
 	checkFatal(t, err)
 
 	err = push.StatusForeach(func(ref string, msg string) int {
-		log.Printf("%s -> %s", ref, msg)
 		return 0
 	})
 	checkFatal(t, err)

repository.go

@@ -366,7 +366,8 @@ func (v *Repository) EnsureLog(name string) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	if ret := C.git_reference_ensure_log(v.ptr, cname); ret < 0 {
+	ret := C.git_reference_ensure_log(v.ptr, cname)
+	if ret < 0 {
 		return MakeGitError(ret)
 	}
 
@@ -399,7 +400,8 @@ func (v *Repository) DwimReference(name string) (*Reference, error) {
 	defer runtime.UnlockOSThread()
 
 	var ptr *C.git_reference
-	if ret := C.git_reference_dwim(&ptr, v.ptr, cname); ret < 0 {
+	ret := C.git_reference_dwim(&ptr, v.ptr, cname)
+	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
 

wrapper.c

@@ -62,4 +62,5 @@ int _go_git_blob_create_fromchunks(git_oid *id,
 {
     return git_blob_create_fromchunks(id, repo, hintpath, _go_blob_chunk_cb, payload);
 }
+
 /* EOF */