Rename :type formatter to :map

Author: renatomassaro

lib/feeb/db/repo.ex

@@ -283,8 +283,8 @@ defmodule Feeb.DB.Repo do
 
   defp format_result(:one, _, _, [row], _, %{format: :raw}), do: {:ok, row}
 
-  defp format_result(:one, query_id, query, [row], _, %{format: :type}),
-    do: {:ok, create_types_from_rows(query_id, query, [row]) |> List.first()}
+  defp format_result(:one, query_id, query, [row], _, %{format: :map}),
+    do: {:ok, create_maps_from_rows(query_id, query, [row]) |> List.first()}
 
   defp format_result(:one, query_id, query, [row], _, _),
     do: {:ok, create_schema_from_rows(query_id, query, [row]) |> List.first()}
@@ -295,13 +295,13 @@ defmodule Feeb.DB.Repo do
   defp format_result(:all, _, _, [], _, _), do: {:ok, []}
   defp format_result(:all, _, _, rows, _, %{format: :raw}), do: {:ok, rows}
 
-  defp format_result(:all, query_id, query, rows, _, %{format: :type}),
-    do: {:ok, create_types_from_rows(query_id, query, rows)}
+  defp format_result(:all, query_id, query, rows, _, %{format: :map}),
+    do: {:ok, create_maps_from_rows(query_id, query, rows)}
 
   defp format_result(:all, query_id, query, rows, _, %{format: :schema}),
     do: {:ok, create_schema_from_rows(query_id, query, rows)}
 
-  defp format_result(:insert, _, _, [], _, %{format: format}) when format in [:raw, :type],
+  defp format_result(:insert, _, _, [], _, %{format: format}) when format in [:raw, :map],
     do: {:ok, nil}
 
   defp format_result(:insert, query_id, query, [], bindings, %{format: :schema}) do
@@ -364,7 +364,7 @@ defmodule Feeb.DB.Repo do
     Enum.map(rows, fn row -> Schema.from_row(model, model.__cols__(), row) end)
   end
 
-  defp create_types_from_rows(query_id, {_, {fields_bindings, _}, :select} = query, rows) do
+  defp create_maps_from_rows(query_id, {_, {fields_bindings, _}, :select} = query, rows) do
     # Performance-wise, not the best solution, but I'd rather keep the code readable for a bit
     # longer. Simply create the full schema and use only the fields the user selected
     create_schema_from_rows(query_id, query, rows)

test/db/db_test.exs

@@ -462,20 +462,20 @@ defmodule Feeb.DBTest do
       assert ["i_am_atom", 50] == DB.one({:all_types, :get_atom_and_integer}, [], format: :raw)
       assert ["{\"foo\":\"bar\"}"] == DB.one({:all_types, :get_map_keys_atom}, [], format: :raw)
 
-      # With the :type flag, we return the values formatted by their types _without_ the full schema
+      # With the :map flag, we return the values formatted by their types _without_ the full schema
       assert %{map_keys_atom: %{foo: "bar"}} ==
-               DB.one({:all_types, :get_map_keys_atom}, [], format: :type)
+               DB.one({:all_types, :get_map_keys_atom}, [], format: :map)
 
       assert %{atom: :i_am_atom, integer: 50} ==
-               DB.one({:all_types, :get_atom_and_integer}, [], format: :type)
+               DB.one({:all_types, :get_atom_and_integer}, [], format: :map)
 
       # Custom selection with different formats
       assert ["Phoebe"] = DB.one({:friends, :fetch}, [1], select: [:name], format: :raw)
-      assert %{name: "Phoebe"} = DB.one({:friends, :fetch}, [1], select: [:name], format: :type)
+      assert %{name: "Phoebe"} = DB.one({:friends, :fetch}, [1], select: [:name], format: :map)
 
       # No matching results
       assert nil == DB.one({:friends, :fetch}, [500], select: [:name], format: :raw)
-      assert nil == DB.one({:friends, :fetch}, [500], select: [:name], format: :type)
+      assert nil == DB.one({:friends, :fetch}, [500], select: [:name], format: :map)
     end
 
     test "works with window functions when using :raw flag", %{shard_id: shard_id} do
@@ -583,21 +583,21 @@ defmodule Feeb.DBTest do
       assert [["{\"foo\":\"bar\"}"], ["{\"girl\":[\"so\",\"confusing\"]}"]] |> Enum.sort() ==
                DB.all({:all_types, :get_map}, [], format: :raw) |> Enum.sort()
 
-      # With the :type flag, we return the values formatted by their types _without_ the full schema
+      # With the :map flag, we return the values formatted by their types _without_ the full schema
       assert [%{map: %{girl: ["so", "confusing"]}}, %{map: %{foo: "bar"}}] |> Enum.sort() ==
-               DB.all({:all_types, :get_map}, [], format: :type) |> Enum.sort()
+               DB.all({:all_types, :get_map}, [], format: :map) |> Enum.sort()
 
       assert [%{atom: :i_am_atom, integer: 50}, %{atom: :other_atom, integer: -2}] |> Enum.sort() ==
-               DB.all({:all_types, :get_atom_and_integer}, [], format: :type) |> Enum.sort()
+               DB.all({:all_types, :get_atom_and_integer}, [], format: :map) |> Enum.sort()
 
       # Custom selection with different formats
       assert [%{name: "Phoebe"}] =
-               DB.all({:friends, :get_by_name}, "Phoebe", select: [:name], format: :type)
+               DB.all({:friends, :get_by_name}, "Phoebe", select: [:name], format: :map)
 
       assert [["Joey"]] = DB.all({:friends, :get_by_name}, "Joey", select: [:name], format: :raw)
 
       # No matching results
-      assert [] == DB.all({:friends, :get_by_name}, "Michael Scott", format: :type)
+      assert [] == DB.all({:friends, :get_by_name}, "Michael Scott", format: :map)
     end
   end