Make Reference call the NIF itself

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")
+  defstruct repo: nil, name: nil, type: nil, target: nil
-  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
 
   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

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),

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"
+    content = "This is some text that will go in a file"
-    Odb.write(odb, content, :blob)
+    {:ok, id} = Odb.write(odb, content, :blob)
+    assert id == Oid.parse("c300118399f01fe52b316061b5d32beb27e0adfd")
 
     Repository.stop(repo)
   end

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"
+    refname2 = "refs/tags/foo2"
-    {:ok, ref} = Reference.create_symbolic(repo, refname, id)
+    {:ok, ref} = Reference.create_symbolic(repo, refname2, refname)
-    {:ok, looked_up} = Reference.lookup(repo, refname)
+    {:ok, looked_up} = Reference.lookup(repo, refname2)
     assert ref == looked_up
 
     Repository.stop(repo)