Update version of elixir to 1.6.0-rc.0

bryanjos · bryanjos · commit d4696fe01f2b · 2017-12-26T21:00:07.000-06:00
diff --git a/.tool-versions b/.tool-versions
@@ -1,3 +1,3 @@
 erlang 20.1
-elixir 1.5.2-otp-20
+elixir 1.6.0-rc.0-otp-20
 nodejs 8.9.1
diff --git a/lib/elixir_script/cli.ex b/lib/elixir_script/cli.ex
@@ -17,51 +17,54 @@ defmodule ElixirScript.CLI do
   ]
 
   def parse_args(args) do
-    { options, input, errors } = OptionParser.parse(args, switches: @switches, aliases: @aliases)
+    {options, input, errors} = OptionParser.parse(args, switches: @switches, aliases: @aliases)
 
     cond do
       length(errors) > 0 ->
         :help
+
       Keyword.get(options, :help, false) ->
         :help
+
       Keyword.get(options, :version, false) ->
         :version
+
       length(input) == 0 ->
         :help
+
       true ->
-        { input, options }
+        {input, options}
     end
-
   end
 
   defp help_message do
-  """
-  usage: elixirscript <module | path> [options]
-  <module> the entry module of your application
-  <path> the path to .ex(s) files to compile
-
-  options:
-  -o  --output [path]   places output at the given path.
-                        Can be a directory or filename.
-  -v  --version         the current version number
-  -h  --help            this message
-  --root                The root import path for FFI imports
-  """
+    """
+    usage: elixirscript <module | path> [options]
+    <module> the entry module of your application
+    <path> the path to .ex(s) files to compile
+
+    options:
+    -o  --output [path]   places output at the given path.
+                          Can be a directory or filename.
+    -v  --version         the current version number
+    -h  --help            this message
+    --root                The root import path for FFI imports
+    """
   end
 
   def process(:help) do
-    IO.write help_message()
+    IO.write(help_message())
   end
 
   def process(:version) do
-    IO.write @app_version
+    IO.write(@app_version)
   end
 
-  def process({ input, options }) do
+  def process({input, options}) do
     if options_contains_unknown_values(options) do
-        process(:help)
+      process(:help)
     else
-        do_process(input, options)
+      do_process(input, options)
     end
   end
 
@@ -76,7 +79,7 @@ defmodule ElixirScript.CLI do
   end
 
   defp options_contains_unknown_values(options) do
-    Enum.any?(options, fn({key, _value}) ->
+    Enum.any?(options, fn {key, _value} ->
       if key in Keyword.keys(@switches) do
         false
       else
@@ -87,8 +90,8 @@ defmodule ElixirScript.CLI do
 
   defp handle_input(input) do
     input
-    |> Enum.map(fn(x) -> String.split(x, [" ", ","], trim: true) end)
-    |> List.flatten
-    |> Enum.map(fn(x) -> Module.concat([x]) end)
+    |> Enum.map(fn x -> String.split(x, [" ", ","], trim: true) end)
+    |> List.flatten()
+    |> Enum.map(fn x -> Module.concat([x]) end)
   end
 end
diff --git a/lib/elixir_script/state.ex b/lib/elixir_script/state.ex
@@ -6,10 +6,10 @@ defmodule ElixirScript.State do
   def start_link(compiler_opts) do
     Agent.start_link(fn ->
       %{
-        modules: Keyword.new,
+        modules: Keyword.new(),
         js_modules: [],
         in_memory_modules: [],
-        compiler_opts: compiler_opts,
+        compiler_opts: compiler_opts
       }
     end)
   end
@@ -19,23 +19,24 @@ defmodule ElixirScript.State do
   end
 
   def get_module(pid, module) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       Keyword.get(state.modules, module)
     end)
   end
 
   def put_module(pid, module, value) do
-    Agent.update(pid, fn(state) ->
-      value = Map.put_new(value, :used, [])
-      |> Map.put_new(:used_modules, [])
+    Agent.update(pid, fn state ->
+      value =
+        Map.put_new(value, :used, [])
+        |> Map.put_new(:used_modules, [])
 
       modules = Keyword.put(state.modules, module, value)
-      %{ state | modules: modules }
+      %{state | modules: modules}
     end)
   end
 
   def add_used_module(pid, module, used_module) do
-    Agent.update(pid, fn(state) ->
+    Agent.update(pid, fn state ->
       module_info = Keyword.get(state.modules, module)
 
       used_modules = Map.get(module_info, :used_modules, [])
@@ -44,22 +45,21 @@ defmodule ElixirScript.State do
       module_info = Map.put(module_info, :used_modules, used_modules)
       modules = Keyword.put(state.modules, module, module_info)
 
-      %{ state | modules: modules }
+      %{state | modules: modules}
     end)
   end
 
-
   def has_used?(pid, module, func) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       module_info = Keyword.get(state.modules, module)
       used = Map.get(module_info, :used, [])
 
-      Enum.find(used, fn(x) -> x == func end) != nil
+      Enum.find(used, fn x -> x == func end) != nil
     end)
   end
 
   def add_used(pid, module, {_function, _arity} = func) do
-    Agent.update(pid, fn(state) ->
+    Agent.update(pid, fn state ->
       module_info = Keyword.get(state.modules, module)
 
       used = Map.get(module_info, :used, [])
@@ -68,79 +68,80 @@ defmodule ElixirScript.State do
       module_info = Map.put(module_info, :used, used)
       modules = Keyword.put(state.modules, module, module_info)
 
-      %{ state | modules: modules }
+      %{state | modules: modules}
     end)
   end
 
   def put_javascript_module(pid, module, name, path) do
-    Agent.update(pid, fn(state) ->
+    Agent.update(pid, fn state ->
       js_modules = Map.get(state, :js_modules, [])
       js_modules = [{module, name, path} | js_modules]
-      %{ state | js_modules: js_modules }
+      %{state | js_modules: js_modules}
     end)
   end
 
   def list_javascript_modules(pid) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       state.js_modules
-      |> Enum.map(fn
-        {module, _name, _path} ->
-          module
+      |> Enum.map(fn {module, _name, _path} ->
+        module
       end)
     end)
   end
 
   def js_modules(pid) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       state.js_modules
     end)
   end
 
   def is_global_module(pid, module) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       result = Enum.find(state.js_modules, fn {mod, _, _} -> mod == module end)
 
       if result == nil, do: false, else: true
     end)
   end
 
   def remove_unused_functions(pid) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       state.compiler_opts.remove_unused_functions
     end)
   end
 
   def get_js_module_name(pid, module) do
-    Agent.get(pid, fn(state) ->
-      {_, name, _} = state.js_modules
-      |> Enum.find(fn {m, _, _} -> module == m end)
+    Agent.get(pid, fn state ->
+      {_, name, _} =
+        state.js_modules
+        |> Enum.find(fn {m, _, _} -> module == m end)
+
       name
     end)
   end
 
   def list_modules(pid) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       state.modules
     end)
   end
 
   def get_in_memory_module(pid, module) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       Keyword.get(state.in_memory_modules, module)
     end)
   end
 
   def get_in_memory_modules(pid) do
-    Agent.get(pid, fn(state) ->
+    Agent.get(pid, fn state ->
       state.in_memory_modules
     end)
   end
 
   def put_in_memory_module(pid, module, beam) do
-    Agent.update(pid, fn(state) ->
+    Agent.update(pid, fn state ->
       in_memory_modules = Map.get(state, :in_memory_modules, [])
       in_memory_modules = Keyword.put(in_memory_modules, module, beam)
-      %{ state | in_memory_modules: in_memory_modules }
+      %{state | in_memory_modules: in_memory_modules}
     end)
   end
 end
