Support multiple root projects

This adds support for multiple projects within the server node,
and starts a project node for each detected project within the
workspace.

It also changes the manager node to use the name of the workspace
folder instead of the name of the first project that starts
distribution.

Author: doorgan

apps/common/lib/lexical/path.ex

@@ -0,0 +1,35 @@
+defmodule Lexical.Path do
+  @moduledoc """
+  Helpers for working with paths.
+  """
+
+  @doc """
+  Checks if the `parent_path` is a parent directory of the `child_path`.
+
+  This function normalizes both paths and compares their segments to determine
+  if the `parent_path` is a prefix of the `child_path`.
+
+  ## Examples
+
+      iex> Lexical.Path.parent_path?("/home/user/docs/file.txt", "/home/user")
+      true
+
+      iex> Lexical.Path.parent_path?("/home/user/docs/file.txt", "/home/admin")
+      false
+
+      iex> Lexical.Path.parent_path?("/home/user/docs", "/home/user/docs")
+      true
+
+      iex> Lexical.Path.parent_path?("/home/user/docs", "/home/user/docs/subdir")
+      false
+  """
+  def parent_path?(child_path, parent_path) do
+    normalized_child = Path.expand(child_path)
+    normalized_parent = Path.expand(parent_path)
+
+    child_segments = Path.split(normalized_child)
+    parent_segments = Path.split(normalized_parent)
+
+    Enum.take(child_segments, length(parent_segments)) == parent_segments
+  end
+end

apps/common/lib/lexical/project.ex

@@ -321,4 +321,24 @@ defmodule Lexical.Project do
     |> root_path()
     |> Path.basename()
   end
+
+  @doc """
+  Finds the project that contains the given path.
+  """
+  def project_for_uri(projects, uri) do
+    path = Document.Path.from_uri(uri)
+
+    Enum.find(projects, fn project ->
+      Lexical.Path.parent_path?(path, root_path(project))
+    end)
+  end
+
+  @doc """
+  Finds the project that contains the given document.
+  """
+  def project_for_document(projects, %Document{} = document) do
+    Enum.find(projects, fn project ->
+      Lexical.Path.parent_path?(document.path, root_path(project))
+    end)
+  end
 end

apps/common/lib/lexical/workspace.ex

@@ -0,0 +1,27 @@
+defmodule Lexical.Workspace do
+  @moduledoc """
+  The representation of the root directory where the server is running.
+  """
+
+  defstruct [:root_path]
+
+  @type t :: %__MODULE__{
+          root_path: String.t() | nil
+        }
+
+  def new(root_path) do
+    %__MODULE__{root_path: root_path}
+  end
+
+  def name(workspace) do
+    Path.basename(workspace.root_path)
+  end
+
+  def set_workspace(workspace) do
+    :persistent_term.put({__MODULE__, :workspace}, workspace)
+  end
+
+  def get_workspace do
+    :persistent_term.get({__MODULE__, :workspace}, nil)
+  end
+end

apps/remote_control/lib/lexical/remote_control.ex

@@ -119,7 +119,15 @@ defmodule Lexical.RemoteControl do
   end
 
   def manager_node_name(%Project{} = project) do
-    :"manager-#{Project.name(project)}-#{Project.entropy(project)}@127.0.0.1"
+    workspace = Lexical.Workspace.get_workspace()
+
+    workspace_name =
+      case workspace do
+        nil -> Project.name(project)
+        _ -> Lexical.Workspace.name(workspace)
+      end
+
+    :"manager-#{workspace_name}-#{Project.entropy(project)}@127.0.0.1"
   end
 
   defp start_net_kernel(%Project{} = project) do

apps/remote_control/lib/lexical/remote_control/project_node_supervisor.ex

@@ -13,11 +13,15 @@ defmodule Lexical.RemoteControl.ProjectNodeSupervisor do
   end
 
   def start_link(%Project{} = project) do
-    DynamicSupervisor.start_link(__MODULE__, project, name: __MODULE__, strategy: :one_for_one)
+    DynamicSupervisor.start_link(__MODULE__, project, name: name(project), strategy: :one_for_one)
+  end
+
+  defp name(%Project{} = project) do
+    :"#{Project.name(project)}::project_node_supervisor"
   end
 
   def start_project_node(%Project{} = project) do
-    DynamicSupervisor.start_child(__MODULE__, ProjectNode.child_spec(project))
+    DynamicSupervisor.start_child(name(project), ProjectNode.child_spec(project))
   end
 
   @impl true

apps/server/lib/lexical/server/configuration.ex

@@ -13,14 +13,14 @@ defmodule Lexical.Server.Configuration do
   alias Lexical.Server.Configuration.Support
   alias Lexical.Server.Dialyzer
 
-  defstruct project: nil,
+  defstruct projects: [],
             support: nil,
             client_name: nil,
             additional_watched_extensions: nil,
             dialyzer_enabled?: false
 
   @type t :: %__MODULE__{
-          project: Project.t() | nil,
+          projects: [Project.t()],
           support: support | nil,
           client_name: String.t() | nil,
           additional_watched_extensions: [String.t()] | nil,
@@ -34,9 +34,9 @@ defmodule Lexical.Server.Configuration do
   @spec new(Lexical.uri(), map(), String.t() | nil) :: t
   def new(root_uri, %ClientCapabilities{} = client_capabilities, client_name) do
     support = Support.new(client_capabilities)
-    project = Project.new(root_uri)
+    projects = find_projects(root_uri)
 
-    %__MODULE__{support: support, project: project, client_name: client_name}
+    %__MODULE__{support: support, projects: projects, client_name: client_name}
     |> tap(&set/1)
   end
 
@@ -45,6 +45,34 @@ defmodule Lexical.Server.Configuration do
     struct!(__MODULE__, [support: Support.new()] ++ attrs)
   end
 
+  defp find_projects(root_uri) do
+    root_path = Lexical.Document.Path.from_uri(root_uri)
+    root_mix_exs = Path.join(root_path, "mix.exs")
+
+    projects =
+      if File.exists?(root_mix_exs) do
+        [Project.new(root_uri)]
+      else
+        find_multiroot_projects(root_path)
+      end
+
+    if projects == [], do: [Project.new(root_uri)], else: projects
+  end
+
+  defp find_multiroot_projects(root_path) do
+    mix_exs_blob = Path.join([root_path, "**", "mix.exs"])
+
+    for mix_exs_path <- Path.wildcard(mix_exs_blob),
+        "deps" not in Path.split(mix_exs_path) do
+      project_uri =
+        mix_exs_path
+        |> Path.dirname()
+        |> Lexical.Document.Path.to_uri()
+
+      Project.new(project_uri)
+    end
+  end
+
   defp set(%__MODULE__{} = config) do
     :persistent_term.put(__MODULE__, config)
   end

apps/server/lib/lexical/server/provider/handlers/code_action.ex

@@ -1,4 +1,5 @@
 defmodule Lexical.Server.Provider.Handlers.CodeAction do
+  alias Lexical.Project
   alias Lexical.Protocol.Requests
   alias Lexical.Protocol.Responses
   alias Lexical.Protocol.Types
@@ -10,11 +11,13 @@ defmodule Lexical.Server.Provider.Handlers.CodeAction do
   require Logger
 
   def handle(%Requests.CodeAction{} = request, %Configuration{} = config) do
+    project = Project.project_for_document(config.projects, request.document)
+
     diagnostics = Enum.map(request.context.diagnostics, &to_code_action_diagnostic/1)
 
     code_actions =
       RemoteControl.Api.code_actions(
-        config.project,
+        project,
         request.document,
         request.range,
         diagnostics,

apps/server/lib/lexical/server/provider/handlers/code_lens.ex

@@ -14,8 +14,10 @@ defmodule Lexical.Server.Provider.Handlers.CodeLens do
   require Logger
 
   def handle(%Requests.CodeLens{} = request, %Configuration{} = config) do
+    project = Project.project_for_document(config.projects, request.document)
+
     lenses =
-      case reindex_lens(config.project, request.document) do
+      case reindex_lens(project, request.document) do
         nil -> []
         lens -> List.wrap(lens)
       end

apps/server/lib/lexical/server/provider/handlers/commands.ex

@@ -30,8 +30,9 @@ defmodule Lexical.Server.Provider.Handlers.Commands do
     response =
       case request.command do
         @reindex_name ->
-          Logger.info("Reindex #{Project.name(config.project)}")
-          reindex(config.project, request.id)
+          project_names = Enum.map_join(config.projects, ", ", &Project.name/1)
+          Logger.info("Reindex #{project_names}")
+          reindex_all(config.projects, request.id)
 
         invalid ->
           message = "#{invalid} is not a valid command"
@@ -41,16 +42,25 @@ defmodule Lexical.Server.Provider.Handlers.Commands do
     {:reply, response}
   end
 
-  defp reindex(%Project{} = project, request_id) do
-    case RemoteControl.Api.reindex(project) do
-      :ok ->
-        Responses.ExecuteCommand.new(request_id, "ok")
+  defp reindex_all(projects, request_id) do
+    result =
+      Enum.reduce_while(projects, :ok, fn project, _ ->
+        case RemoteControl.Api.reindex(project) do
+          :ok ->
+            {:cont, :ok}
 
-      error ->
-        Window.show_error_message("Indexing #{Project.name(project)} failed")
-        Logger.error("Indexing command failed due to #{inspect(error)}")
+          error ->
+            Window.show_error_message("Indexing #{Project.name(project)} failed")
+            Logger.error("Indexing command failed due to #{inspect(error)}")
 
-        internal_error(request_id, "Could not reindex: #{error}")
+            {:halt, internal_error(request_id, "Could not reindex: #{error}")}
+        end
+      end)
+
+    if result == :ok do
+      Responses.ExecuteCommand.new(request_id, "ok")
+    else
+      result
     end
   end
 

apps/server/lib/lexical/server/provider/handlers/completion.ex

@@ -2,6 +2,7 @@ defmodule Lexical.Server.Provider.Handlers.Completion do
   alias Lexical.Ast
   alias Lexical.Document
   alias Lexical.Document.Position
+  alias Lexical.Project
   alias Lexical.Protocol.Requests
   alias Lexical.Protocol.Responses
   alias Lexical.Protocol.Types.Completion
@@ -11,9 +12,11 @@ defmodule Lexical.Server.Provider.Handlers.Completion do
   require Logger
 
   def handle(%Requests.Completion{} = request, %Configuration{} = config) do
+    project = Project.project_for_document(config.projects, request.document)
+
     completions =
       CodeIntelligence.Completion.complete(
-        config.project,
+        project,
         document_analysis(request.document, request.position),
         request.position,
         request.context || Completion.Context.new(trigger_kind: :invoked)