Add a settings package

This lets us modify the libgit2-wide options/settings.

.travis.yml

@@ -5,8 +5,7 @@ go:
   - 1.1
   - tip
 
-env:
-  - PKG_CONFIG_PATH=libgit2/install/lib/pkgconfig LD_LIBRARY_PATH=libgit2/install/lib
-
 install:
   - script/build-libgit2.sh
+  - export PKG_CONFIG_PATH=$PWD/libgit2/install/lib/pkgconfig
+  - export LD_LIBRARY_PATH=$PWD/libgit2/install/lib

git.go

@@ -149,6 +149,10 @@ func MakeGitError(errorCode C.int) error {
 	return &GitError{C.GoString(err.message), int(err.klass), int(errorCode)}
 }
 
+func MakeGitError2(err int) error {
+	return MakeGitError(C.int(err))
+}
+
 func cbool(b bool) C.int {
 	if b {
 		return C.int(1)

script/build-libgit2.sh

@@ -11,7 +11,3 @@ cmake -DTHREADSAFE=ON \
       .
 
 make install
-
-# Let the Go build system know where to find libgit2
-export LD_LIBRARY_PATH="$TMPDIR/libgit2/install/lib"
-export PKG_CONFIG_PATH="$TMPDIR/libgit2/install/lib/pkgconfig"

settings/settings.go

@@ -0,0 +1,109 @@
+package settings
+
+/*
+#cgo pkg-config: libgit2
+#include <git2.h>
+
+int _go_git_opts_get_search_path(int level, git_buf *buf)
+{
+    return git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, level, buf);
+}
+
+int _go_git_opts_set_search_path(int level, const char *path)
+{
+    return git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, level, path);
+}
+
+int _go_git_opts_set_size_t(int opt, size_t val)
+{
+    return git_libgit2_opts(opt, val);
+}
+
+int _go_git_opts_get_size_t(int opt, size_t *val)
+{
+    return git_libgit2_opts(opt, val);
+}
+
+*/
+import "C"
+import (
+	"runtime"
+	"unsafe"
+	"github.com/libgit2/git2go"
+)
+
+func MakeGitError(err C.int) error {
+	return git.MakeGitError2(int(err))
+}
+
+func SearchPath(level git.ConfigLevel) (string, error) {
+	var buf C.git_buf
+	defer C.git_buf_free(&buf)
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	err := C._go_git_opts_get_search_path(C.int(level), &buf)
+	if err < 0 {
+		return "", MakeGitError(err)
+	}
+
+	return C.GoString(buf.ptr), nil
+}
+
+func SetSearchPath(level git.ConfigLevel, path string) error {
+	cpath := C.CString(path)
+	defer C.free(unsafe.Pointer(cpath))
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	err := C._go_git_opts_set_search_path(C.int(level), cpath)
+	if err < 0 {
+		return MakeGitError(err)
+	}
+
+	return nil
+}
+
+func getSizet(opt C.int) (int, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var val C.size_t
+	err := C._go_git_opts_get_size_t(opt, &val);
+	if err < 0 {
+		return 0, MakeGitError(err)
+	}
+
+	return int(val), nil
+}
+
+func setSizet(opt C.int, val int) error {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	cval := C.size_t(val)
+	err := C._go_git_opts_set_size_t(opt, cval);
+	if err < 0 {
+		return MakeGitError(err)
+	}
+
+	return nil
+}
+
+func MwindowSize() (int, error) {
+	return getSizet(C.GIT_OPT_GET_MWINDOW_SIZE)
+}
+
+func SetMwindowSize(size int) error {
+	return setSizet(C.GIT_OPT_SET_MWINDOW_SIZE, size)
+}
+
+func MwindowMappedLimit() (int, error) {
+	return getSizet(C.GIT_OPT_GET_MWINDOW_MAPPED_LIMIT)
+}
+
+func SetMwindowMappedLimit(size int) error {
+	return setSizet(C.GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, size)
+}

settings/settings_test.go

@@ -0,0 +1,66 @@
+package settings
+
+import (
+	"testing"
+	"runtime"
+	"github.com/libgit2/git2go"
+)
+
+type pathPair struct {
+	Level git.ConfigLevel
+	Path  string
+}
+
+func TestSearchPath(t *testing.T) {
+	paths := []pathPair{
+		pathPair{git.ConfigLevelSystem, "/tmp/system"},
+		pathPair{git.ConfigLevelGlobal, "/tmp/global"},
+		pathPair{git.ConfigLevelXDG, "/tmp/xdg"},
+	}
+
+	for _, pair := range paths {
+		err := SetSearchPath(pair.Level, pair.Path)
+		checkFatal(t, err)
+
+		actual, err := SearchPath(pair.Level)
+		checkFatal(t, err)
+
+		if pair.Path != actual {
+			t.Fatal("Search paths don't match")
+		}
+	}
+}
+
+func TestMmapSizes(t *testing.T) {
+	size := 42 * 1024
+
+	err := SetMwindowSize(size)
+	checkFatal(t, err)
+
+	actual, err := MwindowSize()
+	if size != actual {
+		t.Fatal("Sizes don't match")
+	}
+
+	err = SetMwindowMappedLimit(size)
+	checkFatal(t, err)
+
+	actual, err = MwindowMappedLimit()
+	if size != actual {
+		t.Fatal("Sizes don't match")
+	}
+}
+
+func checkFatal(t *testing.T, err error) {
+	if err == nil {
+		return
+	}
+
+	// The failure happens at wherever we were called, not here
+	_, file, line, ok := runtime.Caller(1)
+	if !ok {
+		t.Fatal()
+	}
+
+	t.Fatalf("Fail at %v:%v; %v", file, line, err)
+}