add none raising validate function.

Author: vacarsu

lib/scenic/themes.ex

@@ -111,8 +111,8 @@ defmodule Scenic.Themes do
     end
   end
 
-  def validate(theme)
-  def validate({lib, theme_name} = lib_theme) when is_atom(theme_name) do
+  def validate!(theme)
+  def validate!({lib, theme_name} = lib_theme) when is_atom(theme_name) do
     themes = module().library()
     case Map.get(themes, lib) do
       {themes, schema} ->
@@ -151,7 +151,7 @@ defmodule Scenic.Themes do
     end
   end
 
-  def validate(theme_name) when is_atom(theme_name) do
+  def validate!(theme_name) when is_atom(theme_name) do
     lib = module().library()
     {themes, schema} = Map.get(lib, :scenic)
     case Map.get(themes, theme_name) do
@@ -175,7 +175,7 @@ defmodule Scenic.Themes do
     end
   end
 
-  def validate(
+  def validate!(
         %{
           text: _,
           background: _,
@@ -202,7 +202,7 @@ defmodule Scenic.Themes do
     end)
   end
 
-  def validate(%{} = map) do
+  def validate!(%{} = map) do
     {
       :error,
       """
@@ -218,7 +218,7 @@ defmodule Scenic.Themes do
     }
   end
 
-  def validate(data) do
+  def validate!(data) do
     {
       :error,
       """
@@ -239,6 +239,107 @@ defmodule Scenic.Themes do
     }
   end
 
+  def validate!(
+        theme,
+        schema
+      ) do
+    # we have the schema so we can validate against it.
+    schema
+    |> Enum.reduce({:ok, theme}, fn
+      _, {:error, msg} ->
+        {:error, msg}
+      key, {:ok, _} = acc ->
+        case Map.has_key?(theme, key) do
+          true -> acc
+          false -> err_key(key, theme)
+        end
+    end)
+  end
+
+  def validate(theme)
+  def validate({lib, theme_name} = lib_theme) when is_atom(theme_name) do
+    themes = module().library()
+    case Map.get(themes, lib) do
+      {themes, schema} ->
+        # validate against the schema
+        case Map.get(themes, theme_name) do
+          nil ->
+            {
+              :error,
+              :not_found
+            }
+          theme ->
+            case validate(theme, schema) do
+              {:ok, _} -> {:ok, lib_theme}
+              error -> error
+            end
+        end
+      nil ->
+        {
+          :error,
+          :not_found
+        }
+    end
+  end
+
+  def validate(theme_name) when is_atom(theme_name) do
+    lib = module().library()
+    {themes, schema} = Map.get(lib, :scenic)
+    case Map.get(themes, theme_name) do
+      nil ->
+        {
+          :error,
+          :not_found
+        }
+      theme ->
+        case validate(theme, schema) do
+          {:ok, _} -> {:ok, theme_name}
+          error -> error
+        end
+    end
+  end
+
+  def validate(
+        %{
+          text: _,
+          background: _,
+          border: _,
+          active: _,
+          thumb: _,
+          focus: _
+        } = theme
+      ) do
+    # we dont have the schema so validate against the default,
+    # this is not ideal, but should be fine for now.
+    # we know all the required colors are there.
+    # now make sure they are all valid colors, including any custom added ones.
+    theme
+    |> Enum.reduce({:ok, theme}, fn
+      _, {:error, msg} ->
+        {:error, msg}
+
+      {key, color}, {:ok, _} = acc ->
+        case Color.validate(color) do
+          {:ok, _} -> acc
+          {:error, msg} -> {:error, :invalid_color}
+        end
+    end)
+  end
+
+  def validate(%{} = map) do
+    {
+      :error,
+      :missing_key
+    }
+  end
+
+  def validate(data) do
+    {
+      :error,
+      :invalid
+    }
+  end
+
   def validate(
         theme,
         schema

test/scenic/themes_test.exs

@@ -74,43 +74,43 @@ defmodule Scenic.ThemesTest do
     assert Themes.normalize(:dark) == @theme_dark
   end
 
-  test "custom validate method accepts custom named themes" do
-    assert Themes.validate({:custom_scenic, :custom_dark}) == {:ok, {:custom_scenic, :custom_dark}}
-    assert Themes.validate({:custom_scenic, :custom_light}) == {:ok, {:custom_scenic, :custom_light}}
-    assert Themes.validate({:custom_scenic, :custom_primary}) == {:ok, {:custom_scenic, :custom_primary}}
-    assert Themes.validate({:custom_scenic, :custom_secondary}) == {:ok, {:custom_scenic, :custom_secondary}}
-    assert Themes.validate({:custom_scenic, :custom_success}) == {:ok, {:custom_scenic, :custom_success}}
-    assert Themes.validate({:custom_scenic, :custom_danger}) == {:ok, {:custom_scenic, :custom_danger}}
-    assert Themes.validate({:custom_scenic, :custom_warning}) == {:ok, {:custom_scenic, :custom_warning}}
-    assert Themes.validate({:custom_scenic, :custom_info}) == {:ok, {:custom_scenic, :custom_info}}
-    assert Themes.validate({:custom_scenic, :custom_text}) == {:ok, {:custom_scenic, :custom_text}}
+  test "custom validate! method accepts custom named themes" do
+    assert Themes.validate!({:custom_scenic, :custom_dark}) == {:ok, {:custom_scenic, :custom_dark}}
+    assert Themes.validate!({:custom_scenic, :custom_light}) == {:ok, {:custom_scenic, :custom_light}}
+    assert Themes.validate!({:custom_scenic, :custom_primary}) == {:ok, {:custom_scenic, :custom_primary}}
+    assert Themes.validate!({:custom_scenic, :custom_secondary}) == {:ok, {:custom_scenic, :custom_secondary}}
+    assert Themes.validate!({:custom_scenic, :custom_success}) == {:ok, {:custom_scenic, :custom_success}}
+    assert Themes.validate!({:custom_scenic, :custom_danger}) == {:ok, {:custom_scenic, :custom_danger}}
+    assert Themes.validate!({:custom_scenic, :custom_warning}) == {:ok, {:custom_scenic, :custom_warning}}
+    assert Themes.validate!({:custom_scenic, :custom_info}) == {:ok, {:custom_scenic, :custom_info}}
+    assert Themes.validate!({:custom_scenic, :custom_text}) == {:ok, {:custom_scenic, :custom_text}}
   end
 
   test "custom validate method rejects map without custom standard color" do
-    {:error, msg} = Themes.validate({:custom_scenic, :custom_invalid})
+    {:error, msg} = Themes.validate!({:custom_scenic, :custom_invalid})
     assert msg =~ "Invalid theme specification"
     assert msg =~ "Map entry: :surface"
   end
 
   test "validate accepts the named themes" do
-    assert Themes.validate({:scenic, :dark}) == {:ok, {:scenic, :dark}}
-    assert Themes.validate({:scenic, :light}) == {:ok, {:scenic, :light}}
-    assert Themes.validate({:scenic, :primary}) == {:ok, {:scenic, :primary}}
-    assert Themes.validate({:scenic, :secondary}) == {:ok, {:scenic, :secondary}}
-    assert Themes.validate({:scenic, :success}) == {:ok, {:scenic, :success}}
-    assert Themes.validate({:scenic, :danger}) == {:ok, {:scenic, :danger}}
-    assert Themes.validate({:scenic, :warning}) == {:ok, {:scenic, :warning}}
-    assert Themes.validate({:scenic, :info}) == {:ok, {:scenic, :info}}
-    assert Themes.validate({:scenic, :text}) == {:ok, {:scenic, :text}}
+    assert Themes.validate!({:scenic, :dark}) == {:ok, {:scenic, :dark}}
+    assert Themes.validate!({:scenic, :light}) == {:ok, {:scenic, :light}}
+    assert Themes.validate!({:scenic, :primary}) == {:ok, {:scenic, :primary}}
+    assert Themes.validate!({:scenic, :secondary}) == {:ok, {:scenic, :secondary}}
+    assert Themes.validate!({:scenic, :success}) == {:ok, {:scenic, :success}}
+    assert Themes.validate!({:scenic, :danger}) == {:ok, {:scenic, :danger}}
+    assert Themes.validate!({:scenic, :warning}) == {:ok, {:scenic, :warning}}
+    assert Themes.validate!({:scenic, :info}) == {:ok, {:scenic, :info}}
+    assert Themes.validate!({:scenic, :text}) == {:ok, {:scenic, :text}}
   end
 
   test "validate rejects invalid theme names" do
-    {:error, msg} = Themes.validate(:invalid)
+    {:error, msg} = Themes.validate!(:invalid)
     assert msg =~ "The theme could not be found in library"
   end
 
   test "validate defaults to the scenic library when an atom is passed" do
-    assert Themes.validate(:primary) == {:ok, :primary}
+    assert Themes.validate!(:primary) == {:ok, :primary}
   end
 
   test "validate accepts maps of colors" do
@@ -124,7 +124,7 @@ defmodule Scenic.ThemesTest do
       my_color: :black
     }
 
-    assert Themes.validate(color_map) == {:ok, color_map}
+    assert Themes.validate!(color_map) == {:ok, color_map}
   end
 
   test "validate rejects maps with invalid colors" do
@@ -138,19 +138,23 @@ defmodule Scenic.ThemesTest do
       my_color: :black
     }
 
-    {:error, msg} = Themes.validate(color_map)
+    {:error, msg} = Themes.validate!(color_map)
     assert msg =~ "Map entry: :border"
     assert msg =~ "Invalid Color specification: :invalid"
   end
 
-  test "verify rejects maps without the standard colors" do
+  test "validate! rejects maps without the standard colors" do
     color_map = %{some_name: :red}
-    {:error, msg} = Themes.validate(color_map)
+    {:error, msg} = Themes.validate!(color_map)
     assert msg =~ "didn't include all the required color"
   end
 
-  test "verify rejects invalid values" do
-    {:error, _msg} = Themes.validate("totally wrong")
+  test "validate rejects invalid values" do
+    {:error, _msg} = Themes.validate!("totally wrong")
+  end
+
+  test "validate rejects invalid values and does not raise" do
+    {:error, :invalid} = Themes.validate("totally wrong")
   end
 
   @default_schema [:text, :background, :border, :active, :thumb, :focus]