Refactor elixir code

This should lead to better overview

lib/geef.ex

@@ -13,4 +13,7 @@ defmodule Geef do
     end
   end
 
+  def assert_ok({:ok, ref}), do: ref
+  def assert_ok({:error, error}), do: raise error
+
 end

lib/geef/reference.ex

@@ -1,63 +1,30 @@
 defrecord Geef.Reference, Record.extract(:geef_reference, from: "src/geef_records.hrl") do
-  alias Geef.Repository
+  import Geef
   alias Geef.Reference
 
-  def lookup(repo, name) do
-    case :geef_ref.lookup(repo, name) do
-      {:ok, ref} ->
-        {:ok, Geef.Reference.new ref}
-      error ->
-        error
+  defmacrop rebind(obj) do
+    quote do
+      set_elem(unquote(obj), 0, :geef_reference)
     end
   end
 
-  def lookup!(repo, name) do
-    case lookup(repo, name) do
-      {:ok, ref} ->
-        ref
-      {:error, err} ->
-        raise err
-    end
-  end
 
-  def resolve(ref = Geef.Reference[]) do
-    case :geef_ref.resolve(set_elem(ref, 0, :geef_reference)) do
-      {:ok, ref} ->
-        {:ok, Geef.Reference.new ref}
-      error ->
-        error
-    end
-  end
+  defp maybe_ref({:ok, ref}), do: {:ok, Reference.new ref}
+  defp maybe_ref(err = {:error, _}), do: err
 
-  def resolve!(ref = Geef.Reference[]) do
-    case resolve(ref) do
-      {:ok, resolved} ->
-        resolved
-      {:error, err} ->
-        raise err
-    end
-  end
+  def lookup(repo, name), do: :geef_ref.lookup(repo, name) |> maybe_ref
+  def lookup!(repo, name), do: lookup(repo, name) |> assert_ok
 
-  def dwim(repo, name) do
-    case :geef_ref.dwim(repo, name) do
-      {:ok, ref} ->
-        {:ok, Geef.Reference.new ref}
-      error ->
-        error
-    end
-  end
+  def resolve(ref = Reference[]), do: :geef_ref.resolve(rebind(ref)) |> maybe_ref
+  def resolve!(ref =Reference[]), do: resolve(ref) |> assert_ok
 
-  def dwim!(repo, name) do
-    case dwim(repo, name) do
-      {:ok, ref} -> ref
-      {:error, err} -> raise err
-    end
-  end
+  def dwim(repo, name), do: :geef_ref.dwim(repo, name) |> maybe_ref
+  def dwim!(repo, name), do: dwim(repo, name) |> assert_ok
 
   def shorthand(Reference[name: name]) do
     :geef_ref.shorthand(name)
   end
-  def shorthane(name) do
+  def shorthand(name) do
     :geef_ref.shorthand(name)
   end
 

lib/geef/repository.ex

@@ -1,36 +1,16 @@
 defmodule Geef.Repository do
+  import Geef
 
   def stop(repo), do: :geef_repo.stop(repo)
 
   def open(path),  do: :geef_repo.open(path)
-  def open!(path) do
-    case :geef_repo.open(path) do
-      {:ok, pid} ->
-        pid
-      {:error, err} ->
-        raise err
-    end
-  end
+  def open!(path), do: :geef_repo.open(path) |> assert_ok
 
-  def init(path, bare), do: :geef_repo.open(path, bare)
-  def init!(path, bare) do
-    case :geef_repo.init(path, bare) do
-      {:ok, pid} ->
-        pid
-      {:error, err} ->
-        raise err
-    end
-  end
+  def init(path, bare),  do: :geef_repo.init(path, bare)
+  def init!(path, bare), do: :geef_repo.init(path, bare) |> assert_ok
 
   def odb(repo),  do: :geef_repo.odb(repo)
-  def odb!(repo) do
-    case :geef_repo.odb(repo) do
-      {:ok, pid} ->
-        pid
-      {:error, err} ->
-        raise err
-    end
-  end
+  def odb!(repo), do: :geef_repo.odb(repo) |> assert_ok
 
   def discover(path), do: :geef_repo.disover(path)
 

lib/geef/signature.ex

@@ -3,7 +3,7 @@ defrecord Geef.Signature, Record.extract(:geef_signature, from: "src/geef_record
   def new(name, email), do: :geef_sig.new(name, email) |> maybe_sig
   def new(name, email, time), do: :geef_sig.new(name, email, time) |> maybe_sig
 
-  defp maybe_sig({ok, sig}), do: {ok, Geef.Signature.new sig}
-  defp maybe_sig(error), do: error
+  defp maybe_sig({:ok, sig}), do: Geef.Signature.new(sig)
+  defp maybe_sig({:error, error}), do: raise error
 
 end

lib/geef/tag.ex

@@ -1,6 +1,7 @@
 defmodule Geef.Tag do
   alias Geef.Object
   import :macros, Object
+  import Geef
 
   def peel(tag = Object[type: :tag]) do
     case :geef_tag.peel(rebind(tag)) do
@@ -11,11 +12,6 @@ defmodule Geef.Tag do
     end
   end
 
-  def peel!(tag = Object[type: :tag]) do
-    case peel(tag) do
-      {:ok, peeled} -> peeled
-      {:error, err} -> raise err
-    end
-  end
+  def peel!(tag = Object[type: :tag]), do: peel(tag) |> assert_ok
 
 end