File generated from /Users/batate/mastery/lib/mastery/core/template_validator.ex by COVER 2019-03-16 at 12:03:51

****************************************************************************

        |  defmodule Mastery.Core.TemplateValidator do
        |    import Mastery.Core.Validator
        |  
        |    def errors(fields) when is_map(fields) do
        |      [ ]
        |      |> require(fields, :name, &validate_name/1)
        |      |> require(fields, :category, &validate_name/1)
        |      |> optional(fields, :instructions, &validate_instructions/1)
        |      |> require(fields, :raw, &validate_raw/1)
        |      |> require(fields, :generators, &validate_generators/1)
     0..|      |> require(fields, :checker, &validate_checker/1)
        |    end
        |    def errors(_fields), do: [{nil, "A map of fields is required"}]
        |  
        |    def validate_name(name) when is_atom(name), do: :ok
        |    def validate_name(_name), do: {:error, "must be an atom"}
        |  
        |    def validate_instructions(instructions) when is_binary(instructions), do: :ok
        |    def validate_instructions(_instructions), do: {:error, "must be a binary"}
        |  
        |    def validate_raw(raw) when is_binary(raw) do
     0..|      if String.match?(raw, ~r{\S}) do
        |        :ok
        |      else
        |        {:error, "can't be blank"}
        |      end
        |    end
        |    def validate_raw(_raw), do: {:error, "must be a string"}
        |  
        |    def validate_generators(generators) when is_map(generators) do
        |      generators
        |      |> Enum.map(&validate_generators/1)
     0..|      |> Enum.reject(&(&1 == :ok))
     0..|      |> case do
        |        [ ] ->
        |          :ok
        |        errors ->
        |          {:errors, errors}
        |      end
        |    end
        |    def validate_generators(_generators), do: {:error, "must be a map"}
        |  
        |    def validate_generator({name, generator})
        |    when is_atom(name) and is_list(generator) do
     0..|      if generator != [ ] do
        |        :ok
        |      else
        |        {:error, "can't be empty"}
        |      end
        |    end
        |    def validate_generator({name, generator})
        |    when is_atom(name) and is_function(generator, 0) do
        |      :ok
        |    end
        |    def validate_generator(_generator),
        |      do: {:error, "must be a string to list or function pair"}
        |  
        |    def validate_checker(checker) when is_function(checker, 2), do: :ok
        |    def validate_checker(_checker), do: {:error, "must be an arity 2 function"}
        |  end