feat(extension): credo

Author: mhanberg

lib/next_ls.ex

@@ -63,7 +63,8 @@ defmodule NextLS do
     dynamic_supervisor = Keyword.fetch!(args, :dynamic_supervisor)
 
     registry = Keyword.fetch!(args, :registry)
-    extensions = Keyword.get(args, :extensions, [NextLS.ElixirExtension])
+
+    extensions = Keyword.get(args, :extensions, [NextLS.ElixirExtension, NextLS.CredoExtension])
     cache = Keyword.fetch!(args, :cache)
     {:ok, logger} = DynamicSupervisor.start_child(dynamic_supervisor, {NextLS.Logger, lsp: lsp})
 
@@ -339,7 +340,11 @@ defmodule NextLS do
       {:ok, _} =
         DynamicSupervisor.start_child(
           lsp.assigns.dynamic_supervisor,
-          {extension, cache: lsp.assigns.cache, registry: lsp.assigns.registry, publisher: self()}
+          {extension,
+           cache: lsp.assigns.cache,
+           registry: lsp.assigns.registry,
+           publisher: self(),
+           task_supervisor: lsp.assigns.runtime_task_supervisor}
         )
     end
 
@@ -387,7 +392,14 @@ defmodule NextLS do
                if status == :ready do
                  Progress.stop(lsp, token, "NextLS runtime for folder #{name} has initialized!")
                  GenLSP.log(lsp, "[NextLS] Runtime for folder #{name} is ready...")
-                 send(parent, {:runtime_ready, name, self()})
+
+                 msg = {:runtime_ready, name, self()}
+
+                 dispatch(lsp.assigns.registry, :extensions, fn entries ->
+                   for {pid, _} <- entries, do: send(pid, msg)
+                 end)
+
+                 send(parent, msg)
                else
                  Progress.stop(lsp, token)
                  GenLSP.error(lsp, "[NextLS] Runtime for folder #{name} failed to initialize")
@@ -502,7 +514,13 @@ defmodule NextLS do
                  if status == :ready do
                    Progress.stop(lsp, token, "NextLS runtime for folder #{name} has initialized!")
                    GenLSP.log(lsp, "[NextLS] Runtime for folder #{name} is ready...")
-                   send(parent, {:runtime_ready, name, self()})
+                   msg = {:runtime_ready, name, self()}
+
+                   dispatch(lsp.assigns.registry, :extensions, fn entries ->
+                     for {pid, _} <- entries, do: send(pid, msg)
+                   end)
+
+                   send(parent, msg)
                  else
                    Progress.stop(lsp, token)
                    GenLSP.error(lsp, "[NextLS] Runtime for folder #{name} failed to initialize")

lib/next_ls/extensions/credo_extension.ex

@@ -0,0 +1,150 @@
+defmodule NextLS.CredoExtension do
+  @moduledoc false
+  use GenServer
+
+  alias GenLSP.Enumerations.DiagnosticSeverity
+  alias GenLSP.Structures.CodeDescription
+  alias GenLSP.Structures.Diagnostic
+  alias GenLSP.Structures.Position
+  alias GenLSP.Structures.Range
+  alias NextLS.DiagnosticCache
+  alias NextLS.Runtime
+
+  def start_link(args) do
+    GenServer.start_link(
+      __MODULE__,
+      Keyword.take(args, [:cache, :registry, :publisher, :task_supervisor]),
+      Keyword.take(args, [:name])
+    )
+  end
+
+  @impl GenServer
+  def init(args) do
+    cache = Keyword.fetch!(args, :cache)
+    registry = Keyword.fetch!(args, :registry)
+    publisher = Keyword.fetch!(args, :publisher)
+    task_supervisor = Keyword.fetch!(args, :task_supervisor)
+
+    Registry.register(registry, :extensions, :credo)
+
+    {:ok,
+     %{
+       runtimes: [],
+       cache: cache,
+       registry: registry,
+       task_supervisor: task_supervisor,
+       publisher: publisher,
+       refresh_refs: Map.new()
+     }}
+  end
+
+  def handle_info({:runtime_ready, _name, runtime_pid}, state) do
+    state =
+      case Runtime.call(runtime_pid, {Code, :ensure_loaded?, [Credo]}) do
+        {:ok, true} ->
+          :next_ls
+          |> :code.priv_dir()
+          |> Path.join("monkey/_next_ls_private_credo.ex")
+          |> then(&Runtime.call(runtime_pid, {Code, :compile_file, [&1]}))
+
+          Runtime.call(runtime_pid, {Application, :ensure_all_started, [:credo]})
+
+          Runtime.call(runtime_pid, {GenServer, :call, [Credo.CLI.Output.Shell, {:suppress_output, true}]})
+
+          update_in(state.runtimes, &[runtime_pid | &1])
+
+        _ ->
+          state
+      end
+
+    {:noreply, state}
+  end
+
+  @impl GenServer
+  def handle_info({:compiler, _diagnostics}, state) do
+    refresh_refs =
+      dispatch(state.registry, :runtimes, fn entries ->
+        for {runtime, %{path: path}} <- entries, runtime in state.runtimes, into: %{} do
+          namespace = {:credo, path}
+          DiagnosticCache.clear(state.cache, namespace)
+
+          task =
+            Task.Supervisor.async_nolink(state.task_supervisor, fn ->
+              case Runtime.call(runtime, {:_next_ls_private_credo, :issues, [path]}) do
+                {:ok, issues} -> issues
+                _error -> []
+              end
+            end)
+
+          {task.ref, namespace}
+        end
+      end)
+
+    send(state.publisher, :publish)
+
+    {:noreply, put_in(state.refresh_refs, refresh_refs)}
+  end
+
+  def handle_info({ref, issues}, %{refresh_refs: refs} = state) when is_map_key(refs, ref) do
+    Process.demonitor(ref, [:flush])
+    {{:credo, path} = namespace, refs} = Map.pop(refs, ref)
+
+    for issue <- issues do
+      diagnostic = %Diagnostic{
+        range: %Range{
+          start: %Position{
+            line: issue.line_no - 1,
+            character: (issue.column || 1) - 1
+          },
+          end: %Position{
+            line: issue.line_no - 1,
+            character: issue.column || 1
+          }
+        },
+        severity: category_to_severity(issue.category),
+        data: %{check: issue.check, file: issue.filename},
+        source: "credo",
+        code: Macro.to_string(issue.check),
+        code_description: %CodeDescription{
+          href: "https://hexdocs.pm/credo/#{Macro.to_string(issue.check)}.html"
+        },
+        message: issue.message
+      }
+
+      DiagnosticCache.put(state.cache, namespace, Path.join(path, issue.filename), diagnostic)
+    end
+
+    send(state.publisher, :publish)
+
+    {:noreply, put_in(state.refresh_refs, refs)}
+  end
+
+  def handle_info({:DOWN, ref, :process, _pid, _reason}, %{refresh_refs: refs} = state) when is_map_key(refs, ref) do
+    {_, refs} = Map.pop(refs, ref)
+
+    {:noreply, put_in(state.refresh_refs, refs)}
+  end
+
+  defp dispatch(registry, key, callback) do
+    ref = make_ref()
+    me = self()
+
+    Registry.dispatch(registry, key, fn entries ->
+      result = callback.(entries)
+
+      send(me, {ref, result})
+    end)
+
+    receive do
+      {^ref, result} -> result
+    end
+  end
+
+  defp category_to_severity(:refactor), do: DiagnosticSeverity.error()
+  defp category_to_severity(:warning), do: DiagnosticSeverity.warning()
+  defp category_to_severity(:design), do: DiagnosticSeverity.information()
+
+  defp category_to_severity(:consistency), do: DiagnosticSeverity.information()
+
+  defp category_to_severity(:readability), do: DiagnosticSeverity.information()
+end

lib/next_ls/extensions/elixir_extension.ex

@@ -24,6 +24,10 @@ defmodule NextLS.ElixirExtension do
   end
 
   @impl GenServer
+  def handle_info({:runtime_ready, _path, _pid}, state) do
+    {:noreply, state}
+  end
+
   def handle_info({:compiler, diagnostics}, state) when is_list(diagnostics) do
     DiagnosticCache.clear(state.cache, :elixir)
 

lib/next_ls/runtime.ex

@@ -50,7 +50,7 @@ defmodule NextLS.Runtime do
     on_initialized = Keyword.fetch!(opts, :on_initialized)
     db = Keyword.fetch!(opts, :db)
 
-    Registry.register(registry, :runtimes, %{name: name, uri: uri, db: db})
+    Registry.register(registry, :runtimes, %{name: name, uri: uri, path: working_dir, db: db})
 
     pid =
       cond do

priv/monkey/_next_ls_private_credo.ex

@@ -0,0 +1,10 @@
+defmodule :_next_ls_private_credo do
+  @moduledoc false
+
+  def issues(dir) do
+    ["--strict", "--all", "--working-dir", dir]
+    |> Credo.run()
+    |> Credo.Execution.get_issues()
+  end
+end
+