Optimize and also add completion for Erlang modules

Signed-off-by: José Valim <[email protected]>

Author: José Valim

lib/iex/lib/iex/autocomplete.ex

@@ -87,8 +87,7 @@ defmodule IEx.Autocomplete do
     length = byte_size(hint)
     prefix = :binary.longest_common_prefix(binary)
     if prefix in [0, length] do
-      entries = Enum.reduce(entries, [], fn e, acc -> to_entries(e) ++ acc end)
-      yes("", entries)
+      yes("", Enum.flat_map(entries, &to_entries/1))
     else
       yes(:binary.part(first.name, prefix, length-prefix), [])
     end
@@ -111,13 +110,13 @@ defmodule IEx.Autocomplete do
   end
 
   defp expand_require(mod, hint) do
-    format_expansion module_funs(mod, hint), hint
+    format_expansion match_module_funs(mod, hint), hint
   end
 
   defp expand_import(hint) do
-    funs = module_funs(IEx.Helpers, hint) ++
-           module_funs(Kernel, hint) ++
-           module_funs(Kernel.SpecialForms, hint)
+    funs = match_module_funs(IEx.Helpers, hint) ++
+           match_module_funs(Kernel, hint) ++
+           match_module_funs(Kernel.SpecialForms, hint)
     format_expansion funs, hint
   end
 
@@ -128,10 +127,7 @@ defmodule IEx.Autocomplete do
   end
 
   defp match_erlang_modules(hint) do
-    for {mod, _} <- :code.all_loaded,
-        mod = Atom.to_string(mod),
-        not match?("Elixir." <> _, mod),
-        String.starts_with?(mod, hint) do
+    for mod <- match_modules(hint, true) do
       %{kind: :module, name: mod, type: :erlang}
     end
   end
@@ -140,57 +136,58 @@ defmodule IEx.Autocomplete do
 
   defp expand_elixir_modules(list, hint) do
     mod = Module.concat(list)
-    format_expansion elixir_aliases(mod, hint, list == []) ++ module_funs(mod, hint), hint
-  end
-
-  defp elixir_aliases(mod, hint, root) do
-    modname = Atom.to_string(mod)
-    depth   = length(String.split(modname, ".")) + 1
-    base    = modname <> "." <> hint
-
-    Enum.reduce modules_as_lists(root), [], fn(m, acc) ->
-      if String.starts_with?(m, base) do
-        tokens = String.split(m, ".")
-        if length(tokens) == depth do
-          name = List.last(tokens)
-          [%{kind: :module, type: :elixir, name: name}|acc]
-        else
-          acc
-        end
-      else
-        acc
-      end
+    format_expansion match_elixir_modules(mod, hint, list == []) ++
+                     match_module_funs(mod, hint), hint
+  end
+
+  defp match_elixir_modules(module, hint, root) do
+    module = Atom.to_string(module)
+    depth  = length(String.split(module, ".")) + 1
+    base   = module <> "." <> hint
+
+    for mod <- match_modules(base, root),
+        tokens = String.split(mod, "."),
+        length(tokens) == depth do
+      name = List.last(tokens)
+      %{kind: :module, type: :elixir, name: name}
     end
   end
 
-  defp modules_as_lists(true) do
-    ["Elixir.Elixir"] ++ modules_as_lists(false)
+  ## Helpers
+
+  defp match_modules(hint, root) do
+    get_modules(root)
+    |> :lists.usort()
+    |> Enum.drop_while(& not String.starts_with?(&1, hint))
+    |> Enum.take_while(& String.starts_with?(&1, hint))
+  end
+
+  defp get_modules(true) do
+    ["Elixir.Elixir"] ++ get_modules(false)
   end
 
-  defp modules_as_lists(false) do
+  defp get_modules(false) do
     modules = Enum.map(:code.all_loaded, fn({m, _}) -> Atom.to_string(m) end)
 
     if :code.get_mode() === :interactive do
-      Enum.uniq(modules ++ loaded_applications_as_lists())
+      modules ++ get_modules_from_applications()
     else
       modules
     end
   end
 
-  defp loaded_applications_as_lists do
+  defp get_modules_from_applications do
     for {app, _, _} <- :application.loaded_applications,
         {_, modules} = :application.get_key(app, :modules),
              module <- modules do
       Atom.to_string(module)
     end
   end
 
-  ## Helpers
-
-  defp module_funs(mod, hint) do
+  defp match_module_funs(mod, hint) do
     case ensure_loaded(mod) do
       {:module, _} ->
-        falist = get_funs(mod)
+        falist = get_module_funs(mod)
 
         list = Enum.reduce falist, [], fn {f, a}, acc ->
           case :lists.keyfind(f, 1, acc) do
@@ -203,13 +200,13 @@ defmodule IEx.Autocomplete do
             name = Atom.to_string(fun),
             String.starts_with?(name, hint) do
           %{kind: :function, name: name, arities: arities}
-        end
+        end |> :lists.sort()
       _ ->
         []
     end
   end
 
-  defp get_funs(mod) do
+  defp get_module_funs(mod) do
     if function_exported?(mod, :__info__, 1) do
       if docs = Code.get_docs(mod, :docs) do
         for {tuple, _line, _kind, _sign, doc} <- docs, doc != false, do: tuple
@@ -231,7 +228,7 @@ defmodule IEx.Autocomplete do
   end
 
   defp to_entries(%{kind: :function, name: name, arities: arities}) do
-    for a <- arities, do: "#{name}/#{a}"
+    for a <- :lists.sort(arities), do: "#{name}/#{a}"
   end
 
   defp to_uniq_entries(%{kind: :module}) do

lib/iex/test/iex/autocomplete_test.exs

@@ -7,47 +7,54 @@ defmodule IEx.AutocompleteTest do
     IEx.Autocomplete.expand(Enum.reverse expr)
   end
 
-  test :erlang_module_simple_completion do
-    assert expand(':z') == {:yes, 'lib.', []}
+  test :erlang_module_completion do
+    assert expand(':zl') == {:yes, 'ib.', []}
   end
 
   test :erlang_module_no_completion do
-    assert expand(':x') == {:no, '', []}
-    assert expand('x.Foo') == {:no, '', []}
-  end
-
-  test :erlang_module_common_prefix_completion do
-    assert expand(':us') == {:yes, 'er', []}
+    assert expand(':unknown') == {:no, '', []}
   end
 
   test :erlang_module_multiple_values_completion do
     {:yes, '', list} = expand(':user')
-    assert length(list) > 1
+    assert 'user' in list
+    assert 'user_drv' in list
+  end
+
+  test :erlang_root_completion do
+    {:yes, '', list} = expand(':')
+    assert is_list(list)
+    assert 'lists' in list
+  end
+
+  test :elixir_proxy do
+    {:yes, '', list} = expand('E')
+    assert 'Elixir' in list
   end
 
-  test :elixir_simple_completion do
+  test :elixir_completion do
     assert expand('En') == {:yes, 'um', []}
     assert expand('Enumera') == {:yes, 'ble.', []}
   end
 
-  test :elixir_auto_completion_with_self do
+  test :elixir_completion_with_self do
     assert expand('Enumerable') == {:yes, '.', []}
   end
 
-  test :elixir_auto_completion_on_modules_from_load_path do
-    assert expand('Str') == {:yes, [], ['String', 'StringIO', 'Stream']}
+  test :elixir_completion_on_modules_from_load_path do
+    assert expand('Str') == {:yes, [], ['Stream', 'String', 'StringIO']}
     assert expand('Ma') == {:yes, '', ['Macro', 'Map', 'MatchError']}
     assert expand('Dic') == {:yes, 't.', []}
-    assert expand('Ex')  == {:yes, [], ['Exception', 'ExUnit']}
+    assert expand('Ex')  == {:yes, [], ['ExUnit', 'Exception']}
   end
 
   test :elixir_no_completion do
     assert expand('.')   == {:no, '', []}
     assert expand('Xyz') == {:no, '', []}
+    assert expand('x.Foo') == {:no, '', []}
   end
 
   test :elixir_root_submodule_completion do
-    _ = [foo: 1][:foo]
     assert expand('Elixir.Acce') == {:yes, 'ss.', []}
   end
 
@@ -59,52 +66,43 @@ defmodule IEx.AutocompleteTest do
     assert expand('IEx.Xyz') == {:no, '', []}
   end
 
-  test :elixir_function_completion do
+  test :function_completion do
     assert expand('System.ve') == {:yes, 'rsion', []}
     assert expand(':ets.fun2') == {:yes, 'ms', []}
   end
 
-  test :elixir_function_completion_with_arity do
+  test :function_completion_with_arity do
     assert expand('String.printable?')  == {:yes, '', ['printable?/1']}
     assert expand('String.printable?/') == {:yes, '', ['printable?/1']}
   end
 
-  test :elixir_macro_completion do
+  test :macro_completion do
     {:yes, '', list} = expand('Kernel.is_')
     assert is_list(list)
   end
 
-  test :elixir_root_completion do
+  test :imports_completion do
     {:yes, '', list} = expand('')
     assert is_list(list)
     assert 'h/1' in list
     assert 'unquote/1' in list
+    assert 'pwd/0' in list
   end
 
-  test :elixir_kernel_completion do
+  test :kernel_import_completion do
     assert expand('defstru') == {:yes, 'ct', []}
+    assert expand('put_') == {:yes, '', ['put_elem/3', 'put_in/2', 'put_in/3']}
   end
 
-  test :elixir_special_form_completion do
+  test :kernel_special_form_completion do
     assert expand('unquote_spl') == {:yes, 'icing', []}
   end
 
-  test :elixir_proxy do
-    {:yes, '', list} = expand('E')
-    assert 'Elixir' in list
-  end
-
-  test :elixir_erlang_module_root_completion do
-    {:yes, '', list} = expand(':')
-    assert is_list(list)
-    assert 'lists' in list
-  end
-
   test :completion_inside_expression do
     assert expand('1 En') == {:yes, 'um', []}
     assert expand('Test(En') == {:yes, 'um', []}
-    assert expand('Test :z') == {:yes, 'lib.', []}
-    assert expand('[:z') == {:yes, 'lib.', []}
-    assert expand('{:z') == {:yes, 'lib.', []}
+    assert expand('Test :zl') == {:yes, 'ib.', []}
+    assert expand('[:zl') == {:yes, 'ib.', []}
+    assert expand('{:zl') == {:yes, 'ib.', []}
   end
 end