Combine class/3 and class_name/3 with third argument with default value

Author: EasterPeanut

lib/ex_css_modules/ex_css_modules.ex

@@ -48,88 +48,45 @@ defmodule ExCSSModules do
   attribute. The `keys` argument is used to retrieve the class name or multiple
   class names with class_name/1.
 
+  Returns nil if `return_class?` is falsy. `return_class?` is optional and
+  truthy by default.
+
   Returns nil for a class_name that does not exist.
 
   ## Examples
 
       iex> class(%{ "hello" => "world"}, "hello")
       {:safe, ~s(class="world")}
 
-      iex> class(%{"hello" => "world"}, "foo")
-      nil
-
-  """
-  def class(definition, keys) do
-    definition
-    |> class_name(keys)
-    |> class_attribute()
-  end
-
-  @doc """
-  If `return_class?` is truthy, reads the class definitions and maps them to a
-  class attribute. When `return_class?` is falsy returns nil.
-
-  ## Examples
-
-      iex> class(%{ "hello" => "world"}, "hello", true)
+      iex> class(%{ "hello" => "world"}, :hello, true)
       {:safe, ~s(class="world")}
 
       iex> class(%{ "hello" => "world"}, "hello", false)
       nil
 
+      iex> class(%{"hello" => "world"}, "foo")
+      nil
+
   """
-  def class(definition, keys, return_class?) do
+  def class(definition, keys, return_class? \\ true) do
     definition
     |> class_name(keys, return_class?)
     |> class_attribute()
   end
 
-  @doc """
-  Returns the class name from the definition map if the last argument is truthy.
-  Returns nil if the last argument is falsy.
-
-  ## Examples
-
-      iex> class_name(%{"hello" => "world"}, "hello", true)
-      "world"
-
-      iex> class_name(%{"hello" => "world"}, "hello", "anything")
-      "world"
-
-      iex> class_name(%{"hello" => "world"}, :hello, true)
-      "world"
-
-      iex> class_name(%{"hello" => "world"}, "hello", false)
-      nil
-
-      iex> class_name(%{"hello" => "world"}, "hello", nil)
-      nil
-
-  """
-  def class_name(_, _, false), do: nil
-  def class_name(_, _, nil), do: nil
-  def class_name(definition, key, _), do: class_name(definition, key)
-
   @doc """
   Returns the class name or class names from the definition map, concatenated as
   one string separated by spaces.
 
-  Second argument can be a string or atom name of the key, a tuple with
-  `{key, boolean}` or a list of keys or tuples.
-
-  ## Examples
+  Second argument `key` can be a string or atom name of the key, a tuple with
+  `{key, boolean}` or a list of either keys or tuples.
 
-      iex> class_name(%{"hello" => "world"}, "hello")
-      "world"
+  Returns nil if `return_class?` is falsy. `return_class?` is optional and
+  truthy by default.
 
-      iex> class_name(%{"hello" => "world"}, "foo")
-      nil
-
-      iex> class_name(%{"hello" => "world"}, {"hello", true})
-      "world"
+  Returns nil for a key that does not exist.
 
-      iex> class_name(%{"hello" => "world"}, {"hello", false})
-      nil
+  ## Examples
 
       iex> class_name(%{"hello" => "world", "foo" => "bar"}, ["hello", "foo"])
       "world bar"
@@ -143,26 +100,53 @@ defmodule ExCSSModules do
       iex> class_name(%{"hello" => "world", "foo" => "bar"}, [{:hello, true}, {:foo, false}])
       "world"
 
-      iex> class_name(%{"hello" => "world", "foo" => "bar"}, [{"hello", false}])
+      iex> class_name(%{"hello" => "world"}, "hello")
+      "world"
+
+      iex> class_name(%{"hello" => "world"}, :hello, true)
+      "world"
+
+      iex> class_name(%{"hello" => "world"}, "hello", "anything")
+      "world"
+
+      iex> class_name(%{"hello" => "world"}, {"hello", true})
+      "world"
+
+      iex> class_name(%{"hello" => "world"}, "hello", false)
+      nil
+
+      iex> class_name(%{"hello" => "world"}, {:hello, nil})
+      nil
+
+      iex> class_name(%{"hello" => "world"}, "foo")
       nil
 
       iex> class_name(%{}, "hello")
       nil
 
   """
-  def class_name(definition, keys) when is_list(keys) do
+  def class_name(definition, key, return_class? \\ true)
+
+  def class_name(_, _, false), do: nil
+  def class_name(_, _, nil), do: nil
+
+  def class_name(definition, keys, _) when is_list(keys) do
     keys
     |> Enum.map(&class_name(definition, &1))
     |> Enum.reject(&is_nil/1)
     |> join_class_name()
   end
 
-  def class_name(definition, {key, return_class?}), do: class_name(definition, key, return_class?)
+  def class_name(definition, {key, return_class?}, _),
+    do: class_name(definition, key, return_class?)
 
-  def class_name(definition, key) when is_atom(key),
-    do: key |> Atom.to_string() |> (&class_name(definition, &1)).()
+  def class_name(definition, key, _) when is_atom(key) do
+    key
+    |> Atom.to_string()
+    |> (&class_name(definition, &1)).()
+  end
 
-  def class_name(definition, key) do
+  def class_name(definition, key, _) do
     definition
     |> stylesheet()
     |> Map.get(key, nil)