From 3f4d51c0e1730221f9c36e7d33462de8ddc4829c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Fri, 3 May 2013 14:05:00 +0200 Subject: [PATCH] Simple version of index_add --- c_src/geef.c | 1 + c_src/index.c | 48 +++++++++++++++++++++++++++++++++++++++++++- c_src/index.h | 2 ++ src/geef_index.erl | 12 +++++++++-- src/geef_nif.erl | 27 ++++--------------------- src/geef_records.hrl | 2 ++ src/geef_repo.erl | 5 ++--- test/repo_test.erl | 15 +++++++++++++- 8 files changed, 82 insertions(+), 30 deletions(-) diff --git a/c_src/geef.c b/c_src/geef.c index b1419a4..6488c81 100644 --- a/c_src/geef.c +++ b/c_src/geef.c @@ -171,6 +171,7 @@ static ErlNifFunc geef_funcs[] = {"index_write", 1, geef_index_write}, {"index_write_tree", 1, geef_index_write_tree}, {"index_write_tree", 2, geef_index_write_tree}, + {"index_add", 2, geef_index_add}, {"index_clear", 1, geef_index_clear}, {"index_read_tree", 2, geef_index_read_tree}, }; diff --git a/c_src/index.c b/c_src/index.c index 4c1d10f..e28c037 100644 --- a/c_src/index.c +++ b/c_src/index.c @@ -57,7 +57,7 @@ geef_index_write_tree(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) return enif_make_badarg(env); if (argc == 2) { - if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo)) + if (!enif_get_resource(env, argv[1], geef_repository_type, (void **) &repo)) return enif_make_badarg(env); error = git_index_write_tree_to(&id, index->index, repo->repo); @@ -92,6 +92,52 @@ geef_index_read_tree(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) return atoms.ok; } +ERL_NIF_TERM +geef_index_add(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) +{ + geef_index *index; + const ERL_NIF_TERM *eentry, *oid; + int arity; + ErlNifBinary path, id; + git_index_entry entry; + + if (!enif_get_resource(env, argv[0], geef_index_type, (void **) &index)) + return enif_make_badarg(env); + + if (!enif_get_tuple(env, argv[1], &arity, &eentry)) + return enif_make_badarg(env); + + if (arity != 4) + return enif_make_badarg(env); + + /* TODO: check for the 'tree_entry' tag */ + memset(&entry, 0, sizeof(entry)); + + if (!enif_get_uint(env, eentry[1], &entry.mode)) + return enif_make_badarg(env); + + if (!enif_inspect_iolist_as_binary(env, eentry[3], &path)) + return enif_make_badarg(env); + + if (!geef_terminate_binary(&path)) + return geef_oom(env); + + entry.path = (char *) path.data; + /* Extract the oid from the tuple */ + if (!enif_get_tuple(env, eentry[2], &arity, &oid)) + return enif_make_badarg(env); + + if (!enif_inspect_binary(env, oid[1], &id)) + return enif_make_badarg(env); + + git_oid_fromraw(&entry.oid, id.data); + + if (git_index_add(index->index, &entry) < 0) + return geef_error(env); + + return atoms.ok; +} + ERL_NIF_TERM geef_index_clear(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { diff --git a/c_src/index.h b/c_src/index.h index 5ccf4b4..6bd8981 100644 --- a/c_src/index.h +++ b/c_src/index.h @@ -18,5 +18,7 @@ ERL_NIF_TERM geef_index_write(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[ ERL_NIF_TERM geef_index_write_tree(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]); ERL_NIF_TERM geef_index_clear(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]); ERL_NIF_TERM geef_index_read_tree(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]); +ERL_NIF_TERM geef_index_add(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]); +ERL_NIF_TERM geef_index_new(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]); #endif diff --git a/src/geef_index.erl b/src/geef_index.erl index fe2f3c6..4d20d61 100644 --- a/src/geef_index.erl +++ b/src/geef_index.erl @@ -12,7 +12,7 @@ %% API -export([start_link/1]). --export([new/0, write/1, write_tree/1, write_tree/2, clear/1, stop/1, read_tree/2]). +-export([new/0, write/1, write_tree/1, write_tree/2, clear/1, stop/1, read_tree/2, add/2]). %% gen_server callbacks -export([init/1, handle_call/3, handle_cast/2, handle_info/2, @@ -51,6 +51,11 @@ write_tree(Pid, Repo) -> read_tree(Pid, #object{type=tree, handle=TreeHandle}) -> gen_server:call(Pid, {read_tree, TreeHandle}). +%% @doc Add an entry to the index +-spec add(pid(), index_entry()) -> ok | {error, term()}. +add(Pid, Entry) -> + gen_server:call(Pid, {add, Entry}). + %% @doc Clear the contents of the index. -spec clear(pid()) -> ok. clear(Pid) -> @@ -83,7 +88,7 @@ handle_call(write_tree, _From, State = #state{handle=Handle}) -> handle_call({write_tree, Repo}, _From, State = #state{handle=Handle}) -> RepoHandle = geef_repo:handle(Repo), {ok, Oid} = geef_nif:index_write_tree(Handle, RepoHandle), - Reply = #oid{oid=Oid}, + Reply = {ok, #oid{oid=Oid}}, {reply, Reply, State}; handle_call(clear, _From, State = #state{handle=Handle}) -> Reply = geef_nif:index_clear(Handle), @@ -92,6 +97,9 @@ handle_call(stop, _From, State) -> {stop, normal, ok, State}; handle_call({read_tree, TreeHandle}, _From, State = #state{handle=Handle}) -> Reply = geef_nif:index_read_tree(Handle, TreeHandle), + {reply, Reply, State}; +handle_call({add, Entry}, _From, State = #state{handle=Handle}) -> + Reply = geef_nif:index_add(Handle, Entry), {reply, Reply, State}. %% @private diff --git a/src/geef_nif.erl b/src/geef_nif.erl index ab9a5d1..47d98d0 100644 --- a/src/geef_nif.erl +++ b/src/geef_nif.erl @@ -2,29 +2,7 @@ %%% NIF functions, not to be used directly. -module(geef_nif). --export([reference_list/1, reference_create/5, - reference_to_id/2, reference_glob/2, reference_lookup/2, reference_resolve/1, - reference_target/1, reference_type/1, odb_object_exists/2, odb_write/3]). - -% repository operations --export([repository_get_path/1, repository_get_odb/1, repository_open/1, repository_init/2, - repository_is_bare/1, repository_get_workdir/1, repository_discover/1]). - -% oid parsing --export([oid_fmt/1, oid_parse/1]). - -% objects --export([object_lookup/2, object_id/1, commit_tree_id/1, commit_tree/1, tree_bypath/2, blob_size/1, blob_content/1]). - -% git_libgit2 --export([library_version/0]). - -% revision walker --export([revwalk_new/1, revwalk_push/3, revwalk_next/1, revwalk_sorting/2, revwalk_reset/1]). - -% index --export([index_new/0, index_write/1, index_write_tree/1, index_write_tree/2, - index_clear/1, index_read_tree/2]). +-compile(export_all). -on_load(load_enif/0). @@ -154,6 +132,9 @@ index_write_tree(_Handle, _RepoHandle) -> index_read_tree(_Handle, _TreeHandle) -> ?NIF_FN. +index_add(_Handle, _Entry) -> + ?NIF_FN. + index_clear(_Handle) -> ?NIF_FN. diff --git a/src/geef_records.hrl b/src/geef_records.hrl index b1430f6..f695b6e 100644 --- a/src/geef_records.hrl +++ b/src/geef_records.hrl @@ -4,6 +4,7 @@ -record(revwalk, {handle}). -record(oid, {oid}). -record(object, {type :: atom(), handle}). +-record(index_entry, {mode, id :: oid(), path :: iolist()}). -type ref() :: #ref{}. -type repo() :: #repo{}. @@ -11,3 +12,4 @@ -type odb() :: #odb{}. -type oid() :: #oid{}. -type object() :: #object{}. +-type index_entry() :: #index_entry{}. diff --git a/src/geef_repo.erl b/src/geef_repo.erl index 459215c..9115570 100644 --- a/src/geef_repo.erl +++ b/src/geef_repo.erl @@ -139,9 +139,8 @@ handle_call(stop, _From, State) -> handle_call(revwalk, _From, State = #state{handle=Handle}) -> Reply = handle_revwalk(Handle), {reply, Reply, State}; -handle_call(_Request, _From, State) -> - Reply = {error, "Unkown call"}, - {reply, Reply, State}. +handle_call(handle, _From, State = #state{handle=Handle}) -> + {reply, Handle, State}. %% @private handle_cast(_Msg, State) -> diff --git a/test/repo_test.erl b/test/repo_test.erl index dfcc66f..ab33e3e 100644 --- a/test/repo_test.erl +++ b/test/repo_test.erl @@ -1,9 +1,11 @@ -module(repo_test). -compile([export_all]). -include_lib("eunit/include/eunit.hrl"). +-include("src/geef_records.hrl"). repo_test_() -> - {foreach, fun start/0, fun stop/1, [fun bare_test/1, fun odb_write_test/1, fun create_ref_test/1]}. + {foreach, fun start/0, fun stop/1, [fun bare_test/1, fun odb_write_test/1, + fun create_ref_test/1, fun index_add_test/1]}. start() -> {A, B, C} = now(), @@ -22,6 +24,17 @@ odb_write_test(Repo) -> Expected = geef_oid:parse("c300118399f01fe52b316061b5d32beb27e0adfd"), [?_assertEqual(Actual, Expected)]. +index_add_test(Repo) -> + Data = <<"This is some text that will go in a file">>, + {ok, Odb} = geef_repo:odb(Repo), + {ok, BlobId} = geef_odb:write(Odb, Data, blob), + {ok, Idx} = geef_index:new(), + Entry = #index_entry{mode=8#100644, id=BlobId, path="README"}, + ok = geef_index:add(Idx, Entry), + {ok, TreeId} = geef_index:write_tree(Idx, Repo), + Expected = geef_oid:parse("5a20bbbf65ea75ad4d9f995d179156824ccca3a1"), + [?_assertEqual(Expected, TreeId)]. + create_ref_test(Repo) -> odb_write_test(Repo), Id = geef_oid:parse("c300118399f01fe52b316061b5d32beb27e0adfd"),