Update the bidindings

Make repository parametrized

README.md

@@ -21,22 +21,10 @@ in it.
     $ cd geef
     $ make
 
-Now you should have a .beam file you can load.  I've also included an example
-escript to test some of the functions (currently just hex_to_raw and object_exists):
-
-    $ ./geef h2r de08fe4884650f067bd5703b8a59a8b3b3c99aaa
-    Raw: <<222,8,254,72,132,101,15,6,123,213,112,59,138,89,168,179,179,201,154,170>>
-
-    $ ./geef exists . 89c86150c8b164f441a73f4991b2c339fd4aae7c
-    Exists: true
-
-    $ ./geef exists . 87fcfb277899097823911006f438658ce86b3697
-    Exists: false
-
 The API looks basically like this:
 
-    Raw = geef:hex_to_raw(HexSha).
+    Repo = geef:repository(<<".">>).
-    Repo = geef:repository(".").
+    Workdir = Repo:workdir().
     Odb = geef:repository_odb(Repo).
     Exists = geef:odb_exists(Odb, HexSha).
 

c_src/geef.c

@@ -1,5 +1,6 @@
 #include "erl_nif.h"
 #include "repository.h"
+#include "reference.h"
 #include "geef.h"
 #include <stdio.h>
 #include <string.h>
@@ -7,73 +8,75 @@
 
 ErlNifResourceType *geef_repository_type;
 ErlNifResourceType *geef_odb_type;
+ErlNifResourceType *geef_ref_type;
 
-geef_atoms_t geef_atoms;
+geef_atoms atoms;
-
-static ERL_NIF_TERM
-geef_hex_to_raw(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
-{
-  char sha[MAXBUFLEN];
-  (void)memset(&sha, '\0', sizeof(sha));
-
-  if (enif_get_string(env, argv[0], sha, sizeof(sha), ERL_NIF_LATIN1) < 1)
-      return enif_make_badarg(env);
-
-  git_oid oid;
-  git_oid_fromstr(&oid, sha);
-
-  ErlNifBinary ibin;
-  enif_alloc_binary(20, &ibin);
-  memcpy(ibin.data, (&oid)->id, 20);
-
-  return enif_make_binary(env, &ibin);
-}
 
 static int load(ErlNifEnv *env, void **priv, ERL_NIF_TERM load_info)
 {
-    geef_repository_type = enif_open_resource_type(env, NULL,
+	git_threads_init();
-        "repository_type", geef_repository_free, ERL_NIF_RT_CREATE, NULL);
 
-    if (geef_repository_type == NULL)
+	geef_repository_type = enif_open_resource_type(env, NULL,
-	return -1;
+						     "repository_type", geef_repository_free, ERL_NIF_RT_CREATE, NULL);
 
-    geef_odb_type = enif_open_resource_type(env, NULL,
+	if (geef_repository_type == NULL)
-        "odb_type", geef_odb_free, ERL_NIF_RT_CREATE, NULL);
+		return -1;
 
-    if (geef_odb_type == NULL)
+	geef_odb_type = enif_open_resource_type(env, NULL,
-	return -1;
+					      "odb_type", geef_odb_free, ERL_NIF_RT_CREATE, NULL);
 
-    geef_atoms.ok = enif_make_atom(env, "ok");
+	if (geef_odb_type == NULL)
-    geef_atoms.error = enif_make_atom(env, "error");
+		return -1;
-    geef_atoms.true = enif_make_atom(env, "true");
-    geef_atoms.false = enif_make_atom(env, "false");
-    geef_atoms.repository = enif_make_atom(env, "repository");
 
-    return 0;
+	geef_ref_type = enif_open_resource_type(env, NULL,
+					      "ref_type", geef_ref_free, ERL_NIF_RT_CREATE, NULL);
+
+	if (geef_ref_type == NULL)
+		return -1;
+
+	atoms.ok = enif_make_atom(env, "ok");
+	atoms.error = enif_make_atom(env, "error");
+	atoms.true = enif_make_atom(env, "true");
+	atoms.false = enif_make_atom(env, "false");
+	atoms.repository = enif_make_atom(env, "repository");
+
+	return 0;
+}
+
+static void unload(ErlNifEnv* env, void* priv_data)
+{
+	git_threads_shutdown();
 }
 
 ERL_NIF_TERM
 geef_error(ErlNifEnv *env)
 {
-    const git_error *error;
+	const git_error *error;
 
-    error = giterr_last();
+	error = giterr_last();
-    if (error) {
+	if (error) {
-	return enif_make_tuple2(env, geef_atoms.error,
+		return enif_make_tuple2(env, atoms.error,
-				enif_make_string(env, error->message, ERL_NIF_LATIN1));
+					enif_make_string(env, error->message, ERL_NIF_LATIN1));
-    }
+	}
 
-    return enif_make_tuple2(env, geef_atoms.error,
+	return enif_make_tuple2(env, atoms.error,
-			    enif_make_string(env, "No message specified", ERL_NIF_LATIN1));
+				enif_make_string(env, "No message specified", ERL_NIF_LATIN1));
 }
 
 static ErlNifFunc geef_funcs[] =
 {
-  {"hex_to_raw", 1, geef_hex_to_raw},
+	{"repository_init", 2, geef_repository_init},
-  {"repository_open", 1, geef_repository_open},
+	{"repository_open", 1, geef_repository_open},
-  {"repository_get_path", 1, geef_repository_path},
+	{"repository_is_bare", 1, geef_repository_is_bare},
-  {"repository_get_odb", 1, geef_repository_odb},
+	{"repository_get_path", 1, geef_repository_path},
-  {"odb_object_exists", 2, geef_odb_exists},
+	{"repository_get_workdir", 1, geef_repository_workdir},
+	{"repository_get_odb", 1, geef_repository_odb},
+	{"odb_object_exists", 2, geef_odb_exists},
+	{"reference_list", 1, geef_reference_list},
+	{"reference_to_id", 2, geef_reference_to_id},
+	{"reference_glob", 2, geef_reference_glob},
+	{"reference_lookup", 2, geef_reference_lookup},
+	{"reference_resolve", 1, geef_reference_resolve},
 };
 
-ERL_NIF_INIT(geef, geef_funcs, load, NULL, NULL, NULL)
+ERL_NIF_INIT(geef, geef_funcs, load, NULL, NULL, unload)

c_src/geef.h

@@ -11,8 +11,8 @@ typedef struct {
     ERL_NIF_TERM true;
     ERL_NIF_TERM false;
     ERL_NIF_TERM repository;
-} geef_atoms_t;
+} geef_atoms;
 
-extern geef_atoms_t geef_atoms;
+extern geef_atoms atoms;
 
 #endif

c_src/reference.c

@@ -0,0 +1,194 @@
+#include "geef.h"
+#include "repository.h"
+#include "reference.h"
+#include <string.h>
+#include <git2.h>
+
+ERL_NIF_TERM
+geef_reference_list(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	unsigned int flags = GIT_REF_LISTALL;
+	size_t i;
+	git_strarray array;
+	geef_repository *repo;
+	ERL_NIF_TERM list;
+
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
+
+	if (git_reference_list(&array, repo->repo, flags) < 0)
+		return geef_error(env);
+
+	list = enif_make_list(env, 0);
+	for (i = 0; i < array.count; i++) {
+		ErlNifBinary bin;
+		size_t len = strlen(array.strings[i]);
+
+		if (!enif_alloc_binary(len, &bin))
+			goto on_error;
+
+		memcpy(bin.data, array.strings[i], len);
+		list = enif_make_list_cell(env, enif_make_binary(env, &bin), list);
+	}
+
+	git_strarray_free(&array);
+
+	return list;
+
+on_error:
+	git_strarray_free(&array);
+	return atoms.error;
+}
+
+ERL_NIF_TERM
+geef_reference_lookup(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	geef_repository *repo;
+	geef_ref *res_ref;
+	git_reference *ref;
+	ErlNifBinary bin;
+	ERL_NIF_TERM list, term_ref;
+	char *name;
+	int error;
+
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
+
+	if (!enif_inspect_binary(env, argv[1], &bin))
+		return enif_make_badarg(env);
+
+	name = malloc(bin.size + 1);
+	if (!name)
+		return atoms.error;
+
+	memcpy(name, bin.data, bin.size);
+	name[bin.size] = '\0';
+
+	error = git_reference_lookup(&ref, repo->repo, name);
+	free(name);
+
+	if (error < 0)
+		return geef_error(env);
+
+	res_ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
+	res_ref->ref = ref;
+	term_ref = enif_make_resource(env, res_ref);
+	enif_release_resource(res_ref);
+
+	return enif_make_tuple2(env, atoms.ok, term_ref);
+}
+
+ERL_NIF_TERM
+geef_reference_resolve(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	geef_ref *in_ref, *res_ref;
+	ERL_NIF_TERM term_ref;
+	git_reference *ref;
+
+	if (!enif_get_resource(env, argv[0], geef_ref_type, (void **) &in_ref))
+		return enif_make_badarg(env);
+
+	if (git_reference_resolve(&ref, in_ref->ref) < 0)
+		return geef_error(env);
+
+	res_ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
+	res_ref->ref = ref;
+	term_ref = enif_make_resource(env, res_ref);
+	enif_release_resource(res_ref);
+
+	return enif_make_tuple2(env, atoms.ok, term_ref);
+}
+
+void geef_ref_free(ErlNifEnv *env, void *cd)
+{
+	geef_ref *ref = (geef_ref *) cd;
+	git_reference_free(ref->ref);
+}
+
+struct list_data {
+	ErlNifEnv *env;
+	ERL_NIF_TERM list;
+};
+
+static int append_to_list(const char *name, void *payload)
+{
+	struct list_data *data = (struct list_data *) payload;
+	ErlNifBinary bin;
+	ERL_NIF_TERM list;
+	size_t len = strlen(name);
+
+	if (!enif_alloc_binary(len, &bin))
+		return -1;
+
+	memcpy(bin.data, name, len);
+	data->list = enif_make_list_cell(data->env, enif_make_binary(data->env, &bin), data->list);
+	return 0;
+}
+
+ERL_NIF_TERM
+geef_reference_glob(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	char *glob;
+	int error;
+	git_strarray array;
+	geef_repository *repo;
+	ErlNifBinary bin;
+	struct list_data data;
+
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
+
+	if (!enif_inspect_binary(env, argv[1], &bin))
+		return enif_make_badarg(env);
+
+	glob = malloc(bin.size + 1);
+	if (!glob)
+		return atoms.error;
+
+	memcpy(glob, bin.data, bin.size);
+	glob[bin.size] = '\0';
+
+	data.env = env;
+	data.list = enif_make_list(env, 0);
+
+	error = git_reference_foreach_glob(repo->repo, glob, GIT_REF_LISTALL, append_to_list, &data);
+	free(glob);
+
+	if (error < 0)
+		return geef_error(env);
+
+	return data.list;
+}
+
+ERL_NIF_TERM
+geef_reference_to_id(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	geef_repository *repo;
+	ErlNifBinary bin;
+	char *name;
+	git_oid id;
+
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
+
+	if (!enif_inspect_binary(env, argv[1], &bin))
+		return enif_make_badarg(env);
+
+	name = malloc(bin.size + 1);
+	if (!name)
+		return atoms.error;
+
+	memcpy(name, bin.data, bin.size);
+	name[bin.size] = '\0';
+
+	if (git_reference_name_to_id(&id, repo->repo, name) < 0) {
+		enif_release_binary(&bin);
+		return geef_error(env);
+	}
+
+	if (!enif_alloc_binary(GIT_OID_RAWSZ, &bin))
+		return atoms.error;
+
+	memcpy(bin.data, &id, GIT_OID_RAWSZ);
+	return enif_make_binary(env, &bin);
+}

c_src/reference.h

@@ -0,0 +1,21 @@
+#ifndef GEEF_REFERENCE_H
+#define GEEF_REFERENCE_H
+
+#include "erl_nif.h"
+#include <git2.h>
+
+extern ErlNifResourceType *geef_ref_type;
+
+typedef struct {
+    git_reference *ref;
+} geef_ref;
+
+ERL_NIF_TERM geef_reference_list(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM geef_reference_to_id(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM geef_reference_glob(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM geef_reference_lookup(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM geef_reference_resolve(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+void geef_ref_free(ErlNifEnv *env, void *cd);
+
+#endif

c_src/repository.c

@@ -1,91 +1,193 @@
 #include "repository.h"
 #include "geef.h"
+#include <string.h>
 #include <git2.h>
 
 void geef_repository_free(ErlNifEnv *env, void *cd)
 {
-    geef_repository *grepo = (geef_repository *) cd;
+	geef_repository *grepo = (geef_repository *) cd;
-    git_repository_free(grepo->repo);
+	git_repository_free(grepo->repo);
 }
 
 void geef_odb_free(ErlNifEnv *env, void *cd)
 {
-    geef_odb *odb = (geef_odb *) cd;
+	geef_odb *odb = (geef_odb *) cd;
-    git_odb_free(odb->odb);
+	git_odb_free(odb->odb);
+}
+
+ERL_NIF_TERM
+geef_repository_init(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	char *path;
+	int error, bare;
+	git_repository *repo;
+	geef_repository *res_repo;
+	ErlNifBinary bin;
+	ERL_NIF_TERM term_repo;
+
+	if (!enif_inspect_binary(env, argv[0], &bin))
+		return enif_make_badarg(env);
+
+	path = malloc(bin.size + 1);
+	if (!path)
+		return atoms.error;
+
+	memcpy(path, bin.data, bin.size);
+	path[bin.size] = '\0';
+
+	bare = !enif_compare(argv[1], atoms.true);
+
+	error = git_repository_init(&repo, path, bare);
+	free(path);
+
+	if (error < 0)
+		return geef_error(env);
+
+	res_repo = enif_alloc_resource(geef_repository_type, sizeof(geef_repository));
+	res_repo->repo = repo;
+	term_repo = enif_make_resource(env, res_repo);
+	enif_release_resource(res_repo);
+
+	return enif_make_tuple2(env, atoms.repository, term_repo);
 }
 
 ERL_NIF_TERM
 geef_repository_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 {
-  char path[MAXBUFLEN];
+	char *path;
-  git_repository *repo;
+	int error;
-  geef_repository *res_repo;
+	git_repository *repo;
-  ERL_NIF_TERM term_repo;
+	geef_repository *res_repo;
+	ErlNifBinary bin;
+	ERL_NIF_TERM term_repo;
 
-  if (enif_get_string(env, argv[0], path, sizeof(path), ERL_NIF_LATIN1) < 1)
+	if (!enif_inspect_binary(env, argv[0], &bin))
-      return enif_make_badarg(env);
+		return enif_make_badarg(env);
 
-  if (git_repository_open(&repo, path) < 0)
+	path = malloc(bin.size + 1);
-      return geef_error(env);
+	if (!path)
+		return atoms.error;
 
-  res_repo = enif_alloc_resource(geef_repository_type, sizeof(geef_repository));
+	memcpy(path, bin.data, bin.size);
-  res_repo->repo = repo;
+	path[bin.size] = '\0';
-  term_repo = enif_make_resource(env, res_repo);
-  enif_release_resource(res_repo);
 
-  return enif_make_tuple2(env, geef_atoms.ok, term_repo);
+	error = git_repository_open(&repo, path);
+	free(path);
+
+	if (error < 0)
+		return geef_error(env);
+
+	res_repo = enif_alloc_resource(geef_repository_type, sizeof(geef_repository));
+	res_repo->repo = repo;
+	term_repo = enif_make_resource(env, res_repo);
+	enif_release_resource(res_repo);
+
+	return enif_make_tuple2(env, atoms.ok, term_repo);
 }
 
 ERL_NIF_TERM
 geef_repository_path(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 {
-    geef_repository *repo;
+	geef_repository *repo;
+	const char *path;
+	size_t len;
+	ErlNifBinary bin;
 
-    if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
-        return enif_make_badarg(env);
+		return enif_make_badarg(env);
+
+	path = git_repository_path(repo->repo);
+	len = strlen(path);
+
+	if (!enif_alloc_binary(len, &bin))
+		return atoms.error;
+
+	memcpy(bin.data, path, len);
+	return enif_make_binary(env, &bin);
+}
+
+ERL_NIF_TERM
+geef_repository_workdir(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	geef_repository *repo;
+	const char *path;
+	size_t len;
+	ErlNifBinary bin;
+
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
+
+	if (git_repository_is_bare(repo->repo))
+		return atoms.error;
+
+	path = git_repository_workdir(repo->repo);
+	len = strlen(path);
+
+	if (!enif_alloc_binary(len, &bin))
+		return atoms.error;
+
+	memcpy(bin.data, path, len);
+	return enif_make_binary(env, &bin);
+
+}
+
+ERL_NIF_TERM
+geef_repository_is_bare(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
+{
+	geef_repository *repo;
+	int bare;
+
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
+
+	bare = git_repository_is_bare(repo->repo);
+
+	if (bare)
+		return atoms.true;
+
+	return atoms.false;
 
-    return enif_make_string(env, git_repository_path(repo->repo), ERL_NIF_LATIN1);
 }
 
 ERL_NIF_TERM
 geef_repository_odb(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 {
-    geef_repository *repo;
+	geef_repository *repo;
-    geef_odb *odb;
+	geef_odb *odb;
-    ERL_NIF_TERM term_odb;
+	ERL_NIF_TERM term_odb;
 
-    if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
-        return enif_make_badarg(env);
+		return enif_make_badarg(env);
 
-    odb = enif_alloc_resource(geef_odb_type, sizeof(geef_odb));
+	odb = enif_alloc_resource(geef_odb_type, sizeof(geef_odb));
-    if (git_repository_odb(&odb->odb, repo->repo) < 0)
+	if (git_repository_odb(&odb->odb, repo->repo) < 0)
-	return geef_error(env);
+		return geef_error(env);
 
-    term_odb = enif_make_resource(env, odb);
+	term_odb = enif_make_resource(env, odb);
-    enif_release_resource(odb);
+	enif_release_resource(odb);
 
-    return enif_make_tuple2(env, geef_atoms.ok, term_odb);
+	return enif_make_tuple2(env, atoms.ok, term_odb);
 }
 
 ERL_NIF_TERM
 geef_odb_exists(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 {
-    char sha[MAXBUFLEN] = {0};
+	char sha[MAXBUFLEN] = {0};
-    geef_odb *odb;
+	geef_odb *odb;
-    git_oid oid;
+	git_oid oid;
-    int exists;
+	int exists;
 
-    if (!enif_get_resource(env, argv[0], geef_odb_type, (void **) &odb))
+	if (!enif_get_resource(env, argv[0], geef_odb_type, (void **) &odb))
-        return enif_make_badarg(env);
+		return enif_make_badarg(env);
 
-    if (enif_get_string(env, argv[1], sha, sizeof(sha), ERL_NIF_LATIN1) < 1)
+	if (enif_get_string(env, argv[1], sha, sizeof(sha), ERL_NIF_LATIN1) < 1)
-	return enif_make_badarg(env);
+		return enif_make_badarg(env);
 
-    git_oid_fromstr(&oid, sha);
+	git_oid_fromstr(&oid, sha);
-    exists = git_odb_exists(odb->odb, &oid);
+	exists = git_odb_exists(odb->odb, &oid);
 
-    if (exists)
+	if (exists)
-	return geef_atoms.true;
+		return atoms.true;
 
-    return geef_atoms.false;
+	return atoms.false;
 }

c_src/repository.h

@@ -6,8 +6,11 @@
 
 #define MAXBUFLEN       1024
 
+ERL_NIF_TERM geef_repository_init(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 ERL_NIF_TERM geef_repository_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 ERL_NIF_TERM geef_repository_path(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM geef_repository_workdir(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM geef_repository_is_bare(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 ERL_NIF_TERM geef_repository_odb(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 ERL_NIF_TERM geef_odb_exists(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 

ebin/geef.app

@@ -3,7 +3,7 @@
   {description, ""},
   {vsn, "0.0.1"},
   {modules, [
-             geef
+             geef, repository
             ]},
   {registered, []},
   {applications, [

geef

@@ -1,31 +0,0 @@
-#!/usr/bin/env escript
-%% -*- erlang -*-
-%%! debug verbose -noshell -pa ebin
-
-main(["exists"|_Args]) ->
-    [Path|_Rest] = _Args,
-    [Object|_] = _Rest,
-    Repo = geef:repository(Path),
-    Odb = geef:repository_odb(Repo),
-    Exists = geef:odb_exists(Odb, Object),
-    io:format("Exists: ~w~n", [Exists]);
-main([Command|_Args]) ->
-    case Command of
-      "h2r" ->
-        [Object|_Rest] = _Args,
-        Raw = geef:hex_to_raw(Object),
-        io:format("Raw: ~w~n", [Raw]);
-      "repo-path" ->
-	[Path|_Rest] = _Args,
-	Repo = geef:repository(Path),
-	io:format("Repository path: ~s~n", [geef:repository_path(Repo)]);
-      _Else ->
-        usage()
-    end;
-main(_) ->
-    usage().
-        
-usage() ->
-    io:format("usage: ./geef h2r HEX_SHA\n"),
-    halt(1).
-        

src/geef.erl

@@ -1,5 +1,7 @@
 -module(geef).
--export([hex_to_raw/1, repository/1, repository_path/1, repository_odb/1, odb_exists/2]).
+-export([hex_to_raw/1, repository/1, repository_get_path/1, repository_odb/1,
+	 odb_exists/2, repository_init/2, repository_is_bare/1, repository_get_workdir/1, reference_list/1,
+	 reference_to_id/2, reference_glob/2, reference_lookup/2, reference_resolve/1]).
 -on_load(load_enif/0).
 
 hex_to_raw(_Val) ->
@@ -8,22 +10,46 @@ hex_to_raw(_Val) ->
 repository_open(_Val) ->
     nif_error(?LINE).
 
+repository_is_bare(_Handle) ->
+    nif_error(?LINE).
+
 repository_get_path(_Val) ->
     nif_error(?LINE).
 
+repository_get_workdir(_Handle) ->
+    nif_error(?LINE).
+
 repository_get_odb(_Val) ->
     nif_error(?LINE).
 
-repository_path({repository, Handle}) ->
+repository_init(_Path, _Bare) ->
-    repository_get_path(Handle).
+    nif_error(?LINE).
+
+reference_list(_Repo) ->
+    nif_error(?LINE).
+
+reference_to_id(_Repo, _Refname) ->
+    nif_error(?LINE).
+
+reference_glob(_Repo, _Glob) ->
+    nif_error(?LINE).
+
+reference_lookup(_Repo, _Refname) ->
+    nif_error(?LINE).
+
+reference_resolve(_Handle) ->
+    nif_error(?LINE).
 
 repository(Path) ->
-    {ok, Repository} = repository_open(Path),
+    case repository_open(Path) of
-    {repository, Repository}.
+	{ok, Handle}  ->
+	    repository:new(Handle);
+	other -> other
+    end.
 
 repository_odb({repository, Handle}) ->
     {ok, Odb} = repository_get_odb(Handle),
-    {odb, Odb}.
+    {ok, {odb, Odb}}.
 
 odb_object_exists(_Val, _Val) ->
     nif_error(?LINE).

src/repository.erl

@@ -0,0 +1,8 @@
+-module(repository, [Handle]).
+-export([path/0, workdir/0]).
+
+path() ->
+    geef:repository_get_path(Handle).
+
+workdir() ->
+    geef:repository_get_workdir(Handle).