WIP: Use index to detect test library

.rubocop.yml

@@ -87,3 +87,6 @@ Layout/ClassStructure:
       - include
       - prepend
       - extend
+
+Minitest/LiteralAsActualArgument:
+  Enabled: true

lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -31,10 +31,10 @@ def initialize
 
       @excluded_patterns = T.let(
         [
-          File.join("**", "*_test.rb"),
+          # File.join("**", "*_test.rb"),
           File.join("node_modules", "**", "*"),
-          File.join("spec", "**", "*"),
-          File.join("test", "**", "*"),
+          # File.join("spec", "**", "*"),
+          # File.join("test", "**", "*"),
           File.join("tmp", "**", "*"),
         ],
         T::Array[String],

lib/ruby_indexer/test/method_test.rb

@@ -138,7 +138,7 @@ def bar; end
         entries = T.must(@index[keyword])
         # should receive two entries because module_function creates a singleton method
         # for the Test module and a private method for classes include the Test module
-        assert_equal(entries.size, 2)
+        assert_equal(2, entries.size)
         first_entry, second_entry = *entries
         # The first entry points to the location of the module_function call
         assert_equal("Test", first_entry.owner.name)

lib/ruby_lsp/addon.rb

@@ -214,11 +214,11 @@ def handle_window_show_message_response(title); end
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        uri: URI::Generic,
+        document: RubyLsp::Document[T.untyped],
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_code_lens_listener(response_builder, uri, dispatcher); end
+    def create_code_lens_listener(response_builder, document, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do

lib/ruby_lsp/document.rb

@@ -152,6 +152,16 @@ def find_index_by_position(start_pos, end_pos = nil)
       end
     end
 
+    sig { returns(T::Boolean) }
+    def test_file?
+      false
+    end
+
+    sig { returns(String) }
+    def test_library
+      ""
+    end
+
     private
 
     sig { returns(Scanner) }

lib/ruby_lsp/global_state.rb

@@ -5,9 +5,6 @@ module RubyLsp
   class GlobalState
     extend T::Sig
 
-    sig { returns(String) }
-    attr_reader :test_library
-
     sig { returns(String) }
     attr_accessor :formatter
 
@@ -39,7 +36,6 @@ def initialize
 
       @formatter = T.let("auto", String)
       @linters = T.let([], T::Array[String])
-      @test_library = T.let("minitest", String)
       @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
@@ -142,9 +138,6 @@ def apply_options(options)
         Notification.window_log_message("Auto detected linters: #{@linters.join(", ")}")
       end
 
-      @test_library = detect_test_library(direct_dependencies)
-      notifications << Notification.window_log_message("Detected test library: #{@test_library}")
-
       @has_type_checker = detect_typechecker(all_dependencies)
       if @has_type_checker
         notifications << Notification.window_log_message(
@@ -205,6 +198,22 @@ def supports_watching_files
       @client_capabilities.supports_watching_files
     end
 
+    sig do
+      params(
+        node: T.any(
+          Prism::ConstantPathNode,
+          Prism::ConstantReadNode,
+          Prism::ConstantPathTargetNode,
+        ),
+      ).returns(T.nilable(String))
+    end
+    def constant_name(node)
+      node.full_name
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+           Prism::ConstantPathNode::MissingNodesInConstantPathError
+      nil
+    end
+
     private
 
     sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
@@ -234,26 +243,6 @@ def detect_linters(dependencies, all_dependencies)
       linters
     end
 
-    sig { params(dependencies: T::Array[String]).returns(String) }
-    def detect_test_library(dependencies)
-      if dependencies.any?(/^rspec/)
-        "rspec"
-      # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
-      # by ruby-lsp-rails. A Rails app doesn't need to depend on the rails gem itself, individual components like
-      # activestorage may be added to the gemfile so that other components aren't downloaded. Check for the presence
-      #  of bin/rails to support these cases.
-      elsif bin_rails_present
-        "rails"
-      # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
-      elsif dependencies.any?(/^minitest$/)
-        "minitest"
-      elsif dependencies.any?(/^test-unit/)
-        "test-unit"
-      else
-        "unknown"
-      end
-    end
-
     sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
     def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]

lib/ruby_lsp/listeners/code_lens.rb

@@ -26,17 +26,18 @@ class CodeLens
 
       sig do
         params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
           global_state: GlobalState,
-          uri: URI::Generic,
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+          document: RubyDocument,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, global_state, uri, dispatcher)
-        @response_builder = response_builder
+      def initialize(global_state, response_builder, document, dispatcher)
         @global_state = global_state
-        @uri = T.let(uri, URI::Generic)
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
+        @response_builder = response_builder
+        @uri = T.let(document.uri, URI::Generic)
+        # @test_library = T.let(document.test_library, String)
+        @path = T.let(@uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
         @group_stack = T.let([], T::Array[String])
@@ -65,7 +66,20 @@ def on_class_node_enter(node)
         class_name = node.constant_path.slice
         @group_stack.push(class_name)
 
-        if @path && class_name.end_with?("Test")
+        return unless @path # if file not yet saved
+
+        constant_path_node = node.constant_path
+        return if constant_path_node.is_a?(Prism::CallNode)
+
+        name = constant_name(constant_path_node)
+
+        return unless name
+
+        fully_qualified_name = actual_nesting(name).join("::")
+
+        ancestors = @global_state.index.linearized_ancestors_of(fully_qualified_name)
+
+        if ancestors.include?("Minitest::Test")
           add_test_code_lens(
             node,
             name: class_name,
@@ -79,6 +93,22 @@ def on_class_node_enter(node)
         end
       end
 
+      # TODO: move to index
+
+      sig { params(name: String).returns(T::Array[String]) }
+      def actual_nesting(name)
+        nesting = @stack + [name]
+        corrected_nesting = []
+
+        nesting.reverse_each do |name|
+          corrected_nesting.prepend(name.delete_prefix("::"))
+
+          break if name.start_with?("::")
+        end
+
+        corrected_nesting
+      end
+
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
         @visibility_stack.pop
@@ -178,7 +208,7 @@ def on_call_node_leave(node)
       sig { params(node: Prism::Node, name: String, command: String, kind: Symbol, id: String).void }
       def add_test_code_lens(node, name:, command:, kind:, id: name)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library) && @path
 
         arguments = [
           @path,
@@ -235,7 +265,7 @@ def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
         command += " -Ispec" if File.fnmatch?("**/spec/**/*", path, File::FNM_PATHNAME)
         command += " #{path}"
 
-        case @global_state.test_library
+        case @test_library
         when "minitest"
           last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
           command += if last_dynamic_reference_index
@@ -324,6 +354,44 @@ def generate_fully_qualified_id(group_stack:, method_name: nil)
           group_stack.join("::")
         end
       end
+
+      # TODO: consider moving this to common.rb
+
+      # Returns the detected test library for a group of tests
+      # sig { params(node: T.any(Prism::CallNode, Prism::ClassNode)).returns(String) }
+      # def test_library_for_group(node)
+      #   if node.is_a?(Prism::CallNode)
+      #     receiver = node.receiver
+      #     if node.name == :describe && (!receiver.is_a?(Prism::ConstantReadNode) || receiver.name == :RSpec)
+      #       return "rspec"
+      #     end
+
+      #     return "unknown"
+      #   end
+
+      #   constant_path_node = node.constant_path
+      #   return "unknown" if constant_path_node.is_a?(Prism::CallNode)
+
+      #   class_name = constant_name(constant_path_node)
+      #   # binding.break
+      #   # TODO: handle errors, e.g. if something not indexed
+      #   return "unknown" unless class_name
+
+      #   ancestors = @index.linearized_ancestors_of(class_name)
+
+      #   # ancestors = class_entries
+      #   #   .map { @global_state.index.linearized_ancestors_of(_1.name) }.flatten
+
+      #   if ancestors.include?("ActiveSupport::TestCase") # or ActiveSupport::Testing::Declarative ?
+      #     "rails"
+      #   elsif ancestors.include?("Minitest::Test")
+      #     "minitest"
+      #   elsif ancestors.include?("Test::Unit::TestCase")
+      #     "test-unit"
+      #   else
+      #     "unknown"
+      #   end
+      # end
     end
   end
 end

lib/ruby_lsp/requests/code_lens.rb

@@ -26,19 +26,20 @@ def provider
         params(
           global_state: GlobalState,
           uri: URI::Generic,
+          document: RubyLsp::RubyDocument,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(global_state, uri, dispatcher)
+      def initialize(global_state, uri, document, dispatcher)
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
         )
         super()
-        Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
+        Listeners::CodeLens.new(@global_state, @response_builder, document, dispatcher)
 
         Addon.addons.each do |addon|
-          addon.create_code_lens_listener(@response_builder, uri, dispatcher)
+          addon.create_code_lens_listener(@response_builder, document, dispatcher)
         end
       end
 

lib/ruby_lsp/ruby_document.rb

@@ -257,6 +257,41 @@ def locate_node(position, node_types: [])
       )
     end
 
+    sig { returns(String) }
+    def test_library
+      return "none" unless test_file?
+
+      class_entries = @global_state.index.entries_for(@uri.to_s, RubyIndexer::Entry::Class)
+      unless class_entries
+        return "none"
+      end
+
+      # TODO: consider performance hit
+      # A better approach might be check the classes entries one at a time.
+      ancestors = class_entries
+        .map { @global_state.index.linearized_ancestors_of(_1.name) }.flatten
+
+      # ActiveSupport::TestCase is a subclass of Minitest::Test so we must check for it first
+      if ancestors.include?("ActiveSupport::TestCase")
+        "rails"
+      elsif ancestors.include?("Minitest::Test")
+        "minitest"
+      elsif ancestors.include?("Test::Unit::TestCase")
+        "test-unit"
+      else
+        "unknown"
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def test_file?
+      # if the file is not saved, then we don't know its path, so can't know it's a test
+      return false unless @uri.path # file may not be saved
+
+      path = T.must(@uri.path)
+      path.include?("/test/") || path.include?("/spec/")
+    end
+
     sig { returns(T::Boolean) }
     def should_index?
       # This method controls when we should index documents. If there's no recent edit and the document has just been

lib/ruby_lsp/server.rb

@@ -470,7 +470,8 @@ def run_combined_requests(message)
       folding_range = Requests::FoldingRanges.new(parse_result.comments, dispatcher)
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
-      code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
+      # TODO: seperate PR for global state
+      code_lens = Requests::CodeLens.new(global_state, uri, document, dispatcher) if document.is_a?(RubyDocument)
       inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
 
       if document.is_a?(RubyDocument) && document.should_index?
@@ -494,7 +495,7 @@ def run_combined_requests(message)
       document.cache_set("textDocument/foldingRange", folding_range.perform)
       document.cache_set("textDocument/documentSymbol", document_symbol.perform)
       document.cache_set("textDocument/documentLink", document_link.perform)
-      document.cache_set("textDocument/codeLens", code_lens.perform)
+      document.cache_set("textDocument/codeLens", code_lens.perform) if code_lens
       document.cache_set("textDocument/inlayHint", inlay_hint.perform)
 
       send_message(Result.new(id: message[:id], response: document.cache_get(message[:method])))