ruby-lsp 0.23.10 → 0.23.12

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -0,0 +1,199 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class SpecStyle
+      extend T::Sig
+      include Requests::Support::Common
+
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
+
+      #: (response_builder: ResponseBuilders::TestCollection, global_state: GlobalState, dispatcher: Prism::Dispatcher, uri: 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])
+        @describe_block_nesting = T.let([], T::Array[String])
+        @spec_class_stack = T.let([], T::Array[T::Boolean])
+
+        dispatcher.register(
+          self,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+          :on_call_node_enter, # e.g. `describe` or `it`
+          :on_call_node_leave,
+        )
+      end
+
+      #: (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)
+
+        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
+
+        is_spec = attached_ancestors.include?("Minitest::Spec")
+        @spec_class_stack.push(is_spec)
+
+        @nesting << name
+      end
+
+      #: (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
+
+      #: (node: Prism::ModuleNode) -> void
+      def on_module_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      #: (node: Prism::ClassNode) -> void
+      def on_class_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+        @spec_class_stack.pop
+      end
+
+      #: (node: Prism::CallNode) -> void
+      def on_call_node_enter(node)
+        case node.name
+        when :describe
+          handle_describe(node)
+        when :it, :specify
+          handle_example(node)
+        end
+      end
+
+      #: (node: Prism::CallNode) -> void
+      def on_call_node_leave(node)
+        return unless node.name == :describe && !node.receiver
+
+        @describe_block_nesting.pop
+      end
+
+      private
+
+      #: (node: Prism::CallNode) -> void
+      def handle_describe(node)
+        return if node.block.nil?
+
+        description = extract_description(node)
+        return unless description
+
+        return unless in_spec_context?
+
+        if @nesting.empty? && @describe_block_nesting.empty?
+          test_item = Requests::Support::TestItem.new(
+            description,
+            description,
+            @uri,
+            range_from_node(node),
+            tags: [:minitest],
+          )
+          @response_builder.add(test_item)
+        else
+          add_to_parent_test_group(description, node)
+        end
+
+        @describe_block_nesting << description
+      end
+
+      #: (node: Prism::CallNode) -> void
+      def handle_example(node)
+        return unless in_spec_context?
+
+        return if @describe_block_nesting.empty? && @nesting.empty?
+
+        description = extract_description(node)
+        return unless description
+
+        add_to_parent_test_group(description, node)
+      end
+
+      #: (description: String, node: Prism::CallNode) -> void
+      def add_to_parent_test_group(description, node)
+        parent_test_group = find_parent_test_group
+        return unless parent_test_group
+
+        test_item = Requests::Support::TestItem.new(
+          description,
+          description,
+          @uri,
+          range_from_node(node),
+          tags: [:minitest],
+        )
+        parent_test_group.add(test_item)
+      end
+
+      #: -> Requests::Support::TestItem?
+      def find_parent_test_group
+        root_group_name, nested_describe_groups = if @nesting.empty?
+          [@describe_block_nesting.first, @describe_block_nesting[1..]]
+        else
+          [RubyIndexer::Index.actual_nesting(@nesting, nil).join("::"), @describe_block_nesting]
+        end
+        return unless root_group_name
+
+        test_group = T.let(@response_builder[root_group_name], T.nilable(Requests::Support::TestItem))
+        return unless test_group
+
+        return test_group unless nested_describe_groups
+
+        nested_describe_groups.each do |description|
+          test_group = test_group[description]
+        end
+
+        test_group
+      end
+
+      #: (node: Prism::CallNode) -> String?
+      def extract_description(node)
+        first_argument = node.arguments&.arguments&.first
+        return unless first_argument
+
+        case first_argument
+        when Prism::StringNode
+          first_argument.content
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constant_name(first_argument)
+        else
+          first_argument.slice
+        end
+      end
+
+      #: -> bool
+      def in_spec_context?
+        return true if @nesting.empty?
+
+        T.must(@spec_class_stack.last)
+      end
+
+      #: (node: Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) -> String
+      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/listeners/test_style.rb

@@ -0,0 +1,270 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class TestStyle
+      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 = T.must(queue.shift)
+            tags = Set.new(item[:tags])
+
+            children = item[:children]
+            uri = URI(item[:uri])
+            path = uri.full_path
+            next unless path
+
+            if tags.include?("test_dir")
+              full_files << "#{path}/**/*" if children.empty?
+            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
+            elsif tags.include?("minitest") || tags.include?("test_unit")
+              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?("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
+
+          commands << "#{BASE_COMMAND} -Itest #{full_files.join(" ")}" unless full_files.empty?
+          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(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(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
+
+      ACCESS_MODIFIERS = [:public, :private, :protected].freeze
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
+      BASE_COMMAND = T.let(
+        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])
+        @framework_tag = T.let(:minitest, Symbol)
+
+        dispatcher.register(
+          self,
+          :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
+
+      #: (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
+
+        @framework_tag = :test_unit if attached_ancestors.include?("Test::Unit::TestCase")
+
+        if @framework_tag == :test_unit || 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),
+            tags: [@framework_tag],
+          ))
+        end
+
+        @nesting << name
+      end
+
+      #: (Prism::ModuleNode node) -> 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
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      #: (Prism::DefNode node) -> void
+      def on_def_node_enter(node)
+        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("::")
+
+        # 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(
+          "#{current_group_name}##{name}",
+          name,
+          @uri,
+          range_from_node(node),
+          tags: [@framework_tag],
+        ))
+      end
+
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
+        name = node.name
+        return unless ACCESS_MODIFIERS.include?(name)
+
+        @visibility_stack << name
+      end
+
+      #: (Prism::CallNode node) -> void
+      def on_call_node_leave(node)
+        name = node.name
+        return unless ACCESS_MODIFIERS.include?(name)
+        return unless node.arguments&.arguments
+
+        @visibility_stack.pop
+      end
+
+      private
+
+      #: (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")
+
+        # We only support regular Minitest tests. The declarative syntax provided by ActiveSupport is handled by the
+        # Rails add-on
+        name_parts = fully_qualified_name.split("::")
+        singleton_name = "#{name_parts.join("::")}::<Class:#{name_parts.last}>"
+        !@index.linearized_ancestors_of(singleton_name).include?("ActiveSupport::Testing::Declarative")
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        true
+      end
+
+      #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String
+      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
@@ -46,12 +29,12 @@ module RubyLsp
       @surrounding_method = T.let(surrounding_method, T.nilable(String))
     end
 
-    sig { returns(String) }
+    #: -> String
     def fully_qualified_name
       @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
     end
 
-    sig { returns(T::Array[Symbol]) }
+    #: -> Array[Symbol]
     def locals_for_scope
       locals = []
 
@@ -69,17 +52,7 @@ 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))

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)
       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,7 +91,7 @@ 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]
@@ -189,7 +189,7 @@ 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]
@@ -261,7 +261,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 +272,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 +301,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 +330,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)