wip

Author: andyw8

lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -7,62 +7,96 @@ class CodeLens < ::RubyLsp::Listener
       extend T::Sig
       extend T::Generic
 
+      # This feature is currently experimental. Clients will need to pass `experimentalFeaturesEnabled`
+      # in the initialization options to enable it.
+      #
+      # The
+      # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
+      # request informs the editor of runnable commands such as tests
+      #
+      # # Example
+      #
+      # ```ruby
+      # # Run
+      # class Test < Minitest::Test
+      # end
+      # ```
+
       ResponseType = type_member { { fixed: T.nilable(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, message_queue: Thread::Queue).void }
-      def initialize(uri, message_queue)
+      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.delete_prefix("file://"), String)
-        super
+        emitter.register(self, :on_command, :on_class)
+
+        super(emitter, message_queue) # can be just super later?
       end
 
-      listener_events do
-        sig { params(node: SyntaxTree::Command).void }
-        def on_command(node)
-          if @visibility == "public"
-            message_value = node.message.value
-            if message_value == "test" && node.arguments.parts.any?
-              first_argument = node.arguments.parts.first
-              method_name = first_argument.parts.first.value if first_argument.is_a?(SyntaxTree::StringLiteral)
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        if @visibility == "public"
+          message_value = node.message.value
+          if message_value == "test" && node.arguments.parts.any?
+            first_argument = node.arguments.parts.first
+            method_name = first_argument.parts.first.value if first_argument.is_a?(SyntaxTree::StringLiteral)
+            test_file_path = Pathname.new(@path).relative_path_from(RailsClient.instance.root).to_s
+            line_number = node.location.start_line
+            command = "#{BASE_COMMAND} #{test_file_path}:#{line_number}"
 
-              if method_name
-                add_code_lens(
-                  node,
-                  name: method_name,
-                  command: RubyLsp::Requests::CodeLens::BASE_COMMAND + @path + " --name " + "test_" + method_name.gsub(
-                    " ", "_"
-                  ),
-                )
-              end
+            if method_name
+              add_code_lens(node, name: method_name, command: command)
             end
           end
         end
+      end
 
-        sig { params(node: SyntaxTree::DefNode).void }
-        def on_def(node); end
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_class(node)
+        class_name = node.constant.constant.value
+        if class_name.end_with?("Test")
+          add_code_lens(node, name: class_name, command: "#{BASE_COMMAND} #{@path}")
+        end
       end
 
       private
 
       sig { params(node: SyntaxTree::Node, name: String, command: String).void }
       def add_code_lens(node, name:, command:)
-        @response << ::RubyLsp::Requests::CodeLens.create_code_lens(
+        @response = T.must(@response)
+
+        @response << create_code_lens(
           node,
+          title: "Run",
+          command_name: "rubyLsp.runTest",
           path: @path,
           name: name,
           test_command: command,
           type: "test",
         )
 
-        @response << ::RubyLsp::Requests::CodeLens.create_code_lens(
+        @response << create_code_lens(
+          node,
+          title: "Run In Terminal",
+          command_name: "rubyLsp.runTestInTerminal",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "test_in_terminal",
+        )
+
+        @response << create_code_lens(
           node,
+          title: "Debug",
+          command_name: "rubyLsp.debugTest",
           path: @path,
           name: name,
           test_command: command,

test/ruby_lsp_rails/code_lens_test.rb

@@ -6,19 +6,37 @@
 module RubyLsp
   module Rails
     class CodeLensTest < ActiveSupport::TestCase
-      test "recognizes Rails active support test cases" do
+      test "recognizes Rails Active Support test cases" do
         message_queue = Thread::Queue.new
-        listener = CodeLens.new("", message_queue)
 
-        test_name = "handles test case"
+        store = RubyLsp::Store.new
+        store.set(uri: "file:///fake.rb", source: <<~RUBY, version: 1)
+          class Test < ActiveSupport::TestCase
+            test "an example" do
+              # test body
+            end
+          end
+        RUBY
 
-        RubyLsp::EventEmitter.new(listener).emit_for_target(Command(
-          Ident("test"),
-          Args([StringLiteral([TStringContent(test_name)], "")]),
-          BodyStmt(SyntaxTree::VoidStmt, "", "", "", ""),
-        ))
+        response = RubyLsp::Executor.new(store, message_queue).execute({
+          method: "textDocument/codeLens",
+          params: { textDocument: { uri: "file:///fake.rb" }, position: { line: 0, character: 0 } },
+        }).response
 
-        assert_equal(test_name, T.must(T.must(listener.response).first).command.arguments[1])
+        # There are 9 responses in total. The first 3 responses come from ruby-lsp, but are not visible, as they are
+        # overwritten by those from ruby-lsp-rails.
+        #
+        # The next 3 responses are for the test declaration.
+        # The last 3 are for the test class.
+        assert_equal(9, response.size)
+        assert_match("Run", response[3].command.title)
+        assert_equal("bin/rails test /fake.rb", response[3].command.arguments[2])
+        assert_match("Run In Terminal", response[4].command.title)
+        assert_match("Debug", response[5].command.title)
+
+      ensure
+        RubyLsp::Requests::Hover.listeners.clear
+        T.must(message_queue).close
       end
     end
   end