Adds JSON encoders for all JSON schema types. (#30)

* Adds a JSON encoder for 'array' types
* Adds JSON encoders for 'enum' types
* Adds JSON encoders for 'object' types
* Adds JSON encoders for 'oneOf' types
* Adds JSON encoders for 'union' types
* Adds generic 'print_encoder' to printer.ex
* Removes 'Decoders' from the output paths
* Adjusts all type descriptions and tests accordingly
* Now 'imports' Util functions in printers
* Updates example Elm output
* Bumps major version (v2.0) because of breaking changes in JS2E.generate

Author: dragonwasrobot

.gitignore

@@ -1,3 +1,6 @@
+# The packaged executable
+js2e
+
 # The directory Mix will write compiled artifacts to.
 /_build
 

README.md

@@ -1,6 +1,7 @@
 # JSON schema to Elm
 
-Generates Elm types and JSON decoders from JSON schema specifications.
+Generates Elm types, JSON decoders and JSON encoders from JSON schema
+specifications.
 
 ## Installation
 
@@ -9,16 +10,12 @@ and its build tool `mix` installed, this can be done with `brew install elixir`
 or similar.
 
 - Clone this repository: `git clone [email protected]:dragonwasrobot/json-schema-to-elm.git`
-- Compile the project: `MIX_ENV=prod mix deps.get && mix compile`
-- Build an executable: `MIX_ENV=prod mix escript.build`
+- Build an executable: `MIX_ENV=prod mix build`
 - An executable, `js2e`, has now been created in your current working directory.
 
-For further help, look up the documentation on how
-to [install escripts](https://hexdocs.pm/mix/Mix.Tasks.Escript.Install.html).
-
 ## Usage
 
-See `./js2e` for usage instructions.
+Run `./js2e` for usage instructions.
 
 A proper description of which properties are mandatory are how the generator
 works is still in progress, but feel free to take a look at the `examples`

config/test.exs

@@ -0,0 +1,3 @@
+use Mix.Config
+
+config :logger, level: :debug

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

@@ -0,0 +1,84 @@
+module Domain.Circle exposing (..)
+
+-- Schema for a circle shape
+
+import Json.Decode as Decode
+    exposing
+        ( float
+        , int
+        , string
+        , list
+        , succeed
+        , fail
+        , map
+        , maybe
+        , field
+        , at
+        , andThen
+        , oneOf
+        , nullable
+        , Decoder
+        )
+import Json.Decode.Pipeline
+    exposing
+        ( decode
+        , required
+        , optional
+        , custom
+        )
+import Json.Encode as Encode
+    exposing
+        ( Value
+        , float
+        , int
+        , string
+        , list
+        , object
+        )
+import Domain.Definitions
+    exposing
+        ( Color
+        , colorDecoder
+        , encodeColor
+        , Point
+        , pointDecoder
+        , encodePoint
+        )
+
+
+type alias Root =
+    { center : Point
+    , color : Maybe Color
+    , radius : Float
+    }
+
+
+rootDecoder : Decoder Root
+rootDecoder =
+    decode Root
+        |> required "center" pointDecoder
+        |> optional "color" (Decode.string |> andThen colorDecoder |> maybe) Nothing
+        |> required "radius" Decode.float
+
+
+encodeRoot : Root -> Value
+encodeRoot root =
+    let
+        center =
+            [ ( "center", encodePoint root.center ) ]
+
+        color =
+            case root.color of
+                Just color ->
+                    [ ( "color", encodeColor color ) ]
+
+                Nothing ->
+                    []
+
+        radius =
+            [ ( "radius", Encode.float root.radius ) ]
+    in
+        object <|
+            center
+                ++ color
+                ++ radius

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

@@ -1,15 +1,17 @@
-module Domain.Decoders.Definitions exposing (..)
+module Domain.Definitions exposing (..)
 
 -- Schema for common types
 
 import Json.Decode as Decode
     exposing
-        ( int
+        ( float
+        , int
         , string
+        , list
         , succeed
         , fail
-        , list
         , map
+        , maybe
         , field
         , at
         , andThen
@@ -24,6 +26,15 @@ import Json.Decode.Pipeline
         , optional
         , custom
         )
+import Json.Encode as Encode
+    exposing
+        ( Value
+        , float
+        , int
+        , string
+        , list
+        , object
+        )
 
 
 type Color
@@ -61,5 +72,35 @@ colorDecoder color =
 pointDecoder : Decoder Point
 pointDecoder =
     decode Point
-        |> required "x" float
-        |> required "y" float
+        |> required "x" Decode.float
+        |> required "y" Decode.float
+
+
+encodeColor : Color -> Value
+encodeColor color =
+    case color of
+        Red ->
+            Encode.string "red"
+
+        Yellow ->
+            Encode.string "yellow"
+
+        Green ->
+            Encode.string "green"
+
+        Blue ->
+            Encode.string "blue"
+
+
+encodePoint : Point -> Value
+encodePoint point =
+    let
+        x =
+            [ ( "x", Encode.float point.x ) ]
+
+        y =
+            [ ( "y", Encode.float point.y ) ]
+    in
+        object <|
+            x
+                ++ y

examples/example-output-elm-code/Domain/Decoders/Definitions.elm renamed to examples/example-output-elm-code/Domain/Definitions.elm

@@ -97,7 +97,6 @@ defmodule JS2E do
     end
 
     output_path
-    |> Path.join("Decoders")
     |> File.mkdir_p!()
 
     output_path
@@ -107,9 +106,9 @@ defmodule JS2E do
   def generate(json_schema_paths, module_name) do
 
     schema_dict = Parser.parse_schema_files(json_schema_paths)
-    printed_decoders = Printer.print_schemas(schema_dict, module_name)
+    printed_schemas = Printer.print_schemas(schema_dict, module_name)
 
-    printed_decoders
+    printed_schemas
     |> Enum.each(fn{file_path, file_content} ->
       {:ok, file} = File.open file_path, [:write]
       IO.binwrite file, file_content

lib/js2e.ex

@@ -20,9 +20,9 @@ defmodule JS2E.Printer do
       title = schema_def.title
 
       if module_name != "" do
-        "./#{module_name}/Decoders/#{title}.elm"
+        "./#{module_name}/#{title}.elm"
       else
-        "./Decoders/#{title}.elm"
+        "./#{title}.elm"
       end
     end
 
@@ -59,12 +59,17 @@ defmodule JS2E.Printer do
     decoders = values
     |> Enum.map_join("\n\n", &(print_decoder(&1, type_dict, schema_dict)))
 
+    encoders = values
+    |> Enum.map_join("\n\n", &(print_encoder(&1, type_dict, schema_dict)))
+
     """
     #{String.trim(preamble)}
     \n
     #{String.trim(types)}
     \n
     #{String.trim(decoders)}
+    \n
+    #{String.trim(encoders)}
     """
   end
 
@@ -133,12 +138,31 @@ defmodule JS2E.Printer do
     end
   end
 
-  @spec determine_schema_id(URI.t) :: String.t
-  defp determine_schema_id(identifier) do
-    identifier
-    |> URI.parse
-    |> URI.merge("#")
-    |> to_string
+  @spec print_encoder(
+    Types.typeDefinition,
+    Types.typeDictionary,
+    Types.schemaDictionary
+  ) :: String.t
+  def print_encoder(type_def, type_dict, schema_dict) do
+
+    type_to_printer_dict = %{
+      "ArrayType" => &ArrayPrinter.print_encoder/3,
+      "EnumType" => &EnumPrinter.print_encoder/3,
+      "ObjectType" => &ObjectPrinter.print_encoder/3,
+      "PrimitiveType" => &PrimitivePrinter.print_encoder/3,
+      "OneOfType" => &OneOfPrinter.print_encoder/3,
+      "UnionType" => &UnionPrinter.print_encoder/3,
+      "TypeReference" => &TypeReferencePrinter.print_encoder/3
+    }
+
+    struct_name = Util.get_string_name(type_def)
+
+    if Map.has_key?(type_to_printer_dict, struct_name) do
+      printer = type_to_printer_dict[struct_name]
+      printer.(type_def, type_dict, schema_dict)
+    else
+      Logger.error "Error(print_encoder) unknown type: #{inspect struct_name}"
+    end
   end
 
   @spec resolve_type(
@@ -176,7 +200,14 @@ defmodule JS2E.Printer do
     else
       type
     end
+  end
 
+  @spec determine_schema_id(URI.t) :: String.t
+  defp determine_schema_id(identifier) do
+    identifier
+    |> URI.parse
+    |> URI.merge("#")
+    |> to_string
   end
 
 end