Split IEx introspection functions into its own module

Author: José Valim

lib/iex/lib/iex/helpers.ex

@@ -83,7 +83,7 @@ defmodule IEx.Helpers do
   Shows the documentation for IEx.Helpers.
   """
   def h() do
-    __help__(IEx.Helpers)
+    IEx.Introspection.h(IEx.Helpers)
   end
 
   @doc """
@@ -105,193 +105,34 @@ defmodule IEx.Helpers do
   """
   defmacro h({ :/, _, [{ { :., _, [mod, fun] }, _, [] }, arity] }) do
     quote do
-      IEx.Helpers.__help__(unquote(mod), unquote(fun), unquote(arity))
+      IEx.Introspection.h(unquote(mod), unquote(fun), unquote(arity))
     end
   end
 
   defmacro h({ { :., _, [mod, fun] }, _, [] }) do
     quote do
-      IEx.Helpers.__help__(unquote(mod), unquote(fun))
+      IEx.Introspection.h(unquote(mod), unquote(fun))
     end
   end
 
   defmacro h({ :/, _, [{ fun, _, args }, arity] }) when args == [] or is_atom(args) do
     quote do
-      IEx.Helpers.__help__(unquote(fun), unquote(arity))
+      IEx.Introspection.h(unquote(fun), unquote(arity))
     end
   end
 
   defmacro h({ name, _, args }) when args == [] or is_atom(args) do
     quote do
-      IEx.Helpers.__help__([unquote(__MODULE__), Kernel, Kernel.SpecialForms], unquote(name))
+      IEx.Introspection.h([unquote(__MODULE__), Kernel, Kernel.SpecialForms], unquote(name))
     end
   end
 
   defmacro h(other) do
     quote do
-      IEx.Helpers.__help__(unquote(other))
+      IEx.Introspection.h(unquote(other))
     end
   end
 
-  # Handles documentation for modules
-  @doc false
-  def __help__(module) when is_atom(module) do
-    case Code.ensure_loaded(module) do
-      { :module, _ } ->
-        case module.__info__(:moduledoc) do
-          { _, binary } when is_binary(binary) ->
-            IO.puts IO.ANSI.escape("%{yellow}# #{inspect module}\n")
-            IO.write IO.ANSI.escape("%{yellow}#{binary}")
-          { _, _ } ->
-            IO.puts IO.ANSI.escape("%{red}No docs for #{inspect module} have been found")
-          _ ->
-            IO.puts IO.ANSI.escape("%{red}#{inspect module} was not compiled with docs")
-        end
-      { :error, reason } ->
-        IO.puts IO.ANSI.escape("%{red}Could not load module #{inspect module}: #{reason}")
-    end
-  end
-
-  def __help__(_) do
-    IO.puts IO.ANSI.escape("%{red}Invalid arguments for h helper")
-  end
-
-  # Help for function+arity or module+function
-  @doc false
-  def __help__(modules, function) when is_list(modules) and is_atom(function) do
-    result =
-      Enum.reduce modules, :not_found, fn
-        module, :not_found -> help_mod_fun(module, function)
-        _module, acc -> acc
-      end
-
-    unless result == :ok, do:
-      IO.puts IO.ANSI.escape("%{red}No docs for #{function} have been found")
-
-    :ok
-  end
-
-  def __help__(module, function) when is_atom(module) and is_atom(function) do
-    case help_mod_fun(module, function) do
-      :ok ->
-        :ok
-      :no_docs ->
-        IO.puts IO.ANSI.escape("%{red}#{inspect module} was not compiled with docs")
-      :not_found ->
-        IO.puts IO.ANSI.escape("%{red}No docs for #{inspect module}.#{function} have been found")
-    end
-
-    :ok
-  end
-
-  def __help__(function, arity) when is_atom(function) and is_integer(arity) do
-    __help__([__MODULE__, Kernel, Kernel.SpecialForms], function, arity)
-  end
-
-  def __help__(_, _) do
-    IO.puts IO.ANSI.escape("%{red}Invalid arguments for h helper")
-  end
-
-  defp help_mod_fun(mod, fun) when is_atom(mod) and is_atom(fun) do
-    if docs = mod.__info__(:docs) do
-      result = lc { {f, arity}, _line, _type, _args, doc } inlist docs, fun == f, doc != false do
-        __help__(mod, fun, arity)
-        IO.puts ""
-      end
-
-      if result != [], do: :ok, else: :not_found
-    else
-      :no_docs
-    end
-  end
-
-  # Help for module+function+arity
-  @doc false
-  def __help__(modules, function, arity) when is_list(modules) and is_atom(function) and is_integer(arity) do
-    result =
-      Enum.reduce modules, :not_found, fn
-        module, :not_found -> help_mod_fun_arity(module, function, arity)
-        _module, acc -> acc
-      end
-
-    unless result == :ok, do:
-      IO.puts IO.ANSI.escape("%{red}No docs for #{function}/#{arity} have been found")
-
-    :ok
-  end
-
-  def __help__(module, function, arity) when is_atom(module) and is_atom(function) and is_integer(arity) do
-    case help_mod_fun_arity(module, function, arity) do
-      :ok ->
-        :ok
-      :no_docs ->
-        IO.puts IO.ANSI.escape("%{red}#{inspect module} was not compiled with docs")
-      :not_found ->
-        IO.puts IO.ANSI.escape("%{red}No docs for #{inspect module}.#{function}/#{arity} have been found")
-    end
-
-    :ok
-  end
-
-  def __help__(_, _, _) do
-    IO.puts IO.ANSI.escape("%{red}Invalid arguments for h helper")
-  end
-
-  defp help_mod_fun_arity(mod, fun, arity) when is_atom(mod) and is_atom(fun) and is_integer(arity) do
-    if docs = mod.__info__(:docs) do
-      doc =
-        cond do
-          d = find_doc(docs, fun, arity)         -> d
-          d = find_default_doc(docs, fun, arity) -> d
-          true                                   -> nil
-        end
-
-      if doc do
-        print_doc(doc)
-        :ok
-      else
-        :not_found
-      end
-    else
-      :no_docs
-    end
-  end
-
-  defp find_doc(docs, function, arity) do
-    if doc = List.keyfind(docs, { function, arity }, 0) do
-      case elem(doc, 4) do
-        false -> nil
-        _ -> doc
-      end
-    end
-  end
-
-  defp find_default_doc(docs, function, min) do
-    Enum.find docs, fn(doc) ->
-      case elem(doc, 0) do
-        { ^function, max } when max > min ->
-          defaults = Enum.count elem(doc, 3), match?({ ://, _, _ }, &1)
-          min + defaults >= max
-        _ ->
-          false
-      end
-    end
-  end
-
-  defp print_doc({ { fun, _ }, _line, kind, args, doc }) do
-    args = Enum.map_join(args, ", ", print_doc_arg(&1))
-    IO.puts IO.ANSI.escape("%{yellow}* #{kind} #{fun}(#{args})\n")
-    IO.write IO.ANSI.escape("%{yellow}#{doc}")
-  end
-
-  defp print_doc_arg({ ://, _, [left, right] }) do
-    print_doc_arg(left) <> " // " <> Macro.to_binary(right)
-  end
-
-  defp print_doc_arg({ var, _, _ }) do
-    atom_to_binary(var)
-  end
-
   @doc """
   Prints all types for the given module or prints out a specified type's
   specification
@@ -305,61 +146,20 @@ defmodule IEx.Helpers do
   """
   defmacro t({ :/, _, [{ { :., _, [mod, fun] }, _, [] }, arity] }) do
     quote do
-      IEx.Helpers.__type__(unquote(mod), unquote(fun), unquote(arity))
+      IEx.Introspection.t(unquote(mod), unquote(fun), unquote(arity))
     end
   end
 
   defmacro t({ { :., _, [mod, fun] }, _, [] }) do
     quote do
-      IEx.Helpers.__type__(unquote(mod), unquote(fun))
+      IEx.Introspection.t(unquote(mod), unquote(fun))
     end
   end
 
   defmacro t(module) do
     quote do
-      IEx.Helpers.__type__(unquote(module))
-    end
-  end
-
-  @doc false
-  def __type__(module) do
-    types = lc type inlist Kernel.Typespec.beam_types(module), do: print_type(type)
-
-    if types == [] do
-      IO.puts  IO.ANSI.escape("%{red}No types for #{inspect module} have been found")
-    end
-
-    :ok
-  end
-
-  @doc false
-  def __type__(module, type) when is_atom(type) do
-    types = lc {_, {t, _, _args}} = typespec inlist Kernel.Typespec.beam_types(module),
-               t == type do
-      print_type(typespec)
-      typespec
-    end
-
-    if types == [] do
-       IO.puts  IO.ANSI.escape("%{red}No types for #{inspect module}.#{type} have been found")
-    end
-
-    :ok
-  end
-
-  @doc false
-  def __type__(module, type, arity) do
-    types = lc {_, {t, _, args}} = typespec inlist Kernel.Typespec.beam_types(module),
-               length(args) == arity and t == type, do: typespec
-
-    case types do
-     [] ->
-       IO.puts  IO.ANSI.escape("%{red}No types for #{inspect module}.#{type}/#{arity} have been found")
-     [type] ->
-       print_type(type)
+      IEx.Introspection.t(unquote(module))
     end
-
-    :ok
   end
 
   @doc """
@@ -376,93 +176,32 @@ defmodule IEx.Helpers do
   """
   defmacro s({ :/, _, [{ { :., _, [mod, fun] }, _, [] }, arity] }) do
     quote do
-      IEx.Helpers.__spec__(unquote(mod), unquote(fun), unquote(arity))
+      IEx.Introspection.s(unquote(mod), unquote(fun), unquote(arity))
     end
   end
 
   defmacro s({ { :., _, [mod, fun] }, _, [] }) do
     quote do
-      IEx.Helpers.__spec__(unquote(mod), unquote(fun))
+      IEx.Introspection.s(unquote(mod), unquote(fun))
     end
   end
 
   defmacro s({ fun, _, args }) when args == [] or is_atom(args) do
     quote do
-      IEx.Helpers.__spec__(Kernel, unquote(fun))
+      IEx.Introspection.s(Kernel, unquote(fun))
     end
   end
 
   defmacro s({ :/, _, [{ fun, _, args }, arity] }) when args == [] or is_atom(args) do
     quote do
-      IEx.Helpers.__spec__(Kernel, unquote(fun), unquote(arity))
+      IEx.Introspection.s(Kernel, unquote(fun), unquote(arity))
     end
   end
 
   defmacro s(module) do
     quote do
-      IEx.Helpers.__spec__(unquote(module))
-    end
-  end
-
-  @doc false
-  def __spec__(module) do
-    specs = lc spec inlist beam_specs(module), do: print_spec(spec)
-
-    if specs == [] do
-      IO.puts  IO.ANSI.escape("%{red}No specs for #{inspect module} have been found")
-    end
-
-    :ok
-  end
-
-  @doc false
-  def __spec__(module, function) when is_atom(function) do
-    specs = lc {_kind, {{f, _arity}, _spec}} = spec inlist beam_specs(module),
-               f == function do
-      print_spec(spec)
-      spec
-    end
-
-    if specs == [] do
-      IO.puts  IO.ANSI.escape("%{red}No specs for #{inspect module}.#{function} have been found")
-    end
-
-    :ok
-  end
-
-  @doc false
-  def __spec__(module, function, arity) do
-    specs = lc {_kind, {{f, a}, _spec}} = spec inlist beam_specs(module),
-               f == function and a == arity do
-      print_spec(spec)
-      spec
-    end
-
-    if specs == [] do
-      IO.puts  IO.ANSI.escape("%{red}No specs for #{inspect module}.#{function} have been found")
-    end
-
-    :ok
-  end
-
-  defp beam_specs(module) do
-    specs = Enum.map(Kernel.Typespec.beam_specs(module), {:spec, &1})
-    callbacks = Enum.map(Kernel.Typespec.beam_callbacks(module), {:callback, &1})
-    List.concat(specs, callbacks)
-  end
-
-  defp print_type({ kind, type }) do
-    ast = Kernel.Typespec.type_to_ast(type)
-    IO.puts IO.ANSI.escape("%{yellow}@#{kind} #{Macro.to_binary(ast)}")
-    true
-  end
-
-  defp print_spec({kind, { { name, _arity }, specs }}) do
-    Enum.each specs, fn(spec) ->
-      binary = Macro.to_binary Kernel.Typespec.spec_to_ast(name, spec)
-      IO.puts IO.ANSI.escape("%{yellow}@#{kind} #{binary}")
+      IEx.Introspection.s(unquote(module))
     end
-    true
   end
 
   @doc """