camel case map key formatting

Author: Manos Emmanouilidis

lib/poison/encoder.ex

@@ -22,14 +22,14 @@ defmodule Poison.Encode do
       alias String.Chars
       alias Poison.EncodeError
 
-      @compile {:inline, encode_name: 1}
+      @compile {:inline, encode_name: 2}
 
       # Fast path encoding string keys
-      defp encode_name(value) when is_binary(value) do
+      defp encode_name(value, :default) when is_binary(value) do
         value
       end
 
-      defp encode_name(value) do
+      defp encode_name(value, :default) do
         case Chars.impl_for(value) do
           nil ->
             raise EncodeError, value: value,
@@ -38,6 +38,23 @@ defmodule Poison.Encode do
             impl.to_string(value)
         end
       end
+
+      defp encode_name(value, :camel_case) when is_binary(value) do
+        value
+        |> String.split("_", trim: true)
+        |> camelize(:first)
+        |> Enum.join
+      end
+
+      defp encode_name(value, :camel_case) do
+        value
+        |> encode_name(:default)
+        |> encode_name(:camel_case)
+      end
+
+      defp camelize([], _), do: []
+      defp camelize([h | t], :first), do: [String.downcase(h) | camelize(t, :rest)]
+      defp camelize([h | t], _), do: [String.capitalize(h), camelize(t, :rest)]
     end
   end
 end
@@ -83,13 +100,15 @@ defprotocol Poison.Encoder do
   @typep indent :: non_neg_integer
   @typep offset :: non_neg_integer
   @typep strict_keys :: boolean
+  @typep format_keys :: :default | :camel_case
 
   @type options :: %{
     optional(:escape) => escape,
     optional(:pretty) => pretty,
     optional(:indent) => indent,
     optional(:offset) => offset,
     optional(:strict_keys) => strict_keys,
+    optional(:format_keys) => format_keys
   }
 
   @spec encode(t, options) :: iodata
@@ -235,39 +254,55 @@ defimpl Poison.Encoder, for: Map do
 
   def encode(map, options) do
     map
-    |> strict_keys(Map.get(options, :strict_keys, false))
+    |> strict_keys(Map.get(options, :strict_keys, false), options[:format_keys] || :default)
     |> encode(pretty(options), options)
   end
 
   def encode(map, true, options) do
     indent = indent(options)
     offset = offset(options) + indent
     options = offset(options, offset)
+    key_formatter = options[:format_keys] || :default
 
-    fun = &[",\n", spaces(offset), Encoder.BitString.encode(encode_name(&1), options), ": ",
+    fun = &[",\n", spaces(offset), Encoder.BitString.encode(encode_name(&1, key_formatter), options), ": ",
                                    Encoder.encode(:maps.get(&1, map), options) | &2]
     ["{\n", tl(:lists.foldl(fun, [], :maps.keys(map))), ?\n, spaces(offset - indent), ?}]
   end
 
   def encode(map, _, options) do
-    fun = &[?,, Encoder.BitString.encode(encode_name(&1), options), ?:,
+    key_formatter = options[:format_keys] || :default
+    fun = &[?,, Encoder.BitString.encode(encode_name(&1, key_formatter), options), ?:,
                 Encoder.encode(:maps.get(&1, map), options) | &2]
     [?{, tl(:lists.foldl(fun, [], :maps.keys(map))), ?}]
   end
 
-  defp strict_keys(map, false), do: map
-  defp strict_keys(map, true) do
+  defp strict_keys(map, false, _), do: map
+  defp strict_keys(map, true, :default) do
     map
     |> Map.keys
     |> Enum.each(fn key ->
-      name = encode_name(key)
+      name = encode_name(key, :default)
       if Map.has_key?(map, name) do
         raise EncodeError, value: name,
           message: "duplicate key found: #{inspect(key)}"
       end
     end)
     map
   end
+
+  defp strict_keys(map, true, :camel_case) do
+    map
+    |> Map.keys
+    |> Enum.reduce(%{}, fn (key, acc) ->
+      name = encode_name(key, :camel_case)
+      if Map.has_key?(acc, name) do
+        raise EncodeError, value: name,
+          message: "duplicate key found: #{inspect(key)}"
+      end
+      Map.put(acc, name, :ok)
+    end)
+    map
+  end
 end
 
 defimpl Poison.Encoder, for: List do

test/poison/encoder_test.exs

@@ -192,6 +192,24 @@ defmodule Poison.EncoderTest do
     end
   end
 
+  test "camelCase" do
+    camel_case = [format_keys: :camel_case]
+
+    assert to_json(%{one_two: true}, camel_case) == ~s({"oneTwo":true})
+    assert to_json(%{One_two_three: true}, camel_case) == ~s({"oneTwoThree":true})
+    assert to_json(%{"one_two" => true}, camel_case) == ~s({"oneTwo":true})
+
+    camel_and_strict = camel_case ++ [strict_keys: true]
+
+    assert_raise Poison.EncodeError, ~r/duplicate key found/, fn -> 
+      to_json(%{:one_two => true, "one_two" => 4}, camel_and_strict)
+    end
+
+    assert_raise Poison.EncodeError, ~r/duplicate key found/, fn -> 
+      to_json(%{:one_two => true, "_one_two_" => 4}, camel_and_strict)
+    end
+  end
+
   defp to_json(value, options \\ []) do
     value
     |> Poison.Encoder.encode(Map.new(options))