Don't overload the record constructors

Use 'from_erl' instead of 'new' when transforming erlang records into
elixir records.

lib/geef/blob.ex

@@ -5,7 +5,7 @@ defmodule Geef.Blob do
   def lookup(repo, id) do
     case :geef_obj.lookup(repo, id) do
       {:ok, obj} ->
-        {:ok, Object.new obj}
+        {:ok, Object.from_erl obj}
       error ->
         error
     end

lib/geef/commit.ex

@@ -5,7 +5,7 @@ defmodule Geef.Commit do
   def lookup(repo, id) do
     case :geef_commit.lookup(repo, id) do
       {:ok, commit} ->
-        {:ok, Object.new commit}
+        {:ok, Object.from_erl commit}
       error ->
         error
     end

lib/geef/iterator.ex

@@ -9,7 +9,8 @@ defrecord Geef.Iterator, Record.extract(:geef_iterator, from: "src/geef_records.
     end
   end
 
-  def new(iterator) do
+  @spec from_erl(term()) :: t
+  def from_erl(iterator) do
     set_elem(iterator, 0, Geef.Iterator)
   end
 
@@ -17,7 +18,7 @@ defrecord Geef.Iterator, Record.extract(:geef_iterator, from: "src/geef_records.
     iter =
       case :geef_ref.iterator(repo, regexp) do
         {:ok, iter} ->
-          Iterator.new iter
+          Iterator.from_erl iter
         {:error, error} ->
           raise Geef.IteratorError, message: error
       end
@@ -27,7 +28,7 @@ defrecord Geef.Iterator, Record.extract(:geef_iterator, from: "src/geef_records.
   defp do_stream(iter = Iterator[type: :ref], acc, fun) do
     case :geef_ref.next(rebind(iter)) do
       {:ok, ref} ->
-        do_stream(iter, fun.(Reference.new(ref), acc), fun)
+        do_stream(iter, fun.(Reference.from_erl(ref), acc), fun)
       {:error, :iterover} ->
         acc
       {:error, error} ->

lib/geef/object.ex

@@ -7,22 +7,22 @@ defrecord Geef.Object, Record.extract(:geef_object, from: "src/geef_records.hrl"
     end
   end
 
-  def new(obj) do
-    do_new(obj, elem(obj, 0))
+  def from_erl(obj) do
+    do_from_erl(obj, elem(obj, 0))
   end
 
-  defp do_new(obj, :geef_tree) do
+  defp do_from_erl(obj, :geef_tree) do
     set_elem(obj, 0, Geef.Tree)
   end
 
-  defp do_new(obj, _) do
+  defp do_from_erl(obj, _) do
     set_elem(obj, 0, Geef.Object)
   end
 
   def lookup(repo, id) do
     case :geef_obj.lookup(repo, id) do
       {:ok, obj} ->
-        {:ok, Geef.Object.new obj}
+        {:ok, Geef.Object.from_erl obj}
       error ->
         error
     end

lib/geef/reference.ex

@@ -8,11 +8,11 @@ defrecord Geef.Reference, Record.extract(:geef_reference, from: "src/geef_record
     end
   end
 
-  def new(ref) do
+  def from_erl(ref) do
     set_elem(ref, 0, Geef.Reference)
   end
 
-  defp maybe_ref({:ok, ref}), do: {:ok, Reference.new ref}
+  defp maybe_ref({:ok, ref}), do: {:ok, Reference.from_erl ref}
   defp maybe_ref(err = {:error, _}), do: err
 
   def lookup(repo, name), do: :geef_ref.lookup(repo, name) |> maybe_ref
@@ -34,7 +34,7 @@ defrecord Geef.Reference, Record.extract(:geef_reference, from: "src/geef_record
   def iterator(repo, regexp // :undefined) do
     case :geef_ref.iterator(repo, regexp) do
       {:ok, iter} ->
-        {:ok, Geef.Iterator.new iter}
+        {:ok, Geef.Iterator.from_erl iter}
       other ->
         other
     end

lib/geef/tag.ex

@@ -6,7 +6,7 @@ defmodule Geef.Tag do
   def peel(tag = Object[type: :tag]) do
     case :geef_tag.peel(rebind(tag)) do
       {:ok, peeled} ->
-        {:ok, Object.new peeled}
+        {:ok, Object.from_erl peeled}
       error ->
         error
     end

lib/geef/tree.ex

@@ -1,5 +1,6 @@
 defrecord Geef.TreeEntry, Record.extract(:geef_tree_entry, from: "src/geef_records.hrl") do
-  def new(obj) do
+  @spec from_erl(term()) :: t
+  def from_erl(obj) do
     set_elem(obj, 0, Geef.TreeEntry)
   end
 end
@@ -13,13 +14,13 @@ defrecord Geef.Tree, Record.extract(:geef_object, from: "src/geef_records.hrl")
   def lookup(repo, id) do
     case :geef_tree.lookup(repo, id) do
       {:ok, obj} ->
-        {:ok, Object.new obj}
+        {:ok, Object.from_erl obj}
       error ->
         error
     end
   end
 
-  defp maybe_entry({:ok, entry}), do: {:ok, TreeEntry.new entry}
+  defp maybe_entry({:ok, entry}), do: {:ok, TreeEntry.from_erl entry}
   defp maybe_entry(error = {:error, _}), do: error
 
   def get(tree, path), do: :geef_tree.get(rebind(tree), path) |> maybe_entry