Add source/1 to IEx

Author: josevalim

lib/iex/lib/iex/helpers.ex

@@ -51,6 +51,7 @@ defmodule IEx.Helpers do
     * `ref/1`           - creates a reference from a string
     * `ref/4`           - creates a reference with the 4 integer arguments passed
     * `runtime_info/0`  - prints runtime info (versions, memory usage, stats)
+    * `source/1`        - prints the source location for the given module or function
     * `t/1`             - prints the types for the given module or function
     * `v/0`             - retrieves the last value from the history
     * `v/1`             - retrieves the nth value from the history
@@ -343,6 +344,22 @@ defmodule IEx.Helpers do
     end
   end
 
+  @doc """
+  Prints the source code for the given module or function.
+
+  ## Examples
+
+      iex> source(MyApp)
+      iex> source(MyApp.fun/2)
+
+  """
+  @doc since: "1.20.0"
+  defmacro source(term) do
+    quote do
+      IEx.Introspection.source(unquote(decompose(term, __CALLER__)))
+    end
+  end
+
   @doc """
   Prints the documentation for `IEx.Helpers`.
   """
@@ -476,7 +493,7 @@ defmodule IEx.Helpers do
           raise ArgumentError, "could not load nor find module: #{inspect(module)}"
         end
 
-        source = source(module)
+        source = source_path(module)
 
         cond do
           source == nil ->
@@ -1008,7 +1025,7 @@ defmodule IEx.Helpers do
     end
   end
 
-  defp source(module) do
+  defp source_path(module) do
     source = module.module_info(:compile)[:source]
 
     case source do

lib/iex/lib/iex/introspection.ex

@@ -104,41 +104,27 @@ defmodule IEx.Introspection do
   Opens the given module, mfa, file/line, binary.
   """
   def open(module) when is_atom(module) do
-    case open_mfa(module, :__info__, 1) do
-      {source, nil, _} -> open(source)
-      {_, tuple, _} -> open(tuple)
+    case source_location(module) do
+      {:ok, tuple} -> open(tuple)
       {:error, reason} -> puts_error("Could not open #{inspect(module)}, #{reason}")
     end
 
     dont_display_result()
   end
 
   def open({module, function}) when is_atom(module) and is_atom(function) do
-    case open_mfa(module, function, :*) do
-      {_, _, nil} ->
-        puts_error(
-          "Could not open #{inspect(module)}.#{function}, function/macro is not available"
-        )
-
-      {_, _, tuple} ->
-        open(tuple)
-
-      {:error, reason} ->
-        puts_error("Could not open #{inspect(module)}.#{function}, #{reason}")
+    case source_location({module, function}) do
+      {:ok, tuple} -> open(tuple)
+      {:error, reason} -> puts_error("Could not open #{inspect(module)}.#{function}, #{reason}")
     end
 
     dont_display_result()
   end
 
   def open({module, function, arity})
       when is_atom(module) and is_atom(function) and is_integer(arity) do
-    case open_mfa(module, function, arity) do
-      {_, _, nil} ->
-        puts_error(
-          "Could not open #{inspect(module)}.#{function}/#{arity}, function/macro is not available"
-        )
-
-      {_, _, tuple} ->
+    case source_location({module, function, arity}) do
+      {:ok, tuple} ->
         open(tuple)
 
       {:error, reason} ->
@@ -181,13 +167,83 @@ defmodule IEx.Introspection do
     dont_display_result()
   end
 
-  defp open_mfa(module, fun, arity) do
+  @doc """
+  Prints source code.
+  """
+  def source(module) when is_atom(module) do
+    case source_location(module) do
+      {:ok, {file, _line}} ->
+        IO.puts(File.read!(file))
+
+      {:error, reason} ->
+        puts_error("Could not show source for #{inspect(module)}, #{reason}")
+    end
+
+    dont_display_result()
+  end
+
+  def source({module, function}) when is_atom(module) and is_atom(function) do
+    case source_location({module, function}) do
+      {:ok, {file, _line}} ->
+        IO.puts(File.read!(file))
+
+      {:error, reason} ->
+        puts_error("Could not show source for #{inspect(module)}.#{function}, #{reason}")
+    end
+
+    dont_display_result()
+  end
+
+  def source({module, function, arity})
+      when is_atom(module) and is_atom(function) and is_integer(arity) do
+    case source_location({module, function, arity}) do
+      {:ok, {file, _line}} ->
+        IO.puts(File.read!(file))
+
+      {:error, reason} ->
+        puts_error("Could not show source for #{inspect(module)}.#{function}/#{arity}, #{reason}")
+    end
+
+    dont_display_result()
+  end
+
+  def source(invalid) do
+    puts_error("Invalid arguments for source helper: #{inspect(invalid)}")
+    dont_display_result()
+  end
+
+  defp source_location(module) when is_atom(module) do
+    case source_mfa(module, :__info__, 1) do
+      {source, nil, _} -> {:ok, {source, 1}}
+      {_, tuple, _} -> {:ok, tuple}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp source_location({module, function}) when is_atom(module) and is_atom(function) do
+    case source_mfa(module, function, :*) do
+      {_, _, nil} -> {:error, "function/macro is not available"}
+      {_, _, tuple} -> {:ok, tuple}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp source_location({module, function, arity})
+       when is_atom(module) and is_atom(function) and is_integer(arity) do
+    case source_mfa(module, function, arity) do
+      {_, _, nil} -> {:error, "function/macro is not available"}
+      {_, _, tuple} -> {:ok, tuple}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp source_mfa(module, fun, arity) do
     case Code.ensure_loaded(module) do
       {:module, _} ->
         case module.module_info(:compile)[:source] do
           [_ | _] = source ->
             source = rewrite_source(module, source)
-            open_abstract_code(module, fun, arity, source)
+            source_abstract_code(module, fun, arity, source)
 
           _ ->
             {:error, "source code is not available"}
@@ -198,14 +254,14 @@ defmodule IEx.Introspection do
     end
   end
 
-  defp open_abstract_code(module, fun, arity, source) do
+  defp source_abstract_code(module, fun, arity, source) do
     fun = Atom.to_string(fun)
 
     with [_ | _] = beam <- :code.which(module),
          {:ok, {_, [abstract_code: abstract_code]}} <- :beam_lib.chunks(beam, [:abstract_code]),
          {:raw_abstract_v1, code} <- abstract_code do
       {_, module_pair, fa_pair} =
-        Enum.reduce(code, {source, nil, nil}, &open_abstract_code_reduce(&1, &2, fun, arity))
+        Enum.reduce(code, {source, nil, nil}, &source_abstract_code_reduce(&1, &2, fun, arity))
 
       {source, module_pair, fa_pair}
     else
@@ -214,7 +270,7 @@ defmodule IEx.Introspection do
     end
   end
 
-  defp open_abstract_code_reduce(entry, {file, module_pair, fa_pair}, fun, arity) do
+  defp source_abstract_code_reduce(entry, {file, module_pair, fa_pair}, fun, arity) do
     case entry do
       {:attribute, ann, :module, _} ->
         {file, {file, :erl_anno.line(ann)}, fa_pair}

lib/iex/test/iex/helpers_test.exs

@@ -283,7 +283,7 @@ defmodule IEx.HelpersTest do
 
     test "errors if module is in-memory" do
       assert capture_iex("defmodule Foo, do: nil ; open(Foo)") =~
-               ~r"Invalid arguments for open helper:"
+               "file is not available"
     after
       cleanup_modules([Foo])
     end
@@ -315,6 +315,43 @@ defmodule IEx.HelpersTest do
     end
   end
 
+  describe "source" do
+    @describetag :requires_source
+
+    test "prints source for Elixir module" do
+      assert capture_iex("source(HelperExampleModule)") =~ "defmodule HelperExampleModule"
+    end
+
+    test "prints source for module.function" do
+      assert capture_iex("source(HelperExampleModule.fun)") =~ "defmodule HelperExampleModule"
+    end
+
+    test "prints source for module.function/arity" do
+      assert capture_iex("source(HelperExampleModule.fun/1)") =~ "defmodule HelperExampleModule"
+    end
+
+    test "errors if module is not available" do
+      assert capture_iex("source(:unknown)") ==
+               "Could not show source for :unknown, module is not available"
+    end
+
+    test "errors if module.function is not available" do
+      assert capture_iex("source(:unknown.unknown)") ==
+               "Could not show source for :unknown.unknown, module is not available"
+
+      assert capture_iex("source(:elixir.unknown)") ==
+               "Could not show source for :elixir.unknown, function/macro is not available"
+    end
+
+    test "errors if module.function/arity is not available" do
+      assert capture_iex("source(:unknown.start/10)") ==
+               "Could not show source for :unknown.start/10, module is not available"
+
+      assert capture_iex("source(:elixir.start/10)") ==
+               "Could not show source for :elixir.start/10, function/macro is not available"
+    end
+  end
+
   describe "clear" do
     test "clear the screen with ansi" do
       Application.put_env(:elixir, :ansi_enabled, true)