Refactor IEx.{Server,Evaluator,Pry} APIs and test suites

Author: José Valim

lib/iex/lib/iex.ex

@@ -440,12 +440,12 @@ defmodule IEx do
   the process information. Let's see an example:
 
       import Enum, only: [map: 2]
-      require IEx
+
 
       defmodule Adder do
         def add(a, b) do
           c = a + b
-          IEx.pry
+          require IEx; IEx.pry
         end
       end
 
@@ -472,56 +472,12 @@ defmodule IEx do
   Setting variables or importing modules in IEx does not
   affect the caller's environment (hence it is called `pry`).
   """
-  defmacro pry(timeout \\ 5000) do
+  defmacro pry() do
     quote do
-      IEx.pry(binding(), __ENV__, unquote(timeout))
+      IEx.Pry.pry(binding(), __ENV__)
     end
   end
 
-  @doc """
-  Callback for `IEx.pry/1`.
-
-  You can invoke this function directly when you are not able to invoke
-  `IEx.pry/1` as a macro. This function expects the binding (from
-  `Kernel.binding/0`), the environment (from `__ENV__/0`) and the timeout
-  (a sensible default is 5000).
-  """
-  def pry(binding, env, timeout) do
-    opts = [binding: binding, dot_iex_path: "", env: env, prefix: "pry"]
-    meta = "#{inspect self()} at #{Path.relative_to_cwd(env.file)}:#{env.line}"
-    desc =
-      if File.regular?(env.file) do
-        parse_file(env)
-      else
-        ""
-      end
-
-    res = IEx.Server.take_over("Request to pry #{meta}#{desc}", opts, timeout)
-
-    # We cannot use colors because IEx may be off.
-    case res do
-      {:error, :no_iex} ->
-        extra =
-          case :os.type do
-            {:win32, _} -> " If you are Windows, you may need to start IEx with the --werl flag."
-            _           -> ""
-          end
-        IO.puts :stdio, "Cannot pry #{meta}. Is an IEx shell running?" <> extra
-      _ ->
-        :ok
-    end
-
-    res
-  end
-
-  defp parse_file(env) do
-    lines =
-      env.file
-      |> File.stream!
-      |> Enum.slice(max(env.line - 3, 0), 5)
-    Enum.intersperse(["\n\n" | lines], "    ")
-  end
-
   ## Callbacks
 
   # This is a callback invoked by Erlang shell utilities

lib/iex/lib/iex/evaluator.ex

@@ -14,11 +14,11 @@ defmodule IEx.Evaluator do
     old_leader = Process.group_leader
     Process.group_leader(self(), leader)
 
-    state = loop_state(opts)
+    state = loop_state(server, IEx.History.init, opts)
     command == :ack && :proc_lib.init_ack(self())
 
     try do
-      loop(server, IEx.History.init, state)
+      loop(state)
     after
       Process.group_leader(self(), old_leader)
     end
@@ -71,23 +71,23 @@ defmodule IEx.Evaluator do
     end
   end
 
-  defp loop(server, history, state) do
+  defp loop(%{server: server} = state) do
     receive do
       {:eval, ^server, code, iex_state} ->
-        {result, history, state} = eval(code, iex_state, history, state)
+        {result, state} = eval(code, iex_state, state)
         send server, {:evaled, self(), result}
-        loop(server, history, state)
+        loop(state)
       {:fields_from_env, ref, receiver, fields} ->
         send receiver, {ref, Map.take(state.env, fields)}
-        loop(server, history, state)
+        loop(state)
       {:value_from_binding, ref, receiver, var_name, map_key_path} ->
         value = traverse_binding(state.binding, var_name, map_key_path)
         send receiver, {ref, value}
-        loop(server, history, state)
+        loop(state)
       {:variables_from_binding, ref, receiver, var_prefix} ->
         value = find_matched_variables(state.binding, var_prefix)
         send receiver, {ref, value}
-        loop(server, history, state)
+        loop(state)
       {:done, ^server} ->
         :ok
     end
@@ -110,7 +110,7 @@ defmodule IEx.Evaluator do
         do: var_name
   end
 
-  defp loop_state(opts) do
+  defp loop_state(server, history, opts) do
     env =
       if env = opts[:env] do
         :elixir.env_for_eval(env, [])
@@ -121,7 +121,7 @@ defmodule IEx.Evaluator do
     {_, _, env, scope} = :elixir.eval('import IEx.Helpers', [], env)
 
     binding = Keyword.get(opts, :binding, [])
-    state  = %{binding: binding, scope: scope, env: env}
+    state  = %{binding: binding, scope: scope, env: env, server: server, history: history}
 
     case opts[:dot_iex_path] do
       ""   -> state
@@ -178,34 +178,38 @@ defmodule IEx.Evaluator do
   # https://github.com/elixir-lang/elixir/issues/1089 for discussion.
   @break_trigger '#iex:break\n'
 
-  defp eval(code, iex_state, history, state) do
+  defp eval(code, iex_state, state) do
     try do
-      do_eval(String.to_charlist(code), iex_state, history, state)
+      do_eval(String.to_charlist(code), iex_state, state)
     catch
       kind, error ->
         print_error(kind, error, System.stacktrace)
-        {%{iex_state | cache: ''}, history, state}
+        {%{iex_state | cache: ''}, state}
     end
   end
 
-  defp do_eval(@break_trigger, %IEx.State{cache: ''} = iex_state, history, state) do
-    {iex_state, history, state}
+  defp do_eval(@break_trigger, %IEx.State{cache: ''} = iex_state, state) do
+    {iex_state, state}
   end
 
-  defp do_eval(@break_trigger, iex_state, _history, _state) do
+  defp do_eval(@break_trigger, iex_state, _state) do
     :elixir_errors.parse_error(iex_state.counter, "iex", "incomplete expression", "")
   end
 
-  defp do_eval(latest_input, iex_state, history, state) do
+  defp do_eval(latest_input, iex_state, state) do
     code = iex_state.cache ++ latest_input
     line = iex_state.counter
-    Process.put(:iex_history, history)
-    handle_eval(Code.string_to_quoted(code, [line: line, file: "iex"]), code, line, iex_state, history, state)
+    put_history(state)
+    handle_eval(Code.string_to_quoted(code, [line: line, file: "iex"]), code, line, iex_state, state)
   after
     Process.delete(:iex_history)
   end
 
-  defp handle_eval({:ok, forms}, code, line, iex_state, history, state) do
+  defp put_history(%{history: history}) do
+    Process.put(:iex_history, history)
+  end
+
+  defp handle_eval({:ok, forms}, code, line, iex_state, state) do
     {result, binding, env, scope} =
       :elixir.eval_forms(forms, state.binding, state.env, state.scope)
     unless result == IEx.dont_display_result, do: io_inspect(result)
@@ -218,22 +222,23 @@ defmodule IEx.Evaluator do
                 scope: scope,
                 binding: binding}
 
-    {iex_state, update_history(history, line, code, result), state}
+    {iex_state, update_history(state, line, code, result)}
   end
 
-  defp handle_eval({:error, {_, _, ""}}, code, _line, iex_state, history, state) do
+  defp handle_eval({:error, {_, _, ""}}, code, _line, iex_state, state) do
     # Update iex_state.cache so that IEx continues to add new input to
     # the unfinished expression in "code"
-    {%{iex_state | cache: code}, history, state}
+    {%{iex_state | cache: code}, state}
   end
 
-  defp handle_eval({:error, {line, error, token}}, _code, _line, _iex_state, _, _state) do
+  defp handle_eval({:error, {line, error, token}}, _code, _line, _iex_state, _state) do
     # Encountered malformed expression
     :elixir_errors.parse_error(line, "iex", error, token)
   end
 
-  defp update_history(history, counter, cache, result) do
-    IEx.History.append(history, {counter, cache, result}, IEx.Config.history_size)
+  defp update_history(state, counter, cache, result) do
+    history_size = IEx.Config.history_size
+    update_in(state.history, &IEx.History.append(&1, {counter, cache, result}, history_size))
   end
 
   defp io_inspect(result) do

lib/iex/lib/iex/helpers.ex

@@ -40,7 +40,6 @@ defmodule IEx.Helpers do
     * `pwd/0`         - prints the current working directory
     * `r/1`           - recompiles the given module's source file
     * `recompile/0`   - recompiles the current project
-    * `respawn/0`     - respawns the current shell
     * `system_info/0` - prints system info (versions, memory usage, stats)
     * `v/0`           - retrieves the last value from the history
     * `v/1`           - retrieves the nth value from the history

lib/iex/lib/iex/pry.ex

@@ -0,0 +1,69 @@
+defmodule IEx.Pry do
+  @moduledoc false
+
+  @doc """
+  Callback for `IEx.pry/1`.
+
+  You can invoke this function directly when you are not able to invoke
+  `IEx.pry/1` as a macro. This function expects the binding (from
+  `Kernel.binding/0`) and the environment (from `__ENV__/0`).
+  """
+  def pry(binding, env) do
+    opts = [binding: binding, dot_iex_path: "", env: env, prefix: "pry"]
+    meta = "#{inspect self()} at #{Path.relative_to_cwd(env.file)}:#{env.line}"
+    desc =
+      case whereami(env.file, env.line, 2) do
+        {:ok, lines} -> [?\n, ?\n, lines]
+        :error -> ""
+      end
+
+    res = IEx.Server.take_over("Request to pry #{meta}#{desc}", opts)
+
+    # We cannot use colors because IEx may be off.
+    case res do
+      {:error, :no_iex} ->
+        extra =
+          case :os.type do
+            {:win32, _} -> " If you are Windows, you may need to start IEx with the --werl flag."
+            _           -> ""
+          end
+        IO.puts :stdio, "Cannot pry #{meta}. Is an IEx shell running?" <> extra
+      _ ->
+        :ok
+    end
+
+    res
+  end
+
+  @doc """
+  Formats the location for whereami prying.
+  """
+  def whereami(file, line, radius) do
+    with true <- File.regular?(file),
+         [_ | _] = lines <- whereami_lines(file, line, radius) do
+      {:ok, lines}
+    else
+      _ -> :error
+    end
+  end
+
+  defp whereami_lines(file, line, radius) do
+    min = max(line - radius - 1, 0)
+    max = line + radius - 1
+
+    file
+    |> File.stream!
+    |> Enum.slice(min..max)
+    |> Enum.with_index(min + 1)
+    |> Enum.map(&whereami_format_line(&1, line))
+  end
+
+  defp whereami_format_line({line_text, line_number}, line) do
+    gutter = String.pad_leading(Integer.to_string(line_number), 5, " ")
+    if line_number == line do
+      IO.ANSI.format_fragment([:bright, gutter, ": ", line_text, :normal])
+    else
+      [gutter, ": ", line_text]
+    end
+  end
+end