Merge branch 'master' of https://github.com/kempt09/recase

lib/recase/cases/camel_case.ex

@@ -23,8 +23,4 @@ defmodule Recase.CamelCase do
            rejoin(value, separator: "", case: :title),
          do: String.downcase(<<char::utf8>>) <> rest
   end
-
-  @spec convert(atom()) :: atom()
-  def convert(value) when is_atom(value),
-    do: convert(Atom.to_string(value)) |> Recase.Generic.safe_atom()
 end

lib/recase/cases/constant_case.ex

@@ -18,8 +18,4 @@ defmodule Recase.ConstantCase do
   @spec convert(String.t()) :: String.t()
   def convert(value) when is_binary(value),
     do: rejoin(value, separator: "_", case: :up)
-
-  @spec convert(atom()) :: atom()
-  def convert(value) when is_atom(value),
-    do: convert(Atom.to_string(value)) |> Recase.Generic.safe_atom()
 end

lib/recase/cases/generic.ex

@@ -1,6 +1,6 @@
 defmodule Recase.Generic do
   @moduledoc """
-  Generic module to split and join strings back or convert strings to atoms.
+  Generic module to split and join strings back.
 
   This module should not be used directly.
   """
@@ -82,19 +82,6 @@ defmodule Recase.Generic do
     |> Enum.join(Keyword.get(opts, :separator, ?_))
   end
 
-  @doc """
-  Atomizes a string value.
-  Uses an existing atom if possible.
-  """
-  @spec safe_atom(String.t()) :: atom()
-  def safe_atom(string_value) do
-    try do
-      String.to_existing_atom(string_value)
-   rescue
-       ArgumentError -> String.to_atom(string_value)
-   end
-  end
-
   ##############################################################################
 
   @spec do_split(input :: String.t(), {binary(), acc :: [String.t()]}) :: [

lib/recase/cases/pascal_case.ex

@@ -31,8 +31,4 @@ defmodule Recase.PascalCase do
   @spec convert(String.t()) :: String.t()
   def convert(value) when is_binary(value),
     do: rejoin(value, separator: "", case: :title)
-
-  @spec convert(atom()) :: atom()
-  def convert(value) when is_atom(value),
-    do: convert(Atom.to_string(value)) |> Recase.Generic.safe_atom()
 end

lib/recase/cases/snake_case.ex

@@ -22,8 +22,4 @@ defmodule Recase.SnakeCase do
   @spec convert(String.t()) :: String.t()
   def convert(value) when is_binary(value),
     do: rejoin(value, separator: @sep, case: :down)
-
-  @spec convert(atom()) :: atom()
-  def convert(value) when is_atom(value),
-    do: convert(Atom.to_string(value)) |> Recase.Generic.safe_atom()
 end

lib/recase/utils/enumerable.ex

@@ -20,8 +20,7 @@ defmodule Recase.Enumerable do
     end)
   end
 
-  def atomize_keys(enumerable, fun)
-      when is_list(enumerable) do
+  def atomize_keys(enumerable, fun) when is_list(enumerable) do
     enumerable
     |> Enum.map(fn value -> handle_value(value, fun, &atomize_keys/2) end)
   end
@@ -30,17 +29,14 @@ defmodule Recase.Enumerable do
   Invoke fun for each keys of the enumerable.
   """
   @spec convert_keys(Enumerable.t(), fun) :: Enumerable.t()
-  def convert_keys(enumerable, fun \\ fn x -> x end)
-
   def convert_keys(enumerable, fun) when is_map(enumerable) do
     enumerable
     |> Enum.into(%{}, fn {key, value} ->
       {fun.(key), handle_value(value, fun, &convert_keys/2)}
     end)
   end
 
-  def convert_keys(enumerable, fun)
-      when is_list(enumerable) do
+  def convert_keys(enumerable, fun) when is_list(enumerable) do
     enumerable
     |> Enum.map(fn value -> handle_value(value, fun, &convert_keys/2) end)
   end

test/recase_test/camel_case_test.exs

@@ -16,13 +16,6 @@ defmodule Recase.CamelCaseTest do
     assert convert("camel-casE") == "camelCasE"
   end
 
-  test "should camel case atoms" do
-    assert convert(:camel_case) == :camelCase
-    assert convert(:CamelCase) == :camelCase
-    assert convert(:camelCase) == :camelCase
-    assert convert(:CAMelCase) == :camelCase
-  end
-
   test "should not modify extra chars" do
     assert convert("!#$%^&*(){}[]~`'\"") == "$%^&*(){}[]~`'\""
   end

test/recase_test/constant_case_test.exs

@@ -19,13 +19,6 @@ defmodule Recase.ConstantCaseTest do
     assert convert("constant?!case") == expected
   end
 
-  test "should constant case atoms" do
-    expected = :CONSTANT_CASE
-    assert convert(:constantCase) == expected
-    assert convert(:constant_Case) == expected
-    assert convert(:ConstantCase) == expected
-  end
-
   test "should return single letter" do
     assert convert("a") == "A"
   end

test/recase_test/pascal_case_test.exs

@@ -14,12 +14,6 @@ defmodule Recase.PascalCaseTest do
     assert convert("UpperCase") == "UpperCase"
   end
 
-  test "should pascal case atoms" do
-    assert convert(:upper_case) == :UpperCase
-    assert convert(:upperCase) == :UpperCase
-    assert convert(:UpperCase) == :UpperCase
-  end
-
   test "should not modify extra chars" do
     assert convert("!#$%^&*(){}[]~`'\"") == "$%^&*(){}[]~`'\""
   end

test/recase_test/snake_case_test.exs

@@ -18,13 +18,6 @@ defmodule Recase.SnakeCaseTest do
     assert convert("snake?!case") == "snake_case"
   end
 
-  test "should snake case atoms" do
-    assert convert(:snakeCase) == :snake_case
-    assert convert(:Snake_Case) == :snake_case
-    assert convert(:SnakeCase) == :snake_case
-    assert convert(:SNAKE_CASE) == :snake_case
-  end
-
   test "should return single letter" do
     assert convert("a") == "a"
   end