Merge branch 'master-v23'

Author: carlosmn

.travis.yml

@@ -1,19 +1,15 @@
 language: go
 
-install:
-  - cd "${HOME}"
-  - wget -O libgit2-0.22.1.tar.gz https://github.com/libgit2/libgit2/archive/v0.22.1.tar.gz
-  - tar -xzvf libgit2-0.22.1.tar.gz
-  - cd libgit2-0.22.1 && mkdir build && cd build
-  - cmake -DTHREADSAFE=ON -DBUILD_CLAR=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE="RelWithDebInfo" -DCMAKE_INSTALL_PREFIX=/usr/local .. && make && sudo make install
-  - sudo ldconfig
-  - cd "${TRAVIS_BUILD_DIR}"
+sudo: required
+
+install: ./script/install-libgit2.sh
 
 go:
   - 1.1
   - 1.2
   - 1.3
   - 1.4
+  - 1.5
   - tip
 
 matrix:

branch.go

@@ -90,31 +90,17 @@ func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, er
 	return newBranchIteratorFromC(repo, ptr), nil
 }
 
-func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Branch, error) {
+func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool) (*Branch, error) {
 
 	var ptr *C.git_reference
 	cBranchName := C.CString(branchName)
 	defer C.free(unsafe.Pointer(cBranchName))
 	cForce := cbool(force)
 
-	cSignature, err := signature.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.git_signature_free(cSignature)
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_branch_create(&ptr, repo.ptr, cBranchName, target.cast_ptr, cForce, cSignature, cmsg)
+	ret := C.git_branch_create(&ptr, repo.ptr, cBranchName, target.cast_ptr, cForce)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -132,30 +118,16 @@ func (b *Branch) Delete() error {
 	return nil
 }
 
-func (b *Branch) Move(newBranchName string, force bool, signature *Signature, msg string) (*Branch, error) {
+func (b *Branch) Move(newBranchName string, force bool) (*Branch, error) {
 	var ptr *C.git_reference
 	cNewBranchName := C.CString(newBranchName)
 	defer C.free(unsafe.Pointer(cNewBranchName))
 	cForce := cbool(force)
 
-	cSignature, err := signature.toC()
-	if err != nil {
-		return nil, err
-	}
-	defer C.git_signature_free(cSignature)
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce, cSignature, cmsg)
+	ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}

checkout.go

@@ -15,18 +15,24 @@ type CheckoutStrategy uint
 const (
 	CheckoutNone                      CheckoutStrategy = C.GIT_CHECKOUT_NONE                         // Dry run, no actual updates
 	CheckoutSafe                      CheckoutStrategy = C.GIT_CHECKOUT_SAFE                         // Allow safe updates that cannot overwrite uncommitted data
-	CheckoutSafeCreate                CheckoutStrategy = C.GIT_CHECKOUT_SAFE_CREATE                  // Allow safe updates plus creation of missing files
 	CheckoutForce                     CheckoutStrategy = C.GIT_CHECKOUT_FORCE                        // Allow all updates to force working directory to look like index
+	CheckoutRecreateMissing           CheckoutStrategy = C.GIT_CHECKOUT_RECREATE_MISSING             // Allow checkout to recreate missing files
 	CheckoutAllowConflicts            CheckoutStrategy = C.GIT_CHECKOUT_ALLOW_CONFLICTS              // Allow checkout to make safe updates even if conflicts are found
 	CheckoutRemoveUntracked           CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_UNTRACKED             // Remove untracked files not in index (that are not ignored)
 	CheckoutRemoveIgnored             CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_IGNORED               // Remove ignored files not in index
 	CheckoutUpdateOnly                CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_ONLY                  // Only update existing files, don't create new ones
 	CheckoutDontUpdateIndex           CheckoutStrategy = C.GIT_CHECKOUT_DONT_UPDATE_INDEX            // Normally checkout updates index entries as it goes; this stops that
 	CheckoutNoRefresh                 CheckoutStrategy = C.GIT_CHECKOUT_NO_REFRESH                   // Don't refresh index/config/etc before doing checkout
+	CheckoutSkipUnmerged              CheckoutStrategy = C.GIT_CHECKOUT_SKIP_UNMERGED                // Allow checkout to skip unmerged files
+	CheckoutUserOurs                  CheckoutStrategy = C.GIT_CHECKOUT_USE_OURS                     // For unmerged files, checkout stage 2 from index
+	CheckoutUseTheirs                 CheckoutStrategy = C.GIT_CHECKOUT_USE_THEIRS                   // For unmerged files, checkout stage 3 from index
 	CheckoutDisablePathspecMatch      CheckoutStrategy = C.GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH       // Treat pathspec as simple list of exact match file paths
-	CheckoutSkipUnmerged              CheckoutStrategy = C.GIT_CHECKOUT_SKIP_UNMERGED                // Allow checkout to skip unmerged files (NOT IMPLEMENTED)
-	CheckoutUserOurs                  CheckoutStrategy = C.GIT_CHECKOUT_USE_OURS                     // For unmerged files, checkout stage 2 from index (NOT IMPLEMENTED)
-	CheckoutUseTheirs                 CheckoutStrategy = C.GIT_CHECKOUT_USE_THEIRS                   // For unmerged files, checkout stage 3 from index (NOT IMPLEMENTED)
+	CheckoutSkipLockedDirectories     CheckoutStrategy = C.GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES      // Ignore directories in use, they will be left empty
+	CheckoutDontOverwriteIgnored      CheckoutStrategy = C.GIT_CHECKOUT_DONT_OVERWRITE_IGNORED       // Don't overwrite ignored files that exist in the checkout target
+	CheckoutConflictStyleMerge        CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_MERGE         // Write normal merge files for conflicts
+	CheckoutConflictStyleDiff3        CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_DIFF3         // Include common ancestor data in diff3 format files for conflicts
+	CheckoutDontRemoveExisting        CheckoutStrategy = C.GIT_CHECKOUT_DONT_REMOVE_EXISTING         // Don't overwrite existing files or folders
+	CheckoutDontWriteIndex            CheckoutStrategy = C.GIT_CHECKOUT_DONT_WRITE_INDEX             // Normally checkout writes the index upon completion; this prevents that
 	CheckoutUpdateSubmodules          CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES            // Recursively checkout submodules with same options (NOT IMPLEMENTED)
 	CheckoutUpdateSubmodulesIfChanged CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED // Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED)
 )

cherrypick_test.go

@@ -16,7 +16,7 @@ func checkout(t *testing.T, repo *Repository, commit *Commit) {
 		t.Fatal(err)
 	}
 
-	err = repo.SetHeadDetached(commit.Id(), commit.Author(), "checkout")
+	err = repo.SetHeadDetached(commit.Id())
 	if err != nil {
 		t.Fatal(err)
 	}

clone.go

@@ -11,19 +11,17 @@ import (
 	"unsafe"
 )
 
-type RemoteCreateCallback func(repo Repository, name, url string) (*Remote, ErrorCode)
+type RemoteCreateCallback func(repo *Repository, name, url string) (*Remote, ErrorCode)
 
 type CloneOptions struct {
 	*CheckoutOpts
-	*RemoteCallbacks
+	*FetchOptions
 	Bare                 bool
 	CheckoutBranch       string
 	RemoteCreateCallback RemoteCreateCallback
 }
 
 func Clone(url string, path string, options *CloneOptions) (*Repository, error) {
-	repo := new(Repository)
-
 	curl := C.CString(url)
 	defer C.free(unsafe.Pointer(curl))
 
@@ -40,30 +38,33 @@ func Clone(url string, path string, options *CloneOptions) (*Repository, error)
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
-	ret := C.git_clone(&repo.ptr, curl, cpath, copts)
+
+	var ptr *C.git_repository
+	ret := C.git_clone(&ptr, curl, cpath, copts)
+	freeCheckoutOpts(&copts.checkout_opts)
 
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
 
-	runtime.SetFinalizer(repo, (*Repository).Free)
-	return repo, nil
+	return newRepositoryFromC(ptr), nil
 }
 
 //export remoteCreateCallback
 func remoteCreateCallback(cremote unsafe.Pointer, crepo unsafe.Pointer, cname, curl *C.char, payload unsafe.Pointer) C.int {
 	name := C.GoString(cname)
 	url := C.GoString(curl)
-	repo := Repository{(*C.git_repository)(crepo)}
+	repo := newRepositoryFromC((*C.git_repository)(crepo))
+	// We don't own this repository, so make sure we don't try to free it
+	runtime.SetFinalizer(repo, nil)
 
 	if opts, ok := pointerHandles.Get(payload).(CloneOptions); ok {
 		remote, err := opts.RemoteCreateCallback(repo, name, url)
+		// clear finalizer as the calling C function will
+		// free the remote itself
+		runtime.SetFinalizer(remote, nil)
 
 		if err == ErrOk && remote != nil {
-			// clear finalizer as the calling C function will
-			// free the remote itself
-			runtime.SetFinalizer(remote, nil)
-
 			cptr := (**C.git_remote)(cremote)
 			*cptr = remote.ptr
 		} else if err == ErrOk && remote == nil {
@@ -83,7 +84,7 @@ func populateCloneOptions(ptr *C.git_clone_options, opts *CloneOptions) {
 		return
 	}
 	populateCheckoutOpts(&ptr.checkout_opts, opts.CheckoutOpts)
-	populateRemoteCallbacks(&ptr.remote_callbacks, opts.RemoteCallbacks)
+	populateFetchOptions(&ptr.fetch_opts, opts.FetchOptions)
 	ptr.bare = cbool(opts.Bare)
 
 	if opts.RemoteCreateCallback != nil {

clone_test.go

@@ -18,10 +18,20 @@ func TestClone(t *testing.T) {
 	path, err := ioutil.TempDir("", "git2go")
 	checkFatal(t, err)
 
+	ref, err := repo.References.Lookup("refs/heads/master")
+	checkFatal(t, err)
+
 	repo2, err := Clone(repo.Path(), path, &CloneOptions{Bare: true})
 	defer cleanupTestRepo(t, repo2)
 
 	checkFatal(t, err)
+
+	ref2, err := repo2.References.Lookup("refs/heads/master")
+	checkFatal(t, err)
+
+	if ref.Cmp(ref2) != 0 {
+		t.Fatal("reference in clone does not match original ref")
+	}
 }
 
 func TestCloneWithCallback(t *testing.T) {
@@ -37,10 +47,10 @@ func TestCloneWithCallback(t *testing.T) {
 
 	opts := CloneOptions{
 		Bare: true,
-		RemoteCreateCallback: func(r Repository, name, url string) (*Remote, ErrorCode) {
+		RemoteCreateCallback: func(r *Repository, name, url string) (*Remote, ErrorCode) {
 			testPayload += 1
 
-			remote, err := r.CreateRemote(REMOTENAME, url)
+			remote, err := r.Remotes.Create(REMOTENAME, url)
 			if err != nil {
 				return nil, ErrGeneric
 			}
@@ -58,7 +68,7 @@ func TestCloneWithCallback(t *testing.T) {
 		t.Fatal("Payload's value has not been changed")
 	}
 
-	remote, err := repo2.LookupRemote(REMOTENAME)
+	remote, err := repo2.Remotes.Lookup(REMOTENAME)
 	if err != nil || remote == nil {
 		t.Fatal("Remote was not created properly")
 	}