Tuple types (#46)

Adds support for tuple typing for the 'items' property, see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5.

Specifically, the commit contains:
* A tuple type definition
* A tuple type parser + tests
* A tuple type printer + tests

This commit closes issue #3

Author: dragonwasrobot

README.md

@@ -75,6 +75,7 @@ import Json.Decode as Decode
         , map
         , maybe
         , field
+        , index
         , at
         , andThen
         , oneOf
@@ -92,6 +93,7 @@ import Json.Encode as Encode
     exposing
         ( Value
         , object
+        , list
         )
 
 
@@ -206,6 +208,7 @@ import Json.Decode as Decode
         , map
         , maybe
         , field
+        , index
         , at
         , andThen
         , oneOf
@@ -223,6 +226,7 @@ import Json.Encode as Encode
     exposing
         ( Value
         , object
+        , list
         )
 import Domain.Definitions
 
@@ -259,7 +263,10 @@ encodeCircle circle =
         radius =
             [ ( "radius", Encode.float circle.radius ) ]
     in
-        object <| center ++ color ++ radius
+        object <|
+            center
+                ++ color
+                ++ radius
 ```
 
 ## Tests

examples/example-output-elm-code/Domain/Circle.elm

@@ -9,6 +9,7 @@ import Json.Decode as Decode
         , map
         , maybe
         , field
+        , index
         , at
         , andThen
         , oneOf
@@ -26,6 +27,7 @@ import Json.Encode as Encode
     exposing
         ( Value
         , object
+        , list
         )
 import Domain.Definitions
 

examples/example-output-elm-code/Domain/Definitions.elm

@@ -9,6 +9,7 @@ import Json.Decode as Decode
         , map
         , maybe
         , field
+        , index
         , at
         , andThen
         , oneOf
@@ -26,6 +27,7 @@ import Json.Encode as Encode
     exposing
         ( Value
         , object
+        , list
         )
 
 

lib/parser.ex

@@ -7,7 +7,7 @@ defmodule JS2E.Parser do
   require Logger
   alias JS2E.Parsers.{ArrayParser, ObjectParser, EnumParser, PrimitiveParser,
                       DefinitionsParser, AllOfParser, AnyOfParser, OneOfParser,
-                      UnionParser, TypeReferenceParser}
+                      UnionParser, TupleParser, TypeReferenceParser}
   alias JS2E.{TypePath, Types, Predicates}
   alias JS2E.Types.SchemaDefinition
 
@@ -100,6 +100,10 @@ defmodule JS2E.Parser do
         schema_root_node
         |> parse_type(schema_id, [], name)
 
+      Predicates.tuple_type?(schema_root_node) ->
+        schema_root_node
+        |> parse_type(schema_id, [], name)
+
       Predicates.array_type?(schema_root_node) ->
         schema_root_node
         |> parse_type(schema_id, [], name)
@@ -169,6 +173,7 @@ defmodule JS2E.Parser do
       {&Predicates.one_of_type?/1, &OneOfParser.parse/5},
       {&Predicates.object_type?/1, &ObjectParser.parse/5},
       {&Predicates.array_type?/1, &ArrayParser.parse/5},
+      {&Predicates.tuple_type?/1, &TupleParser.parse/5},
       {&Predicates.primitive_type?/1, &PrimitiveParser.parse/5},
       {&Predicates.definitions?/1, &DefinitionsParser.parse/5}
     ]

lib/parsers/tuple_parser.ex

@@ -0,0 +1,50 @@
+defmodule JS2E.Parsers.TupleParser do
+  @behaviour JS2E.Parsers.ParserBehaviour
+  @moduledoc ~S"""
+  Parses a JSON schema array type:
+
+      {
+        "type": "array",
+        "items": [
+          { "$ref": "#/rectangle" },
+          { "$ref": "#/circle" }
+        ]
+      }
+
+  Into a `JS2E.Types.TupleType`.
+  """
+
+  require Logger
+  import JS2E.Parsers.Util
+  alias JS2E.{TypePath, Types}
+  alias JS2E.Types.TupleType
+
+  @doc ~S"""
+  Parses a JSON schema array type into an `JS2E.Types.TupleType`.
+  """
+  @impl JS2E.Parsers.ParserBehaviour
+  @spec parse(map, URI.t, URI.t | nil, TypePath.t, String.t)
+  :: Types.typeDictionary
+  def parse(schema_node, parent_id, id, path, name) do
+    Logger.debug "Parsing '#{inspect path}' as TupleType"
+
+    descendants_types_dict =
+      schema_node
+      |> Map.get("items")
+      |> create_descendants_type_dict(parent_id, path)
+    Logger.debug "Descendants types dict: #{inspect descendants_types_dict}"
+
+    tuple_types =
+      descendants_types_dict
+      |> create_types_list(path)
+    Logger.debug "Tuple types: #{inspect tuple_types}"
+
+    tuple_type = TupleType.new(name, path, tuple_types)
+    Logger.debug "Parsed tuple type: #{inspect tuple_type}"
+
+    tuple_type
+    |> create_type_dict(path, id)
+    |> Map.merge(descendants_types_dict)
+  end
+
+end

lib/predicates.ex

@@ -209,4 +209,28 @@ defmodule JS2E.Predicates do
     type == "array" && is_map(items)
   end
 
+  @doc ~S"""
+  Returns true if the json subschema represents a tuple type.
+
+  ## Examples
+
+      iex> JS2E.Predicates.tuple_type?(%{})
+      false
+
+      iex> JS2E.Predicates.tuple_type?(%{"type" => "array"})
+      false
+
+      iex> aTuple = %{"type" => "array",
+      ...>            "items" => [%{"$ref" => "#foo"}, %{"$ref" => "#bar"}]}
+      iex> JS2E.Predicates.tuple_type?(aTuple)
+      true
+
+  """
+  @spec tuple_type?(map) :: boolean
+  def tuple_type?(schema_node) do
+    type = schema_node["type"]
+    items = schema_node["items"]
+    type == "array" && is_list(items)
+  end
+
 end

lib/printer.ex

@@ -177,7 +177,6 @@ defmodule JS2E.Printer do
   ) :: {Types.typeDefinition, SchemaDefinition.t}
   def resolve_type!(identifier, schema_def, schema_dict) do
     Logger.debug "Looking up '#{inspect identifier}' in #{inspect schema_def}"
-    type_dict = schema_def.types
 
     {resolved_type, resolved_schema_def} = cond do
 

lib/printers/tuple_printer.ex

@@ -0,0 +1,155 @@
+defmodule JS2E.Printers.TuplePrinter do
+  @behaviour JS2E.Printers.PrinterBehaviour
+  @moduledoc """
+  A printer for printing a 'tuple' type decoder.
+  """
+
+  @templates_location Application.get_env(:js2e, :templates_location)
+  @type_location Path.join(@templates_location, "tuple/type.elm.eex")
+  @decoder_location Path.join(@templates_location, "tuple/decoder.elm.eex")
+  @encoder_location Path.join(@templates_location, "tuple/encoder.elm.eex")
+
+  require Elixir.{EEx, Logger}
+  import JS2E.Printers.Util
+  alias JS2E.{Printer, TypePath, Types}
+  alias JS2E.Types.{TupleType, SchemaDefinition}
+
+  EEx.function_from_file(:defp, :type_template, @type_location,
+    [:type_name, :type_fields])
+
+  EEx.function_from_file(:defp, :decoder_template, @decoder_location,
+    [:decoder_name, :type_name, :clauses])
+
+  EEx.function_from_file(:defp, :encoder_template, @encoder_location,
+    [:encoder_name, :type_name, :properties])
+
+  @impl JS2E.Printers.PrinterBehaviour
+  @spec print_type(Types.typeDefinition, SchemaDefinition.t,
+    Types.schemaDictionary) :: String.t
+  def print_type(%TupleType{name: name,
+                            path: _path,
+                            items: types}, schema_def, schema_dict) do
+
+    type_name = upcase_first name
+    type_fields = create_type_fields(types, schema_def, schema_dict)
+
+    type_template(type_name, type_fields)
+  end
+
+  @spec create_type_fields([TypePath.t], SchemaDefinition.t,
+    Types.schemaDictionary) :: [String.t]
+  defp create_type_fields(types, schema_def, schema_dict) do
+    types |> Enum.map(&(create_type_field(&1, schema_def, schema_dict)))
+  end
+
+  @spec create_type_field(TypePath.t, SchemaDefinition.t,
+    Types.schemaDictionary) :: String.t
+  defp create_type_field(type_path, schema_def, schema_dict) do
+    type_path
+    |> Printer.resolve_type!(schema_def, schema_dict)
+    |> create_type_name(schema_def)
+  end
+
+  @impl JS2E.Printers.PrinterBehaviour
+  @spec print_decoder(Types.typeDefinition, SchemaDefinition.t,
+    Types.schemaDictionary) :: String.t
+  def print_decoder(%TupleType{name: name,
+                               path: _path,
+                               items: type_paths},
+    schema_def, schema_dict) do
+
+    decoder_name = "#{name}Decoder"
+    type_name = upcase_first name
+    clauses = create_decoder_clauses(type_paths, schema_def, schema_dict)
+
+    decoder_template(decoder_name, type_name, clauses)
+  end
+
+  @spec create_decoder_clauses(
+    [TypePath.t],
+    SchemaDefinition.t,
+    Types.schemaDictionary
+  ) :: [map]
+  defp create_decoder_clauses(type_paths, schema_def, schema_dict) do
+
+    type_paths
+    |> Enum.map(fn type_path ->
+      create_decoder_clause(type_path, schema_def, schema_dict)
+    end)
+  end
+
+  @spec create_decoder_clause(
+    TypePath.t,
+    SchemaDefinition.t,
+    Types.schemaDictionary
+  ) :: map
+  defp create_decoder_clause(type_path, schema_def, schema_dict) do
+
+    {property_type, resolved_schema_def} =
+      type_path
+      |> Printer.resolve_type!(schema_def, schema_dict)
+
+    decoder_name = create_decoder_name(
+      {property_type, resolved_schema_def}, schema_def)
+
+    cond do
+      union_type?(property_type) || one_of_type?(property_type) ->
+        create_decoder_union_clause(decoder_name)
+
+      enum_type?(property_type) ->
+        property_type_decoder =
+          property_type.type
+          |> determine_primitive_type_decoder!()
+
+        create_decoder_enum_clause(property_type_decoder, decoder_name)
+
+      true ->
+        create_decoder_normal_clause(decoder_name)
+    end
+  end
+
+  defp create_decoder_union_clause(decoder_name) do
+    %{decoder_name: decoder_name}
+  end
+
+  defp create_decoder_enum_clause(property_type_decoder, decoder_name) do
+    %{property_decoder: property_type_decoder,
+      decoder_name: decoder_name}
+  end
+
+  defp create_decoder_normal_clause(decoder_name) do
+    %{decoder_name: decoder_name}
+  end
+
+  @impl JS2E.Printers.PrinterBehaviour
+  @spec print_encoder(Types.typeDefinition, SchemaDefinition.t,
+    Types.schemaDictionary) :: String.t
+  def print_encoder(%TupleType{name: name,
+                               path: _path,
+                               items: type_paths},
+    schema_def, schema_dict) do
+
+    type_name = upcase_first name
+    encoder_name = "encode#{type_name}"
+
+    properties = create_encoder_properties(type_paths, schema_def, schema_dict)
+
+    template = encoder_template(encoder_name, type_name, properties)
+    trim_newlines(template)
+  end
+
+  defp create_encoder_properties(type_paths, schema_def, schema_dict) do
+
+    type_paths
+    |> Enum.map(fn type_path ->
+      Printer.resolve_type!(type_path, schema_def, schema_dict)
+    end)
+    |> Enum.reduce([], fn ({resolved_property, resolved_schema}, properties) ->
+      encoder_name = create_encoder_name(
+      {resolved_property, resolved_schema}, schema_def)
+      updated_property = Map.put(resolved_property, :encoder_name, encoder_name)
+      properties ++ [updated_property]
+    end)
+  end
+
+end

lib/types/array_type.ex

@@ -2,16 +2,6 @@ defmodule JS2E.Types.ArrayType do
   @moduledoc ~S"""
   Represents a custom 'array' type definition in a JSON schema.
 
-  Limitations:
-
-  While the standard states
-
-      The value of "items" MUST be either a schema or array of schemas.
-
-  We limit the value of "items" such that it MUST be a schema and nothing else.
-
-  Furthermore, the "type" keyword MUST be present and have the value "array".
-
   JSON Schema:
 
       "rectangles": {