From a8ad0d204052d8bd9c4d0093cce62c54afa67188 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 19 May 2015 14:33:30 +0200
Subject: [PATCH 1/3] Index: Add ReadTree()

---
 index.go      | 14 ++++++++++++++
 index_test.go | 28 ++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/index.go b/index.go
index 9f37f33..009aeb6 100644
--- a/index.go
+++ b/index.go
@@ -240,6 +240,20 @@ func (v *Index) WriteTreeTo(repo *Repository) (*Oid, error) {
 	return oid, nil
 }
 
+// ReadTree replaces the contents of the index with those of the given
+// tree
+func (v *Index) ReadTree(tree *Tree) error {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_index_read_tree(v.ptr, tree.cast_ptr);
+	if ret < 0 {
+		return MakeGitError(ret)
+	}
+
+	return nil
+}
+
 func (v *Index) WriteTree() (*Oid, error) {
 	oid := new(Oid)
 
diff --git a/index_test.go b/index_test.go
index 647a0b8..a1f0c9c 100644
--- a/index_test.go
+++ b/index_test.go
@@ -22,6 +22,34 @@ func TestCreateRepoAndStage(t *testing.T) {
 	}
 }
 
+func TestIndexReadTree(t *testing.T) {
+	repo := createTestRepo(t)
+	defer cleanupTestRepo(t, repo)
+
+	_, _ = seedTestRepo(t, repo)
+
+	ref, err := repo.Head()
+	checkFatal(t, err)
+
+	obj, err := ref.Peel(ObjectTree);
+	checkFatal(t, err)
+
+	tree := obj.(*Tree)
+
+	idx, err := NewIndex()
+	checkFatal(t, err)
+
+	err = idx.ReadTree(tree)
+	checkFatal(t, err)
+
+	id, err := idx.WriteTreeTo(repo)
+	checkFatal(t, err)
+
+	if tree.Id().Cmp(id) != 0 {
+		t.Fatalf("Read and written trees are not the same")
+	}
+}
+
 func TestIndexWriteTreeTo(t *testing.T) {
 	repo := createTestRepo(t)
 	defer cleanupTestRepo(t, repo)

From d7a0495000e35d06993605a9a31a5f9823292f8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 19 May 2015 14:56:01 +0200
Subject: [PATCH 2/3] Index: Add OpenIndex

This lets you persist an index at an arbitrary location.
---
 index.go      | 18 ++++++++++++++++++
 index_test.go | 24 ++++++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/index.go b/index.go
index 009aeb6..2082ebd 100644
--- a/index.go
+++ b/index.go
@@ -96,6 +96,24 @@ func NewIndex() (*Index, error) {
 	return &Index{ptr: ptr}, nil
 }
 
+// OpenIndex creates a new index at the given path. If the file does
+// not exist it will be created when Write() is called.
+func OpenIndex(path string) (*Index, error) {
+	var ptr *C.git_index
+
+	var cpath = C.CString(path)
+	defer C.free(unsafe.Pointer(cpath))
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	if err := C.git_index_open(&ptr, cpath); err < 0 {
+		return nil, MakeGitError(err)
+	}
+
+	return &Index{ptr: ptr}, nil
+}
+
 // Add adds or replaces the given entry to the index, making a copy of
 // the data
 func (v *Index) Add(entry *IndexEntry) error {
diff --git a/index_test.go b/index_test.go
index a1f0c9c..9b54945 100644
--- a/index_test.go
+++ b/index_test.go
@@ -2,6 +2,7 @@ package git
 
 import (
 	"io/ioutil"
+	"os"
 	"runtime"
 	"testing"
 )
@@ -148,6 +149,29 @@ func TestIndexAddAllCallback(t *testing.T) {
 	}
 }
 
+func TestIndexOpen(t *testing.T) {
+	repo := createTestRepo(t)
+	defer cleanupTestRepo(t, repo)
+
+	path := repo.Workdir() + "/heyindex"
+
+	_, err := os.Stat(path)
+	if !os.IsNotExist(err) {
+		t.Fatal("new index file already exists")
+	}
+
+	idx, err := OpenIndex(path)
+	checkFatal(t, err)
+
+	err = idx.Write()
+	checkFatal(t, err)
+
+	_, err = os.Stat(path)
+	if os.IsNotExist(err) {
+		t.Fatal("new index file did not get written")
+	}
+}
+
 func checkFatal(t *testing.T, err error) {
 	if err == nil {
 		return

From 72c19f73c9170720780839cd1561486e075d35a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 19 May 2015 15:05:00 +0200
Subject: [PATCH 3/3] Index: Add Path() accessor

---
 index.go      | 6 ++++++
 index_test.go | 8 ++++++++
 2 files changed, 14 insertions(+)

diff --git a/index.go b/index.go
index 2082ebd..1a899f1 100644
--- a/index.go
+++ b/index.go
@@ -114,6 +114,12 @@ func OpenIndex(path string) (*Index, error) {
 	return &Index{ptr: ptr}, nil
 }
 
+// Path returns the index' path on disk or an empty string if it
+// exists only in memory.
+func (v *Index) Path() string {
+	return C.GoString(C.git_index_path(v.ptr))
+}
+
 // Add adds or replaces the given entry to the index, making a copy of
 // the data
 func (v *Index) Add(entry *IndexEntry) error {
diff --git a/index_test.go b/index_test.go
index 9b54945..9283b83 100644
--- a/index_test.go
+++ b/index_test.go
@@ -83,6 +83,10 @@ func TestIndexAddAndWriteTreeTo(t *testing.T) {
 	idx, err := NewIndex()
 	checkFatal(t, err)
 
+	if idx.Path() != "" {
+		t.Fatal("in-memory repo has a path")
+	}
+
 	entry := IndexEntry{
 		Path: "README",
 		Id:   blobID,
@@ -163,6 +167,10 @@ func TestIndexOpen(t *testing.T) {
 	idx, err := OpenIndex(path)
 	checkFatal(t, err)
 
+	if path != idx.Path() {
+		t.Fatalf("mismatched index paths, expected %v, got %v", path, idx.Path())
+	}
+
 	err = idx.Write()
 	checkFatal(t, err)