From c4fce1a218fd33938c0be90e939531c0a00ebf7f Mon Sep 17 00:00:00 2001
From: Carlos Martín Nieto <cmn@dwim.me>
Date: Sun, 15 Mar 2015 01:49:32 +0100
Subject: Update to libgit2 d675982a153

There's been some changes to the checkout strategy, especially the
SAFE_CREATE mode, which is now the RECREATE_MISSING flag, though that
shouldn't be necessary to use in the general case.

The largest changes come from the removal of the signture from
ref-modifying functions/methods and the removal of the reflog string in
all but those directly related to moving references.
---
 remote_test.go | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

(limited to 'remote_test.go')

diff --git a/remote_test.go b/remote_test.go
index 54a66ed..bbbdeb9 100644
--- a/remote_test.go
+++ b/remote_test.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"testing"
-	"time"
 )
 
 func TestRefspecs(t *testing.T) {
@@ -73,7 +72,7 @@ func TestCertificateCheck(t *testing.T) {
 
 	err = remote.SetCallbacks(&callbacks)
 	checkFatal(t, err)
-	err = remote.Fetch([]string{}, nil, "")
+	err = remote.Fetch([]string{}, "")
 	checkFatal(t, err)
 }
 
@@ -168,13 +167,7 @@ func TestRemotePrune(t *testing.T) {
 	checkFatal(t, err)
 	defer commit.Free()
 
-	sig := &Signature{
-		Name:  "Rand Om Hacker",
-		Email: "random@hacker.com",
-		When:  time.Now(),
-	}
-
-	remoteRef, err := remoteRepo.CreateBranch("test-prune", commit, true, sig, "branch test-prune")
+	remoteRef, err := remoteRepo.CreateBranch("test-prune", commit, true)
 	checkFatal(t, err)
 
 	repo := createTestRepo(t)
@@ -189,10 +182,10 @@ func TestRemotePrune(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", remoteUrl)
 	checkFatal(t, err)
 
-	err = remote.Fetch([]string{"test-prune"}, sig, "")
+	err = remote.Fetch([]string{"test-prune"}, "")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/remotes/origin/test-prune", head, true, sig, "remote reference")
+	_, err = repo.CreateReference("refs/remotes/origin/test-prune", head, true, "remote reference")
 	checkFatal(t, err)
 
 	err = remoteRef.Delete()
-- 
cgit v1.2.3


From 36e0a256fe79f87447bb730fda53e5cbc90eb47c Mon Sep 17 00:00:00 2001
From: Carlos Martín Nieto <cmn@dwim.me>
Date: Mon, 8 Jun 2015 04:11:21 +0200
Subject: Update to libgit2 b6011e29

---
 clone.go       |   4 +-
 git.go         |   4 +-
 index.go       |  42 +++++++------
 odb.go         |   8 ++-
 odb_test.go    |   2 +-
 remote.go      | 184 ++++++++++++++++++++++++++++-----------------------------
 remote_test.go |  45 ++++----------
 submodule.go   |   4 +-
 vendor/libgit2 |   2 +-
 9 files changed, 140 insertions(+), 155 deletions(-)

(limited to 'remote_test.go')

diff --git a/clone.go b/clone.go
index b796b6e..233300d 100644
--- a/clone.go
+++ b/clone.go
@@ -12,7 +12,7 @@ import (
 
 type CloneOptions struct {
 	*CheckoutOpts
-	*RemoteCallbacks
+	*FetchOptions
 	Bare                 bool
 	CheckoutBranch       string
 	RemoteCreateCallback C.git_remote_create_cb
@@ -55,7 +55,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 {
diff --git a/git.go b/git.go
index 5f69837..ae65cb7 100644
--- a/git.go
+++ b/git.go
@@ -76,8 +76,8 @@ const (
 	ErrNonFastForward ErrorCode = C.GIT_ENONFASTFORWARD
 	// Name/ref spec was not in a valid format
 	ErrInvalidSpec ErrorCode = C.GIT_EINVALIDSPEC
-	// Merge conflicts prevented operation
-	ErrMergeConflict ErrorCode = C.GIT_EMERGECONFLICT
+	// Checkout conflicts prevented operation
+	ErrConflict ErrorCode = C.GIT_ECONFLICT
 	// Lock file prevented operation
 	ErrLocked ErrorCode = C.GIT_ELOCKED
 	// Reference value does not match expected
diff --git a/index.go b/index.go
index c1bfb74..0174dc1 100644
--- a/index.go
+++ b/index.go
@@ -12,7 +12,6 @@ import "C"
 import (
 	"fmt"
 	"runtime"
-	"time"
 	"unsafe"
 )
 
@@ -31,13 +30,18 @@ type Index struct {
 	ptr *C.git_index
 }
 
+type IndexTime struct {
+	seconds     int32
+	nanoseconds uint32
+}
+
 type IndexEntry struct {
-	Ctime time.Time
-	Mtime time.Time
+	Ctime IndexTime
+	Mtime IndexTime
 	Mode  Filemode
-	Uid   uint
-	Gid   uint
-	Size  uint
+	Uid   uint32
+	Gid   uint32
+	Size  uint32
 	Id    *Oid
 	Path  string
 }
@@ -47,26 +51,26 @@ func newIndexEntryFromC(entry *C.git_index_entry) *IndexEntry {
 		return nil
 	}
 	return &IndexEntry{
-		time.Unix(int64(entry.ctime.seconds), int64(entry.ctime.nanoseconds)),
-		time.Unix(int64(entry.mtime.seconds), int64(entry.mtime.nanoseconds)),
+		IndexTime { int32(entry.ctime.seconds), uint32(entry.ctime.nanoseconds) },
+		IndexTime { int32(entry.mtime.seconds), uint32(entry.mtime.nanoseconds) },
 		Filemode(entry.mode),
-		uint(entry.uid),
-		uint(entry.gid),
-		uint(entry.file_size),
+		uint32(entry.uid),
+		uint32(entry.gid),
+		uint32(entry.file_size),
 		newOidFromC(&entry.id),
 		C.GoString(entry.path),
 	}
 }
 
 func populateCIndexEntry(source *IndexEntry, dest *C.git_index_entry) {
-	dest.ctime.seconds = C.git_time_t(source.Ctime.Unix())
-	dest.ctime.nanoseconds = C.uint(source.Ctime.UnixNano())
-	dest.mtime.seconds = C.git_time_t(source.Mtime.Unix())
-	dest.mtime.nanoseconds = C.uint(source.Mtime.UnixNano())
-	dest.mode = C.uint(source.Mode)
-	dest.uid = C.uint(source.Uid)
-	dest.gid = C.uint(source.Gid)
-	dest.file_size = C.git_off_t(source.Size)
+	dest.ctime.seconds = C.int32_t(source.Ctime.seconds)
+	dest.ctime.nanoseconds = C.uint32_t(source.Ctime.nanoseconds)
+	dest.mtime.seconds = C.int32_t(source.Mtime.seconds)
+	dest.mtime.nanoseconds = C.uint32_t(source.Mtime.nanoseconds)
+	dest.mode = C.uint32_t(source.Mode)
+	dest.uid = C.uint32_t(source.Uid)
+	dest.gid = C.uint32_t(source.Gid)
+	dest.file_size = C.uint32_t(source.Size)
 	dest.id = *source.Id.toC()
 	dest.path = C.CString(source.Path)
 }
diff --git a/odb.go b/odb.go
index 6b21329..be0870e 100644
--- a/odb.go
+++ b/odb.go
@@ -11,6 +11,7 @@ import (
 	"reflect"
 	"runtime"
 	"unsafe"
+	"fmt"
 )
 
 type Odb struct {
@@ -106,7 +107,9 @@ func odbForEachCb(id *C.git_oid, handle unsafe.Pointer) int {
 	}
 
 	err := data.callback(newOidFromC(id))
+	fmt.Println("err %v", err)
 	if err != nil {
+		fmt.Println("returning EUSER")
 		data.err = err
 		return C.GIT_EUSER
 	}
@@ -127,6 +130,7 @@ func (v *Odb) ForEach(callback OdbForEachCallback) error {
 	defer pointerHandles.Untrack(handle)
 
 	ret := C._go_git_odb_foreach(v.ptr, handle)
+	fmt.Println("ret %v", ret);
 	if ret == C.GIT_EUSER {
 		return data.err
 	} else if ret < 0 {
@@ -172,13 +176,13 @@ func (v *Odb) NewReadStream(id *Oid) (*OdbReadStream, error) {
 // NewWriteStream opens a write stream to the ODB, which allows you to
 // create a new object in the database. The size and type must be
 // known in advance
-func (v *Odb) NewWriteStream(size int, otype ObjectType) (*OdbWriteStream, error) {
+func (v *Odb) NewWriteStream(size int64, otype ObjectType) (*OdbWriteStream, error) {
 	stream := new(OdbWriteStream)
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_odb_open_wstream(&stream.ptr, v.ptr, C.size_t(size), C.git_otype(otype))
+	ret := C.git_odb_open_wstream(&stream.ptr, v.ptr, C.git_off_t(size), C.git_otype(otype))
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
diff --git a/odb_test.go b/odb_test.go
index 2fb6840..0d765b9 100644
--- a/odb_test.go
+++ b/odb_test.go
@@ -17,7 +17,7 @@ func TestOdbStream(t *testing.T) {
 
 	str := "hello, world!"
 
-	stream, error := odb.NewWriteStream(len(str), ObjectBlob)
+	stream, error := odb.NewWriteStream(int64(len(str)), ObjectBlob)
 	checkFatal(t, error)
 	n, error := io.WriteString(stream, str)
 	checkFatal(t, error)
diff --git a/remote.go b/remote.go
index 72d3934..705bc0c 100644
--- a/remote.go
+++ b/remote.go
@@ -69,6 +69,51 @@ type RemoteCallbacks struct {
 	PushUpdateReferenceCallback
 }
 
+type FetchPrune uint
+
+const (
+	 // Use the setting from the configuration
+	FetchPruneFallback FetchPrune = C.GIT_FETCH_PRUNE_FALLBACK
+	// Force pruning on
+	FetchPruneOn       FetchPrune = C.GIT_FETCH_PRUNE
+	// Force pruning off
+	FetchNoPrune       FetchPrune = C.GIT_FETCH_NO_PRUNE
+)
+
+type DownloadTags uint
+
+const (
+
+	// Use the setting from the configuration.
+	DownloadTagsFallback DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_FALLBACK
+	// Ask the server for tags pointing to objects we're already
+	// downloading.
+	DownloadTagsAuto     DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_AUTO
+
+	// Don't ask for any tags beyond the refspecs.
+	DownloadTagsNone     DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_NONE
+
+	// Ask for the all the tags.
+	DownloadTagsAll      DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_ALL
+)
+
+type FetchOptions struct {
+	// Callbacks to use for this fetch operation
+	RemoteCallbacks RemoteCallbacks
+	// Whether to perform a prune after the fetch
+	Prune           FetchPrune
+	// Whether to write the results to FETCH_HEAD. Defaults to
+	// on. Leave this default in order to behave like git.
+	UpdateFetchhead bool
+
+	// Determines how to behave regarding tags on the remote, such
+	// as auto-downloading tags for objects we're downloading or
+	// downloading all of them.
+	//
+	// The default is to auto-follow tags.
+	DownloadTags    DownloadTags
+}
+
 type Remote struct {
 	ptr       *C.git_remote
 	callbacks RemoteCallbacks
@@ -267,23 +312,6 @@ func RemoteIsValidName(name string) bool {
 	return false
 }
 
-func (r *Remote) SetCallbacks(callbacks *RemoteCallbacks) error {
-	r.callbacks = *callbacks
-
-	var ccallbacks C.git_remote_callbacks
-	populateRemoteCallbacks(&ccallbacks, &r.callbacks)
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ecode := C.git_remote_set_callbacks(r.ptr, &ccallbacks)
-	if ecode < 0 {
-		return MakeGitError(ecode)
-	}
-
-	return nil
-}
-
 func (r *Remote) Free() {
 	runtime.SetFinalizer(r, nil)
 	C.git_remote_free(r.ptr)
@@ -359,18 +387,16 @@ func (repo *Repository) CreateRemoteWithFetchspec(name string, url string, fetch
 	return remote, nil
 }
 
-func (repo *Repository) CreateAnonymousRemote(url, fetch string) (*Remote, error) {
+func (repo *Repository) CreateAnonymousRemote(url string) (*Remote, error) {
 	remote := &Remote{}
 
 	curl := C.CString(url)
 	defer C.free(unsafe.Pointer(curl))
-	cfetch := C.CString(fetch)
-	defer C.free(unsafe.Pointer(cfetch))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_create_anonymous(&remote.ptr, repo.ptr, curl, cfetch)
+	ret := C.git_remote_create_anonymous(&remote.ptr, repo.ptr, curl)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -395,18 +421,6 @@ func (repo *Repository) LookupRemote(name string) (*Remote, error) {
 	return remote, nil
 }
 
-func (o *Remote) Save() error {
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ret := C.git_remote_save(o.ptr)
-	if ret < 0 {
-		return MakeGitError(ret)
-	}
-	return nil
-}
-
 func (o *Remote) Owner() Repository {
 	return Repository{C.git_remote_owner(o.ptr)}
 }
@@ -423,42 +437,48 @@ func (o *Remote) PushUrl() string {
 	return C.GoString(C.git_remote_pushurl(o.ptr))
 }
 
-func (o *Remote) SetUrl(url string) error {
+func (o *Repository) RemoteSetUrl(remote, url string) error {
 	curl := C.CString(url)
 	defer C.free(unsafe.Pointer(curl))
+	cremote := C.CString(remote)
+	defer C.free(unsafe.Pointer(cremote))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_set_url(o.ptr, curl)
+	ret := C.git_remote_set_url(o.ptr, cremote, curl)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
 	return nil
 }
 
-func (o *Remote) SetPushUrl(url string) error {
+func (o *Repository) RemoteSetPushUrl(remote, url string) error {
 	curl := C.CString(url)
 	defer C.free(unsafe.Pointer(curl))
+	cremote := C.CString(remote)
+	defer C.free(unsafe.Pointer(cremote))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_set_pushurl(o.ptr, curl)
+	ret := C.git_remote_set_pushurl(o.ptr, cremote, curl)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
 	return nil
 }
 
-func (o *Remote) AddFetch(refspec string) error {
+func (o *Repository) RemoteAddFetch(remote, refspec string) error {
 	crefspec := C.CString(refspec)
 	defer C.free(unsafe.Pointer(crefspec))
+	cremote := C.CString(remote)
+	defer C.free(unsafe.Pointer(cremote))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_add_fetch(o.ptr, crefspec)
+	ret := C.git_remote_add_fetch(o.ptr, cremote, crefspec)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
@@ -519,30 +539,16 @@ func (o *Remote) FetchRefspecs() ([]string, error) {
 	return refspecs, nil
 }
 
-func (o *Remote) SetFetchRefspecs(refspecs []string) error {
-	crefspecs := C.git_strarray{}
-	crefspecs.count = C.size_t(len(refspecs))
-	crefspecs.strings = makeCStringsFromStrings(refspecs)
-	defer freeStrarray(&crefspecs)
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ret := C.git_remote_set_fetch_refspecs(o.ptr, &crefspecs)
-	if ret < 0 {
-		return MakeGitError(ret)
-	}
-	return nil
-}
-
-func (o *Remote) AddPush(refspec string) error {
+func (o *Repository) RemoteAddPush(remote, refspec string) error {
 	crefspec := C.CString(refspec)
 	defer C.free(unsafe.Pointer(crefspec))
+	cremote := C.CString(remote)
+	defer C.free(unsafe.Pointer(cremote))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_add_push(o.ptr, crefspec)
+	ret := C.git_remote_add_push(o.ptr, cremote, crefspec)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
@@ -564,43 +570,26 @@ func (o *Remote) PushRefspecs() ([]string, error) {
 	return refspecs, nil
 }
 
-func (o *Remote) SetPushRefspecs(refspecs []string) error {
-	crefspecs := C.git_strarray{}
-	crefspecs.count = C.size_t(len(refspecs))
-	crefspecs.strings = makeCStringsFromStrings(refspecs)
-	defer freeStrarray(&crefspecs)
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ret := C.git_remote_set_push_refspecs(o.ptr, &crefspecs)
-	if ret < 0 {
-		return MakeGitError(ret)
-	}
-	return nil
-}
-
-func (o *Remote) ClearRefspecs() {
-	C.git_remote_clear_refspecs(o.ptr)
-}
-
 func (o *Remote) RefspecCount() uint {
 	return uint(C.git_remote_refspec_count(o.ptr))
 }
 
-func (o *Remote) SetUpdateFetchHead(val bool) {
-	C.git_remote_set_update_fetchhead(o.ptr, cbool(val))
-}
-
-func (o *Remote) UpdateFetchHead() bool {
-	return C.git_remote_update_fetchhead(o.ptr) > 0
+func populateFetchOptions(options *C.git_fetch_options, opts *FetchOptions) {
+	C.git_fetch_init_options(options, C.GIT_FETCH_OPTIONS_VERSION)
+	if opts == nil {
+		return;
+	}
+	populateRemoteCallbacks(&options.callbacks, &opts.RemoteCallbacks)
+	options.prune = C.git_fetch_prune_t(opts.Prune)
+	options.update_fetchhead = cbool(opts.UpdateFetchhead)
+	options.download_tags = C.git_remote_autotag_option_t(opts.DownloadTags)
 }
 
 // Fetch performs a fetch operation. refspecs specifies which refspecs
 // to use for this fetch, use an empty list to use the refspecs from
 // the configuration; msg specifies what to use for the reflog
 // entries. Leave "" to use defaults.
-func (o *Remote) Fetch(refspecs []string, msg string) error {
+func (o *Remote) Fetch(refspecs []string, opts *FetchOptions,  msg string) error {
 
 	var cmsg *C.char = nil
 	if msg != "" {
@@ -613,29 +602,35 @@ func (o *Remote) Fetch(refspecs []string, msg string) error {
 	crefspecs.strings = makeCStringsFromStrings(refspecs)
 	defer freeStrarray(&crefspecs)
 
+	var coptions C.git_fetch_options
+	populateFetchOptions(&coptions, opts);
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_fetch(o.ptr, &crefspecs, cmsg)
+	ret := C.git_remote_fetch(o.ptr, &crefspecs, &coptions, cmsg)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
 	return nil
 }
 
-func (o *Remote) ConnectFetch() error {
-	return o.Connect(ConnectDirectionFetch)
+func (o *Remote) ConnectFetch(callbacks *RemoteCallbacks) error {
+	return o.Connect(ConnectDirectionFetch, callbacks)
 }
 
-func (o *Remote) ConnectPush() error {
-	return o.Connect(ConnectDirectionPush)
+func (o *Remote) ConnectPush(callbacks *RemoteCallbacks) error {
+	return o.Connect(ConnectDirectionPush, callbacks)
 }
 
-func (o *Remote) Connect(direction ConnectDirection) error {
+func (o *Remote) Connect(direction ConnectDirection, callbacks *RemoteCallbacks) error {
+	var ccallbacks C.git_remote_callbacks;
+	populateRemoteCallbacks(&ccallbacks, callbacks)
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	if ret := C.git_remote_connect(o.ptr, C.git_direction(direction)); ret != 0 {
+	if ret := C.git_remote_connect(o.ptr, C.git_direction(direction), &ccallbacks); ret != 0 {
 		return MakeGitError(ret)
 	}
 	return nil
@@ -713,11 +708,14 @@ func (o *Remote) PruneRefs() bool {
 	return C.git_remote_prune_refs(o.ptr) > 0
 }
 
-func (o *Remote) Prune() error {
+func (o *Remote) Prune(callbacks *RemoteCallbacks) error {
+	var ccallbacks C.git_remote_callbacks;
+	populateRemoteCallbacks(&ccallbacks, callbacks)
+
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_prune(o.ptr)
+	ret := C.git_remote_prune(o.ptr, &ccallbacks)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
diff --git a/remote_test.go b/remote_test.go
index 23c80f5..cbb52aa 100644
--- a/remote_test.go
+++ b/remote_test.go
@@ -5,27 +5,6 @@ import (
 	"testing"
 )
 
-func TestRefspecs(t *testing.T) {
-	repo := createTestRepo(t)
-	defer cleanupTestRepo(t, repo)
-
-	remote, err := repo.CreateAnonymousRemote("git://foo/bar", "refs/heads/*:refs/heads/*")
-	checkFatal(t, err)
-
-	expected := []string{
-		"refs/heads/*:refs/remotes/origin/*",
-		"refs/pull/*/head:refs/remotes/origin/*",
-	}
-
-	err = remote.SetFetchRefspecs(expected)
-	checkFatal(t, err)
-
-	actual, err := remote.FetchRefspecs()
-	checkFatal(t, err)
-
-	compareStringList(t, expected, actual)
-}
-
 func TestListRemotes(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)
@@ -60,15 +39,15 @@ func TestCertificateCheck(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
-	callbacks := RemoteCallbacks{
-		CertificateCheckCallback: func(cert *Certificate, valid bool, hostname string) ErrorCode {
-			return assertHostname(cert, valid, hostname, t)
+	options := FetchOptions {
+		RemoteCallbacks: RemoteCallbacks{
+			CertificateCheckCallback: func(cert *Certificate, valid bool, hostname string) ErrorCode {
+				return assertHostname(cert, valid, hostname, t)
+			},
 		},
 	}
 
-	err = remote.SetCallbacks(&callbacks)
-	checkFatal(t, err)
-	err = remote.Fetch([]string{}, "")
+	err = remote.Fetch([]string{}, &options, "")
 	checkFatal(t, err)
 }
 
@@ -79,7 +58,7 @@ func TestRemoteConnect(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
-	err = remote.ConnectFetch()
+	err = remote.ConnectFetch(nil)
 	checkFatal(t, err)
 }
 
@@ -90,7 +69,7 @@ func TestRemoteLs(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
-	err = remote.ConnectFetch()
+	err = remote.ConnectFetch(nil)
 	checkFatal(t, err)
 
 	heads, err := remote.Ls()
@@ -108,7 +87,7 @@ func TestRemoteLsFiltering(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
-	err = remote.ConnectFetch()
+	err = remote.ConnectFetch(nil)
 	checkFatal(t, err)
 
 	heads, err := remote.Ls("master")
@@ -172,7 +151,7 @@ func TestRemotePrune(t *testing.T) {
 	remote, err := repo.CreateRemote("origin", remoteUrl)
 	checkFatal(t, err)
 
-	err = remote.Fetch([]string{"test-prune"}, "")
+	err = remote.Fetch([]string{"test-prune"}, nil, "")
 	checkFatal(t, err)
 
 	_, err = repo.CreateReference("refs/remotes/origin/test-prune", head, true, "remote reference")
@@ -187,10 +166,10 @@ func TestRemotePrune(t *testing.T) {
 	rr, err := repo.LookupRemote("origin")
 	checkFatal(t, err)
 
-	err = rr.ConnectFetch()
+	err = rr.ConnectFetch(nil)
 	checkFatal(t, err)
 
-	err = rr.Prune()
+	err = rr.Prune(nil)
 	checkFatal(t, err)
 
 	_, err = repo.LookupReference("refs/remotes/origin/test-prune")
diff --git a/submodule.go b/submodule.go
index 6edc1d7..05cfd73 100644
--- a/submodule.go
+++ b/submodule.go
@@ -14,7 +14,7 @@ import (
 // SubmoduleUpdateOptions
 type SubmoduleUpdateOptions struct {
 	*CheckoutOpts
-	*RemoteCallbacks
+	*FetchOptions
 	CloneCheckoutStrategy CheckoutStrategy
 }
 
@@ -348,7 +348,7 @@ func populateSubmoduleUpdateOptions(ptr *C.git_submodule_update_options, opts *S
 	}
 
 	populateCheckoutOpts(&ptr.checkout_opts, opts.CheckoutOpts)
-	populateRemoteCallbacks(&ptr.remote_callbacks, opts.RemoteCallbacks)
+	populateFetchOptions(&ptr.fetch_opts, opts.FetchOptions)
 	ptr.clone_checkout_strategy = C.uint(opts.CloneCheckoutStrategy)
 
 	return nil
diff --git a/vendor/libgit2 b/vendor/libgit2
index 4c02d39..b6011e2 160000
--- a/vendor/libgit2
+++ b/vendor/libgit2
@@ -1 +1 @@
-Subproject commit 4c02d393748d0db382450871ad9ef6898a2ce360
+Subproject commit b6011e296e4db6942d71f5a8548d1308353927ee
-- 
cgit v1.2.3


From 4b9cbd78fd266767f6bdf55257c4ee2b1611bbe0 Mon Sep 17 00:00:00 2001
From: Carlos Martín Nieto <cmn@dwim.me>
Date: Sun, 28 Jun 2015 00:51:17 +0200
Subject: Create a RemoteCollection for managing remotes

Instead of making the 'Remote' part of the function calls, create a
collection object which serves to namespace the operations for the
remotes.
---
 push_test.go   |  2 +-
 remote.go      | 44 ++++++++++++++++++++++++--------------------
 remote_test.go | 20 ++++++++++----------
 repository.go  | 19 ++++++++++++++-----
 4 files changed, 49 insertions(+), 36 deletions(-)

(limited to 'remote_test.go')

diff --git a/push_test.go b/push_test.go
index 4686c65..a9fc90d 100644
--- a/push_test.go
+++ b/push_test.go
@@ -11,7 +11,7 @@ func TestRemotePush(t *testing.T) {
 	localRepo := createTestRepo(t)
 	defer cleanupTestRepo(t, localRepo)
 
-	remote, err := localRepo.CreateRemote("test_push", repo.Path())
+	remote, err := localRepo.Remotes.Create("test_push", repo.Path())
 	checkFatal(t, err)
 
 	seedTestRepo(t, localRepo)
diff --git a/remote.go b/remote.go
index 4ff2040..5bed309 100644
--- a/remote.go
+++ b/remote.go
@@ -317,13 +317,17 @@ func (r *Remote) Free() {
 	C.git_remote_free(r.ptr)
 }
 
-func (repo *Repository) ListRemotes() ([]string, error) {
+type RemoteCollection struct {
+	repo *Repository
+}
+
+func (c *RemoteCollection) List() ([]string, error) {
 	var r C.git_strarray
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ecode := C.git_remote_list(&r, repo.ptr)
+	ecode := C.git_remote_list(&r, c.repo.ptr)
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
@@ -333,7 +337,7 @@ func (repo *Repository) ListRemotes() ([]string, error) {
 	return remotes, nil
 }
 
-func (repo *Repository) CreateRemote(name string, url string) (*Remote, error) {
+func (c *RemoteCollection) Create(name string, url string) (*Remote, error) {
 	remote := &Remote{}
 
 	cname := C.CString(name)
@@ -344,7 +348,7 @@ func (repo *Repository) CreateRemote(name string, url string) (*Remote, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_create(&remote.ptr, repo.ptr, cname, curl)
+	ret := C.git_remote_create(&remote.ptr, c.repo.ptr, cname, curl)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -352,21 +356,21 @@ func (repo *Repository) CreateRemote(name string, url string) (*Remote, error) {
 	return remote, nil
 }
 
-func (repo *Repository) DeleteRemote(name string) error {
+func (c *RemoteCollection) Delete(name string) error {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_delete(repo.ptr, cname)
+	ret := C.git_remote_delete(c.repo.ptr, cname)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
 	return nil
 }
 
-func (repo *Repository) CreateRemoteWithFetchspec(name string, url string, fetch string) (*Remote, error) {
+func (c *RemoteCollection) CreateWithFetchspec(name string, url string, fetch string) (*Remote, error) {
 	remote := &Remote{}
 
 	cname := C.CString(name)
@@ -379,7 +383,7 @@ func (repo *Repository) CreateRemoteWithFetchspec(name string, url string, fetch
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_create_with_fetchspec(&remote.ptr, repo.ptr, cname, curl, cfetch)
+	ret := C.git_remote_create_with_fetchspec(&remote.ptr, c.repo.ptr, cname, curl, cfetch)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -387,7 +391,7 @@ func (repo *Repository) CreateRemoteWithFetchspec(name string, url string, fetch
 	return remote, nil
 }
 
-func (repo *Repository) CreateAnonymousRemote(url string) (*Remote, error) {
+func (c *RemoteCollection) CreateAnonymous(url string) (*Remote, error) {
 	remote := &Remote{}
 
 	curl := C.CString(url)
@@ -396,7 +400,7 @@ func (repo *Repository) CreateAnonymousRemote(url string) (*Remote, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_create_anonymous(&remote.ptr, repo.ptr, curl)
+	ret := C.git_remote_create_anonymous(&remote.ptr, c.repo.ptr, curl)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -404,7 +408,7 @@ func (repo *Repository) CreateAnonymousRemote(url string) (*Remote, error) {
 	return remote, nil
 }
 
-func (repo *Repository) LookupRemote(name string) (*Remote, error) {
+func (c *RemoteCollection) Lookup(name string) (*Remote, error) {
 	remote := &Remote{}
 
 	cname := C.CString(name)
@@ -413,7 +417,7 @@ func (repo *Repository) LookupRemote(name string) (*Remote, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_lookup(&remote.ptr, repo.ptr, cname)
+	ret := C.git_remote_lookup(&remote.ptr, c.repo.ptr, cname)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -433,7 +437,7 @@ func (o *Remote) PushUrl() string {
 	return C.GoString(C.git_remote_pushurl(o.ptr))
 }
 
-func (o *Repository) RemoteSetUrl(remote, url string) error {
+func (c *RemoteCollection) SetUrl(remote, url string) error {
 	curl := C.CString(url)
 	defer C.free(unsafe.Pointer(curl))
 	cremote := C.CString(remote)
@@ -442,14 +446,14 @@ func (o *Repository) RemoteSetUrl(remote, url string) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_set_url(o.ptr, cremote, curl)
+	ret := C.git_remote_set_url(c.repo.ptr, cremote, curl)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
 	return nil
 }
 
-func (o *Repository) RemoteSetPushUrl(remote, url string) error {
+func (c *RemoteCollection) SetPushUrl(remote, url string) error {
 	curl := C.CString(url)
 	defer C.free(unsafe.Pointer(curl))
 	cremote := C.CString(remote)
@@ -458,14 +462,14 @@ func (o *Repository) RemoteSetPushUrl(remote, url string) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_set_pushurl(o.ptr, cremote, curl)
+	ret := C.git_remote_set_pushurl(c.repo.ptr, cremote, curl)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
 	return nil
 }
 
-func (o *Repository) RemoteAddFetch(remote, refspec string) error {
+func (c *RemoteCollection) AddFetch(remote, refspec string) error {
 	crefspec := C.CString(refspec)
 	defer C.free(unsafe.Pointer(crefspec))
 	cremote := C.CString(remote)
@@ -474,7 +478,7 @@ func (o *Repository) RemoteAddFetch(remote, refspec string) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_add_fetch(o.ptr, cremote, crefspec)
+	ret := C.git_remote_add_fetch(c.repo.ptr, cremote, crefspec)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
@@ -535,7 +539,7 @@ func (o *Remote) FetchRefspecs() ([]string, error) {
 	return refspecs, nil
 }
 
-func (o *Repository) RemoteAddPush(remote, refspec string) error {
+func (c *RemoteCollection) AddPush(remote, refspec string) error {
 	crefspec := C.CString(refspec)
 	defer C.free(unsafe.Pointer(crefspec))
 	cremote := C.CString(remote)
@@ -544,7 +548,7 @@ func (o *Repository) RemoteAddPush(remote, refspec string) error {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_remote_add_push(o.ptr, cremote, crefspec)
+	ret := C.git_remote_add_push(c.repo.ptr, cremote, crefspec)
 	if ret < 0 {
 		return MakeGitError(ret)
 	}
diff --git a/remote_test.go b/remote_test.go
index cbb52aa..4e64489 100644
--- a/remote_test.go
+++ b/remote_test.go
@@ -9,7 +9,7 @@ func TestListRemotes(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)
 
-	_, err := repo.CreateRemote("test", "git://foo/bar")
+	_, err := repo.Remotes.Create("test", "git://foo/bar")
 
 	checkFatal(t, err)
 
@@ -17,7 +17,7 @@ func TestListRemotes(t *testing.T) {
 		"test",
 	}
 
-	actual, err := repo.ListRemotes()
+	actual, err := repo.Remotes.List()
 	checkFatal(t, err)
 
 	compareStringList(t, expected, actual)
@@ -36,7 +36,7 @@ func TestCertificateCheck(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)
 
-	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
+	remote, err := repo.Remotes.Create("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
 	options := FetchOptions {
@@ -55,7 +55,7 @@ func TestRemoteConnect(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)
 
-	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
+	remote, err := repo.Remotes.Create("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
 	err = remote.ConnectFetch(nil)
@@ -66,7 +66,7 @@ func TestRemoteLs(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)
 
-	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
+	remote, err := repo.Remotes.Create("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
 	err = remote.ConnectFetch(nil)
@@ -84,7 +84,7 @@ func TestRemoteLsFiltering(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)
 
-	remote, err := repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
+	remote, err := repo.Remotes.Create("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
 	err = remote.ConnectFetch(nil)
@@ -117,10 +117,10 @@ func TestRemotePruneRefs(t *testing.T) {
 	err = config.SetBool("remote.origin.prune", true)
 	checkFatal(t, err)
 
-	_, err = repo.CreateRemote("origin", "https://github.com/libgit2/TestGitRepository")
+	_, err = repo.Remotes.Create("origin", "https://github.com/libgit2/TestGitRepository")
 	checkFatal(t, err)
 
-	remote, err := repo.LookupRemote("origin")
+	remote, err := repo.Remotes.Lookup("origin")
 	checkFatal(t, err)
 
 	if !remote.PruneRefs() {
@@ -148,7 +148,7 @@ func TestRemotePrune(t *testing.T) {
 	defer config.Free()
 
 	remoteUrl := fmt.Sprintf("file://%s", remoteRepo.Workdir())
-	remote, err := repo.CreateRemote("origin", remoteUrl)
+	remote, err := repo.Remotes.Create("origin", remoteUrl)
 	checkFatal(t, err)
 
 	err = remote.Fetch([]string{"test-prune"}, nil, "")
@@ -163,7 +163,7 @@ func TestRemotePrune(t *testing.T) {
 	err = config.SetBool("remote.origin.prune", true)
 	checkFatal(t, err)
 
-	rr, err := repo.LookupRemote("origin")
+	rr, err := repo.Remotes.Lookup("origin")
 	checkFatal(t, err)
 
 	err = rr.ConnectFetch(nil)
diff --git a/repository.go b/repository.go
index 9917c60..860050f 100644
--- a/repository.go
+++ b/repository.go
@@ -12,7 +12,16 @@ import (
 
 // Repository
 type Repository struct {
-	ptr *C.git_repository
+	ptr     *C.git_repository
+	// Remotes represents the collection of remotes and can be
+	// used to add, remove and configure remotes for this
+	// repository.
+	Remotes  RemoteCollection
+}
+
+func initRepositoryObject(repo *Repository) {
+	repo.Remotes.repo = repo
+	runtime.SetFinalizer(repo, (*Repository).Free)
 }
 
 func OpenRepository(path string) (*Repository, error) {
@@ -29,7 +38,7 @@ func OpenRepository(path string) (*Repository, error) {
 		return nil, MakeGitError(ret)
 	}
 
-	runtime.SetFinalizer(repo, (*Repository).Free)
+	initRepositoryObject(repo)
 	return repo, nil
 }
 
@@ -47,7 +56,7 @@ func OpenRepositoryExtended(path string) (*Repository, error) {
 		return nil, MakeGitError(ret)
 	}
 
-	runtime.SetFinalizer(repo, (*Repository).Free)
+	initRepositoryObject(repo)
 	return repo, nil
 }
 
@@ -65,7 +74,7 @@ func InitRepository(path string, isbare bool) (*Repository, error) {
 		return nil, MakeGitError(ret)
 	}
 
-	runtime.SetFinalizer(repo, (*Repository).Free)
+	initRepositoryObject(repo)
 	return repo, nil
 }
 
@@ -80,7 +89,7 @@ func NewRepositoryWrapOdb(odb *Odb) (repo *Repository, err error) {
 		return nil, MakeGitError(ret)
 	}
 
-	runtime.SetFinalizer(repo, (*Repository).Free)
+	initRepositoryObject(repo)
 	return repo, nil
 }
 
-- 
cgit v1.2.3


From 01a2d8d38d4683c6e29da21240ffff7ae7b3a680 Mon Sep 17 00:00:00 2001
From: Carlos Martín Nieto <cmn@dwim.me>
Date: Sun, 28 Jun 2015 01:12:32 +0200
Subject: Create a ReferenceCollection for managing references

As with the other commits, this clears up the clutter in naming and
around the Repository's API.
---
 merge_test.go     |   4 +-
 push_test.go      |   4 +-
 reference.go      | 124 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 reference_test.go |  22 +++++-----
 remote_test.go    |   4 +-
 repository.go     | 126 +++---------------------------------------------------
 revparse_test.go  |   2 +-
 7 files changed, 147 insertions(+), 139 deletions(-)

(limited to 'remote_test.go')

diff --git a/merge_test.go b/merge_test.go
index 0b1faca..5c62f5c 100644
--- a/merge_test.go
+++ b/merge_test.go
@@ -10,7 +10,7 @@ func TestMergeWithSelf(t *testing.T) {
 
 	seedTestRepo(t, repo)
 
-	master, err := repo.LookupReference("refs/heads/master")
+	master, err := repo.References.Lookup("refs/heads/master")
 	checkFatal(t, err)
 
 	mergeHead, err := repo.AnnotatedCommitFromRef(master)
@@ -28,7 +28,7 @@ func TestMergeAnalysisWithSelf(t *testing.T) {
 
 	seedTestRepo(t, repo)
 
-	master, err := repo.LookupReference("refs/heads/master")
+	master, err := repo.References.Lookup("refs/heads/master")
 	checkFatal(t, err)
 
 	mergeHead, err := repo.AnnotatedCommitFromRef(master)
diff --git a/push_test.go b/push_test.go
index a9fc90d..8f6e806 100644
--- a/push_test.go
+++ b/push_test.go
@@ -19,9 +19,9 @@ func TestRemotePush(t *testing.T) {
 	err = remote.Push([]string{"refs/heads/master"}, nil)
 	checkFatal(t, err)
 
-	_, err = localRepo.LookupReference("refs/remotes/test_push/master")
+	_, err = localRepo.References.Lookup("refs/remotes/test_push/master")
 	checkFatal(t, err)
 
-	_, err = repo.LookupReference("refs/heads/master")
+	_, err = repo.References.Lookup("refs/heads/master")
 	checkFatal(t, err)
 }
diff --git a/reference.go b/reference.go
index 61e2b26..d24e054 100644
--- a/reference.go
+++ b/reference.go
@@ -21,6 +21,130 @@ type Reference struct {
 	repo *Repository
 }
 
+type ReferenceCollection struct {
+	repo *Repository
+}
+
+func (c *ReferenceCollection) Lookup(name string) (*Reference, error) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+	var ptr *C.git_reference
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ecode := C.git_reference_lookup(&ptr, c.repo.ptr, cname)
+	if ecode < 0 {
+		return nil, MakeGitError(ecode)
+	}
+
+	return newReferenceFromC(ptr, c.repo), nil
+}
+
+func (c *ReferenceCollection) Create(name string, id *Oid, force bool, msg string) (*Reference, error) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+
+	var cmsg *C.char
+	if msg == "" {
+		cmsg = nil
+	} else {
+		cmsg = C.CString(msg)
+		defer C.free(unsafe.Pointer(cmsg))
+	}
+
+	var ptr *C.git_reference
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ecode := C.git_reference_create(&ptr, c.repo.ptr, cname, id.toC(), cbool(force), cmsg)
+	if ecode < 0 {
+		return nil, MakeGitError(ecode)
+	}
+
+	return newReferenceFromC(ptr, c.repo), nil
+}
+
+func (c *ReferenceCollection) CreateSymbolic(name, target string, force bool, msg string) (*Reference, error) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+
+	ctarget := C.CString(target)
+	defer C.free(unsafe.Pointer(ctarget))
+
+	var cmsg *C.char
+	if msg == "" {
+		cmsg = nil
+	} else {
+		cmsg = C.CString(msg)
+		defer C.free(unsafe.Pointer(cmsg))
+	}
+
+	var ptr *C.git_reference
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ecode := C.git_reference_symbolic_create(&ptr, c.repo.ptr, cname, ctarget, cbool(force), cmsg)
+	if ecode < 0 {
+		return nil, MakeGitError(ecode)
+	}
+
+	return newReferenceFromC(ptr, c.repo), nil
+}
+
+// EnsureLog ensures that there is a reflog for the given reference
+// name and creates an empty one if necessary.
+func (c *ReferenceCollection) EnsureLog(name string) error {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_reference_ensure_log(c.repo.ptr, cname)
+	if ret < 0 {
+		return MakeGitError(ret)
+	}
+
+	return nil
+}
+
+// HasLog returns whether there is a reflog for the given reference
+// name
+func (c *ReferenceCollection) HasLog(name string) (bool, error) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_reference_has_log(c.repo.ptr, cname)
+	if ret < 0 {
+		return false, MakeGitError(ret)
+	}
+
+	return ret == 1, nil
+}
+
+// Dwim looks up a reference by DWIMing its short name
+func (c *ReferenceCollection) Dwim(name string) (*Reference, error) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var ptr *C.git_reference
+	ret := C.git_reference_dwim(&ptr, c.repo.ptr, cname)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+
+	return newReferenceFromC(ptr, c.repo), nil
+}
+
 func newReferenceFromC(ptr *C.git_reference, repo *Repository) *Reference {
 	ref := &Reference{ptr: ptr, repo: repo}
 	runtime.SetFinalizer(ref, (*Reference).Free)
diff --git a/reference_test.go b/reference_test.go
index e891e7a..f1546e2 100644
--- a/reference_test.go
+++ b/reference_test.go
@@ -13,14 +13,14 @@ func TestRefModification(t *testing.T) {
 
 	commitId, treeId := seedTestRepo(t, repo)
 
-	_, err := repo.CreateReference("refs/tags/tree", treeId, true, "testTreeTag")
+	_, err := repo.References.Create("refs/tags/tree", treeId, true, "testTreeTag")
 	checkFatal(t, err)
 
-	tag, err := repo.LookupReference("refs/tags/tree")
+	tag, err := repo.References.Lookup("refs/tags/tree")
 	checkFatal(t, err)
 	checkRefType(t, tag, ReferenceOid)
 
-	ref, err := repo.LookupReference("HEAD")
+	ref, err := repo.References.Lookup("HEAD")
 	checkFatal(t, err)
 	checkRefType(t, ref, ReferenceSymbolic)
 
@@ -46,7 +46,7 @@ func TestRefModification(t *testing.T) {
 
 	_, err = tag.Rename("refs/tags/renamed", false, "")
 	checkFatal(t, err)
-	tag, err = repo.LookupReference("refs/tags/renamed")
+	tag, err = repo.References.Lookup("refs/tags/renamed")
 	checkFatal(t, err)
 	checkRefType(t, ref, ReferenceOid)
 
@@ -77,13 +77,13 @@ func TestReferenceIterator(t *testing.T) {
 	commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree)
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/one", commitId, true, "headOne")
+	_, err = repo.References.Create("refs/heads/one", commitId, true, "headOne")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/two", commitId, true, "headTwo")
+	_, err = repo.References.Create("refs/heads/two", commitId, true, "headTwo")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/heads/three", commitId, true, "headThree")
+	_, err = repo.References.Create("refs/heads/three", commitId, true, "headThree")
 	checkFatal(t, err)
 
 	iter, err := repo.NewReferenceIterator()
@@ -136,7 +136,7 @@ func TestReferenceOwner(t *testing.T) {
 
 	commitId, _ := seedTestRepo(t, repo)
 
-	ref, err := repo.CreateReference("refs/heads/foo", commitId, true, "")
+	ref, err := repo.References.Create("refs/heads/foo", commitId, true, "")
 	checkFatal(t, err)
 
 	owner := ref.Owner()
@@ -155,10 +155,10 @@ func TestUtil(t *testing.T) {
 
 	commitId, _ := seedTestRepo(t, repo)
 
-	ref, err := repo.CreateReference("refs/heads/foo", commitId, true, "")
+	ref, err := repo.References.Create("refs/heads/foo", commitId, true, "")
 	checkFatal(t, err)
 
-	ref2, err := repo.DwimReference("foo")
+	ref2, err := repo.References.Dwim("foo")
 	checkFatal(t, err)
 
 	if ref.Cmp(ref2) != 0 {
@@ -169,7 +169,7 @@ func TestUtil(t *testing.T) {
 		t.Fatalf("refs/heads/foo has no foo shorthand")
 	}
 
-	hasLog, err := repo.HasLog("refs/heads/foo")
+	hasLog, err := repo.References.HasLog("refs/heads/foo")
 	checkFatal(t, err)
 	if !hasLog {
 		t.Fatalf("branches have logs by default")
diff --git a/remote_test.go b/remote_test.go
index 4e64489..73c637f 100644
--- a/remote_test.go
+++ b/remote_test.go
@@ -154,7 +154,7 @@ func TestRemotePrune(t *testing.T) {
 	err = remote.Fetch([]string{"test-prune"}, nil, "")
 	checkFatal(t, err)
 
-	_, err = repo.CreateReference("refs/remotes/origin/test-prune", head, true, "remote reference")
+	_, err = repo.References.Create("refs/remotes/origin/test-prune", head, true, "remote reference")
 	checkFatal(t, err)
 
 	err = remoteRef.Delete()
@@ -172,7 +172,7 @@ func TestRemotePrune(t *testing.T) {
 	err = rr.Prune(nil)
 	checkFatal(t, err)
 
-	_, err = repo.LookupReference("refs/remotes/origin/test-prune")
+	_, err = repo.References.Lookup("refs/remotes/origin/test-prune")
 	if err == nil {
 		t.Fatal("Expected error getting a pruned reference")
 	}
diff --git a/repository.go b/repository.go
index 0427d85..8aa39ef 100644
--- a/repository.go
+++ b/repository.go
@@ -17,15 +17,19 @@ type Repository struct {
 	// used to add, remove and configure remotes for this
 	// repository.
 	Remotes  RemoteCollection
-	// Submodules represents the collectin of submodules and can
+	// Submodules represents the collection of submodules and can
 	// be used to add, remove and configure submodules in this
 	// repostiory.
 	Submodules SubmoduleCollection
+	// References represents the collection of references and can
+	// be used to create, remove or update refernces for this repository.
+	References ReferenceCollection
 }
 
 func initRepositoryObject(repo *Repository) {
 	repo.Remotes.repo    = repo
 	repo.Submodules.repo = repo
+	repo.References.repo = repo
 	runtime.SetFinalizer(repo, (*Repository).Free)
 }
 
@@ -190,22 +194,6 @@ func (v *Repository) LookupTag(id *Oid) (*Tag, error) {
 	return obj.(*Tag), nil
 }
 
-func (v *Repository) LookupReference(name string) (*Reference, error) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-	var ptr *C.git_reference
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ecode := C.git_reference_lookup(&ptr, v.ptr, cname)
-	if ecode < 0 {
-		return nil, MakeGitError(ecode)
-	}
-
-	return newReferenceFromC(ptr, v), nil
-}
-
 func (v *Repository) Head() (*Reference, error) {
 	var ptr *C.git_reference
 
@@ -245,59 +233,6 @@ func (v *Repository) SetHeadDetached(id *Oid) error {
 	return nil
 }
 
-func (v *Repository) CreateReference(name string, id *Oid, force bool, msg string) (*Reference, error) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
-	var ptr *C.git_reference
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ecode := C.git_reference_create(&ptr, v.ptr, cname, id.toC(), cbool(force), cmsg)
-	if ecode < 0 {
-		return nil, MakeGitError(ecode)
-	}
-
-	return newReferenceFromC(ptr, v), nil
-}
-
-func (v *Repository) CreateSymbolicReference(name, target string, force bool, msg string) (*Reference, error) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	ctarget := C.CString(target)
-	defer C.free(unsafe.Pointer(ctarget))
-
-	var cmsg *C.char
-	if msg == "" {
-		cmsg = nil
-	} else {
-		cmsg = C.CString(msg)
-		defer C.free(unsafe.Pointer(cmsg))
-	}
-
-	var ptr *C.git_reference
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), cmsg)
-	if ecode < 0 {
-		return nil, MakeGitError(ecode)
-	}
-
-	return newReferenceFromC(ptr, v), nil
-}
-
 func (v *Repository) Walk() (*RevWalk, error) {
 
 	var walkPtr *C.git_revwalk
@@ -479,57 +414,6 @@ func (v *Repository) TreeBuilderFromTree(tree *Tree) (*TreeBuilder, error) {
 	return bld, nil
 }
 
-// EnsureLog ensures that there is a reflog for the given reference
-// name and creates an empty one if necessary.
-func (v *Repository) EnsureLog(name string) error {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ret := C.git_reference_ensure_log(v.ptr, cname)
-	if ret < 0 {
-		return MakeGitError(ret)
-	}
-
-	return nil
-}
-
-// HasLog returns whether there is a reflog for the given reference
-// name
-func (v *Repository) HasLog(name string) (bool, error) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	ret := C.git_reference_has_log(v.ptr, cname)
-	if ret < 0 {
-		return false, MakeGitError(ret)
-	}
-
-	return ret == 1, nil
-}
-
-// DwimReference looks up a reference by DWIMing its short name
-func (v *Repository) DwimReference(name string) (*Reference, error) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	var ptr *C.git_reference
-	ret := C.git_reference_dwim(&ptr, v.ptr, cname)
-	if ret < 0 {
-		return nil, MakeGitError(ret)
-	}
-
-	return newReferenceFromC(ptr, v), nil
-}
-
 // CreateNote adds a note for an object
 func (v *Repository) CreateNote(
 	ref string, author, committer *Signature, id *Oid,
diff --git a/revparse_test.go b/revparse_test.go
index 4bc327c..091a76b 100644
--- a/revparse_test.go
+++ b/revparse_test.go
@@ -34,7 +34,7 @@ func TestRevparseExt(t *testing.T) {
 
 	_, treeId := seedTestRepo(t, repo)
 
-	ref, err := repo.CreateReference("refs/heads/master", treeId, true, "")
+	ref, err := repo.References.Create("refs/heads/master", treeId, true, "")
 	checkFatal(t, err)
 
 	obj, ref, err := repo.RevparseExt("master")
-- 
cgit v1.2.3