Update the bidindings

Make repository parametrized

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;
-
-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);
-}
+geef_atoms atoms;
 
 static int load(ErlNifEnv *env, void **priv, ERL_NIF_TERM load_info)
 {
-    geef_repository_type = enif_open_resource_type(env, NULL,
-        "repository_type", geef_repository_free, ERL_NIF_RT_CREATE, NULL);
+	git_threads_init();
 
-    if (geef_repository_type == NULL)
-	return -1;
+	geef_repository_type = enif_open_resource_type(env, NULL,
+						     "repository_type", geef_repository_free, ERL_NIF_RT_CREATE, NULL);
 
-    geef_odb_type = enif_open_resource_type(env, NULL,
-        "odb_type", geef_odb_free, ERL_NIF_RT_CREATE, NULL);
+	if (geef_repository_type == NULL)
+		return -1;
 
-    if (geef_odb_type == NULL)
-	return -1;
+	geef_odb_type = enif_open_resource_type(env, NULL,
+					      "odb_type", geef_odb_free, ERL_NIF_RT_CREATE, NULL);
 
-    geef_atoms.ok = enif_make_atom(env, "ok");
-    geef_atoms.error = enif_make_atom(env, "error");
-    geef_atoms.true = enif_make_atom(env, "true");
-    geef_atoms.false = enif_make_atom(env, "false");
-    geef_atoms.repository = enif_make_atom(env, "repository");
+	if (geef_odb_type == NULL)
+		return -1;
 
-    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();
-    if (error) {
-	return enif_make_tuple2(env, geef_atoms.error,
-				enif_make_string(env, error->message, ERL_NIF_LATIN1));
-    }
+	error = giterr_last();
+	if (error) {
+		return enif_make_tuple2(env, atoms.error,
+					enif_make_string(env, error->message, ERL_NIF_LATIN1));
+	}
 
-    return enif_make_tuple2(env, geef_atoms.error,
-			    enif_make_string(env, "No message specified", ERL_NIF_LATIN1));
+	return enif_make_tuple2(env, atoms.error,
+				enif_make_string(env, "No message specified", ERL_NIF_LATIN1));
 }
 
 static ErlNifFunc geef_funcs[] =
 {
-  {"hex_to_raw", 1, geef_hex_to_raw},
-  {"repository_open", 1, geef_repository_open},
-  {"repository_get_path", 1, geef_repository_path},
-  {"repository_get_odb", 1, geef_repository_odb},
-  {"odb_object_exists", 2, geef_odb_exists},
+	{"repository_init", 2, geef_repository_init},
+	{"repository_open", 1, geef_repository_open},
+	{"repository_is_bare", 1, geef_repository_is_bare},
+	{"repository_get_path", 1, geef_repository_path},
+	{"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;
-    git_repository_free(grepo->repo);
+	geef_repository *grepo = (geef_repository *) cd;
+	git_repository_free(grepo->repo);
 }
 
 void geef_odb_free(ErlNifEnv *env, void *cd)
 {
-    geef_odb *odb = (geef_odb *) cd;
-    git_odb_free(odb->odb);
+	geef_odb *odb = (geef_odb *) cd;
+	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];
-  git_repository *repo;
-  geef_repository *res_repo;
-  ERL_NIF_TERM term_repo;
+	char *path;
+	int error;
+	git_repository *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)
-      return enif_make_badarg(env);
+	if (!enif_inspect_binary(env, argv[0], &bin))
+		return enif_make_badarg(env);
 
-  if (git_repository_open(&repo, path) < 0)
-      return geef_error(env);
+	path = malloc(bin.size + 1);
+	if (!path)
+		return atoms.error;
 
-  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);
+	memcpy(path, bin.data, bin.size);
+	path[bin.size] = '\0';
 
-  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))
-        return enif_make_badarg(env);
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		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_odb *odb;
-    ERL_NIF_TERM term_odb;
+	geef_repository *repo;
+	geef_odb *odb;
+	ERL_NIF_TERM term_odb;
 
-    if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
-        return enif_make_badarg(env);
+	if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
+		return enif_make_badarg(env);
 
-    odb = enif_alloc_resource(geef_odb_type, sizeof(geef_odb));
-    if (git_repository_odb(&odb->odb, repo->repo) < 0)
-	return geef_error(env);
+	odb = enif_alloc_resource(geef_odb_type, sizeof(geef_odb));
+	if (git_repository_odb(&odb->odb, repo->repo) < 0)
+		return geef_error(env);
 
-    term_odb = enif_make_resource(env, odb);
-    enif_release_resource(odb);
+	term_odb = enif_make_resource(env, 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};
-    geef_odb *odb;
-    git_oid oid;
-    int exists;
+	char sha[MAXBUFLEN] = {0};
+	geef_odb *odb;
+	git_oid oid;
+	int exists;
 
-    if (!enif_get_resource(env, argv[0], geef_odb_type, (void **) &odb))
-        return enif_make_badarg(env);
+	if (!enif_get_resource(env, argv[0], geef_odb_type, (void **) &odb))
+		return enif_make_badarg(env);
 
-    if (enif_get_string(env, argv[1], sha, sizeof(sha), ERL_NIF_LATIN1) < 1)
-	return enif_make_badarg(env);
+	if (enif_get_string(env, argv[1], sha, sizeof(sha), ERL_NIF_LATIN1) < 1)
+		return enif_make_badarg(env);
 
-    git_oid_fromstr(&oid, sha);
-    exists = git_odb_exists(odb->odb, &oid);
+	git_oid_fromstr(&oid, sha);
+	exists = git_odb_exists(odb->odb, &oid);
 
-    if (exists)
-	return geef_atoms.true;
+	if (exists)
+		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[]);