doc: handle elixir type info in from_map/1 & to_map/1

If a top-level key named "type": "Foo" is present, check to see if a
corresponding atom named :"Elixir.Foo" is present in the existing
atom table.

This permits user functions to dispatch based on atom type in the
returned doc struct, to an Ecto schema function directly, or similar
custom user function as required.

- upgrade from_map/1 and to_map/1
- add coerce_to_elixir_type/1
- add coerce_to_json_string/1
- remove struct related names from type fields
- sprinkle a few tests

lib/sofa/doc.ex

@@ -146,6 +146,13 @@ defmodule Sofa.Doc do
        }} ->
         {:ok, %Doc{doc | rev: rev}}
 
+      {:ok, _sofa,
+       %Sofa.Response{
+         status: 202,
+         body: %{"rev" => rev}
+       }} ->
+        {:ok, %Doc{doc | rev: rev}}
+
       {:error,
        %Sofa.Response{
          status: 400
@@ -197,22 +204,32 @@ defmodule Sofa.Doc do
       |> Map.put("_id", id)
       |> Map.put("_rev", rev)
       |> Map.put("_attachments", atts)
-      |> Map.put("type", type)
+      |> Map.put("type", coerce_to_json_string(type))
 
     # skip all top level keys with value nil
-    m = :maps.filter(&Sofa.Doc.drop_nil_values/2, m)
+    m = :maps.filter(&drop_nil_values/2, m)
     # merge with precedence taking from Struct side
     Map.merge(body, m)
   end
 
   @spec drop_nil_values(any, any) :: false | true
-  def drop_nil_values(_, v) do
+  defp drop_nil_values(_, v) do
     case v do
       nil -> false
       _ -> true
     end
   end
 
+  @spec coerce_to_json_string(atom) :: String.t() | nil
+  defp coerce_to_json_string(nil), do: nil
+
+  defp coerce_to_json_string(atom) do
+    case Atom.to_string(atom) do
+      "Elixir." <> module -> module
+      _ -> nil
+    end
+  end
+
   @doc """
   Converts CouchDB-native JSON-friendly map to internal %Sofa.Doc{} format
 
@@ -233,10 +250,12 @@ defmodule Sofa.Doc do
     # key beginning with "_" as they are restricted within CouchDB
     body =
       Map.drop(m, [
+        "__struct__",
         "_attachments",
         "_id",
         "_rev",
         "type",
+        :__struct__,
         :_attachments,
         :_id,
         :_rev
@@ -246,10 +265,34 @@ defmodule Sofa.Doc do
     # grab the rest we need them
     rev = Map.get(m, "_rev", nil)
     atts = Map.get(m, "_attachments", nil)
-    type = Map.get(m, "type", "nil") |> String.to_existing_atom()
+    type = Map.get(m, "type", "nil") |> coerce_to_elixir_type()
     %Sofa.Doc{attachments: atts, body: body, id: id, rev: rev, type: type}
   end
 
+  @doc """
+  Coerces a CouchDB "type" field to an existing atom. It is assumed that there
+  will be a related Elixir Module Type of the same name. Elixir prefixes Module
+  names with Elixir. and then elides this in iex, tests, and elsewhere, but
+  here we need to make that explicit.
+
+  The "user" type is special-cased as it is already present in CouchDB /_users
+  database.
+
+  This function is expected to be paired up with Ecto Schemas to properly manage
+  the appropriate fields in your document body.
+  """
+  @spec coerce_to_elixir_type(String.t()) :: atom
+  defp coerce_to_elixir_type("user"), do: :user
+
+  defp coerce_to_elixir_type(type) do
+    # exception generated if no existing type is found
+    String.to_existing_atom("Elixir." <> type)
+  rescue
+    ArgumentError -> nil
+  else
+    found -> found
+  end
+
   # this would be a Protocol for people to defimpl on their own structs
   # @spec from_struct(map()) :: %Sofa.Doc{}
   # def from_struct(m = %{id: id, __Struct__: type}) do

test/sofa_doc_test.exs

@@ -258,8 +258,8 @@ defmodule SofaDocTest do
   end
 
   test "from_map doesn't leak forbidden keys into doc.body" do
-    bad_keys = ["_rev", "_attachments", :_id, :_rev, :_attachments]
-    good_map = %{"_id" => "toasty", "key" => "important", "type" => "hellvetica"}
+    bad_keys = ["_rev", "_attachments", :_id, :_rev, :_attachments, :__struct__, "__struct__"]
+    good_map = %{"_id" => "toasty", "key" => "important", "type" => "Sofa"}
 
     pruned_map =
       Enum.reduce(bad_keys, good_map, fn x, a -> Map.put(a, x, "blah") end)
@@ -271,7 +271,28 @@ defmodule SofaDocTest do
              body: %{"key" => "important"},
              id: "toasty",
              rev: "blah",
-             type: :hellvetica
+             type: Sofa
+           })
+  end
+
+  test "to_map coerces Elixir module types to JSON strings" do
+
+    doc = Sofa.Doc.new("Hellvetica")
+    m = %{doc | type: Sofa.Doc} |> Sofa.Doc.to_map()
+    assert "Sofa.Doc" == m["type"]
+
+    assert !Map.has_key?(Sofa.Doc.to_map(doc), "type")
+  end
+
+  test "from_map coerces type strings to Elixir types" do
+    m = %{"_rev" => "1-leet", "_id" => "abc123", "type" => "Sofa.Doc"}
+
+    assert Map.equal?(Sofa.Doc.from_map(m), %Sofa.Doc{
+             attachments: nil,
+             body: %{},
+             id: "abc123",
+             rev: "1-leet",
+             type: Sofa.Doc
            })
   end