Add Code Lens behaviour for running Rails tests

Author: andyw8

Gemfile.lock

@@ -3,7 +3,7 @@ PATH
   specs:
     ruby-lsp-rails (0.1.0)
       rails (>= 6.0)
-      ruby-lsp (>= 0.5.1, < 0.7.0)
+      ruby-lsp (>= 0.6.2, < 0.7.0)
       sorbet-runtime (>= 0.5.9897)
 
 GEM
@@ -195,7 +195,7 @@ GEM
       rubocop (~> 1.51)
     rubocop-sorbet (0.7.0)
       rubocop (>= 0.90.0)
-    ruby-lsp (0.6.1)
+    ruby-lsp (0.6.2)
       language_server-protocol (~> 3.17.0)
       sorbet-runtime
       syntax_tree (>= 6.1.1, < 7)

Rakefile

@@ -27,9 +27,6 @@ RDoc::Task.new do |rdoc|
   rdoc.options.push("--copy-files", "LICENSE.txt")
 end
 
-RubyLsp::CheckDocs.new(
-  FileList["#{__dir__}/lib/ruby_lsp/ruby_lsp_rails/**/*.rb"],
-  FileList["#{__dir__}/**/*.gif"],
-)
+RubyLsp::CheckDocs.new(FileList["#{__dir__}/lib/ruby_lsp/**/*.rb"], FileList["#{__dir__}/misc/**/*.gif"])
 
 task default: :test

lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -0,0 +1,139 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    # ![CodeLens demo](../../code_lens.gif)
+    #
+    # This feature adds several CodeLens features for Rails applications using the built-in test framework:
+    # - Run tests in the VS Terminal
+    # - Run tests in the VS Code Test Explorer
+    # - Debug tests
+    #
+    # The
+    # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
+    # request informs the editor of runnable commands such as tests
+    #
+    # Example:
+    #
+    # For the following code, Code Lenses will be added above the class definition above each test method.
+    #
+    # ```ruby
+    # Run
+    # class HelloTest < ActiveSupport::TestCase
+    #   test "outputs hello" do
+    #     # ...
+    #   end
+    #
+    #   test "outputs goodbye" do
+    #     # ...
+    #   end
+    # end
+    # ````
+    #
+    # The code lenses will be displayed above the class and above each test method.
+    class CodeLens < ::RubyLsp::Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[::RubyLsp::Interface::CodeLens] } }
+      BASE_COMMAND = "bin/rails test"
+
+      ::RubyLsp::Requests::CodeLens.add_listener(self)
+
+      sig { override.returns(ResponseType) }
+      attr_reader :response
+
+      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(uri, emitter, message_queue)
+        @response = T.let([], ResponseType)
+        @visibility = T.let("public", String)
+        @prev_visibility = T.let("public", String)
+        @path = T.let(URI(uri).path, T.nilable(String))
+        @relative_path = T.let(Pathname.new(@path).relative_path_from(RailsClient.instance.root).to_s, String)
+        emitter.register(self, :on_command, :on_class, :on_def)
+
+        super(emitter, message_queue)
+      end
+
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        return unless @visibility == "public"
+
+        message_value = node.message.value
+        return unless message_value == "test" && node.arguments.parts.any?
+
+        first_argument = node.arguments.parts.first
+        return unless first_argument.is_a?(SyntaxTree::StringLiteral)
+
+        test_name = first_argument.parts.first.value
+        return unless test_name
+
+        line_number = node.location.start_line
+        command = "#{BASE_COMMAND} #{@relative_path}:#{line_number}"
+        add_test_code_lens(node, name: test_name, command: command, kind: :example)
+      end
+
+      # Although uncommon, Rails tests can be written with the classic "def test_name" syntax.
+      sig { params(node: SyntaxTree::DefNode).void }
+      def on_def(node)
+        method_name = node.name.value
+        if method_name.start_with?("test_")
+          line_number = node.location.start_line
+          command = "#{BASE_COMMAND} #{@relative_path}:#{line_number}"
+          add_test_code_lens(node, name: method_name, command: command, kind: :example)
+        end
+      end
+
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_class(node)
+        class_name = node.constant.constant.value
+        if class_name.end_with?("Test")
+          command = "#{BASE_COMMAND} #{@relative_path}"
+          add_test_code_lens(node, name: class_name, command: command, kind: :group)
+        end
+      end
+
+      private
+
+      sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
+      def add_test_code_lens(node, name:, command:, kind:)
+        arguments = [
+          @path,
+          name,
+          command,
+          {
+            start_line: node.location.start_line - 1,
+            start_column: node.location.start_column,
+            end_line: node.location.end_line - 1,
+            end_column: node.location.end_column,
+          },
+        ]
+
+        @response << create_code_lens(
+          node,
+          title: "Run",
+          command_name: "rubyLsp.runTest",
+          arguments: arguments,
+          data: { type: "test", kind: kind },
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Run In Terminal",
+          command_name: "rubyLsp.runTestInTerminal",
+          arguments: arguments,
+          data: { type: "test_in_terminal", kind: kind },
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Debug",
+          command_name: "rubyLsp.debugTest",
+          arguments: arguments,
+          data: { type: "debug", kind: kind },
+        )
+      end
+    end
+  end
+end

lib/ruby_lsp/ruby_lsp_rails/extension.rb

@@ -5,6 +5,7 @@
 
 require_relative "rails_client"
 require_relative "hover"
+require_relative "code_lens"
 
 module RubyLsp
   module Rails
@@ -13,6 +14,7 @@ class Extension < ::RubyLsp::Extension
 
       sig { override.void }
       def activate
+        # Must be the last statement in activate since it raises to display a notification for the user
         RubyLsp::Rails::RailsClient.instance.check_if_server_is_running!
       end
 

lib/ruby_lsp/ruby_lsp_rails/rails_client.rb

@@ -7,7 +7,8 @@
 module RubyLsp
   module Rails
     class RailsClient
-      class ServerAddressUnknown < StandardError; end
+      class ServerNotRunningError < StandardError; end
+      class NeedsRestartError < StandardError; end
 
       extend T::Sig
       include Singleton
@@ -30,16 +31,21 @@ def initialize
         @root = T.let(Dir.exist?(dummy_path) ? dummy_path : project_root.to_s, String)
         app_uri_path = "#{@root}/tmp/app_uri.txt"
 
-        if File.exist?(app_uri_path)
-          url = File.read(app_uri_path).chomp
+        unless File.exist?(app_uri_path)
+          raise NeedsRestartError, <<~MESSAGE
+            The Ruby LSP Rails extension needs to be initialized. Please restart the Rails server and the Ruby LSP
+            to get Rails features in the editor
+          MESSAGE
+        end
 
-          scheme, rest = url.split("://")
-          uri, port = T.must(rest).split(":")
+        url = File.read(app_uri_path).chomp
 
-          @ssl = T.let(scheme == "https", T::Boolean)
-          @uri = T.let(T.must(uri), T.nilable(String))
-          @port = T.let(T.must(port).to_i, Integer)
-        end
+        scheme, rest = url.split("://")
+        uri, port = T.must(rest).split(":")
+
+        @ssl = T.let(scheme == "https", T::Boolean)
+        @uri = T.let(T.must(uri), String)
+        @port = T.let(T.must(port).to_i, Integer)
       end
 
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -48,15 +54,15 @@ def model(name)
         return unless response.code == "200"
 
         JSON.parse(response.body.chomp, symbolize_names: true)
-      rescue Errno::ECONNREFUSED, ServerAddressUnknown
-        nil
+      rescue Errno::ECONNREFUSED
+        raise ServerNotRunningError, SERVER_NOT_RUNNING_MESSAGE
       end
 
       sig { void }
       def check_if_server_is_running!
         request("activate", 0.2)
-      rescue Errno::ECONNREFUSED, ServerAddressUnknown
-        warn(SERVER_NOT_RUNNING_MESSAGE)
+      rescue Errno::ECONNREFUSED
+        raise ServerNotRunningError, SERVER_NOT_RUNNING_MESSAGE
       rescue Net::ReadTimeout
         # If the server is running, but the initial request is taking too long, we don't want to block the
         # initialization of the Ruby LSP
@@ -66,8 +72,6 @@ def check_if_server_is_running!
 
       sig { params(path: String, timeout: T.nilable(Float)).returns(Net::HTTPResponse) }
       def request(path, timeout = nil)
-        raise ServerAddressUnknown unless @uri
-
         http = Net::HTTP.new(@uri, @port)
         http.use_ssl = @ssl
         http.read_timeout = timeout if timeout

lib/ruby_lsp_rails/railtie.rb

@@ -14,15 +14,7 @@ class Railtie < ::Rails::Railtie
           if defined?(::Rails::Server)
             ssl_enable, host, port = ::Rails::Server::Options.new.parse!(ARGV).values_at(:SSLEnable, :Host, :Port)
             app_uri = "#{ssl_enable ? "https" : "http"}://#{host}:#{port}"
-            app_uri_path = "#{::Rails.root}/tmp/app_uri.txt"
-            File.write(app_uri_path, app_uri)
-
-            at_exit do
-              # The app_uri.txt file should only exist when the server is running. The extension uses its presence to
-              # report if the server is running or not. If the server is not running, some of the extension features
-              # will not be available.
-              File.delete(app_uri_path) if File.exist?(app_uri_path)
-            end
+            File.write("#{::Rails.root}/tmp/app_uri.txt", app_uri)
           end
         end
       end

misc/code_lens.gif

@@ -22,6 +22,6 @@ Gem::Specification.new do |spec|
   end
 
   spec.add_dependency("rails", ">= 6.0")
-  spec.add_dependency("ruby-lsp", ">= 0.5.1", "< 0.7.0")
+  spec.add_dependency("ruby-lsp", ">= 0.6.2", "< 0.7.0")
   spec.add_dependency("sorbet-runtime", ">= 0.5.9897")
 end