Improves testing (#41)

* Adds test coverage
* Adds doctests
* Groups predicates into module and adds doctests
* Fixes bug when referencing root schema

Author: dragonwasrobot

README.md

@@ -201,3 +201,13 @@ that have references across files, e.g.
 then the corresponding Elm file, `Domain.Circle`, will import the
 definitions (types, encoders and decoders) from the other Elm module,
 `Domain/Definitions.elm`.
+
+## Tests
+
+Run the standard mix task
+
+    mix test
+
+for test coverage run
+
+    mix coveralls.html

lib/parser.ex

@@ -8,7 +8,7 @@ defmodule JS2E.Parser do
   alias JS2E.Parsers.{ArrayParser, ObjectParser, EnumParser, PrimitiveParser,
                       DefinitionsParser, AllOfParser, AnyOfParser, OneOfParser,
                       UnionParser, TypeReferenceParser}
-  alias JS2E.{TypePath, Types}
+  alias JS2E.{TypePath, Types, Predicates}
   alias JS2E.Types.SchemaDefinition
 
   @type nodeParser :: (
@@ -77,7 +77,7 @@ defmodule JS2E.Parser do
 
   @spec parse_definitions(map, URI.t) :: Types.typeDictionary
   defp parse_definitions(schema_root_node, schema_id) do
-    if definitions?(schema_root_node) do
+    if Predicates.definitions?(schema_root_node) do
       schema_root_node
       |> DefinitionsParser.parse(schema_id, nil, ["#"], "")
     else
@@ -92,15 +92,15 @@ defmodule JS2E.Parser do
     name = "#"
 
     cond do
-      ref_type?(schema_root_node) ->
+      Predicates.ref_type?(schema_root_node) ->
         schema_root_node
         |> TypeReferenceParser.parse(schema_id, schema_id, type_path, name)
 
-      object_type?(schema_root_node) ->
+      Predicates.object_type?(schema_root_node) ->
         schema_root_node
         |> parse_type(schema_id, [], name)
 
-      array_type?(schema_root_node) ->
+      Predicates.array_type?(schema_root_node) ->
         schema_root_node
         |> parse_type(schema_id, [], name)
 
@@ -161,16 +161,16 @@ defmodule JS2E.Parser do
   defp determine_node_parser(schema_node) do
 
     predicate_node_type_pairs = [
-      {&ref_type?/1, &TypeReferenceParser.parse/5},
-      {&enum_type?/1, &EnumParser.parse/5},
-      {&union_type?/1, &UnionParser.parse/5},
-      {&all_of_type?/1, &AllOfParser.parse/5},
-      {&any_of_type?/1, &AnyOfParser.parse/5},
-      {&one_of_type?/1, &OneOfParser.parse/5},
-      {&object_type?/1, &ObjectParser.parse/5},
-      {&array_type?/1, &ArrayParser.parse/5},
-      {&primitive_type?/1, &PrimitiveParser.parse/5},
-      {&definitions?/1, &DefinitionsParser.parse/5}
+      {&Predicates.ref_type?/1, &TypeReferenceParser.parse/5},
+      {&Predicates.enum_type?/1, &EnumParser.parse/5},
+      {&Predicates.union_type?/1, &UnionParser.parse/5},
+      {&Predicates.all_of_type?/1, &AllOfParser.parse/5},
+      {&Predicates.any_of_type?/1, &AnyOfParser.parse/5},
+      {&Predicates.one_of_type?/1, &OneOfParser.parse/5},
+      {&Predicates.object_type?/1, &ObjectParser.parse/5},
+      {&Predicates.array_type?/1, &ArrayParser.parse/5},
+      {&Predicates.primitive_type?/1, &PrimitiveParser.parse/5},
+      {&Predicates.definitions?/1, &DefinitionsParser.parse/5}
     ]
 
     predicate_node_type_pairs
@@ -194,54 +194,4 @@ defmodule JS2E.Parser do
     end
   end
 
-  @spec definitions?(map) :: boolean
-  defp definitions?(schema_node) do
-    Map.has_key?(schema_node, "definitions")
-  end
-
-  @spec primitive_type?(map) :: boolean
-  defp primitive_type?(schema_node) do
-    schema_node["type"] in ["null", "boolean", "string", "number", "integer"]
-  end
-
-  @spec ref_type?(map) :: boolean
-  defp ref_type?(schema_node) do
-    Map.has_key?(schema_node, "$ref")
-  end
-
-  @spec enum_type?(map) :: boolean
-  defp enum_type?(schema_node) do
-    Map.has_key?(schema_node, "enum")
-  end
-
-  @spec all_of_type?(map) :: boolean
-  defp all_of_type?(schema_node) do
-    Map.get(schema_node, "allOf")
-  end
-
-  @spec any_of_type?(map) :: boolean
-  defp any_of_type?(schema_node) do
-    Map.get(schema_node, "anyOf")
-  end
-
-  @spec one_of_type?(map) :: boolean
-  defp one_of_type?(schema_node) do
-    Map.get(schema_node, "oneOf")
-  end
-
-  @spec union_type?(map) :: boolean
-  defp union_type?(schema_node) do
-    is_list(schema_node["type"])
-  end
-
-  @spec object_type?(map) :: boolean
-  defp object_type?(schema_node) do
-    schema_node["type"] == "object" && Map.has_key?(schema_node, "properties")
-  end
-
-  @spec array_type?(map) :: boolean
-  defp array_type?(schema_node) do
-    schema_node["type"] == "array" && Map.has_key?(schema_node, "items")
-  end
-
 end

lib/parsers/object_parser.ex

@@ -63,9 +63,20 @@ defmodule JS2E.Parsers.ObjectParser do
     end)
   end
 
+  @doc ~S"""
+  Creates a property dictionary based on a type dictionary and a type path.
+
+  ## Examples
+
+      iex> type_dict = %{}
+      ...> path = JS2E.TypePath.from_string("#")
+      ...> JS2E.Parsers.ObjectParser.create_property_dict(type_dict, path)
+      %{}
+
+  """
   @spec create_property_dict(Types.typeDictionary, TypePath.t)
   :: Types.propertyDictionary
-  defp create_property_dict(type_dict, path) do
+  def create_property_dict(type_dict, path) do
     type_dict
     |> Enum.reduce(%{}, fn({child_path, child_type}, reference_dict) ->
       child_type_path = TypePath.add_child(path, child_type.name)

lib/parsers/util.ex

@@ -47,7 +47,7 @@ defmodule JS2E.Parsers.Util do
   end
 
   @doc ~S"""
-  Returns a list of type paths based when given a type dictionary.
+  Returns a list of type paths when given a type dictionary.
   """
   @spec create_types_list(Types.typeDictionary, TypePath.t) :: [TypePath.t]
   def create_types_list(type_dict, path) do

lib/predicates.ex

@@ -0,0 +1,212 @@
+defmodule JS2E.Predicates do
+  @moduledoc ~S"""
+  Contains various predicate functions for working with json schemas.
+  """
+
+  @doc ~S"""
+  Returns true if the json schema contains a 'definitions' property.
+
+  ## Examples
+
+      iex> JS2E.Predicates.definitions?(%{"title" => "A fancy title"})
+      false
+
+      iex> JS2E.Predicates.definitions?(%{"definitions" => %{}})
+      true
+
+  """
+  @spec definitions?(map) :: boolean
+  def definitions?(schema_node) do
+    definitions = schema_node["definitions"]
+    is_map(definitions)
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents a primitive type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.primitive_type?(%{})
+      false
+
+      iex> JS2E.Predicates.primitive_type?(%{"type" => "object"})
+      false
+
+      iex> JS2E.Predicates.primitive_type?(%{"type" => "boolean"})
+      true
+
+      iex> JS2E.Predicates.primitive_type?(%{"type" => "integer"})
+      true
+
+  """
+  @spec primitive_type?(map) :: boolean
+  def primitive_type?(schema_node) do
+    type = schema_node["type"]
+    type in ["null", "boolean", "string", "number", "integer"]
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents a reference to another schema.
+
+  ## Examples
+
+      iex> JS2E.Predicates.ref_type?(%{})
+      false
+
+      iex> JS2E.Predicates.ref_type?(%{"$ref" => "#foo"})
+      true
+
+  """
+  @spec ref_type?(map) :: boolean
+  def ref_type?(schema_node) do
+    ref = schema_node["$ref"]
+    is_binary(ref)
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents an enum type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.enum_type?(%{})
+      false
+
+      iex> JS2E.Predicates.enum_type?(%{"enum" => ["red", "yellow", "green"]})
+      true
+
+  """
+  @spec enum_type?(map) :: boolean
+  def enum_type?(schema_node) do
+    enum = schema_node["enum"]
+    is_list(enum)
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents an allOf type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.all_of_type?(%{})
+      false
+
+      iex> JS2E.Predicates.all_of_type?(%{"allOf" => []})
+      false
+
+      iex> JS2E.Predicates.all_of_type?(%{"allOf" => [%{"$ref" => "#foo"}]})
+      true
+
+  """
+  @spec all_of_type?(map) :: boolean
+  def all_of_type?(schema_node) do
+    all_of = schema_node["allOf"]
+    is_list(all_of) && length(all_of) > 0
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents an anyOf type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.any_of_type?(%{})
+      false
+
+      iex> JS2E.Predicates.any_of_type?(%{"anyOf" => []})
+      false
+
+      iex> JS2E.Predicates.any_of_type?(%{"anyOf" => [%{"$ref" => "#foo"}]})
+      true
+
+  """
+  @spec any_of_type?(map) :: boolean
+  def any_of_type?(schema_node) do
+    any_of = schema_node["anyOf"]
+    is_list(any_of) && length(any_of) > 0
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents an oneOf type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.one_of_type?(%{})
+      false
+
+      iex> JS2E.Predicates.one_of_type?(%{"oneOf" => []})
+      false
+
+      iex> JS2E.Predicates.one_of_type?(%{"oneOf" => [%{"$ref" => "#foo"}]})
+      true
+
+  """
+  @spec one_of_type?(map) :: boolean
+  def one_of_type?(schema_node) do
+    one_of = schema_node["oneOf"]
+    is_list(one_of) && length(one_of) > 0
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents a union type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.union_type?(%{})
+      false
+
+      iex> JS2E.Predicates.union_type?(%{"type" => ["number", "integer", "string"]})
+      true
+
+  """
+  @spec union_type?(map) :: boolean
+  def union_type?(schema_node) do
+    type = schema_node["type"]
+    is_list(type)
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents an allOf type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.object_type?(%{})
+      false
+
+      iex> JS2E.Predicates.object_type?(%{"type" => "object"})
+      false
+
+      iex> anObject = %{"type" => "object",
+      ...>              "properties" => %{"name" => %{"type" => "string"}}}
+      iex> JS2E.Predicates.object_type?(anObject)
+      true
+
+  """
+  @spec object_type?(map) :: boolean
+  def object_type?(schema_node) do
+    type = schema_node["type"]
+    properties = schema_node["properties"]
+    type == "object" && is_map(properties)
+  end
+
+  @doc ~S"""
+  Returns true if the json subschema represents an array type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.array_type?(%{})
+      false
+
+      iex> JS2E.Predicates.array_type?(%{"type" => "array"})
+      false
+
+      iex> anArray = %{"type" => "array", "items" => %{"$ref" => "#foo"}}
+      iex> JS2E.Predicates.array_type?(anArray)
+      true
+
+  """
+  @spec array_type?(map) :: boolean
+  def array_type?(schema_node) do
+    type = schema_node["type"]
+    items = schema_node["items"]
+    type == "array" && is_map(items)
+  end
+
+end

lib/printers/enum_printer.ex

@@ -152,6 +152,8 @@ defmodule JS2E.Printers.EnumPrinter do
 
   @spec create_elm_value(String.t, String.t) :: String.t
   defp create_elm_value(value, type) do
+    Logger.debug "Value: #{value}, Type: #{type}"
+
     case type do
       "string" ->
         upcase_first value