Ensure IEx runs only after Elixir's CLI process its options

Author: José Valim

bin/mix

@@ -11,7 +11,7 @@ readlink_f () {
 
 SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
-ERL_OPTS=""
+EXECUTABLE="elixir"
 
-if [ "$1" = "iex" ]; then ERL_OPTS="-user Elixir-IEx-CLI -iex wait true"; fi
-exec "$SCRIPT_PATH"/elixir --erl "$ERL_OPTS" -e "Mix.start; Mix.CLI.run" -- "$@"
+if [ "$1" = "iex" ]; then EXECUTABLE="iex"; fi
+exec "$SCRIPT_PATH"/$EXECUTABLE -e "Mix.start; Mix.CLI.run" -- "$@"

lib/elixir/lib/kernel/cli.ex

@@ -1,27 +1,45 @@
-defrecord Kernel.CLI.Config, commands: [], output: ".",
-                             compile: [], halt: true, compiler_options: []
-
 defmodule Kernel.CLI do
-  @moduledoc false
-
-  @doc """
-  Invoked directly from erlang boot process. It parses all argv
-  options and execute them in the order they are specified.
+  @moduledoc """
+  Module responsible for controlling Elixir's CLI
   """
-  def process_argv(options) do
-    { config, argv } = process_options(options, Kernel.CLI.Config.new)
+
+  defrecord Config, commands: [], output: ".",
+                    compile: [], halt: true, compiler_options: []
+
+  # This is the API invoked by Elixir boot process.
+  @doc false
+  def main(options) do
+    { config, argv } = process_argv(options, Kernel.CLI.Config.new)
 
     argv = lc arg inlist argv, do: list_to_binary(arg)
     :gen_server.call(:elixir_code_server, { :argv, argv })
 
-    all_commands = Enum.reverse(config.commands)
+    run fn ->
+      Enum.map Enum.reverse(config.commands), process_command(&1, config)
+      :gen_server.cast(:elixir_code_server, :finished)
+    end, config.halt
+  end
 
-    run fn -> Enum.map all_commands, process_command(&1, config) end, config.halt
+  @doc """
+  Wait until the CLI finishes procesing options.
+  """
+  def wait_until_finished do
+    case :gen_server.call(:elixir_code_server, { :wait_until_finished, self }) do
+      :wait ->
+        receive do
+          { :elixir_code_server, :finished } -> :ok
+        end
+      :ok -> :ok
+    end
   end
 
   @doc """
-  Runs the given function and wraps any exception or
-  error in messages useful for the command line.
+  Runs the given function by catching any failure
+  and printing them to stdout. `at_exit` hooks are
+  also invoked before exiting.
+
+  This function is used by Elixir's CLI and also
+  by escripts generated by Elixir.
   """
   def run(fun, halt // true) do
     try do
@@ -141,15 +159,15 @@ defmodule Kernel.CLI do
 
   # Process init options
 
-  def process_options(['--'|t], config) do
+  defp process_argv(['--'|t], config) do
     { config, t }
   end
 
-  def process_options(['--compile'|t], config) do
+  defp process_argv(['--compile'|t], config) do
     process_compiler t, config
   end
 
-  def process_options(['-S',h|t], config) do
+  defp process_argv(['-S',h|t], config) do
     exec = System.find_executable(h)
     if exec do
       { config.prepend_commands([require: list_to_binary(exec)]), t }
@@ -159,17 +177,17 @@ defmodule Kernel.CLI do
     end
   end
 
-  def process_options([h|t] = list, config) do
+  defp process_argv([h|t] = list, config) do
     case h do
       '-' ++ _ ->
-        shared_option? list, config, process_options(&1, &2)
+        shared_option? list, config, process_argv(&1, &2)
       _ ->
         h = list_to_binary(h)
         { config.prepend_commands([require: h]), t }
     end
   end
 
-  def process_options([], config) do
+  defp process_argv([], config) do
     { config, [] }
   end
 

lib/elixir/src/elixir.erl

@@ -1,6 +1,6 @@
 -module(elixir).
 -behaviour(application).
--export([main/1, start_cli/0, start_app/0,
+-export([main/1, start_cli/0,
   scope_for_eval/1, eval/2, eval/3, eval/4,
   eval_quoted/2, eval_quoted/3, eval_quoted/4,
   eval_forms/3]).
@@ -16,6 +16,12 @@
 -export([start/2, stop/1, config_change/3]).
 
 start(_Type, _Args) ->
+  %% Set the shell to unicode so printing inside scripts work
+  %% Those can take a while, so let's do it in a new process
+  spawn(fun() ->
+    io:setopts(standard_io, [{encoding,unicode}]),
+    io:setopts(standard_error, [{encoding,unicode}])
+  end),
   elixir_sup:start_link([]).
 
 stop(_S) ->
@@ -27,29 +33,14 @@ config_change(_Changed, _New, _Remove) ->
 %% escript entry point
 
 main(Args) ->
-  start_app(),
-  'Elixir.Kernel.CLI':process_argv(Args).
-
-%% ELIXIR ENTRY POINTS
-
-% Start the Elixir app. This is the proper way to boot Elixir from
-% inside an Erlang process.
-
-start_app() ->
-  case lists:keyfind(?MODULE, 1, application:loaded_applications()) of
-    false ->
-      application:start(?MODULE),
-      %% Set the shell to unicode so printing inside scripts work
-      io:setopts(standard_io, [{encoding,unicode}]),
-      io:setopts(standard_error, [{encoding,unicode}]);
-    _ -> ok
-  end.
+  application:start(?MODULE),
+  'Elixir.Kernel.CLI':main(Args).
 
 % Boot and process given options. Invoked by Elixir's script.
 
 start_cli() ->
-  start_app(),
-  'Elixir.Kernel.CLI':process_argv(init:get_plain_arguments()).
+  application:start(?MODULE),
+  'Elixir.Kernel.CLI':main(init:get_plain_arguments()).
 
 %% EVAL HOOKS
 

lib/elixir/src/elixir_code_server.erl

@@ -8,7 +8,8 @@
   at_exit=[],
   pool=[],
   counter=0,
-  compiler_options=[{docs,true},{debug_info,true}]
+  compiler_options=[{docs,true},{debug_info,true}],
+  waiting=[]
 }).
 
 start_link() ->
@@ -17,6 +18,13 @@ start_link() ->
 init(_args) ->
   { ok, #elixir_code_server{} }.
 
+handle_call({ wait_until_finished, Pid }, _, Config) ->
+  Waiting = Config#elixir_code_server.waiting,
+  case is_list(Waiting) of
+    true  -> { reply, wait, Config#elixir_code_server{waiting=[Pid|Waiting]} };
+    false -> { reply, ok, Config }
+  end;
+
 handle_call({ acquire, Path }, From, Config) ->
   Current = Config#elixir_code_server.loaded,
   case orddict:find(Path, Current) of
@@ -67,6 +75,11 @@ handle_call(retrieve_module_name, _From, Config) ->
 handle_call(_Request, _From, Config) ->
   { reply, undef, Config }.
 
+handle_cast(finished, Config) ->
+  Waiting = Config#elixir_code_server.waiting,
+  [Pid ! { elixir_code_server, finished } || Pid <- lists:reverse(Waiting)],
+  { noreply, Config#elixir_code_server{waiting=done} };
+
 handle_cast({ loaded, Path }, Config) ->
   Current = Config#elixir_code_server.loaded,
   case orddict:find(Path, Current) of

lib/elixir/src/elixir_compiler.erl

@@ -114,7 +114,7 @@ module(Forms, File, Options, Bootstrap, Callback) when
 %% Invoked from the Makefile.
 
 core() ->
-  elixir:start_app(),
+  application:start(elixir),
   gen_server:call(elixir_code_server, { compiler_options, [{docs,false},{internal,true}] }),
   [core_file(File) || File <- core_main()].
 

lib/elixir/test/elixir/kernel/cli_test.exs

@@ -29,12 +29,6 @@ defmodule Kernel.CLI.OptionParsingTest do
     # pz
     assert File.expand_path('lib/list', root) inlist path
   end
-
-  test :require do
-    options = ['-r', fixture_path('../../../lib/list/*') /> to_char_list, '-r', '/never/gonna/*/up']
-    { config, _argv } = Kernel.CLI.process_options(options, Kernel.CLI.Config.new)
-    assert {:require, fixture_path "../../../lib/list/chars.ex"} inlist config.commands
-  end
 end
 
 defmodule Kernel.CLI.AtExitTest do

lib/elixir/test/erlang/test_helper.erl

@@ -3,7 +3,7 @@
 -export([test/0, run_and_remove/2, throw_elixir/1, throw_erlang/1]).
 
 test() ->
-  elixir:start_app(),
+  application:start(elixir),
   eunit:test([
     atom_test,
     conditionals_test,