ruby-lsp-rails 0.3.31 → 0.4.8

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -9,19 +9,13 @@ module RubyLsp
     # request allows users to navigate between associations, validations, callbacks and ActiveSupport test cases with
     # VS Code's "Go to Symbol" feature.
     class DocumentSymbol
-      extend T::Sig
       include Requests::Support::Common
       include ActiveSupportTestCaseHelper
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::DocumentSymbol,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, dispatcher)
         @response_builder = response_builder
-        @namespace_stack = T.let([], T::Array[String])
+        @namespace_stack = [] #: Array[String]
 
         dispatcher.register(
           self,
@@ -33,7 +27,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return if @namespace_stack.empty?
 
@@ -51,50 +45,52 @@ module RubyLsp
         return if receiver && !receiver.is_a?(Prism::SelfNode)
 
         message = node.message
+        return unless message
+
         case message
         when *Support::Callbacks::ALL, "validate"
-          handle_all_arg_types(node, T.must(message))
+          handle_all_arg_types(node, message)
         when "validates", "validates!", "validates_each", "belongs_to", "has_one", "has_many",
           "has_and_belongs_to_many", "attr_readonly", "scope"
-          handle_symbol_and_string_arg_types(node, T.must(message))
+          handle_symbol_and_string_arg_types(node, message)
         when "validates_with"
-          handle_class_arg_types(node, T.must(message))
+          handle_class_arg_types(node, message)
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         add_to_namespace_stack(node)
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         remove_from_namespace_stack(node)
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         add_to_namespace_stack(node)
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         remove_from_namespace_stack(node)
       end
 
       private
 
-      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      #: ((Prism::ClassNode | Prism::ModuleNode) node) -> void
       def add_to_namespace_stack(node)
         @namespace_stack << node.constant_path.slice
       end
 
-      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      #: ((Prism::ClassNode | Prism::ModuleNode) node) -> void
       def remove_from_namespace_stack(node)
         @namespace_stack.delete(node.constant_path.slice)
       end
 
-      sig { params(node: Prism::CallNode, message: String).void }
+      #: (Prism::CallNode node, String message) -> void
       def handle_all_arg_types(node, message)
         block = node.block
 
@@ -119,7 +115,9 @@ module RubyLsp
             append_document_symbol(
               name: "#{message} :#{name}",
               range: range_from_location(argument.location),
-              selection_range: range_from_location(T.must(argument.value_loc)),
+              selection_range: range_from_location(
+                argument.value_loc, #: as !nil
+              ),
             )
           when Prism::StringNode
             name = argument.content
@@ -164,7 +162,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode, message: String).void }
+      #: (Prism::CallNode node, String message) -> void
       def handle_symbol_and_string_arg_types(node, message)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -178,7 +176,9 @@ module RubyLsp
             append_document_symbol(
               name: "#{message} :#{name}",
               range: range_from_location(argument.location),
-              selection_range: range_from_location(T.must(argument.value_loc)),
+              selection_range: range_from_location(
+                argument.value_loc, #: as !nil
+              ),
             )
           when Prism::StringNode
             name = argument.content
@@ -193,7 +193,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode, message: String).void }
+      #: (Prism::CallNode node, String message) -> void
       def handle_class_arg_types(node, message)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -213,13 +213,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          name: String,
-          range: RubyLsp::Interface::Range,
-          selection_range: RubyLsp::Interface::Range,
-        ).void
-      end
+      #: (name: String, range: RubyLsp::Interface::Range, selection_range: RubyLsp::Interface::Range) -> void
       def append_document_symbol(name:, range:, selection_range:)
         @response_builder.last.children << RubyLsp::Interface::DocumentSymbol.new(
           name: name,

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -15,46 +15,50 @@ module RubyLsp
     # # ^ hovering here will show information about the User model
     # ```
     class Hover
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          client: RunnerClient,
-          response_builder: ResponseBuilders::Hover,
-          node_context: NodeContext,
-          global_state: GlobalState,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (RunnerClient client, ResponseBuilders::Hover response_builder, NodeContext node_context, GlobalState global_state, Prism::Dispatcher dispatcher) -> void
       def initialize(client, response_builder, node_context, global_state, dispatcher)
         @client = client
         @response_builder = response_builder
-        @nesting = T.let(node_context.nesting, T::Array[String])
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter)
+        @node_context = node_context
+        @nesting = node_context.nesting #: Array[String]
+        @index = global_state.index #: RubyIndexer::Index
+        dispatcher.register(
+          self,
+          :on_constant_path_node_enter,
+          :on_constant_read_node_enter,
+          :on_symbol_node_enter,
+        )
       end
 
-      sig { params(node: Prism::ConstantPathNode).void }
+      #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
         entries = @index.resolve(node.slice, @nesting)
-        return unless entries
+        item = entries&.first
+        return unless item
 
-        name = T.must(entries.first).name
+        name = item.name
         generate_column_content(name)
       end
 
-      sig { params(node: Prism::ConstantReadNode).void }
+      #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
         entries = @index.resolve(node.name.to_s, @nesting)
-        return unless entries
+        item = entries&.first
+        return unless item
 
-        generate_column_content(T.must(entries.first).name)
+        generate_column_content(item.name)
+      end
+
+      #: (Prism::SymbolNode node) -> void
+      def on_symbol_node_enter(node)
+        handle_possible_dsl(node)
       end
 
       private
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def generate_column_content(name)
         model = @client.model(name)
         return if model.nil?
@@ -66,20 +70,41 @@ module RubyLsp
           category: :documentation,
         ) if schema_file
 
-        @response_builder.push(
-          model[:columns].map do |name, type, default_value, nullable|
-            primary_key_suffix = " (PK)" if model[:primary_keys].include?(name)
-            suffixes = []
-            suffixes << "default: #{format_default(default_value, type)}" if default_value
-            suffixes << "not null" unless nullable || primary_key_suffix
-            suffix_string = " - #{suffixes.join(" - ")}" if suffixes.any?
-            "**#{name}**: #{type}#{primary_key_suffix}#{suffix_string}\n"
-          end.join("\n"),
-          category: :documentation,
-        )
+        if model[:columns].any?
+          @response_builder.push(
+            "### Columns",
+            category: :documentation,
+          )
+          @response_builder.push(
+            model[:columns].map do |name, type, default_value, nullable|
+              primary_key_suffix = " (PK)" if model[:primary_keys].include?(name)
+              foreign_key_suffix = " (FK)" if model[:foreign_keys].include?(name)
+              suffixes = []
+              suffixes << "default: #{format_default(default_value, type)}" if default_value
+              suffixes << "not null" unless nullable || primary_key_suffix
+              suffix_string = " - #{suffixes.join(" - ")}" if suffixes.any?
+              "- **#{name}**: #{type}#{primary_key_suffix}#{foreign_key_suffix}#{suffix_string}\n"
+            end.join("\n"),
+            category: :documentation,
+          )
+        end
+
+        if model[:indexes].any?
+          @response_builder.push(
+            "### Indexes",
+            category: :documentation,
+          )
+          @response_builder.push(
+            model[:indexes].map do |index|
+              uniqueness = index[:unique] ? " (unique)" : ""
+              "- **#{index[:name]}** (#{index[:columns].join(",")})#{uniqueness}"
+            end.join("\n"),
+            category: :documentation,
+          )
+        end
       end
 
-      sig { params(default_value: String, type: String).returns(String) }
+      #: (String default_value, String type) -> String
       def format_default(default_value, type)
         case type
         when "boolean"
@@ -90,6 +115,55 @@ module RubyLsp
           default_value
         end
       end
+
+      #: (Prism::SymbolNode node) -> void
+      def handle_possible_dsl(node)
+        node = @node_context.call_node
+        return unless node
+        return unless self_receiver?(node)
+
+        message = node.message
+
+        return unless message
+
+        if Support::Associations::ALL.include?(message)
+          handle_association(node)
+        end
+      end
+
+      #: (Prism::CallNode node) -> void
+      def handle_association(node)
+        first_argument = node.arguments&.arguments&.first
+        return unless first_argument.is_a?(Prism::SymbolNode)
+
+        association_name = first_argument.unescaped
+
+        result = @client.association_target(
+          model_name: @nesting.join("::"),
+          association_name: association_name,
+        )
+
+        return unless result
+
+        generate_hover(result[:name])
+      end
+
+      # Copied from `RubyLsp::Listeners::Hover#generate_hover`
+      #: (String name) -> void
+      def generate_hover(name)
+        entries = @index.resolve(name, @node_context.nesting)
+        return unless entries
+
+        # We should only show hover for private constants if the constant is defined in the same namespace as the
+        # reference
+        first_entry = entries.first #: as !nil
+        full_name = first_entry.name
+        return if first_entry.private? && full_name != "#{@node_context.fully_qualified_name}::#{name}"
+
+        categorized_markdown_from_index_entries(full_name, entries).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -4,13 +4,8 @@
 module RubyLsp
   module Rails
     class IndexingEnhancement < RubyIndexer::Enhancement
-      extend T::Sig
-
-      sig do
-        override.params(
-          call_node: Prism::CallNode,
-        ).void
-      end
+      # @override
+      #: (Prism::CallNode call_node) -> void
       def on_call_node_enter(call_node)
         owner = @listener.current_owner
         return unless owner
@@ -26,11 +21,8 @@ module RubyLsp
         end
       end
 
-      sig do
-        override.params(
-          call_node: Prism::CallNode,
-        ).void
-      end
+      # @override
+      #: (Prism::CallNode call_node) -> void
       def on_call_node_leave(call_node)
         if call_node.name == :class_methods && call_node.block
           @listener.pop_namespace_stack
@@ -39,12 +31,7 @@ module RubyLsp
 
       private
 
-      sig do
-        params(
-          owner: RubyIndexer::Entry::Namespace,
-          call_node: Prism::CallNode,
-        ).void
-      end
+      #: (RubyIndexer::Entry::Namespace owner, Prism::CallNode call_node) -> void
       def handle_association(owner, call_node)
         arguments = call_node.arguments&.arguments
         return unless arguments
@@ -73,7 +60,7 @@ module RubyLsp
         @listener.add_method("#{name}=", loc, writer_signatures)
       end
 
-      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      #: (RubyIndexer::Entry::Namespace owner, Prism::CallNode call_node) -> void
       def handle_concern_extend(owner, call_node)
         arguments = call_node.arguments&.arguments
         return unless arguments
@@ -98,7 +85,7 @@ module RubyLsp
         end
       end
 
-      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      #: (RubyIndexer::Entry::Namespace owner, Prism::CallNode call_node) -> void
       def handle_class_methods(owner, call_node)
         return unless call_node.block
 

data/lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb

@@ -0,0 +1,171 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    class RailsTestStyle < Listeners::TestDiscovery
+      BASE_COMMAND = "bundle exec ruby -r#{Listeners::TestStyle::MINITEST_REPORTER_PATH} bin/rails test" #: String
+
+      class << self
+        #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+        def resolve_test_commands(items)
+          commands = []
+          queue = items.dup
+
+          full_files = []
+
+          until queue.empty?
+            item = queue.shift #: as !nil
+            tags = Set.new(item[:tags])
+            next unless tags.include?("framework:rails")
+
+            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")
+              commands << "#{BASE_COMMAND} #{path} --name \"/#{Shellwords.escape(item[:id])}(#|::)/\""
+            else
+              full_files << "#{path}:#{item.dig(:range, :start, :line) + 1}"
+            end
+
+            queue.concat(children)
+          end
+
+          unless full_files.empty?
+            commands << "#{BASE_COMMAND} #{full_files.join(" ")}"
+          end
+
+          commands
+        end
+      end
+
+      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def initialize(response_builder, global_state, dispatcher, uri)
+        @parent_stack = [response_builder] #: Array[(Requests::Support::TestItem | ResponseBuilders::TestCollection)?]
+        super(response_builder, global_state, uri)
+
+        register_events(
+          dispatcher,
+          :on_class_node_enter,
+          :on_call_node_enter,
+          :on_def_node_enter,
+        )
+      end
+
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_enter(node)
+        with_test_ancestor_tracking(node) do |name, ancestors|
+          if declarative_minitest?(ancestors, name)
+            test_item = Requests::Support::TestItem.new(
+              name,
+              name,
+              @uri,
+              range_from_node(node),
+              framework: :rails,
+            )
+
+            last_test_group.add(test_item)
+            @response_builder.add_code_lens(test_item)
+            @parent_stack << test_item
+          else
+            @parent_stack << nil
+          end
+        end
+      end
+
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node)
+        @parent_stack.pop
+        super
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node)
+        @parent_stack << nil
+        super
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_leave(node)
+        @parent_stack.pop
+        super
+      end
+
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
+        return unless node.name == :test
+        return unless node.block
+
+        arguments = node.arguments&.arguments
+        first_arg = arguments&.first
+        return unless first_arg.is_a?(Prism::StringNode)
+
+        test_name = first_arg.unescaped
+        test_name = "<empty test name>" if test_name.empty?
+
+        # Rails' `test "foo bar"` helper defines a method `def test_foo_bar`. We normalize test names
+        # the same way (spaces to underscores, prefix with `test_`) to match the actual method names
+        # Rails uses at runtime, ensuring proper test discovery and execution.
+        rails_normalized_name = "test_#{test_name.gsub(/\s+/, "_")}"
+
+        add_test_item(node, rails_normalized_name)
+      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_")
+
+        add_test_item(node, name)
+      end
+
+      private
+
+      #: (Array[String] attached_ancestors, String fully_qualified_name) -> bool
+      def declarative_minitest?(attached_ancestors, fully_qualified_name)
+        # The declarative test style is present as long as the class extends
+        # ActiveSupport::Testing::Declarative
+        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
+        false
+      end
+
+      #: (Prism::Node node, String test_name) -> void
+      def add_test_item(node, test_name)
+        parent = @parent_stack.last
+        return unless parent.is_a?(Requests::Support::TestItem)
+
+        example_item = Requests::Support::TestItem.new(
+          "#{parent.id}##{test_name}",
+          test_name,
+          @uri,
+          range_from_node(node),
+          framework: :rails,
+        )
+        parent.add(example_item)
+        @response_builder.add_code_lens(example_item)
+      end
+
+      #: -> (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
+    end
+  end
+end