fix: resolves issue #91

Author: heywhy

apps/expert/lib/expert/engine_node.ex

@@ -171,9 +171,11 @@ defmodule Expert.EngineNode do
     # Expert release, and we build it on the fly for the project elixir+opt
     # versions if it was not built yet.
     defp glob_paths(%Project{} = project) do
+      {:ok, erl, _env} = Expert.Port.erlang_executable(project)
       {:ok, elixir, env} = Expert.Port.elixir_executable(project)
 
       expert_priv = :code.priv_dir(:expert)
+      root_path = Project.root_path(project)
       packaged_engine_source = Path.join([expert_priv, "engine_source", "apps", "engine"])
 
       engine_source =
@@ -183,6 +185,8 @@ defmodule Expert.EngineNode do
 
       build_engine_script = Path.join(expert_priv, "build_engine.exs")
 
+      :ok = patch_versions_file(root_path, engine_source, erl, elixir)
+
       opts =
         [
           :stderr_to_stdout,
@@ -238,6 +242,70 @@ defmodule Expert.EngineNode do
       |> Path.join("lib/**/ebin")
       |> Path.wildcard()
     end
+
+    defp patch_versions_file(root_path, engine_source, erl, elixir) do
+      {elixir_version, 0} = System.cmd(elixir, ["--short-version"], cd: root_path)
+
+      {erl_version, 0} =
+        System.cmd(
+          erl,
+          [
+            "-eval",
+            "{ok, Version} = file:read_file(filename:join([code:root_dir(), \"releases\", erlang:system_info(otp_release), \"OTP_VERSION\"])), io:fwrite(Version), halt().",
+            "-noshell"
+          ],
+          cd: root_path
+        )
+
+      versions_path = Path.join([engine_source, ".tool-versions"])
+
+      overrides = %{
+        "elixir" => String.trim(elixir_version),
+        "erlang" => String.trim(erl_version)
+      }
+
+      with true <- File.exists?(versions_path),
+           {:ok, versions} <- read_versions(versions_path) do
+        updated = Map.merge(versions, overrides)
+        content = versions_to_iodata(updated)
+
+        File.write(versions_path, content)
+      else
+        false ->
+          content = versions_to_iodata(overrides)
+
+          File.write(versions_path, content)
+
+        error ->
+          error
+      end
+    end
+
+    defp versions_to_iodata(versions) do
+      Enum.map(versions, fn {lang, version} -> [lang, " ", version, "\n"] end)
+    end
+
+    defp read_versions(path) do
+      case File.read(path) do
+        {:ok, content} ->
+          versions =
+            content
+            |> String.split("\n")
+            |> Enum.map(&String.trim/1)
+            |> Enum.reject(&(&1 == ""))
+            |> Enum.reduce(%{}, fn line, acc ->
+              case String.split(line) do
+                [lang, version] -> Map.put(acc, lang, version)
+                [] -> acc
+              end
+            end)
+
+          {:ok, versions}
+
+        {:error, _reason} = error ->
+          error
+      end
+    end
   end
 
   @stop_timeout 1_000

apps/expert/lib/expert/port.ex

@@ -32,28 +32,36 @@ defmodule Expert.Port do
   end
 
   def elixir_executable(%Project{} = project) do
+    find_executable(project, "elixir")
+  end
+
+  def erlang_executable(%Project{} = project) do
+    find_executable(project, "erl")
+  end
+
+  defp find_executable(project, exe) do
     root_path = Project.root_path(project)
 
     {path_result, env} =
-      with nil <- version_manager_path_and_env("asdf", root_path),
-           nil <- version_manager_path_and_env("mise", root_path),
-           nil <- version_manager_path_and_env("rtx", root_path) do
-        {File.cd!(root_path, fn -> System.find_executable("elixir") end), System.get_env()}
+      with nil <- version_manager_path_and_env("asdf", exe, root_path),
+           nil <- version_manager_path_and_env("mise", exe, root_path),
+           nil <- version_manager_path_and_env("rtx", exe, root_path) do
+        {File.cd!(root_path, fn -> System.find_executable(exe) end), System.get_env()}
       end
 
     case path_result do
       nil ->
-        {:error, :no_elixir}
+        {:error, :"#{exe}_not_found"}
 
       executable when is_binary(executable) ->
         {:ok, executable, env}
     end
   end
 
-  defp version_manager_path_and_env(manager, root_path) do
+  defp version_manager_path_and_env(manager, exe, root_path) do
     with true <- is_binary(System.find_executable(manager)),
-         env = reset_env(manager, root_path),
-         {path, 0} <- System.cmd(manager, ~w(which elixir), cd: root_path, env: env) do
+         env = reset_env(manager, exe, root_path),
+         {path, 0} <- System.cmd(manager, ["which", exe], cd: root_path, env: env) do
       {String.trim(path), env}
     else
       _ ->
@@ -64,8 +72,8 @@ defmodule Expert.Port do
   # We launch expert by asking the version managers to provide an environment,
   # which contains path munging. This initial environment is present in the running
   # VM, and needs to be undone so we can find the correct elixir executable in the project.
-  defp reset_env("asdf", root_path) do
-    {env, _} = System.cmd("asdf", ~w(env elixir), cd: root_path)
+  defp reset_env("asdf", exe, root_path) do
+    {env, _} = System.cmd("asdf", ["env", exe], cd: root_path)
 
     env =
       env
@@ -93,7 +101,7 @@ defmodule Expert.Port do
     end)
   end
 
-  defp reset_env("rtx", root_path) do
+  defp reset_env("rtx", _exe, root_path) do
     {env, _} = System.cmd("rtx", ~w(env -s bash), cd: root_path)
 
     env
@@ -118,7 +126,7 @@ defmodule Expert.Port do
     |> Enum.reject(&is_nil/1)
   end
 
-  defp reset_env("mise", root_path) do
+  defp reset_env("mise", _exe, root_path) do
     {env, _} = System.cmd("mise", ~w(env -s bash), cd: root_path)
 
     env