Merge pull request #1121 from alco/iex-limit-history

Iex limit history

Author: José Valim

lib/iex/lib/iex/helpers.ex

@@ -76,19 +76,6 @@ defmodule IEx.Helpers do
     end
   end
 
-  @doc """
-  Prints the history of expressions evaluated during the session along with
-  their results.
-  """
-  def v do
-    history = Enum.reverse(Process.get(:iex_history))
-    Enum.each(history, print_history(&1))
-  end
-
-  defp print_history(config) do
-    IO.puts IEx.color(:info, "#{config.counter}: #{config.cache}#=> #{inspect config.result}\n")
-  end
-
   @doc """
   Prints the documentation for `IEx.Helpers`.
   """
@@ -217,20 +204,28 @@ defmodule IEx.Helpers do
     end
   end
 
+  @doc """
+  Prints the history of expressions evaluated during the session along with
+  their results.
+  """
+  def v do
+    inspect_opts = IEx.Options.get(:inspect)
+    IEx.History.each(print_history_entry(&1, inspect_opts))
+  end
+
+  defp print_history_entry(config, inspect_opts) do
+    IO.write IEx.color(:info, "#{config.counter}: #{config.cache}#=> ")
+    IO.puts  IEx.color(:eval_result, "#{inspect config.result, inspect_opts}\n")
+  end
+
   @doc """
   Retrieves nth expression's value from the history.
 
   Use negative values to lookup expression values relative to the current one.
   For instance, v(-1) returns the result of the last evaluated expression.
   """
-  def v(n) when n < 0 do
-    history = Process.get(:iex_history)
-    Enum.fetch!(history, abs(n) - 1).result
-  end
-
-  def v(n) when n > 0 do
-    history = Process.get(:iex_history) |> Enum.reverse
-    Enum.fetch!(history, n - 1).result
+  def v(n) do
+    IEx.History.nth(n).result
   end
 
   @doc """
@@ -268,10 +263,15 @@ defmodule IEx.Helpers do
   Flushes all messages sent to the shell and prints them out.
   """
   def flush do
+    inspect_opts = IEx.Options.get(:inspect)
+    do_flush(inspect_opts)
+  end
+
+  defp do_flush(inspect_opts) do
     receive do
       msg ->
-        IO.inspect(msg)
-        flush
+        IO.inspect(msg, inspect_opts)
+        do_flush(inspect_opts)
     after
       0 -> :ok
     end

lib/iex/lib/iex/history.ex

@@ -0,0 +1,129 @@
+defmodule IEx.History do
+  @moduledoc false
+
+  def init do
+    Process.put(:iex_history_start_counter, 1)
+    Process.put(:iex_history_counter, 1)
+  end
+
+  ### append ###
+
+  def append(entry, counter) do
+    Process.put({:iex_history, counter}, entry)
+    Process.put(:iex_history_counter, counter+1)
+
+    limit = IEx.Options.get(:history_size)
+    start_counter = Process.get(:iex_history_start_counter)
+    should_collect = limit_history(start_counter, counter, limit, false)
+    if should_collect do
+      collect_garbage()
+    end
+  end
+
+  defp limit_history(_, _, limit, _) when limit < 0 do
+    false
+  end
+
+  defp limit_history(counter, max_counter, limit, should_collect) when max_counter - counter < limit do
+    Process.put(:iex_history_start_counter, counter)
+    should_collect
+  end
+
+  defp limit_history(counter, max_counter, limit, should_collect) do
+    if not should_collect do
+      entry = Process.delete({:iex_history, counter})
+      should_collect = has_binary(entry.result)
+    else
+      Process.delete({:iex_history, counter})
+    end
+    limit_history(counter+1, max_counter, limit, should_collect)
+  end
+
+  # Checks val and each of its elements (if it is a list or a tuple)
+  # recursively to see if it has any binaries
+  defp has_binary(val) do
+    try do
+      has_bin(val)
+    catch
+      :throw, true -> true
+    end
+  end
+
+  # Worker function used by has_binary. Throws when the first binary of the
+  # minimum specified size is found
+  defp has_bin(val) when is_tuple(val) do
+    has_bin(val, tuple_size(val)-1)
+  end
+
+  defp has_bin([h|t]) do
+    has_bin(h)
+    has_bin(t)
+  end
+
+  defp has_bin(val) when byte_size(val) > 64 do
+    throw true
+  end
+
+  defp has_bin(_) do
+    false
+  end
+
+  defp has_bin(_, -1) do
+    false
+  end
+
+  defp has_bin(tuple, index) do
+    has_bin(elem(tuple, index))
+    has_bin(tuple, index-1)
+  end
+
+  # Based on https://github.com/erlang/otp/blob/7dcccee4371477e983f026db9e243cb66900b1ef/lib/stdlib/src/shell.erl#L1401
+  defp collect_garbage do
+    :erlang.garbage_collect(self())
+    try do
+      :erlang.garbage_collect(Process.whereis(:user))
+    catch
+      _, _ -> nil
+    end
+    try do
+      :erlang.garbage_collect(Process.group_leader())
+    catch
+      _, _ -> nil
+    end
+    :erlang.garbage_collect()
+  end
+
+  ### each ###
+
+  def each(fun) do
+    each(Process.get(:iex_history_start_counter),
+         Process.get(:iex_history_counter),
+         fun)
+  end
+
+  defp each(counter, max_counter, fun) when counter < max_counter do
+    entry = Process.get({:iex_history, counter})
+    fun.(entry)
+    each(counter+1, max_counter, fun)
+  end
+
+  defp each(_, _, _) do
+    :ok
+  end
+
+  ### nth ###
+
+  def nth(n) do
+    entry = case n do
+      n when n >= 0 ->
+        Process.get({:iex_history, n})
+      n when n < 0 ->
+        counter = Process.get(:iex_history_counter)
+        Process.get({:iex_history, counter + n})
+    end
+    if nil?(entry) do
+      raise "Out of bounds"
+    end
+    entry
+  end
+end

lib/iex/lib/iex/options.ex

@@ -36,6 +36,7 @@ defmodule IEx.Options do
   @supported_options [
     colors: [],
     inspect: [],
+    history_size: [],
   ]
 
   @doc """
@@ -64,6 +65,11 @@ defmodule IEx.Options do
     opts
   end
 
+  def get(:history_size) do
+    { :ok, size } = :application.get_env(:iex, :history_size)
+    size
+  end
+
   def get(name) do
     raise_option(name)
   end
@@ -97,7 +103,7 @@ defmodule IEx.Options do
   end
 
   def set(:colors, _) do
-    raise_value
+    raise_value("a keyword list")
   end
 
   def set(:inspect, opts) when is_list(opts) do
@@ -108,7 +114,17 @@ defmodule IEx.Options do
   end
 
   def set(:inspect, _) do
-    raise_value
+    raise_value("a keyword list")
+  end
+
+  def set(:history_size, size) when is_integer(size) do
+    old_size = get(:history_size)
+    :application.set_env(:iex, :history_size, size)
+    old_size
+  end
+
+  def set(:history_size, _) do
+    raise_value("an integer")
   end
 
   def set(name, _) do
@@ -187,12 +203,24 @@ defmodule IEx.Options do
   """
   def inspect
 
+  @doc """
+  **NOTE**: This is just a stub for documentation purposes. Use
+  `IEx.Options.get` and `IEx.Options.set` to query and change the option's
+  value.
+
+  Number of expressions and their results to keep in the history.
+
+  The value is an integer. When it is negative, the history is unlimited.
+
+  """
+  def history_size
+
   defp raise_option(name) do
     raise ArgumentError, message: "Unknown IEx option #{inspect name}"
   end
 
-  defp raise_value do
-    raise ArgumentError, message: "Expected the value to be a keyword list"
+  defp raise_value(type) do
+    raise ArgumentError, message: "Expected the value to be #{type}"
   end
 
   defp filtered_kw(reference_kw, user_kw) do

lib/iex/lib/iex/server.ex

@@ -4,13 +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 input history
+    * keeping expression history
 
   """
   def start(config) do
-    Process.put :iex_history, []
+    IEx.History.init
 
     { _, _, scope } = :elixir.eval('require IEx.Helpers', [], 0, config.scope)
     config = config.scope(scope)
@@ -81,9 +82,9 @@ defmodule IEx.Server do
 
         io_put result
 
-        config = config.result(result)
-        update_history(config.cache(code).scope(nil))
-        config.update_counter(&1+1).cache('').binding(new_binding).scope(scope)
+        config = config.cache(code).scope(nil).result(result)
+        update_history(config)
+        config.update_counter(&1+1).cache('').binding(new_binding).scope(scope).result(nil)
 
       { :error, { line_no, error, token } } ->
         if token == [] do
@@ -135,8 +136,7 @@ defmodule IEx.Server do
   end
 
   defp update_history(config) do
-    current = Process.get :iex_history
-    Process.put :iex_history, [config|current]
+    IEx.History.append(config, config.counter)
   end
 
   defp io_get(config) do

lib/iex/mix.exs

@@ -17,6 +17,7 @@ defmodule IEx.Mixfile do
         directory: "blue",
         device: "green"
       ],
+      history_size: 20,
       started: true
     ]]
   end