chore: support dev server using tcp transport (#43)

* chore: support dev server using tcp transport

* fix: compile expert before release

* fix: use Logger instead of IO.puts

* chore: fix credo issues

* fix: typo

* fix: try higher timeout so the slow GH runners don't freak out

* fix: transform beans in a process

* fix: bring back old beam transforms task options

Author: doorgan

.iex.exs

@@ -17,7 +17,7 @@ defmodule Engine.Plugin.Discovery do
 
   @namespaced_document_module [:Forge, :Document]
                               |> Module.concat()
-                              |> Forge.Namespace.Module.apply()
+                              |> Forge.Namespace.Module.run(apps: [:forge], roots: [Forge])
 
   def run do
     for {app_name, _, _} <- :application.loaded_applications(),
@@ -49,10 +49,12 @@ defmodule Engine.Plugin.Discovery do
   end
 
   defp namespace_module(module) when is_atom(module) do
+    app = Application.get_application(module)
+
     module
     |> :code.which()
     |> List.to_string()
-    |> Forge.Namespace.Transform.Beams.apply()
+    |> Forge.Namespace.Transform.Beams.apply_to_all(apps: [app])
   end
 
   defp unload_module(module) do

.iex.namespaced.exs

@@ -12,13 +12,31 @@ defmodule Expert.Application do
 
   @impl true
   def start(_type, _args) do
+    {m, f, a} = Application.get_env(:expert, :arg_parser)
+
+    argv = apply(m, f, a)
+
+    {opts, _, _invalid} =
+      OptionParser.parse(argv,
+        strict: [port: :integer]
+      )
+
+    buffer_opts =
+      case opts[:port] do
+        port when is_integer(port) ->
+          [communication: {GenLSP.Communication.TCP, [port: port]}]
+
+        _ ->
+          []
+      end
+
     children = [
       document_store_child_spec(),
       {DynamicSupervisor, Expert.Project.DynamicSupervisor.options()},
       {DynamicSupervisor, name: Expert.DynamicSupervisor},
       {GenLSP.Assigns, [name: Expert.Assigns]},
       {Task.Supervisor, name: :expert_task_queue},
-      {GenLSP.Buffer, name: Expert.Buffer},
+      {GenLSP.Buffer, [name: Expert.Buffer] ++ buffer_opts},
       {Expert,
        name: Expert,
        buffer: Expert.Buffer,

apps/engine/lib/engine/plugin/discovery.ex

@@ -166,11 +166,19 @@ defmodule Expert.EngineNode do
     # When Engine is built in CI for a version matrix, we'll need to check if
     # we have the right version downloaded, and if not, we should download it.
     defp glob_paths do
-      :expert
-      |> :code.priv_dir()
+      engine_path = System.get_env("EXPERT_ENGINE_PATH", default_engine_path())
+
+      Logger.info("Using Engine path: #{Path.expand(engine_path)}")
+
+      engine_path
+      |> Path.expand()
       |> Path.join("lib/**/ebin")
       |> Path.wildcard()
     end
+
+    defp default_engine_path do
+      :expert |> :code.priv_dir() |> Path.join("engine")
+    end
   end
 
   @stop_timeout 1_000

apps/expert/.iex.exs

@@ -1,7 +1,5 @@
 defmodule Expert.Release do
   def assemble(release) do
-    Mix.Task.run(:namespace, [release.path])
-
     engine_path = Path.expand("../../../engine", __DIR__)
 
     source = Path.join([engine_path, "_build/dev_ns"])
@@ -10,10 +8,13 @@ defmodule Expert.Release do
       Path.join([
         release.path,
         "lib",
-        "xp_expert-#{release.version}",
-        "priv"
+        "#{release.name}-#{release.version}",
+        "priv",
+        "engine"
       ])
 
+    File.mkdir_p!(dest)
+
     File.cp_r!(source, dest)
 
     release

apps/expert/lib/expert/application.ex

@@ -23,7 +23,7 @@ defmodule Expert.MixProject do
 
   def application do
     [
-      extra_applications: [:logger, :runtime_tools, :kernel, :erts, :observer],
+      extra_applications: [:logger, :runtime_tools, :kernel, :erts, :observer, :wx],
       mod: {Expert.Application, []}
     ]
   end

apps/expert/lib/expert/engine_node.ex

@@ -6,6 +6,25 @@ defmodule Forge.Namespace.Abstract do
   https://www.erlang.org/doc/apps/erts/absform.html
   """
 
+  def code_from(path) do
+    with {:ok, {_orig_module, code_parts}} <- :beam_lib.chunks(path, [:abstract_code]),
+         {:ok, {:raw_abstract_v1, forms}} <- Keyword.fetch(code_parts, :abstract_code) do
+      {:ok, forms}
+    else
+      _ ->
+        {:error, :not_found}
+    end
+  end
+
+  def run(abstract_format, opts) when is_list(abstract_format) do
+    fn ->
+      Process.put(:abstract_code_opts, opts)
+      Enum.map(abstract_format, fn af -> rewrite(af) end)
+    end
+    |> Task.async()
+    |> Task.await()
+  end
+
   def rewrite(abstract_format) when is_list(abstract_format) do
     Enum.map(abstract_format, &rewrite/1)
   end
@@ -294,6 +313,7 @@ defmodule Forge.Namespace.Abstract do
   end
 
   defp rewrite_module(module) do
-    Forge.Namespace.Module.apply(module)
+    opts = Process.get(:abstract_code_opts)
+    Forge.Namespace.Module.run(module, opts)
   end
 end

apps/expert/lib/expert/release.ex

@@ -1,18 +1,21 @@
 defmodule Forge.Namespace.Module do
   @namespace_prefix "XP"
 
-  def apply(module_name) do
+  def run(module_name, opts) do
+    apps = Keyword.fetch!(opts, :apps)
+    roots = Keyword.fetch!(opts, :roots)
+
     cond do
       prefixed?(module_name) ->
         module_name
 
-      module_name in Mix.Tasks.Namespace.app_names() ->
+      opts[:do_apps] && module_name in apps ->
         :"xp_#{module_name}"
 
       true ->
         module_name
         |> Atom.to_string()
-        |> apply_namespace()
+        |> apply_namespace(roots)
     end
   end
 
@@ -28,7 +31,7 @@ defmodule Forge.Namespace.Module do
   def prefixed?(@namespace_prefix <> _),
     do: true
 
-  def prefixed?("xp" <> _),
+  def prefixed?("xp_" <> _),
     do: true
 
   def prefixed?([?x, ?p, ?_ | _]), do: true
@@ -38,8 +41,9 @@ defmodule Forge.Namespace.Module do
   def prefixed?(_),
     do: false
 
-  defp apply_namespace("Elixir." <> rest) do
-    Mix.Tasks.Namespace.root_modules()
+  defp apply_namespace("Elixir." <> rest, roots) do
+    roots
+    |> Enum.filter(fn module -> Macro.classify_atom(module) == :alias end)
     |> Enum.map(fn module -> module |> Module.split() |> List.first() end)
     |> Enum.reduce_while(rest, fn root_module, module ->
       if has_root_module?(root_module, module) do
@@ -57,8 +61,14 @@ defmodule Forge.Namespace.Module do
     |> Module.concat()
   end
 
-  defp apply_namespace(erlang_module) do
-    String.to_atom(erlang_module)
+  defp apply_namespace(erlang_module, roots) do
+    erlang_module = String.to_atom(erlang_module)
+
+    if erlang_module in roots do
+      :"xp_#{erlang_module}"
+    else
+      erlang_module
+    end
   end
 
   defp has_root_module?(root_module, root_module), do: true