add custom validation mechanism.

Author: vacarsu

lib/scenic/themes.ex

@@ -4,6 +4,11 @@ defmodule Scenic.Themes do
   By registering themes in this way you can safely pull in themes from external libraries,
   without theme names colliding, as well as get all the validation.
 
+  You can add additional keys to be validated on your custom themes by returning a tuple with your map of themes and a list of keys to be validated
+  from your load function.
+
+  All themes will validate against the default schema. If you provide additional keys, the list will get merged with the list of default keys.
+
   ### Required Configuration
   Setting up themes requires some initial setup.
 
@@ -23,13 +28,15 @@ defmodule Scenic.Themes do
       text: @text
     }
 
+    schema [:surface] # add additional required keys to your theme
+
     use Scenic.Themes,
       sources: [
         {:scenic, Scenic.Themes"},
         {:my_app, load()}
       ]
 
-    def load(), do: @themes
+    def load(), do: {@themes, @schema}
   end
   ```
 
@@ -42,67 +49,41 @@ defmodule Scenic.Themes do
 
   Now themes are passed around scenic in the form of `{:library_name, :theme_name}` as opposed to just :theme_name.
   """
-
-  @theme_light %{
-    text: :black,
-    background: :white,
-    border: :dark_grey,
-    active: {215, 215, 215},
-    thumb: :cornflower_blue,
-    focus: :blue,
-    highlight: :saddle_brown
-  }
-
-  @theme_dark %{
-    text: :white,
-    background: :black,
-    border: :light_grey,
-    active: {40, 40, 40},
-    thumb: :cornflower_blue,
-    focus: :cornflower_blue,
-    highlight: :sandy_brown
-  }
-
-  @primary Map.merge(@theme_dark, %{background: {72, 122, 252}, active: {58, 94, 201}})
-  @secondary Map.merge(@theme_dark, %{background: {111, 117, 125}, active: {86, 90, 95}})
-  @success Map.merge(@theme_dark, %{background: {99, 163, 74}, active: {74, 123, 56}})
-  @danger Map.merge(@theme_dark, %{background: {191, 72, 71}, active: {164, 54, 51}})
-  @warning Map.merge(@theme_light, %{background: {239, 196, 42}, active: {197, 160, 31}})
-  @info Map.merge(@theme_dark, %{background: {94, 159, 183}, active: {70, 119, 138}})
-  @text Map.merge(@theme_dark, %{text: {72, 122, 252}, background: :clear, active: :clear})
-  @themes %{
-    light: @theme_light,
-    dark: @theme_dark,
-    primary: @primary,
-    secondary: @secondary,
-    success: @success,
-    danger: @danger,
-    warning: @warning,
-    info: @info,
-    text: @text
-  }
-
-  @callback load() :: list
+  @callback load() :: {map, list} | map
+  @optional_callbacks load: 0
 
   defmacro __using__(using_opts \\ []) do
     quote do
       alias Scenic.Primitive.Style.Paint.Color
       @behaviour Scenic.Themes
       @sources Keyword.get(unquote(using_opts), :sources, [])
+      @default_schema [:text, :background, :border, :active, :thumb, :focus]
+
       @library_themes Enum.reduce(@sources, %{}, fn
         {lib, module}, acc when is_atom(module) ->
-          themes = module.load()
-          Map.put_new(acc, lib, themes)
+          case module.load() do
+            {themes, schema} ->
+              Map.put_new(acc, lib, {themes, List.flatten([@default_schema | schema])})
+            themes ->
+              Map.put_new(acc, lib, {themes, @default_schema})
+          end
+        {lib, {themes, schema}}, acc ->
+          Map.put_new(acc, lib, {themes, List.flatten([@default_schema | schema])})
         {lib, themes}, acc ->
-          Map.put_new(acc, lib, themes)
+          Map.put_new(acc, lib, {themes, @default_schema})
         _, acc -> acc
       end)
 
       def validate(theme)
-      def validate({lib, theme} = lib_theme) when is_atom(theme) do
+      def validate({lib, theme_name} = lib_theme) when is_atom(theme_name) do
+        {_, schema} = Map.get(@library_themes, lib)
         case normalize(lib_theme) do
-          map when is_map(map) ->
-            {:ok, lib_theme}
+          theme ->
+            # validate against the schema
+            case validate(theme, schema) do
+              {:ok, _} -> {:ok, lib_theme}
+              error -> error
+            end
           nil ->
             {
               :error,
@@ -118,6 +99,23 @@ defmodule Scenic.Themes do
         end
       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(
             %{
               text: _,
@@ -128,6 +126,8 @@ defmodule Scenic.Themes do
               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
@@ -153,6 +153,7 @@ defmodule Scenic.Themes do
           You passed in a map, but it didn't include all the required color specifications.
           It must contain a valid color for each of the following entries.
             :text, :background, :border, :active, :thumb, :focus
+          If you're using a custom theme please check the documentation for that specific theme.
           #{IO.ANSI.default_color()}
           """
         }
@@ -176,6 +177,37 @@ defmodule Scenic.Themes do
         }
       end
 
+      @doc false
+      def normalize({lib, theme_name}) when is_atom(theme_name) do
+        case Map.get(@library_themes, lib) do
+          {themes, schema} -> Map.get(themes, theme_name)
+          nil -> nil
+        end
+      end
+
+      def normalize(theme) when is_map(theme), do: theme
+
+      @doc false
+      def preset({lib, theme_name}) do
+        case Map.get(@library_themes, lib) do
+          {themes, schema} -> Map.get(themes, theme_name)
+          nil -> nil
+        end
+      end
+
+      defp err_key(key, map) do
+        {
+          :error,
+          """
+          #{IO.ANSI.red()}Invalid theme specification
+          Received: #{inspect(map)}
+          #{IO.ANSI.yellow()}
+          Map entry: #{inspect(key)}
+          #{IO.ANSI.default_color()}
+          """
+        }
+      end
+
       defp err_color(key, msg) do
         {
           :error,
@@ -186,17 +218,10 @@ defmodule Scenic.Themes do
           """
         }
       end
-
-      @doc false
-      def normalize({lib, theme}) when is_atom(theme), do: Map.get(Map.get(@library_themes, lib), theme)
-      def normalize(theme) when is_map(theme), do: theme
-
-      @doc false
-      def preset({lib, theme}), do: Map.get(Map.get(@library_themes, lib), theme)
     end
   end
 
-  @moduledoc false
+  @doc false
   def module() do
     with {:ok, config} <- Application.fetch_env(:scenic, :themes),
          {:ok, module} <- Keyword.fetch(config, :module) do
@@ -226,12 +251,54 @@ defmodule Scenic.Themes do
     end
   end
 
+  @doc false
   def validate(theme), do: module().validate(theme)
 
+  @doc false
   def normalize(theme), do: module().normalize(theme)
 
+  @doc false
   def preset(theme), do: module().preset(theme)
 
+  @theme_light %{
+    text: :black,
+    background: :white,
+    border: :dark_grey,
+    active: {215, 215, 215},
+    thumb: :cornflower_blue,
+    focus: :blue,
+    highlight: :saddle_brown
+  }
+
+  @theme_dark %{
+    text: :white,
+    background: :black,
+    border: :light_grey,
+    active: {40, 40, 40},
+    thumb: :cornflower_blue,
+    focus: :cornflower_blue,
+    highlight: :sandy_brown
+  }
+
+  @primary Map.merge(@theme_dark, %{background: {72, 122, 252}, active: {58, 94, 201}})
+  @secondary Map.merge(@theme_dark, %{background: {111, 117, 125}, active: {86, 90, 95}})
+  @success Map.merge(@theme_dark, %{background: {99, 163, 74}, active: {74, 123, 56}})
+  @danger Map.merge(@theme_dark, %{background: {191, 72, 71}, active: {164, 54, 51}})
+  @warning Map.merge(@theme_light, %{background: {239, 196, 42}, active: {197, 160, 31}})
+  @info Map.merge(@theme_dark, %{background: {94, 159, 183}, active: {70, 119, 138}})
+  @text Map.merge(@theme_dark, %{text: {72, 122, 252}, background: :clear, active: :clear})
+  @themes %{
+    light: @theme_light,
+    dark: @theme_dark,
+    primary: @primary,
+    secondary: @secondary,
+    success: @success,
+    danger: @danger,
+    warning: @warning,
+    info: @info,
+    text: @text
+  }
+
   @doc false
   def load(), do: @themes
 end

test/scenic/themes_test.exs

@@ -63,6 +63,24 @@ defmodule Scenic.ThemesTest do
     assert Themes.normalize({:scenic, :dark}) == @theme_dark
   end
 
+  test "custom validate method accepts names 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})
+    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}}

test/support/custom_themes.ex

@@ -0,0 +1,62 @@
+defmodule Scenic.Test.CustomThemes do
+  @theme_light %{
+    text: :black,
+    background: :white,
+    surface: :gainsboro,
+    border: :dark_grey,
+    active: {215, 215, 215},
+    thumb: :cornflower_blue,
+    focus: :blue,
+    highlight: :saddle_brown
+  }
+
+  @theme_dark %{
+    text: :white,
+    background: :black,
+    surface: :gainsboro,
+    border: :light_grey,
+    active: {40, 40, 40},
+    thumb: :cornflower_blue,
+    focus: :cornflower_blue,
+    highlight: :sandy_brown
+  }
+
+  @theme_dark_invalid %{
+    text: :white,
+    background: :black,
+    border: :light_grey,
+    active: {40, 40, 40},
+    thumb: :cornflower_blue,
+    focus: :cornflower_blue
+  }
+
+  @primary Map.merge(@theme_dark, %{surface: :gainsboro, background: {72, 122, 252}, active: {58, 94, 201}})
+  @secondary Map.merge(@theme_dark, %{surface: :gainsboro, background: {111, 117, 125}, active: {86, 90, 95}})
+  @success Map.merge(@theme_dark, %{surface: :gainsboro, background: {99, 163, 74}, active: {74, 123, 56}})
+  @danger Map.merge(@theme_dark, %{surface: :gainsboro, background: {191, 72, 71}, active: {164, 54, 51}})
+  @warning Map.merge(@theme_light, %{surface: :gainsboro, background: {239, 196, 42}, active: {197, 160, 31}})
+  @info Map.merge(@theme_dark, %{surface: :gainsboro, background: {94, 159, 183}, active: {70, 119, 138}})
+  @text Map.merge(@theme_dark, %{text: {72, 122, 252}, surface: :gainsboro, background: :clear, active: :clear})
+
+  @themes %{
+    custom_light: @theme_light,
+    custom_dark: @theme_dark,
+    custom_primary: @primary,
+    custom_secondary: @secondary,
+    custom_success: @success,
+    custom_danger: @danger,
+    custom_warning: @warning,
+    custom_info: @info,
+    custom_text: @text,
+    custom_invalid: @theme_dark_invalid
+  }
+
+  @schema [:surface]
+
+  use Scenic.Themes,
+    sources: [
+      {:custom_scenic, {@themes, @schema}}
+    ]
+
+  def load(), do: {@themes, @schema}
+end