Merge branch 'iex-exceptions-take-2' of github.com:pragdave/elixir into pragdave-iex-exceptions-take-2

Author: José Valim

lib/elixir/lib/exception.ex

@@ -223,35 +223,46 @@ defmodule Exception do
   @doc """
   Receives a tuple representing a stacktrace entry and formats it.
   """
-  def format_stacktrace_entry(entry)
+  def format_stacktrace_entry(entry) do
+    format_stacktrace_entry_into_fields(entry)
+    |> tuple_to_list
+    |> Enum.filter(fn field -> field && field != "" end)
+    |> Enum.join(" ")
+  end
+
+  @doc """
+  Returns the fields from a single frame in a stack trace as a list of 
+  `[ app, location, mfa/module/file ]` where all but location can be nil. 
+  Intended for use inside the Elixir libraries and iex only
+  """
 
   # From Macro.Env.stacktrace
-  def format_stacktrace_entry({ module, :__MODULE__, 0, location }) do
-    format_location(location) <> inspect(module) <> " (module)"
+  def format_stacktrace_entry_into_fields({ module, :__MODULE__, 0, location }) do
+    { nil, format_location(location), inspect(module) <> " (module)" }
   end
 
   # From :elixir_compiler_*
-  def format_stacktrace_entry({ _module, :__MODULE__, 1, location }) do
-    format_location(location) <> "(module)"
+  def format_stacktrace_entry_into_fields({ _module, :__MODULE__, 1, location }) do
+    { nil, format_location(location), "(module)" }
   end
 
   # From :elixir_compiler_*
-  def format_stacktrace_entry({ _module, :__FILE__, 1, location }) do
-    format_location(location) <> "(file)"
+  def format_stacktrace_entry_into_fields({ _module, :__FILE__, 1, location }) do
+    { nil, format_location(location),  "(file)" }
   end
 
-  def format_stacktrace_entry({module, fun, arity, location}) do
-    format_application(module) <> format_location(location) <> format_mfa(module, fun, arity)
+  def format_stacktrace_entry_into_fields({module, fun, arity, location}) do
+    { format_application(module), format_location(location), format_mfa(module, fun, arity) }
   end
 
-  def format_stacktrace_entry({fun, arity, location}) do
-    format_location(location) <> format_fa(fun, arity)
+  def format_stacktrace_entry_into_fields({fun, arity, location}) do
+    { nil, format_location(location), format_fa(fun, arity) }
   end
 
   defp format_application(module) do
     case :application.get_application(module) do
-      { :ok, app } -> "(" <> atom_to_binary(app) <> ") "
-      :undefined   -> ""
+      { :ok, app } -> "(" <> atom_to_binary(app) <> ")"
+      :undefined   -> nil
     end
   end
 
@@ -268,7 +279,6 @@ defmodule Exception do
     catch
       :stacktrace -> Enum.drop(:erlang.get_stacktrace, 1)
     end
-
     case trace do
       [] -> "\n"
       s  -> "    " <> Enum.map_join(s, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
@@ -309,74 +319,97 @@ defmodule Exception do
 
   """
   def format_fa(fun, arity) do
-    if is_list(arity) do
-      inspected = lc x inlist arity, do: inspect(x)
-      "#{inspect fun}(#{Enum.join(inspected, ", ")})"
-    else
-      "#{inspect fun}/#{arity}"
-    end
+    "#{inspect fun}#{format_arity(arity)}"
   end
 
   @doc """
   Receives a module, fun and arity and formats it
   as shown in stacktraces. The arity may also be a list
   of arguments.
-
+  
   ## Examples
-
       iex> Exception.format_mfa Foo, :bar, 1
       "Foo.bar/1"
       iex> Exception.format_mfa Foo, :bar, []
       "Foo.bar()"
       iex> Exception.format_mfa nil, :bar, []
       "nil.bar()"
 
+  Anonymous functions are reported as -func/arity-anonfn-count-,
+  where func is the name of the enclosing function. Convert to
+  "nth fn in func/arity"
   """
-  def format_mfa(module, fun, arity) do
-    fun =
-      case inspect(fun) do
-        << ?:, erl :: binary >> -> erl
-        elixir -> elixir
-      end
 
-    if is_list(arity) do
-      inspected = lc x inlist arity, do: inspect(x)
-      "#{inspect module}.#{fun}(#{Enum.join(inspected, ", ")})"
-    else
-      "#{inspect module}.#{fun}/#{arity}"
-    end
+  def format_mfa(module, nil, arity), 
+  do: do_format_mfa(module, "nil", arity) 
+
+  def format_mfa(module, fun, arity) when is_atom(fun),
+  do: do_format_mfa(module, to_string(fun), arity) 
+
+  defp do_format_mfa(module, fun, arity) when not(is_binary(fun)),
+  do: format_mfa(module, inspect(fun), arity) 
+
+  defp do_format_mfa(module, "-" <> fun, arity) do
+    [ outer_fun, "fun", count, "" ] = String.split(fun, "-")
+    "#{format_nth(count)} anonymous fn#{format_arity(arity)} in #{inspect module}.#{outer_fun}"
   end
 
+  # Erlang internal
+  defp do_format_mfa(module, ":" <> fun, arity),  
+  do: format_mfa(module, maybe_quote_name(fun), arity)
+
+  defp do_format_mfa(module, fun, arity) do
+    "#{inspect module}.#{maybe_quote_name(fun)}#{format_arity(arity)}"
+  end
+
+  defp format_arity(arity) when is_list(arity) do
+    inspected = lc x inlist arity, do: inspect(x)
+    "(#{Enum.join(inspected, ", ")})"
+  end
+
+  defp format_arity(arity),  do: "/#{arity}"
+
+  defp format_nth("0"), do: "first"
+  defp format_nth("1"), do: "second"
+  defp format_nth("2"), do: "third"
+  defp format_nth(n),   do:  "#{binary_to_integer(n)+1}th"
+
+
   @doc """
   Formats the given file and line as shown in stacktraces.
-  If any of the values are nil, they are omitted.
+  If any of the values are nil, they are omitted. If the
+  optional suffix is omitted, a space is appended to
+  the result.
 
   ## Examples
 
       iex> Exception.format_file_line("foo", 1)
       "foo:1: "
 
+      iex> Exception.format_file_line("foo", 1, "")
+      "foo:1:"
+
       iex> Exception.format_file_line("foo", nil)
       "foo: "
 
       iex> Exception.format_file_line(nil, nil)
       ""
 
   """
-  def format_file_line(file, line) do
+  def format_file_line(file, line, suffix // " ") do
     if file do
       if line && line != 0 do
-        "#{file}:#{line}: "
+        "#{file}:#{line}:#{suffix}"
       else
-        "#{file}: "
+        "#{file}:#{suffix}"
       end
     else
       ""
     end
   end
 
   defp format_location(opts) do
-    format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line)
+    format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line), ""
   end
 
   defp from_stacktrace([{ module, function, args, _ }|_]) when is_list(args) do
@@ -390,4 +423,50 @@ defmodule Exception do
   defp from_stacktrace(_) do
     { nil, nil, nil }
   end
+
+
+  # have to use :re here because exceptions may be triggered before Regexp
+  # module is compiled.
+  @function_name_re :re.compile(
+    %S{
+       \A(                                       
+            [\w]+[?!]?         
+          | ->
+          | <-
+          | :: 
+          | \|{1,3}
+          | =
+          | &&&?
+          | <=?
+          | >=? 
+          | ===?
+          | !==?
+          | =~
+          | <<< 
+          | >>>
+          | \+\+? 
+          | --? 
+          | <>
+          | \+
+          | -
+          | \*
+          | //?
+          | ^^^
+          | !
+          | \^ 
+          | & 
+          | ~~~
+          | @
+    )\z}, [:extended] )
+
+  defp maybe_quote_name(fun) do
+    name = to_string(fun)
+    {:ok, re} = @function_name_re
+    case :re.run(name, re) do
+      { :match, _} -> name
+      _            -> inspect name
+    end
+  end
+
+                                    
 end

lib/elixir/test/elixir/exception_test.exs

@@ -42,9 +42,13 @@ defmodule Kernel.ExceptionTest do
   end
 
   test "format_stacktrace_entry with application" do
-    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: 'file.ex']}) == "(elixir) file.ex: Exception.bar()"
-    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: 'file.ex', line: 10]}) == "(elixir) file.ex:10: Exception.bar()"
-    assert Exception.format_stacktrace_entry({:lists, :bar, [1, 2, 3], []}) == "(stdlib) :lists.bar(1, 2, 3)"  end
+    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: 'file.ex']}) == 
+                       "(elixir) file.ex: Exception.bar()"
+    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: 'file.ex', line: 10]}) ==
+                       "(elixir) file.ex:10: Exception.bar()"
+    assert Exception.format_stacktrace_entry({:lists, :bar, [1, 2, 3], []}) == 
+                       "(stdlib) :lists.bar(1, 2, 3)"  
+  end
 
   test "format_stacktrace_entry with fun" do
     assert Exception.format_stacktrace_entry({fn(x) -> x end, [1], []}) =~ %r/#Function<.+>\(1\)/
@@ -98,10 +102,9 @@ defmodule Kernel.ExceptionTest do
         [top|_] = System.stacktrace
         top
       end
-
     file = __ENV__.file |> Path.relative_to_cwd |> String.to_char_list!
     assert {Kernel.ExceptionTest, :"test raise preserves the stacktrace", _,
-           [file: ^file, line: 96]} = stacktrace
+           [file: ^file, line: 100]} = stacktrace
   end
 
   test "defexception" do

lib/iex/lib/iex/evaluator.ex

@@ -200,14 +200,62 @@ defmodule IEx.Evaluator do
       io_error callback.()
       case prune_stacktrace(trace) do
         []    -> :ok
-        other -> io_error Exception.format_stacktrace(other)
+        other -> IO.puts(pretty_stacktrace(other))
       end
     catch
-      _, _ ->
-        io_error "** (IEx.Error) error when printing exception message and stacktrace"
+      type, detail ->
+        io_error "** (IEx.Error) #{str(type)} (#{str(detail)}) when printing exception message and stacktrace"
     end
   end
 
+  defp str(thing) when is_binary(thing), do: thing
+  defp str(thing) do
+    try do: to_string(thing), rescue: (_ -> inspect(thing))
+  end
+    
+
+
+  # at this point, the trace is nonempty
+  def pretty_stacktrace(trace) do
+    frames = (lc frame inlist trace do
+                Exception.format_stacktrace_entry_into_fields(frame)
+              end)
+    col_0_width = calculate_width(frames, 0)
+    col_1_width = calculate_width(frames, 1)
+    lines = (lc frame inlist frames, do: pretty_print_frame(frame, col_0_width, col_1_width))
+    "  " <> Enum.join(lines, "\n  ")
+  end
+
+  defp pretty_print_frame({app, location, detail}, c1_width, c2_width) do
+    s_app = String.rjust(app||"", c1_width)
+    s_loc = String.ljust(location, c2_width)
+      
+    "#{IEx.color(:eval_error, s_app)} #{IEx.color(:stack_loc, s_loc)} #{IEx.color(:stack_mfa, detail)}"
+  end
+
+  # Look through all the entries in a particular column. If the
+  # longest differs from the smallest by less than 8, return
+  # the longest, so that smaller entries will be padded
+  # and all entries for that column will be the same length. 
+  # If the difference is greater, return 0, and no padding
+  # will be done. Public to allow testing
+  @doc nil
+  def calculate_width([ head | rest_of_lists ], column) do
+    first_line_length = length_for(head, column)
+    {min, max} = Enum.reduce(rest_of_lists, 
+                              {first_line_length,first_line_length}, 
+                              fn (line, {min, max}) ->
+                                   length = length_for(line, column)
+                                   {min(min, length), max(max, length)}
+                              end)
+    if max - min < 8, do: max, else: 0
+  end
+
+  defp length_for(line, column) do
+    string = elem line, column
+    if string, do: String.length(string), else: 0
+  end
+
   defp prune_stacktrace([{ :erl_eval, _, _, _ }|_]),  do: []
   defp prune_stacktrace([{ __MODULE__, _, _, _ }|_]), do: []
   defp prune_stacktrace([h|t]), do: [h|prune_stacktrace(t)]

lib/iex/lib/iex/options.ex

@@ -123,10 +123,12 @@ defmodule IEx.Options do
 
     * `:enabled`      - boolean value that allows for switching the coloring on and off
     * `:eval_result`  - color for an expression's resulting value
-    * `:eval_error`   - color for error messages
-    * `:eval_info`    - color for various informational messages
-    * `:ls_directory` - color for directory entries (ls helper)
-    * `:ls_device`    - color for device entries (ls helper)
+    * `:eval_error`   - … error messages
+    * `:stack_loc`    - … the location in a stack trace
+    * `:error_mfa`    - … the function name in a stack trace
+    * `:eval_info`    - … various informational messages
+    * `:ls_directory` - … for directory entries (ls helper)
+    * `:ls_device`    - … device entries (ls helper)
 
   When printing documentation, IEx will convert the markdown
   documentation to ANSI as well. Those can be configured via:

lib/iex/mix.exs

@@ -18,9 +18,11 @@ defmodule IEx.Mixfile do
 
       # Used by default on evaluation cycle
       eval_interrupt: "yellow",
-      eval_result: "yellow",
-      eval_error: "red",
-      eval_info: "normal",
+      eval_result:    "yellow",
+      eval_error:     "red",
+      eval_info:      "normal",
+      stack_loc:      "red,bright",
+      stack_mfa:      "green",
 
       # Used by ls
       ls_directory: "blue",