From fffdb470325715b6730567ecb4f2bda0d84f2c4f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Sun, 3 Aug 2014 02:08:44 +0200 Subject: [PATCH] Make Reference call the NIF itself --- lib/geef/reference.ex | 72 ++++++++++++++++++++++++++++------------- src/geef_repo.erl | 14 ++++++++ test/object_test.exs | 5 +-- test/reference_test.exs | 6 ++-- 4 files changed, 69 insertions(+), 28 deletions(-) diff --git a/lib/geef/reference.ex b/lib/geef/reference.ex index 1a05bcf..42d9d76 100644 --- a/lib/geef/reference.ex +++ b/lib/geef/reference.ex @@ -4,44 +4,70 @@ defmodule Geef.Reference do import Geef alias Geef.Reference - record = Record.extract(:geef_reference, from: "src/geef_records.hrl") - keys = :lists.map(&elem(&1, 0), record) - vals = :lists.map(&{&1, [], nil}, keys) - pairs = :lists.zip(keys, vals) - - defstruct keys - - def to_record(%Geef.Reference{unquote_splicing(pairs)}) do - {:geef_reference, unquote_splicing(vals)} - end - - def from_record({:geef_reference, unquote_splicing(vals)}) do - %Geef.Reference{unquote_splicing(pairs)} - end - - defp maybe_ref({:ok, ref}), do: {:ok, Reference.from_record(ref)} - defp maybe_ref(err = {:error, _}), do: err + defstruct repo: nil, name: nil, type: nil, target: nil def create(repo, name, target, force \\ :false) do - :geef_ref.create(repo, name, target, force) |> maybe_ref + # fixme: this needs to ask the repo itself + repo_handle = :geef_repo.handle(repo) + case :geef_nif.reference_create(repo_handle, name, :oid, target, force) do + :ok -> + {:ok, %Reference{repo: repo, name: name, type: :oid, target: target}} + error -> + error + end end def create!(repo, name, target, force \\ :false) do create(repo, name, target, force) |> assert_ok end + def create_symbolic(repo, name, target, force \\ :false) do - :geef_ref.create(repo, name, target, force) |> maybe_ref + # fixme: this needs to ask the repo itself + repo_handle = :geef_repo.handle(repo) + case :geef_nif.reference_create(repo_handle, name, :symbolic, target, force) do + :ok -> + {:ok, %Reference{repo: repo, name: name, type: :symbolic, target: target}} + error -> + error + end end def create_symbolic!(repo, name, target, force \\ :false) do - create(repo, name, target, force) |> assert_ok + create_symbolic(repo, name, target, force) |> assert_ok end - def lookup(repo, name), do: :geef_ref.lookup(repo, name) |> maybe_ref + def lookup(repo, name) do + case :geef_repo.reference_lookup(repo, name) do + {:ok, type, target} -> + {:ok, %Reference{repo: repo, name: name, type: type, target: target}} + error -> + error + end + end def lookup!(repo, name), do: lookup(repo, name) |> assert_ok - def resolve(ref = %Reference{}), do: :geef_ref.resolve(to_record(ref)) |> maybe_ref + # A direct referene is only ever going to be itself + def resolve(ref = %Reference{type: :oid}) do + {:ok, ref} + end + def resolve(%Reference{repo: repo, name: name}) do + case :geef_repo.reference_resolve(repo, name) do + {:ok, resolved_name, target} -> + {:ok, %Reference{repo: repo, name: resolved_name, type: :oid, target: target}} + error -> + error + end + end + def resolve!(ref = %Reference{}), do: resolve(ref) |> assert_ok - def dwim(repo, name), do: :geef_ref.dwim(repo, name) |> maybe_ref + def dwim(repo, name) do + case :geef_repo.reference_dwim(repo, name) do + {:ok, real_name, type, target} -> + {:ok, %Reference{repo: repo, name: real_name, type: type, target: target}} + error -> + error + end + end + def dwim!(repo, name), do: dwim(repo, name) |> assert_ok def shorthand(%Reference{name: name}) do diff --git a/src/geef_repo.erl b/src/geef_repo.erl index a994a58..494c32f 100644 --- a/src/geef_repo.erl +++ b/src/geef_repo.erl @@ -16,6 +16,7 @@ -export([reference_has_log/2]). -export([reflog_read/2, reflog_delete/2]). -export([config/1]). +-export([reference_lookup/2]). -include("geef_records.hrl"). -record(state, {handle}). @@ -77,6 +78,12 @@ is_bare(Pid) -> references(Pid) -> gen_server:call(Pid, refs). +reference_lookup(Pid, Name) -> + gen_server:call(Pid, {lookup_reference, Name}). + +reference_resolve(Pid, Name) -> + gen_server:call(Pid, {lookup_resolve, Name}). + lookup_object(Pid, Oid) -> gen_server:call(Pid, {lookup_object, Oid}). @@ -163,6 +170,13 @@ handle_call({reflog_delete, Name}, _From, State = #state{handle=Handle}) -> Reply = geef_nif:reflog_delete(Handle, Name), {reply, Reply, State}; +handle_call({lookup_reference, Name}, _From, State = #state{handle=Handle}) -> + Reply = geef_nif:reference_lookup(Handle, Name), + {reply, Reply, State}; + +handle_call({reference_resolve, Name}, _From, State = #state{handle=Handle}) -> + Reply = geef_nif:reference_resolve(Handle, Name), + {reply, Reply, State}; handle_call(config, _From, State = #state{handle=Handle}) -> Reply = handle_config(Handle), diff --git a/test/object_test.exs b/test/object_test.exs index d79c177..12a7607 100644 --- a/test/object_test.exs +++ b/test/object_test.exs @@ -15,8 +15,9 @@ defmodule ObjectTest do { :ok, odb } = Repository.odb(repo) #{ :ok, index } = :geef_index.new - content = "I'm some content" - Odb.write(odb, content, :blob) + content = "This is some text that will go in a file" + {:ok, id} = Odb.write(odb, content, :blob) + assert id == Oid.parse("c300118399f01fe52b316061b5d32beb27e0adfd") Repository.stop(repo) end diff --git a/test/reference_test.exs b/test/reference_test.exs index d6a4658..482abbc 100644 --- a/test/reference_test.exs +++ b/test/reference_test.exs @@ -20,9 +20,9 @@ defmodule ReferenceTest do {:ok, looked_up} = Reference.lookup(repo, refname) assert ref == looked_up - refname = "refs/tags/foo2" - {:ok, ref} = Reference.create_symbolic(repo, refname, id) - {:ok, looked_up} = Reference.lookup(repo, refname) + refname2 = "refs/tags/foo2" + {:ok, ref} = Reference.create_symbolic(repo, refname2, refname) + {:ok, looked_up} = Reference.lookup(repo, refname2) assert ref == looked_up Repository.stop(repo)