fix: add to PATH based on installed tool versions

Author: heywhy

apps/expert/lib/expert/engine_node.ex

@@ -171,11 +171,9 @@ 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 =
@@ -185,8 +183,6 @@ 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,
@@ -242,70 +238,6 @@ 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,36 +32,28 @@ 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", 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()}
+      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()}
       end
 
     case path_result do
       nil ->
-        {:error, :"#{exe}_not_found"}
+        {:error, :no_elixir}
 
       executable when is_binary(executable) ->
         {:ok, executable, env}
     end
   end
 
-  defp version_manager_path_and_env(manager, exe, root_path) do
+  defp version_manager_path_and_env(manager, root_path) do
     with true <- is_binary(System.find_executable(manager)),
-         env = reset_env(manager, exe, root_path),
-         {path, 0} <- System.cmd(manager, ["which", exe], cd: root_path, env: env) do
+         env = reset_env(manager, root_path),
+         {path, 0} <- System.cmd(manager, ~w(which elixir), cd: root_path, env: env) do
       {String.trim(path), env}
     else
       _ ->
@@ -72,36 +64,26 @@ 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", exe, root_path) do
-    {env, _} = System.cmd("asdf", ["env", exe], cd: root_path)
-
-    env =
-      env
-      |> String.trim()
-      |> String.split("\n")
-      |> Enum.map(fn key_and_value ->
-        [key, value] =
-          key_and_value
-          |> String.split("=", parts: 2)
-          |> Enum.map(&String.trim/1)
+  defp reset_env("asdf", root_path) do
+    data_dir = System.get_env("ASDF_DATA_DIR") || Path.join(System.user_home!(), ".asdf")
+    installs_dir = Path.join(data_dir, "installs")
 
-        {key, value}
-      end)
-      |> Enum.reject(&is_nil/1)
+    {current, 0} = System.cmd("asdf", ["list"], cd: root_path)
 
-    asdf_path =
-      case List.keyfind(env, "ASDF_INSTALL_PATH", 0) do
-        {_, path} -> Path.join(path, "../../../shims")
-        _ -> ""
-      end
+    versions = parse_asdf_installed_versions(current, %{})
+
+    installed_bin_paths =
+      versions
+      |> Enum.map(fn {tool, version} -> Path.join([installs_dir, tool, version, "bin"]) end)
+      |> Enum.join(":")
 
     Enum.map(System.get_env(), fn
-      {"PATH", path} -> {"PATH", "#{asdf_path}:#{path}"}
+      {"PATH", path} -> {"PATH", "#{installed_bin_paths}:#{path}"}
       other -> other
     end)
   end
 
-  defp reset_env("rtx", _exe, root_path) do
+  defp reset_env("rtx", root_path) do
     {env, _} = System.cmd("rtx", ~w(env -s bash), cd: root_path)
 
     env
@@ -126,7 +108,7 @@ defmodule Expert.Port do
     |> Enum.reject(&is_nil/1)
   end
 
-  defp reset_env("mise", _exe, root_path) do
+  defp reset_env("mise", root_path) do
     {env, _} = System.cmd("mise", ~w(env -s bash), cd: root_path)
 
     env
@@ -151,6 +133,39 @@ defmodule Expert.Port do
     |> Enum.reject(&is_nil/1)
   end
 
+  defp parse_asdf_installed_versions(output, acc) when is_binary(output) do
+    output
+    |> String.split("\n", trim: true)
+    |> parse_asdf_installed_versions(acc)
+  end
+
+  defp parse_asdf_installed_versions([], acc), do: acc
+
+  defp parse_asdf_installed_versions([line | rest], acc) do
+    tool_fn? = &(not String.starts_with?(&1, " "))
+
+    case tool_fn?.(line) do
+      true ->
+        {versions, rest} = Enum.split_while(rest, &(not tool_fn?.(&1)))
+        versions = Enum.map(versions, &String.trim/1)
+        version = Enum.find(versions, &String.starts_with?(&1, "*"))
+
+        case version do
+          nil ->
+            parse_asdf_installed_versions(rest, acc)
+
+          version when is_binary(version) ->
+            version = String.trim(version, "*")
+            acc = Map.put(acc, line, version)
+
+            parse_asdf_installed_versions(rest, acc)
+        end
+
+      false ->
+        parse_asdf_installed_versions(rest, acc)
+    end
+  end
+
   @doc """
   Launches an executable in the project context via a port.
   """