ruby-lsp 0.23.11 → 0.23.16

data/lib/ruby_lsp/listeners/test_style.rb

@@ -3,93 +3,180 @@
 
 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_*}.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[:label]] = { 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?
+            commands << "#{BASE_COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{full_files.join(" ")}"
+          end
+
+          commands
+        end
+
+        private
+
+        #: (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]
+            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
+
+          "#{BASE_COMMAND} -Itest #{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 = +"#{BASE_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
       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
+      BASE_COMMAND = begin
+        Bundler.with_original_env { Bundler.default_lockfile }
+        "bundle exec ruby"
+      rescue Bundler::GemfileNotFound
+        "ruby"
+      end #: String
+
+      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> 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])
+        super
+
+        @framework = :minitest #: Symbol
 
         dispatcher.register(
           self,
+          # Common handlers registered in parent class
           :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 }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
-        @visibility_stack << :public
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
-
-        fully_qualified_name = RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
-
-        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
-        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),
-          ))
+        with_test_ancestor_tracking(node) do |name, ancestors|
+          @framework = :test_unit if ancestors.include?("Test::Unit::TestCase")
+
+          if @framework == :test_unit || non_declarative_minitest?(ancestors, name)
+            @response_builder.add(Requests::Support::TestItem.new(
+              name,
+              name,
+              @uri,
+              range_from_node(node),
+              framework: @framework,
+            ))
+          end
         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
-      end
-
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
-      end
-
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
-      end
-
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         return if @visibility_stack.last != :public
 
@@ -109,10 +196,11 @@ module RubyLsp
           name,
           @uri,
           range_from_node(node),
+          framework: @framework,
         ))
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         name = node.name
         return unless ACCESS_MODIFIERS.include?(name)
@@ -120,7 +208,7 @@ module RubyLsp
         @visibility_stack << name
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_leave(node)
         name = node.name
         return unless ACCESS_MODIFIERS.include?(name)
@@ -131,7 +219,7 @@ module RubyLsp
 
       private
 
-      sig { params(attached_ancestors: T::Array[String], fully_qualified_name: String).returns(T::Boolean) }
+      #: (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 +231,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

@@ -3,18 +3,18 @@
 
 module RubyLsp
   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,12 +29,14 @@ module RubyLsp
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def syntax_error?
       @syntax_error
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> LanguageId
     def language_id
       LanguageId::RBS
     end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -7,7 +7,6 @@ module RubyLsp
     # request is used to to resolve the edit field for a given code action, if it is not already provided in the
     # textDocument/codeAction response. We can use it for scenarios that require more computation such as refactoring.
     class CodeActionResolve < Request
-      extend T::Sig
       include Support::Common
 
       NEW_VARIABLE_NAME = "new_variable"
@@ -23,7 +22,7 @@ module RubyLsp
         end
       end
 
-      sig { params(document: RubyDocument, global_state: GlobalState, code_action: T::Hash[Symbol, T.untyped]).void }
+      #: (RubyDocument document, GlobalState global_state, Hash[Symbol, untyped] code_action) -> void
       def initialize(document, global_state, code_action)
         super()
         @document = document
@@ -31,7 +30,8 @@ module RubyLsp
         @code_action = code_action
       end
 
-      sig { override.returns(T.any(Interface::CodeAction, Error)) }
+      # @override
+      #: -> (Interface::CodeAction | Error)
       def perform
         return Error::EmptySelection if @document.source.empty?
 
@@ -53,7 +53,7 @@ module RubyLsp
 
       private
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction | Error)
       def switch_block_style
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
@@ -91,13 +91,13 @@ module RubyLsp
         )
       end
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction | Error)
       def refactor_variable
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
@@ -115,10 +115,10 @@ module RubyLsp
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
         # immediately after that closest node
-        closest_node = T.must(closest_statements.child_nodes.compact.min_by do |node|
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
           distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
           distance <= 0 ? Float::INFINITY : distance
-        end)
+        end #: as !nil
 
         return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
 
@@ -153,7 +153,8 @@ module RubyLsp
           indentation_line = lines[indentation_line_number]
           return Error::InvalidTargetRange unless indentation_line
 
-          indentation = T.must(indentation_line[/\A */]).size
+          indentation = indentation_line[/\A */] #: as !nil
+            .size
 
           target_range = {
             start: { line: target_line, character: indentation },
@@ -189,13 +190,13 @@ module RubyLsp
         )
       end
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction | Error)
       def refactor_method
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
         node_context = RubyDocument.locate(
@@ -261,7 +262,7 @@ module RubyLsp
         )
       end
 
-      sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }
+      #: (Hash[Symbol, untyped] range, String new_text) -> Interface::TextEdit
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(
           range: Interface::Range.new(
@@ -272,7 +273,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::BlockNode, indentation: T.nilable(String)).returns(String) }
+      #: (Prism::BlockNode node, String? indentation) -> String
       def recursively_switch_nested_block_styles(node, indentation)
         parameters = node.parameters
         body = node.body
@@ -301,7 +302,7 @@ module RubyLsp
         source
       end
 
-      sig { params(body: Prism::Node, indentation: T.nilable(String)).returns(String) }
+      #: (Prism::Node body, String? indentation) -> String
       def switch_block_body(body, indentation)
         # Check if there are any nested blocks inside of the current block
         body_loc = body.location
@@ -330,7 +331,7 @@ module RubyLsp
         indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
       end
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction | Error)
       def create_attribute_accessor
         source_range = @code_action.dig(:data, :range)
 
@@ -379,16 +380,14 @@ module RubyLsp
 
         attribute_name = node.name[1..]
         indentation = " " * (closest_node.location.start_column + 2)
-        attribute_accessor_source = T.must(
-          case @code_action[:title]
-          when CodeActions::CREATE_ATTRIBUTE_READER
-            "#{indentation}attr_reader :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_WRITER
-            "#{indentation}attr_writer :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
-            "#{indentation}attr_accessor :#{attribute_name}\n\n"
-          end,
-        )
+        attribute_accessor_source = case @code_action[:title]
+        when CodeActions::CREATE_ATTRIBUTE_READER
+          "#{indentation}attr_reader :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_WRITER
+          "#{indentation}attr_writer :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+          "#{indentation}attr_accessor :#{attribute_name}\n\n"
+        end #: as !nil
 
         target_start_line = closest_node.location.start_line
         target_range = {

data/lib/ruby_lsp/requests/code_actions.rb

@@ -7,8 +7,6 @@ module RubyLsp
     # request informs the editor of RuboCop quick fixes that can be applied. These are accessible by hovering over a
     # specific diagnostic.
     class CodeActions < Request
-      extend T::Sig
-
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
       TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
@@ -16,22 +14,17 @@ module RubyLsp
       CREATE_ATTRIBUTE_WRITER = "Create Attribute Writer"
       CREATE_ATTRIBUTE_ACCESSOR = "Create Attribute Accessor"
 
-      INSTANCE_VARIABLE_NODES = T.let(
-        [
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
+      INSTANCE_VARIABLE_NODES = [
+        Prism::InstanceVariableAndWriteNode,
+        Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableReadNode,
+        Prism::InstanceVariableTargetNode,
+        Prism::InstanceVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::CodeActionRegistrationOptions) }
+        #: -> Interface::CodeActionRegistrationOptions
         def provider
           Interface::CodeActionRegistrationOptions.new(
             document_selector: nil,
@@ -40,22 +33,17 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          range: T::Hash[Symbol, T.untyped],
-          context: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, Hash[Symbol, untyped] range, Hash[Symbol, untyped] context) -> void
       def initialize(document, range, context)
         super()
         @document = document
-        @uri = T.let(document.uri, URI::Generic)
+        @uri = document.uri #: URI::Generic
         @range = range
         @context = context
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::CodeAction], Object))) }
+      # @override
+      #: -> (Array[Interface::CodeAction] & Object)?
       def perform
         diagnostics = @context[:diagnostics]
 
@@ -88,7 +76,7 @@ module RubyLsp
 
       private
 
-      sig { returns(T::Array[Interface::CodeAction]) }
+      #: -> Array[Interface::CodeAction]
       def attribute_actions
         return [] unless @document.is_a?(RubyDocument)