Slightly tidy up IEx.Server

Author: José Valim

lib/iex/lib/iex.ex

@@ -171,6 +171,19 @@ defmodule IEx do
     match?({ :ok, true }, :application.get_env(:iex, :started))
   end
 
+  @doc """
+  Returns `string` escaped using the specified color.
+  ANSI escapes in `string` are not processed in any way.
+  """
+  def color(color_name, string) do
+    colors = IEx.Options.get(:colors)
+    enabled = colors[:enabled]
+    IO.ANSI.escape_fragment("%{#{colors[color_name]}}", enabled)
+      <> string <> IO.ANSI.escape_fragment("%{reset}", enabled)
+  end
+
+  ## Callbacks
+
   # This is a callback invoked by Erlang shell utilities
   # when someone press Ctrl+G and adds 's Elixir.IEx'.
   @doc false
@@ -187,8 +200,6 @@ defmodule IEx do
         _        -> :init.wait_until_started()
       end
 
-      Process.flag(:trap_exit, true)
-
       start_iex()
       callback.()
 
@@ -199,19 +210,6 @@ defmodule IEx do
   end
 
   @doc false
-  def dont_display_result, do: :"do not show this result in iex"
-
-  ## Boot Helpers
-
-  defp start_iex do
-    :application.start(:elixir)
-    :application.start(:iex)
-  end
-
-  @doc """
-  Returns the default config used to launch IEx. This config is also used by
-  `IEx.TestFramework`.
-  """
   def boot_config(opts) do
     scope = :elixir.scope_for_eval(
       file: "iex",
@@ -225,6 +223,22 @@ defmodule IEx do
     ]
   end
 
+  @doc false
+  def dont_display_result, do: :"do not show this result in iex"
+
+  ## Helpers
+
+  defp start_iex do
+    :application.start(:elixir)
+    :application.start(:iex)
+
+    # Disable ANSI-escape-sequence-based coloring on Windows
+    # Can be overriden in .iex
+    if match?({ :win32, _ }, :os.type()) do
+      IEx.Options.set :colors, enabled: false
+    end
+  end
+
   defp set_expand_fun do
     gl = Process.group_leader
     glnode = node gl
@@ -249,15 +263,4 @@ defmodule IEx do
   defp run_after_spawn do
     lc fun inlist Enum.reverse(after_spawn), do: fun.()
   end
-
-  @doc """
-  Returns `string` escaped using the specified color. ANSI escapes in `string`
-  are not processed in any way.
-  """
-  def color(color_name, string) do
-    colors = IEx.Options.get(:colors)
-    enabled = colors[:enabled]
-    IO.ANSI.escape_fragment("%{#{colors[color_name]}}", enabled)
-      <> string <> IO.ANSI.escape_fragment("%{reset}", enabled)
-  end
 end

lib/iex/lib/iex/history.ex

@@ -1,13 +1,18 @@
 defmodule IEx.History do
   @moduledoc false
 
+  @doc """
+  Initializes IEx process variables. All history
+  information is kept in the process dictionary.
+  """
   def init do
     Process.put(:iex_history_start_counter, 1)
     Process.put(:iex_history_counter, 1)
   end
 
-  ### append ###
-
+  @doc """
+  Appends one entry to the history with the given counter.
+  """
   def append(entry, counter) do
     Process.put({:iex_history, counter}, entry)
     Process.put(:iex_history_counter, counter+1)
@@ -93,8 +98,9 @@ defmodule IEx.History do
     :erlang.garbage_collect()
   end
 
-  ### each ###
-
+  @doc """
+  Enumerates each item in the history.
+  """
   def each(fun) do
     each(Process.get(:iex_history_start_counter),
          Process.get(:iex_history_counter),
@@ -111,8 +117,9 @@ defmodule IEx.History do
     :ok
   end
 
-  ### nth ###
-
+  @doc """
+  Gets the nth item in the history.
+  """
   def nth(n) do
     entry = case n do
       n when n >= 0 ->

lib/iex/lib/iex/server.ex

@@ -4,14 +4,14 @@ defmodule IEx.Server do
   @doc """
   Eval loop for an IEx session. Its responsibilities include:
 
-    * loading of .iex files
-    * reading input
-    * trapping exceptions in the code being evaluated
-    * keeping expression history
+  * loading of .iex files
+  * reading input
+  * trapping exceptions in the code being evaluated
+  * keeping expression history
 
   """
   def start(config) do
-    init_systems()
+    IEx.History.init
 
     { _, _, scope } = :elixir.eval('require IEx.Helpers', [], 0, config.scope)
     config = config.scope(scope)
@@ -26,17 +26,22 @@ defmodule IEx.Server do
 
     old_flag = Process.flag(:trap_exit, true)
     self_pid = self
+
+    # We have one loop for receiving input and
+    # another loop for evaluating contents.
     pid = spawn_link(fn -> input_loop(self_pid) end)
 
     try do
-      do_loop(config.input_pid(pid))
+      eval_loop(config.input_pid(pid))
     after
       Process.exit(pid, :normal)
       Process.flag(:trap_exit, old_flag)
     end
   end
 
-  defp do_loop(config) do
+  ## Eval loop
+
+  defp eval_loop(config) do
     prefix = config.cache != []
     config.input_pid <- { :do_input, prefix, config.counter }
     wait_input(config)
@@ -57,7 +62,7 @@ defmodule IEx.Server do
                 config.cache('')
             end
 
-          do_loop(new_config)
+          eval_loop(new_config)
         end
 
       { :EXIT, _pid, :normal } ->
@@ -68,16 +73,6 @@ defmodule IEx.Server do
     end
   end
 
-  defp init_systems() do
-    IEx.History.init
-
-    # Disable ANSI-escape-sequence-based coloring on Windows
-    # Can be overriden in .iex
-    if match?({ :win32, _ }, :os.type()) do
-      IEx.Options.set :colors, enabled: false
-    end
-  end
-
   # Instead of doing just `:elixir.eval`, we first parse the expression to see
   # if it's well formed. If parsing succeeds, we evaluate the AST as usual.
   #
@@ -128,45 +123,69 @@ defmodule IEx.Server do
     end
   end
 
+  defp update_history(config) do
+    IEx.History.append(config, config.counter)
+  end
+
+  defp io_put(result) do
+    IO.puts :stdio, IEx.color(:eval_result, inspect(result, inspect_opts))
+  end
+
+  defp io_error(result) do
+    IO.puts :stdio, IEx.color(:error, result)
+  end
+
+  defp inspect_opts do
+    opts = IEx.Options.get(:inspect)
+    case :io.columns(:standard_input) do
+      { :ok, width } -> Keyword.put(opts, :width, min(width, 80))
+      { :error, _ }  -> opts
+    end
+  end
+
+  ## Load dot iex helpers
+
   # Locates and loads an .iex file from one of predefined locations. Returns
   # new config.
   defp load_dot_iex(config, path // nil) do
     candidates = if path do
       [path]
     else
-      Enum.map [".iex", "~/.iex"], &Path.expand(&1)
+      Enum.map [".iex", "~/.iex"], &Path.expand/1
     end
 
-    path = Enum.find candidates, fn path -> File.regular?(path) end
+    path = Enum.find candidates, &File.regular?/1
 
     if nil?(path) do
       config
     else
-      try do
-        code  = File.read!(path)
-        scope = :elixir.scope_for_eval(config.scope, file: path)
-
-        # Evaluate the contents in the same environment do_loop will run in
-        { _result, binding, scope } =
-          :elixir.eval(String.to_char_list!(code),
-                       config.binding,
-                       0,
-                       scope)
-
-        scope = :elixir.scope_for_eval(scope, file: "iex")
-        config.binding(binding).scope(scope)
-      catch
-        kind, error ->
-          print_error(kind, Exception.normalize(kind, error), System.stacktrace)
-          System.halt(1)
-      end
+      eval_dot_iex(config, path)
     end
   end
 
-  defp update_history(config) do
-    IEx.History.append(config, config.counter)
+  defp eval_dot_iex(config, path) do
+    try do
+      code  = File.read!(path)
+      scope = :elixir.scope_for_eval(config.scope, file: path)
+
+      # Evaluate the contents in the same environment eval_loop will run in
+      { _result, binding, scope } =
+        :elixir.eval(String.to_char_list!(code),
+                     config.binding,
+                     0,
+                     scope)
+
+      scope = :elixir.scope_for_eval(scope, file: "iex")
+      config.binding(binding).scope(scope)
+    catch
+      kind, error ->
+        print_error(kind, Exception.normalize(kind, error), System.stacktrace)
+        System.halt(1)
+    end
   end
 
+  ## Input loop
+
   defp input_loop(iex_pid) do
     receive do
       { :do_input, prefix, counter } ->
@@ -192,26 +211,12 @@ defmodule IEx.Server do
     end
   end
 
-  defp io_put(result) do
-    IO.puts :stdio, IEx.color(:eval_result, inspect(result, inspect_opts))
-  end
-
-  defp io_error(result) do
-    IO.puts :stdio, IEx.color(:error, result)
-  end
-
-  defp inspect_opts do
-    opts = IEx.Options.get(:inspect)
-    case :io.columns(:standard_input) do
-      { :ok, width } -> Keyword.put(opts, :width, min(width, 80))
-      { :error, _ }  -> opts
-    end
-  end
-
   defp remote_prefix do
     if node == node(:erlang.group_leader), do: "iex", else: "rem"
   end
 
+  ## Error handling
+
   defp print_error(:error, exception, stacktrace) do
     print_stacktrace stacktrace, fn ->
       "** (#{inspect exception.__record__(:name)}) #{exception.message}"