feat: exclude modules by wildcard name (elixir-editors#363)

* feat: exclude modules by wildcard name

With this PR I'd like to introduce the possibility for modules to be excluded without knowing their full name.

Example:

```
{
            "type": "mix_task",
            "name": "mix phx.server",
            "request": "launch",
            "task": "phx.server",
            "projectDir": "${workspaceRoot}",
            "excludeModules": [
                ":phoenix",
                "Phoenix",
                "Phoenix.*"
            ]
}
```

This helped me to use the debugging feature of the vscode-elixir-ls extension. Without this feature I was unable to collect all the modules names that need to be excluded.

* incorporate lukaszsamson's review comments

* fix: remove IO.inspect

Author: zetaron

apps/elixir_ls_debugger/lib/debugger/server.ex

@@ -530,12 +530,11 @@ defmodule ElixirLS.Debugger.Server do
       Mix.Task.run("app.start", [])
     end
 
-    exclude_modules =
+    exclude_module_names =
       config
       |> Map.get("excludeModules", [])
-      |> Enum.map(&string_to_module/1)
 
-    interpret_modules_in(Mix.Project.build_path(), exclude_modules)
+    interpret_modules_in(Mix.Project.build_path(), exclude_module_names)
 
     if required_files = config["requireFiles"], do: require_files(required_files)
 
@@ -583,12 +582,16 @@ defmodule ElixirLS.Debugger.Server do
     }
   end
 
-  defp interpret_modules_in(path, exclude_modules) do
+  defp interpret_modules_in(path, exclude_module_names) do
+    exclude_module_pattern =
+      exclude_module_names
+      |> Enum.map(&wildcard_module_name_to_pattern/1)
+
     path
     |> Path.join("**/*.beam")
     |> Path.wildcard()
     |> Enum.map(&(Path.basename(&1, ".beam") |> String.to_atom()))
-    |> Enum.filter(&interpretable?(&1, exclude_modules))
+    |> Enum.filter(&interpretable?(&1, exclude_module_pattern))
     |> Enum.map(fn mod ->
       try do
         {:module, _} = :int.ni(mod)
@@ -601,9 +604,30 @@ defmodule ElixirLS.Debugger.Server do
     end)
   end
 
-  defp interpretable?(module, exclude_modules) do
+  defp wildcard_module_name_to_pattern(module_name) do
+    module_name
+    |> prefix_module_name()
+    |> Regex.escape()
+    |> String.replace("\\*", ~s(.+))
+    |> Regex.compile!()
+  end
+
+  defp interpretable?(module, exclude_module_pattern) do
     :int.interpretable(module) == true and !:code.is_sticky(module) and module != __MODULE__ and
-      module not in exclude_modules
+      not excluded_module?(module, exclude_module_pattern)
+  end
+
+  defp excluded_module?(module, exclude_module_pattern) do
+    module_name = module |> Atom.to_string()
+
+    Enum.any?(exclude_module_pattern, &Regex.match?(&1, module_name))
+  end
+
+  defp prefix_module_name(module_name) when is_binary(module_name) do
+    case module_name do
+      ":" <> name -> name
+      _ -> "Elixir." <> module_name
+    end
   end
 
   defp change_env(env) do
@@ -697,11 +721,4 @@ defmodule ElixirLS.Debugger.Server do
         {:error, "Cannot interpret module #{inspect(module)}"}
     end
   end
-
-  defp string_to_module(str) when is_binary(str) do
-    case str do
-      ":" <> name -> String.to_atom(name)
-      name -> String.to_atom("Elixir." <> name)
-    end
-  end
 end