Runs mix format on the codebase (#55)

Closes #54

Author: dragonwasrobot

config/config.exs

@@ -2,7 +2,6 @@ use Mix.Config
 
 config :elixir, ansi_enabled: true
 
-config :js2e,
-  templates_location: "./priv/templates/"
+config :js2e, templates_location: "./priv/templates/"
 
-import_config "#{Mix.env}.exs"
+import_config "#{Mix.env()}.exs"

lib/js2e.ex

@@ -23,14 +23,12 @@ defmodule JS2E do
   alias JS2E.Parsers.{ParserWarning, ParserError}
   alias JS2E.Printers.PrinterError
 
-  @spec main([String.t]) :: :ok
+  @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
-      IO.puts @moduledoc
+      IO.puts(@moduledoc)
       exit(:normal)
     end
 
@@ -42,22 +40,21 @@ 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}")
+      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)
   end
 
-  @spec resolve_all_paths([String.t]) :: [Path.t]
+  @spec resolve_all_paths([String.t()]) :: [Path.t()]
   defp resolve_all_paths(paths) do
     paths
     |> Enum.filter(&File.exists?/1)
-    |> Enum.reduce([], fn (filename, files) ->
+    |> Enum.reduce([], fn filename, files ->
       cond do
-        File.dir? filename ->
+        File.dir?(filename) ->
           walk_directory(filename) ++ files
 
         String.ends_with?(filename, ".json") ->
@@ -69,15 +66,15 @@ defmodule JS2E do
     end)
   end
 
-  @spec walk_directory(String.t) :: [String.t]
+  @spec walk_directory(String.t()) :: [String.t()]
   defp walk_directory(dir) do
     dir
-    |> File.ls!
+    |> File.ls!()
     |> Enum.reduce([], fn file, files ->
       filename = "#{dir}/#{file}"
 
       cond do
-        File.dir? filename ->
+        File.dir?(filename) ->
           walk_directory(filename) ++ files
 
         String.ends_with?(file, ".json") ->
@@ -89,58 +86,55 @@ defmodule JS2E do
     end)
   end
 
-  @spec create_output_dir(list) :: String.t
+  @spec create_output_dir(list) :: String.t()
   defp create_output_dir(options) do
-
-    output_path = if Keyword.has_key?(options, :module_name) do
-      Keyword.get(options, :module_name)
-    else
-      "Domain"
-    end
+    output_path =
+      if Keyword.has_key?(options, :module_name) do
+        Keyword.get(options, :module_name)
+      else
+        "Domain"
+      end
 
     output_path
     |> File.mkdir_p!()
 
     output_path
   end
 
-  @spec generate([String.t], String.t) :: :ok
+  @spec generate([String.t()], String.t()) :: :ok
   def generate(schema_paths, module_name) do
-
-    Logger.info "Parsing JSON schema files!"
+    Logger.info("Parsing JSON schema files!")
     parser_result = 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!"
+      Logger.info("Converting to Elm code!")
       printer_result = print_schemas(parser_result.schema_dict, module_name)
 
       if length(printer_result.errors) > 0 do
         pretty_printer_errors(printer_result.errors)
-
       else
-        Logger.info "Printing Elm code to file(s)!"
+        Logger.info("Printing Elm code to file(s)!")
 
         file_dict = printer_result.file_dict
+
         Enum.each(file_dict, fn {file_path, file_content} ->
-          {:ok, file} = File.open file_path, [:write]
-          IO.binwrite file, file_content
-          File.close file
-          Logger.info "Created file '#{file_path}'"
+          {:ok, file} = File.open(file_path, [:write])
+          IO.binwrite(file, file_content)
+          File.close(file)
+          Logger.info("Created file '#{file_path}'")
         end)
       end
     end
   end
 
-  @spec pretty_parser_warnings([ParserWarning.t]) :: :ok
+  @spec pretty_parser_warnings([ParserWarning.t()]) :: :ok
   defp pretty_parser_warnings(warnings) do
     warnings
     |> Enum.each(fn {file_path, warnings} ->
       if length(warnings) > 0 do
-
         warning_header()
 
         warnings
@@ -150,45 +144,50 @@ defmodule JS2E do
             warning_type
             |> to_string
             |> String.replace("_", " ")
-            |> String.downcase
+            |> String.downcase()
 
-          padding = String.duplicate("-",
-            max(0, 74 - String.length(pretty_warning_type) - String.length(file_path)))
+          padding =
+            String.duplicate(
+              "-",
+              max(0, 74 - String.length(pretty_warning_type) - String.length(file_path))
+            )
 
           warnings
           |> Enum.each(fn warning ->
             print_header("--- #{pretty_warning_type} #{padding} #{file_path}\n")
-            IO.puts warning.message
+            IO.puts(warning.message)
           end)
         end)
-
       end
     end)
+
     :ok
   end
 
-  @spec pretty_parser_errors([ParserError.t]) :: :ok
+  @spec pretty_parser_errors([ParserError.t()]) :: :ok
   defp pretty_parser_errors(errors) do
     errors
     |> Enum.each(fn {file_path, errors} ->
       if length(errors) > 0 do
-
         errors
         |> Enum.group_by(fn err -> err.error_type end)
         |> Enum.each(fn {error_type, errors} ->
           pretty_error_type =
             error_type
             |> to_string
             |> String.replace("_", " ")
-            |> String.upcase
+            |> String.upcase()
 
-          padding = String.duplicate("-",
-            max(0, 74 - String.length(pretty_error_type) - String.length(file_path)))
+          padding =
+            String.duplicate(
+              "-",
+              max(0, 74 - String.length(pretty_error_type) - String.length(file_path))
+            )
 
           errors
           |> Enum.each(fn error ->
             print_header("--- #{pretty_error_type} #{padding} #{file_path}\n")
-            IO.puts error.message
+            IO.puts(error.message)
           end)
         end)
       end
@@ -197,52 +196,49 @@ defmodule JS2E do
     :ok
   end
 
-  @spec pretty_printer_errors([PrinterError.t]) :: :ok
+  @spec pretty_printer_errors([PrinterError.t()]) :: :ok
   defp pretty_printer_errors(errors) do
-
     errors
     |> Enum.each(fn {file_path, errors} ->
       if length(errors) > 0 do
-
         errors
         |> Enum.group_by(fn err -> err.error_type end)
         |> Enum.each(fn {error_type, errors} ->
-
           pretty_error_type =
             error_type
             |> to_string
             |> String.replace("_", " ")
-            |> String.upcase
+            |> String.upcase()
 
-          padding = String.duplicate("-",
-            max(0, 74 - String.length(pretty_error_type) - String.length(file_path)))
+          padding =
+            String.duplicate(
+              "-",
+              max(0, 74 - String.length(pretty_error_type) - String.length(file_path))
+            )
 
           errors
           |> Enum.each(fn error ->
             print_header("--- #{pretty_error_type} #{padding} #{file_path}\n")
-            IO.puts error.message
+            IO.puts(error.message)
           end)
         end)
-
       end
     end)
+
     :ok
   end
 
   defp print_error(str) do
-    IO.puts IO.ANSI.format([:cyan, str])
+    IO.puts(IO.ANSI.format([:cyan, str]))
   end
 
   defp print_header(str) do
-    IO.puts IO.ANSI.format([:cyan, str])
+    IO.puts(IO.ANSI.format([:cyan, str]))
   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])
+    IO.puts(IO.ANSI.format([:yellow, header]))
   end
-
 end

lib/parser.ex

@@ -9,18 +9,17 @@ defmodule JS2E.Parser do
   alias JS2E.Parsers.{RootParser, SchemaResult, ErrorUtil}
   alias JS2E.Printers.Util
 
-  @spec parse_schema_files([Path.t]) :: SchemaResult.t
+  @spec parse_schema_files([Path.t()]) :: SchemaResult.t()
   def parse_schema_files(schema_paths) do
     init_schema_result = SchemaResult.new()
 
     schema_paths
-    |> Enum.reduce(init_schema_result, fn (schema_path, acc) ->
+    |> Enum.reduce(init_schema_result, fn schema_path, acc ->
       schema_path
-      |> File.read!
-      |> Poison.decode!
+      |> File.read!()
+      |> Poison.decode!()
       |> RootParser.parse_schema(schema_path)
       |> SchemaResult.merge(acc)
     end)
   end
-
 end

lib/parsers/all_of_parser.ex

@@ -30,11 +30,14 @@ defmodule JS2E.Parsers.AllOfParser do
   """
 
   require Logger
-  import JS2E.Parsers.Util, only: [
-    parse_child_types: 3,
-    create_types_list: 2,
-    create_type_dict: 3
-  ]
+
+  import JS2E.Parsers.Util,
+    only: [
+      parse_child_types: 3,
+      create_types_list: 2,
+      create_type_dict: 3
+    ]
+
   alias JS2E.Parsers.{ErrorUtil, ParserResult}
   alias JS2E.{Types, TypePath}
   alias JS2E.Types.AllOfType
@@ -55,20 +58,20 @@ defmodule JS2E.Parsers.AllOfParser do
 
   """
   @impl JS2E.Parsers.ParserBehaviour
-  @spec type?(Types.node) :: boolean
+  @spec type?(Types.node()) :: boolean
   def type?(%{"allOf" => all_of})
-  when is_list(all_of) and length(all_of) > 0, do: true
+      when is_list(all_of) and length(all_of) > 0,
+      do: true
+
   def type?(_schema_node), do: false
 
   @doc ~S"""
   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
-
+      when is_list(all_of) do
     child_path = TypePath.add_child(path, "allOf")
 
     child_types_result =
@@ -86,5 +89,4 @@ defmodule JS2E.Parsers.AllOfParser do
     |> ParserResult.new()
     |> ParserResult.merge(child_types_result)
   end
-
 end