improve to also handle lists + simpler code

Author: mindreframer

lib/atomic_map.ex

@@ -1,19 +1,21 @@
 defmodule AtomicMap do
+
   def convert(map, opts) when is_map(map) do
     safe = Keyword.get(opts, :safe, true)
-    map |> Enum.reduce(%{}, fn
-       # convert strings to atoms
-       {k,v}, acc when is_binary(k) and is_map(v)
-           -> Map.put(acc, as_atom(k, safe), convert(v, opts));
-       {k,v}, acc when is_map(v)
-           -> Map.put(acc, k, convert(v, opts));
-       {k,v}, acc when is_binary(k)
-           -> Map.put(acc, as_atom(k, safe), v);
-       {k,v}, acc
-           -> Map.put(acc, k, v)
+    map |> Enum.reduce(%{}, fn({k,v}, acc)->
+       if is_binary(k), do: k = as_atom(k, safe)
+       cond do
+          is_complex?(v) -> Map.put(acc, k, convert(v, opts));
+          true           -> Map.put(acc, k, v)
+      end
     end)
   end
+  def convert(list, opts) when is_list(list) do
+    list |> Enum.map(fn(x)-> convert(x, opts) end)
+  end
+  def convert(v, opts),  do: v
 
+  defp is_complex?(v), do: is_map(v) || is_list(v)
   defp as_atom(s, true) when is_binary(s), do: s |> String.to_existing_atom
   defp as_atom(s, true),                   do: s
 

test/atomic_map_test.exs

@@ -8,6 +8,30 @@ defmodule AtomicMapTest do
     assert AtomicMap.convert(input, safe: true) == expected
   end
 
+  test "works with maps with lists" do
+    input    = %{ "a" => [ %{"c" => 1}, %{"c" => 2}] }
+    expected = %{a: [%{c: 1}, %{c: 2}] }
+    assert AtomicMap.convert(input, safe: true) == expected
+  end
+
+  test "works with lists with maps" do
+    input    = [ %{"c" => 1}, %{"c" => 2}, %{"c" => %{"b" => 4}}]
+    expected = [%{c: 1}, %{c: 2}, %{c: %{b: 4}}]
+    assert AtomicMap.convert(input, safe: true) == expected
+  end
+
+  test "works with mixed keys (string / atoms)" do
+    input    = [ %{"c" => 1}, %{:c => 2}, %{"c" => %{:b => 4}}]
+    expected = [%{c: 1}, %{c: 2}, %{c: %{b: 4}}]
+    assert AtomicMap.convert(input, safe: true) == expected
+  end
+
+  test "works with simple values" do
+    input    = "2"
+    expected = "2"
+    assert AtomicMap.convert(input, safe: true) == expected
+  end
+
   test "raises for not existing atoms" do
     assert_raise ArgumentError, fn ->
       input = %{"a" => 2, "b" => %{"c" => 4}, "__not___existing__" => 5}