Elixir 1.6 (#56)

- Adds support for Elixir 1.6 (fixes issues related to a breaking change in the URI module).
- Adds a .formatter.exs file
- Closes #53

Author: dragonwasrobot

.formatter.exs

@@ -0,0 +1,4 @@
+[
+  inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 80
+]

.tool-versions

@@ -1,2 +1,2 @@
 erlang 20.1
-elixir 1.5.1
+elixir 1.6.3

README.md

@@ -39,7 +39,7 @@ so it can be fixed.
 If we supply `js2e` with the following JSON schema file, `definitions.json`:
 ``` json
 {
-    "$schema": "http://json-schema.org/draft-04/schema",
+    "$schema": "http://json-schema.org/draft-04/schema#",
     "title": "Definitions",
     "id": "http://example.com/definitions.json",
     "description": "Schema for common types",
@@ -66,10 +66,10 @@ If we supply `js2e` with the following JSON schema file, `definitions.json`:
 }
 ```
 
-it produces the following Elm file, `Domain/Definitions.elm`:
+it produces the following Elm file, `Data/Definitions.elm`:
 
 ``` elm
-module Domain.Definitions exposing (..)
+module Data.Definitions exposing (..)
 
 -- Schema for common types
 
@@ -177,7 +177,7 @@ that have references across files, e.g.
 
 ``` json
 {
-    "$schema": "http://json-schema.org/draft-04/schema",
+    "$schema": "http://json-schema.org/draft-04/schema#",
     "title": "Circle",
     "id": "http://example.com/circle.json",
     "description": "Schema for a circle shape",
@@ -197,12 +197,12 @@ that have references across files, e.g.
 }
 ```
 
-then the corresponding Elm file, `Domain/Circle.elm`, will import the
+then the corresponding Elm file, `Data/Circle.elm`, will import the
 definitions (types, encoders and decoders) from the other Elm module,
-`Domain/Definitions.elm`.
+`Data/Definitions.elm`.
 
 ``` elm
-module Domain.Circle exposing (..)
+module Data.Circle exposing (..)
 
 -- Schema for a circle shape
 
@@ -233,34 +233,34 @@ import Json.Encode as Encode
         , object
         , list
         )
-import Domain.Definitions
+import Data.Definitions
 
 
 type alias Circle =
-    { center : Domain.Definitions.Point
-    , color : Maybe Domain.Definitions.Color
+    { center : Data.Definitions.Point
+    , color : Maybe Data.Definitions.Color
     , radius : Float
     }
 
 
 circleDecoder : Decoder Circle
 circleDecoder =
     decode Circle
-        |> required "center" Domain.Definitions.pointDecoder
-        |> optional "color" (Decode.string |> andThen Domain.Definitions.colorDecoder |> maybe) Nothing
+        |> required "center" Data.Definitions.pointDecoder
+        |> optional "color" (Decode.string |> andThen Data.Definitions.colorDecoder |> maybe) Nothing
         |> required "radius" Decode.float
 
 
 encodeCircle : Circle -> Value
 encodeCircle circle =
     let
         center =
-            [ ( "center", Domain.Definitions.encodePoint circle.center ) ]
+            [ ( "center", Data.Definitions.encodePoint circle.center ) ]
 
         color =
             case circle.color of
                 Just color ->
-                    [ ( "color", Domain.Definitions.encodeColor color ) ]
+                    [ ( "color", Data.Definitions.encodeColor color ) ]
 
                 Nothing ->
                     []

examples/example-input-json-schemas/circle.json

@@ -1,5 +1,5 @@
 {
-    "$schema": "http://json-schema.org/draft-04/schema",
+    "$schema": "http://json-schema.org/draft-04/schema#",
     "title": "Circle",
     "id": "http://example.com/circle.json",
     "description": "Schema for a circle shape",

examples/example-input-json-schemas/definitions.json

@@ -1,5 +1,5 @@
 {
-    "$schema": "http://json-schema.org/draft-04/schema",
+    "$schema": "http://json-schema.org/draft-04/schema#",
     "title": "Definitions",
     "id": "http://example.com/definitions.json",
     "description": "Schema for common types",

examples/example-output-elm-code/Domain/Circle.elm renamed to examples/example-output-elm-code/Data/Circle.elm

@@ -1,4 +1,4 @@
-module Domain.Circle exposing (..)
+module Data.Circle exposing (..)
 
 -- Schema for a circle shape
 
@@ -29,34 +29,34 @@ import Json.Encode as Encode
         , object
         , list
         )
-import Domain.Definitions
+import Data.Definitions
 
 
 type alias Circle =
-    { center : Domain.Definitions.Point
-    , color : Maybe Domain.Definitions.Color
+    { center : Data.Definitions.Point
+    , color : Maybe Data.Definitions.Color
     , radius : Float
     }
 
 
 circleDecoder : Decoder Circle
 circleDecoder =
     decode Circle
-        |> required "center" Domain.Definitions.pointDecoder
-        |> optional "color" (Decode.string |> andThen Domain.Definitions.colorDecoder |> maybe) Nothing
+        |> required "center" Data.Definitions.pointDecoder
+        |> optional "color" (Decode.string |> andThen Data.Definitions.colorDecoder |> maybe) Nothing
         |> required "radius" Decode.float
 
 
 encodeCircle : Circle -> Value
 encodeCircle circle =
     let
         center =
-            [ ( "center", Domain.Definitions.encodePoint circle.center ) ]
+            [ ( "center", Data.Definitions.encodePoint circle.center ) ]
 
         color =
             case circle.color of
                 Just color ->
-                    [ ( "color", Domain.Definitions.encodeColor color ) ]
+                    [ ( "color", Data.Definitions.encodeColor color ) ]
 
                 Nothing ->
                     []

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

@@ -1,4 +1,4 @@
-module Domain.Definitions exposing (..)
+module Data.Definitions exposing (..)
 
 -- Schema for common types
 

lib/js2e.ex

@@ -14,20 +14,21 @@ defmodule JS2E do
   ## Options
 
       * `--module-name` - the module name prefix for the printed Elm modules \
-      default value is 'Domain'.
+      default value is 'Data'.
   """
 
   require Logger
-  import JS2E.Parser, only: [parse_schema_files: 1]
-  import JS2E.Printer, only: [print_schemas: 2]
+  alias JS2E.Parser
+  alias JS2E.Printer
   alias JS2E.Parsers.{ParserWarning, ParserError}
   alias JS2E.Printers.PrinterError
 
   @spec main([String.t()]) :: :ok
   def main(args) do
-    {options, paths, errors} = OptionParser.parse(args, switches: [module_name: :string])
+    {options, paths, errors} =
+      OptionParser.parse(args, switches: [module_name: :string])
 
-    if length(paths) == 0 do
+    if Enum.empty?(paths) == true do
       IO.puts(@moduledoc)
       exit(:normal)
     end
@@ -39,13 +40,16 @@ defmodule JS2E do
 
     files = resolve_all_paths(paths)
 
-    if length(files) == 0 do
-      print_error("Error: Could not find any " <> "JSON files in path: #{inspect(paths)}")
+    if Enum.empty?(files) == true do
+      print_error(
+        "Error: Could not find any " <> "JSON files in path: #{inspect(paths)}"
+      )
+
       exit(:no_files)
     end
 
     output_path = create_output_dir(options)
-    JS2E.generate(files, output_path)
+    generate(files, output_path)
   end
 
   @spec resolve_all_paths([String.t()]) :: [Path.t()]
@@ -92,7 +96,7 @@ defmodule JS2E do
       if Keyword.has_key?(options, :module_name) do
         Keyword.get(options, :module_name)
       else
-        "Domain"
+        "Data"
       end
 
     output_path
@@ -104,14 +108,16 @@ defmodule JS2E do
   @spec generate([String.t()], String.t()) :: :ok
   def generate(schema_paths, module_name) do
     Logger.info("Parsing JSON schema files!")
-    parser_result = parse_schema_files(schema_paths)
+    parser_result = Parser.parse_schema_files(schema_paths)
     pretty_parser_warnings(parser_result.warnings)
 
     if length(parser_result.errors) > 0 do
       pretty_parser_errors(parser_result.errors)
     else
       Logger.info("Converting to Elm code!")
-      printer_result = print_schemas(parser_result.schema_dict, module_name)
+
+      printer_result =
+        Printer.print_schemas(parser_result.schema_dict, module_name)
 
       if length(printer_result.errors) > 0 do
         pretty_printer_errors(printer_result.errors)
@@ -149,7 +155,11 @@ defmodule JS2E do
           padding =
             String.duplicate(
               "-",
-              max(0, 74 - String.length(pretty_warning_type) - String.length(file_path))
+              max(
+                0,
+                74 - String.length(pretty_warning_type) -
+                  String.length(file_path)
+              )
             )
 
           warnings
@@ -181,7 +191,10 @@ defmodule JS2E do
           padding =
             String.duplicate(
               "-",
-              max(0, 74 - String.length(pretty_error_type) - String.length(file_path))
+              max(
+                0,
+                74 - String.length(pretty_error_type) - String.length(file_path)
+              )
             )
 
           errors
@@ -213,7 +226,10 @@ defmodule JS2E do
           padding =
             String.duplicate(
               "-",
-              max(0, 74 - String.length(pretty_error_type) - String.length(file_path))
+              max(
+                0,
+                74 - String.length(pretty_error_type) - String.length(file_path)
+              )
             )
 
           errors
@@ -237,7 +253,8 @@ defmodule JS2E do
   end
 
   defp warning_header do
-    header = String.duplicate("^", 35) <> " WARNINGS " <> String.duplicate("^", 35)
+    header =
+      String.duplicate("^", 35) <> " WARNINGS " <> String.duplicate("^", 35)
 
     IO.puts(IO.ANSI.format([:yellow, header]))
   end

lib/parsers/all_of_parser.ex

@@ -69,7 +69,8 @@ defmodule JS2E.Parsers.AllOfParser do
   Parses a JSON schema allOf type into an `JS2E.Types.AllOfType`.
   """
   @impl JS2E.Parsers.ParserBehaviour
-  @spec parse(Types.node(), URI.t(), URI.t() | nil, TypePath.t(), String.t()) :: ParserResult.t()
+  @spec parse(Types.node(), URI.t(), URI.t() | nil, TypePath.t(), String.t()) ::
+          ParserResult.t()
   def parse(%{"allOf" => all_of}, parent_id, id, path, name)
       when is_list(all_of) do
     child_path = TypePath.add_child(path, "allOf")

lib/parsers/any_of_parser.ex

@@ -68,8 +68,13 @@ defmodule JS2E.Parsers.AnyOfParser do
   Parses a JSON schema anyOf type into an `JS2E.Types.AnyOfType`.
   """
   @impl JS2E.Parsers.ParserBehaviour
-  @spec parse(Types.schemaNode(), URI.t(), URI.t() | nil, TypePath.t(), String.t()) ::
-          ParserResult.t()
+  @spec parse(
+          Types.schemaNode(),
+          URI.t(),
+          URI.t() | nil,
+          TypePath.t(),
+          String.t()
+        ) :: ParserResult.t()
   def parse(%{"anyOf" => any_of}, parent_id, id, path, name)
       when is_list(any_of) do
     child_path = TypePath.add_child(path, "anyOf")

lib/parsers/array_parser.ex

@@ -52,8 +52,13 @@ defmodule JS2E.Parsers.ArrayParser do
   Parses a JSON schema array type into an `JS2E.Types.ArrayType`.
   """
   @impl JS2E.Parsers.ParserBehaviour
-  @spec parse(Types.schemaNode(), URI.t(), URI.t() | nil, TypePath.t(), String.t()) ::
-          ParserResult.t()
+  @spec parse(
+          Types.schemaNode(),
+          URI.t(),
+          URI.t() | nil,
+          TypePath.t(),
+          String.t()
+        ) :: ParserResult.t()
   def parse(schema_node, parent_id, id, path, name) do
     items_abs_path =
       path

lib/parsers/definitions_parser.ex

@@ -49,7 +49,8 @@ defmodule JS2E.Parsers.DefinitionsParser do
   Parses a JSON schema 'definitions' property into a map of types.
   """
   @impl JS2E.Parsers.ParserBehaviour
-  @spec parse(map, URI.t(), URI.t() | nil, TypePath.t(), String.t()) :: ParserResult.t()
+  @spec parse(map, URI.t(), URI.t() | nil, TypePath.t(), String.t()) ::
+          ParserResult.t()
   def parse(%{"definitions" => definitions}, parent_id, _id, path, _name) do
     child_path =
       path

lib/parsers/enum_parser.ex

@@ -46,8 +46,13 @@ defmodule JS2E.Parsers.EnumParser do
   Parses a JSON schema enum type into an `JS2E.Types.EnumType`.
   """
   @impl JS2E.Parsers.ParserBehaviour
-  @spec parse(Types.schemaNode(), URI.t(), URI.t() | nil, TypePath.t(), String.t()) ::
-          ParserResult.t()
+  @spec parse(
+          Types.schemaNode(),
+          URI.t(),
+          URI.t() | nil,
+          TypePath.t(),
+          String.t()
+        ) :: ParserResult.t()
   def parse(%{"enum" => enum, "type" => type}, _parent_id, id, path, name) do
     # TODO: Check that the enum values all have the same type
 

lib/parsers/error_util.ex

@@ -109,7 +109,8 @@ defmodule JS2E.Parsers.ErrorUtil do
     ParserError.new(identifier, :name_collision, error_msg)
   end
 
-  @spec invalid_uri(Types.typeIdentifier(), String.t(), String.t()) :: ParserError.t()
+  @spec invalid_uri(Types.typeIdentifier(), String.t(), String.t()) ::
+          ParserError.t()
   def invalid_uri(identifier, property, actual) do
     full_identifier = print_identifier(identifier)
     stringified_value = sanitize_value(actual)
@@ -127,7 +128,8 @@ defmodule JS2E.Parsers.ErrorUtil do
     ParserError.new(identifier, :invalid_uri, error_msg)
   end
 
-  @spec unknown_node_type(Types.typeIdentifier(), String.t(), Types.node()) :: ParserError.t()
+  @spec unknown_node_type(Types.typeIdentifier(), String.t(), Types.node()) ::
+          ParserError.t()
   def unknown_node_type(identifier, name, schema_node) do
     full_identifier =
       identifier