fix: revert dev server (#48)

* Revert "fix: use correct build directory when namespacing expert"

This reverts commit b6540dd.

* Revert "fix: properly set the mix env when building expert"

This reverts commit 4caf258.

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

This reverts commit 15581e7.

* chore: remove just start docs

Author: doorgan

.iex.exs

@@ -0,0 +1,7 @@
+use Expert.IEx.Helpers
+
+try do
+  Mix.ensure_application!(:observer)
+rescue
+  _ -> nil
+end

.iex.namespaced.exs

@@ -0,0 +1,2 @@
+use XPExpert.Server.IEx.Helpers
+alias XPExpert, as: EXpert

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

@@ -17,7 +17,7 @@ defmodule Engine.Plugin.Discovery do
 
   @namespaced_document_module [:Forge, :Document]
                               |> Module.concat()
-                              |> Forge.Namespace.Module.run(apps: [:forge], roots: [Forge])
+                              |> Forge.Namespace.Module.apply()
 
   def run do
     for {app_name, _, _} <- :application.loaded_applications(),
@@ -49,12 +49,10 @@ 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_to_all(apps: [app])
+    |> Forge.Namespace.Transform.Beams.apply()
   end
 
   defp unload_module(module) do

apps/expert/.iex.exs

@@ -0,0 +1,14 @@
+alias Forge.Project
+
+other_project =
+  [
+    File.cwd!(),
+    "..",
+    "..",
+    "..",
+    "eakins"
+  ]
+  |> Path.join()
+  |> Path.expand()
+
+project = Forge.Project.new("file://#{other_project}")

apps/expert/lib/expert/application.ex

@@ -12,31 +12,13 @@ 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] ++ buffer_opts},
+      {GenLSP.Buffer, name: Expert.Buffer},
       {Expert,
        name: Expert,
        buffer: Expert.Buffer,

apps/expert/lib/expert/engine_node.ex

@@ -166,19 +166,11 @@ 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
-      engine_path = System.get_env("EXPERT_ENGINE_PATH", default_engine_path())
-
-      Logger.info("Using Engine path: #{Path.expand(engine_path)}")
-
-      engine_path
-      |> Path.expand()
+      :expert
+      |> :code.priv_dir()
       |> 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/lib/expert/release.ex

@@ -1,5 +1,7 @@
 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"])
@@ -8,13 +10,10 @@ defmodule Expert.Release do
       Path.join([
         release.path,
         "lib",
-        "#{release.name}-#{release.version}",
-        "priv",
-        "engine"
+        "xp_expert-#{release.version}",
+        "priv"
       ])
 
-    File.mkdir_p!(dest)
-
     File.cp_r!(source, dest)
 
     release

apps/expert/mix.exs

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

apps/forge/lib/forge/namespace/abstract.ex

@@ -6,25 +6,6 @@ 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
@@ -313,7 +294,6 @@ defmodule Forge.Namespace.Abstract do
   end
 
   defp rewrite_module(module) do
-    opts = Process.get(:abstract_code_opts)
-    Forge.Namespace.Module.run(module, opts)
+    Forge.Namespace.Module.apply(module)
   end
 end

apps/forge/lib/forge/namespace/module.ex

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