ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_lsp/listeners/test_style.rb

@@ -3,125 +3,245 @@
 
 module RubyLsp
   module Listeners
-    class TestStyle
-      extend T::Sig
+    class TestStyle < TestDiscovery
+      class << self
+        # Resolves the minimal set of commands required to execute the requested tests
+        #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+        def resolve_test_commands(items)
+          # A nested hash of file_path => test_group => { tags: [], examples: [test_example] } to ensure we build the
+          # minimum amount of commands needed to execute the requested tests. This is only used for specific examples
+          # where we will need more complex regexes to execute it all at the same time
+          aggregated_tests = Hash.new do |hash, key|
+            hash[key] = Hash.new do |inner_h, inner_k|
+              inner_h[inner_k] = { tags: Set.new, examples: [] }
+            end
+          end
+
+          # Full files are paths that should be executed as a whole e.g.: an entire test file or directory
+          full_files = []
+          queue = items.dup
+
+          until queue.empty?
+            item = queue.shift #: as !nil
+            tags = Set.new(item[:tags])
+            next unless tags.include?("framework:minitest") || tags.include?("framework:test_unit")
+
+            children = item[:children]
+            uri = URI(item[:uri])
+            path = uri.full_path
+            next unless path
+
+            if tags.include?("test_dir")
+              if children.empty?
+                full_files.concat(Dir.glob(
+                  "#{path}/**/{*_test,test_*,*_spec}.rb",
+                  File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
+                ))
+              end
+            elsif tags.include?("test_file")
+              full_files << path if children.empty?
+            elsif tags.include?("test_group")
+              # If all of the children of the current test group are other groups, then there's no need to add it to the
+              # aggregated examples
+              unless children.any? && children.all? { |child| child[:tags].include?("test_group") }
+                aggregated_tests[path][item[:id]] = { tags: tags, examples: [] }
+              end
+            else
+              class_name, method_name = item[:id].split("#")
+              aggregated_tests[path][class_name][:examples] << method_name
+              aggregated_tests[path][class_name][:tags].merge(tags)
+            end
+
+            queue.concat(children) unless children.empty?
+          end
+
+          commands = []
+
+          aggregated_tests.each do |file_path, groups_and_examples|
+            # Separate groups into Minitest and Test Unit. You can have both frameworks in the same file, but you cannot
+            # have a group belongs to both at the same time
+            minitest_groups, test_unit_groups = groups_and_examples.partition do |_, info|
+              info[:tags].include?("framework:minitest")
+            end
+
+            if minitest_groups.any?
+              commands << handle_minitest_groups(file_path, minitest_groups)
+            end
+
+            if test_unit_groups.any?
+              commands.concat(handle_test_unit_groups(file_path, test_unit_groups))
+            end
+          end
+
+          unless full_files.empty?
+            specs, tests = full_files.partition { |path| spec?(path) }
+
+            commands << "#{COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{tests.join(" ")}" if tests.any?
+            commands << "#{COMMAND} -Ispec -e \"ARGV.each { |f| require f }\" #{specs.join(" ")}" if specs.any?
+          end
+
+          commands
+        end
+
+        private
+
+        #: (String) -> bool
+        def spec?(path)
+          File.fnmatch?("**/spec/**/*_spec.rb", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+        end
+
+        #: (String, Hash[String, Hash[Symbol, untyped]]) -> String
+        def handle_minitest_groups(file_path, groups_and_examples)
+          regexes = groups_and_examples.flat_map do |group, info|
+            examples = info[:examples].map { |e| Shellwords.escape(e).gsub(/test_\d{4}/, "test_\\d{4}") }
+            group_regex = Shellwords.escape(group).gsub(
+              Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
+              ".*",
+            )
+            if examples.empty?
+              "^#{group_regex}(#|::)"
+            elsif examples.length == 1
+              "^#{group_regex}##{examples[0]}\\$"
+            else
+              "^#{group_regex}#(#{examples.join("|")})\\$"
+            end
+          end
+
+          regex = if regexes.length == 1
+            regexes[0]
+          else
+            "(#{regexes.join("|")})"
+          end
+
+          load_path = spec?(file_path) ? "-Ispec" : "-Itest"
+          "#{COMMAND} #{load_path} #{file_path} --name \"/#{regex}/\""
+        end
+
+        #: (String, Hash[String, Hash[Symbol, untyped]]) -> Array[String]
+        def handle_test_unit_groups(file_path, groups_and_examples)
+          groups_and_examples.map do |group, info|
+            examples = info[:examples]
+            group_regex = Shellwords.escape(group).gsub(
+              Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
+              ".*",
+            )
+            command = +"#{COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}\\$/\""
+
+            unless examples.empty?
+              command << if examples.length == 1
+                " --name \"/#{examples[0]}\\$/\""
+              else
+                " --name \"/(#{examples.join("|")})\\$/\""
+              end
+            end
+
+            command
+          end
+        end
+      end
+
       include Requests::Support::Common
 
+      MINITEST_REPORTER_PATH = File.expand_path("../test_reporters/minitest_reporter.rb", __dir__) #: String
+      TEST_UNIT_REPORTER_PATH = File.expand_path("../test_reporters/test_unit_reporter.rb", __dir__) #: String
+      BASE_COMMAND = begin
+        Bundler.with_original_env { Bundler.default_lockfile }
+        "bundle exec ruby"
+      rescue Bundler::GemfileNotFound
+        "ruby"
+      end #: String
+      COMMAND = "#{BASE_COMMAND} -r#{MINITEST_REPORTER_PATH} -r#{TEST_UNIT_REPORTER_PATH}" #: String
       ACCESS_MODIFIERS = [:public, :private, :protected].freeze
-      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
-
-      sig do
-        params(
-          response_builder: ResponseBuilders::TestCollection,
-          global_state: GlobalState,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
-      end
+
+      #: (ResponseBuilders::TestCollection, GlobalState, Prism::Dispatcher, URI::Generic) -> void
       def initialize(response_builder, global_state, dispatcher, uri)
-        @response_builder = response_builder
-        @uri = uri
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @visibility_stack = T.let([:public], T::Array[Symbol])
-        @nesting = T.let([], T::Array[String])
-
-        dispatcher.register(
-          self,
+        super(response_builder, global_state, uri)
+
+        @framework = :minitest #: Symbol
+        @parent_stack = [@response_builder] #: Array[(Requests::Support::TestItem | ResponseBuilders::TestCollection)?]
+
+        register_events(
+          dispatcher,
           :on_class_node_enter,
-          :on_class_node_leave,
-          :on_module_node_enter,
-          :on_module_node_leave,
           :on_def_node_enter,
           :on_call_node_enter,
           :on_call_node_leave,
         )
       end
 
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_enter(node)
-        @visibility_stack << :public
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        with_test_ancestor_tracking(node) do |name, ancestors|
+          @framework = :test_unit if ancestors.include?("Test::Unit::TestCase")
 
-        fully_qualified_name = RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
+          if @framework == :test_unit || non_declarative_minitest?(ancestors, name)
+            test_item = Requests::Support::TestItem.new(
+              name,
+              name,
+              @uri,
+              range_from_node(node),
+              framework: @framework,
+            )
 
-        attached_ancestors = begin
-          @index.linearized_ancestors_of(fully_qualified_name)
-        rescue RubyIndexer::Index::NonExistingNamespaceError
-          # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
-          # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
-          [node.superclass&.slice].compact
+            last_test_group.add(test_item)
+            @response_builder.add_code_lens(test_item)
+            @parent_stack << test_item
+          else
+            @parent_stack << nil
+          end
         end
-
-        if attached_ancestors.include?("Test::Unit::TestCase") ||
-            non_declarative_minitest?(attached_ancestors, fully_qualified_name)
-
-          @response_builder.add(Requests::Support::TestItem.new(
-            fully_qualified_name,
-            fully_qualified_name,
-            @uri,
-            range_from_node(node),
-          ))
-        end
-
-        @nesting << name
       end
 
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_enter(node)
-        @visibility_stack << :public
-
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
-
-        @nesting << name
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @parent_stack.pop
+        super
       end
 
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @parent_stack << nil
+        super
       end
 
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @parent_stack.pop
+        super
       end
 
-      sig { params(node: Prism::DefNode).void }
-      def on_def_node_enter(node)
+      #: (Prism::DefNode node) -> void
+      def on_def_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         return if @visibility_stack.last != :public
 
         name = node.name.to_s
         return unless name.start_with?("test_")
 
         current_group_name = RubyIndexer::Index.actual_nesting(@nesting, nil).join("::")
+        parent = @parent_stack.last
+        return unless parent.is_a?(Requests::Support::TestItem)
 
-        # If we're finding a test method, but for the wrong framework, then the group test item will not have been
-        # previously pushed and thus we return early and avoid adding items for a framework this listener is not
-        # interested in
-        test_item = @response_builder[current_group_name]
-        return unless test_item
-
-        test_item.add(Requests::Support::TestItem.new(
+        example_item = Requests::Support::TestItem.new(
           "#{current_group_name}##{name}",
           name,
           @uri,
           range_from_node(node),
-        ))
+          framework: @framework,
+        )
+        parent.add(example_item)
+        @response_builder.add_code_lens(example_item)
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         name = node.name
         return unless ACCESS_MODIFIERS.include?(name)
 
         @visibility_stack << name
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_leave(node)
+      #: (Prism::CallNode node) -> void
+      def on_call_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         name = node.name
         return unless ACCESS_MODIFIERS.include?(name)
         return unless node.arguments&.arguments
@@ -131,7 +251,13 @@ module RubyLsp
 
       private
 
-      sig { params(attached_ancestors: T::Array[String], fully_qualified_name: String).returns(T::Boolean) }
+      #: -> (Requests::Support::TestItem | ResponseBuilders::TestCollection)
+      def last_test_group
+        index = @parent_stack.rindex { |i| i } #: as !nil
+        @parent_stack[index] #: as Requests::Support::TestItem | ResponseBuilders::TestCollection
+      end
+
+      #: (Array[String] attached_ancestors, String fully_qualified_name) -> bool
       def non_declarative_minitest?(attached_ancestors, fully_qualified_name)
         return false unless attached_ancestors.include?("Minitest::Test")
 
@@ -143,22 +269,6 @@ module RubyLsp
       rescue RubyIndexer::Index::NonExistingNamespaceError
         true
       end
-
-      sig do
-        params(
-          node: T.any(
-            Prism::ConstantPathNode,
-            Prism::ConstantReadNode,
-            Prism::ConstantPathTargetNode,
-            Prism::CallNode,
-            Prism::MissingNode,
-          ),
-        ).returns(String)
-      end
-      def name_with_dynamic_reference(node)
-        slice = node.slice
-        slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
-      end
     end
   end
 end

data/lib/ruby_lsp/node_context.rb

@@ -5,36 +5,19 @@ module RubyLsp
   # This class allows listeners to access contextual information about a node in the AST, such as its parent,
   # its namespace nesting, and the surrounding CallNode (e.g. a method call).
   class NodeContext
-    extend T::Sig
-
-    sig { returns(T.nilable(Prism::Node)) }
+    #: Prism::Node?
     attr_reader :node, :parent
 
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader :nesting
 
-    sig { returns(T.nilable(Prism::CallNode)) }
+    #: Prism::CallNode?
     attr_reader :call_node
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :surrounding_method
 
-    sig do
-      params(
-        node: T.nilable(Prism::Node),
-        parent: T.nilable(Prism::Node),
-        nesting_nodes: T::Array[T.any(
-          Prism::ClassNode,
-          Prism::ModuleNode,
-          Prism::SingletonClassNode,
-          Prism::DefNode,
-          Prism::BlockNode,
-          Prism::LambdaNode,
-          Prism::ProgramNode,
-        )],
-        call_node: T.nilable(Prism::CallNode),
-      ).void
-    end
+    #: (Prism::Node? node, Prism::Node? parent, Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nesting_nodes, Prism::CallNode? call_node) -> void
     def initialize(node, parent, nesting_nodes, call_node)
       @node = node
       @parent = parent
@@ -42,16 +25,16 @@ module RubyLsp
       @call_node = call_node
 
       nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
-      @nesting = T.let(nesting, T::Array[String])
-      @surrounding_method = T.let(surrounding_method, T.nilable(String))
+      @nesting = nesting #: Array[String]
+      @surrounding_method = surrounding_method #: String?
     end
 
-    sig { returns(String) }
+    #: -> String
     def fully_qualified_name
-      @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
+      @fully_qualified_name ||= @nesting.join("::") #: String?
     end
 
-    sig { returns(T::Array[Symbol]) }
+    #: -> Array[Symbol]
     def locals_for_scope
       locals = []
 
@@ -69,20 +52,10 @@ module RubyLsp
 
     private
 
-    sig do
-      params(nodes: T::Array[T.any(
-        Prism::ClassNode,
-        Prism::ModuleNode,
-        Prism::SingletonClassNode,
-        Prism::DefNode,
-        Prism::BlockNode,
-        Prism::LambdaNode,
-        Prism::ProgramNode,
-      )]).returns([T::Array[String], T.nilable(String)])
-    end
+    #: (Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nodes) -> [Array[String], String?]
     def handle_nesting_nodes(nodes)
       nesting = []
-      surrounding_method = T.let(nil, T.nilable(String))
+      surrounding_method = nil #: String?
 
       @nesting_nodes.each do |node|
         case node

data/lib/ruby_lsp/rbs_document.rb

@@ -2,19 +2,16 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  #: [ParseResultType = Array[RBS::AST::Declarations::Base]]
   class RBSDocument < Document
-    extend T::Sig
-    extend T::Generic
-
-    ParseResultType = type_member { { fixed: T::Array[RBS::AST::Declarations::Base] } }
-
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
-      @syntax_error = T.let(false, T::Boolean)
+      @syntax_error = false #: bool
       super
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -29,14 +26,16 @@ module RubyLsp
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def syntax_error?
       @syntax_error
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> Symbol
     def language_id
-      LanguageId::RBS
+      :rbs
     end
   end
 end