ruby-lsp-rails 0.3.31 → 0.4.1

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -15,18 +15,9 @@ 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
@@ -35,26 +26,26 @@ module RubyLsp
         dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_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
 
-        name = T.must(entries.first).name
+        name = entries.first.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
 
-        generate_column_content(T.must(entries.first).name)
+        generate_column_content(entries.first.name)
       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 +57,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"

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,150 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    class RailsTestStyle < Listeners::TestDiscovery
+      BASE_COMMAND = "#{RbConfig.ruby} 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 = T.must(queue.shift)
+            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
+
+      #: (RunnerClient client, ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def initialize(client, response_builder, global_state, dispatcher, uri)
+        super(response_builder, global_state, dispatcher, uri)
+
+        dispatcher.register(
+          self,
+          :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,
+            )
+
+            @response_builder.add(test_item)
+          end
+        end
+      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.content
+        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)
+        test_item = group_test_item
+        return unless test_item
+
+        test_item.add(Requests::Support::TestItem.new(
+          "#{test_item.id}##{test_name}",
+          test_name,
+          @uri,
+          range_from_node(node),
+          framework: :rails,
+        ))
+      end
+
+      #: -> Requests::Support::TestItem?
+      def group_test_item
+        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
+        @response_builder[current_group_name]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -8,12 +8,10 @@ module RubyLsp
   module Rails
     class RunnerClient
       class << self
-        extend T::Sig
-
-        sig { params(outgoing_queue: Thread::Queue).returns(RunnerClient) }
-        def create_client(outgoing_queue)
+        #: (Thread::Queue outgoing_queue, RubyLsp::GlobalState global_state) -> RunnerClient
+        def create_client(outgoing_queue, global_state)
           if File.exist?("bin/rails")
-            new(outgoing_queue)
+            new(outgoing_queue, global_state)
           else
             unless outgoing_queue.closed?
               outgoing_queue << RubyLsp::Notification.window_log_message(
@@ -46,13 +44,11 @@ module RubyLsp
       class MessageError < StandardError; end
       class EmptyMessageError < MessageError; end
 
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :rails_root
 
-      sig { params(outgoing_queue: Thread::Queue).void }
-      def initialize(outgoing_queue)
+      #: (Thread::Queue outgoing_queue, RubyLsp::GlobalState global_state) -> void
+      def initialize(outgoing_queue, global_state)
         @outgoing_queue = T.let(outgoing_queue, Thread::Queue)
         @mutex = T.let(Mutex.new, Mutex)
         # Spring needs a Process session ID. It uses this ID to "attach" itself to the parent process, so that when the
@@ -71,7 +67,15 @@ module RubyLsp
         log_message("Ruby LSP Rails booting server")
 
         stdin, stdout, stderr, wait_thread = Bundler.with_original_env do
-          Open3.popen3("bundle", "exec", "rails", "runner", "#{__dir__}/server.rb", "start")
+          Open3.popen3(
+            "bundle",
+            "exec",
+            "rails",
+            "runner",
+            "#{__dir__}/server.rb",
+            "start",
+            server_relevant_capabilities(global_state),
+          )
         end
 
         @stdin = T.let(stdin, IO)
@@ -100,10 +104,16 @@ module RubyLsp
           end
         end
 
-        @logger_thread = T.let(
+        # Responsible for transmitting notifications coming from the server to the outgoing queue, so that we can do
+        # things such as showing progress notifications initiated by the server
+        @notifier_thread = T.let(
           Thread.new do
-            while (content = @stderr.gets("\n"))
-              log_message(content, type: RubyLsp::Constant::MessageType::LOG)
+            until @stderr.closed?
+              notification = read_notification
+
+              unless @outgoing_queue.closed? || !notification
+                @outgoing_queue << notification
+              end
             end
           rescue IOError
             # The server was shutdown and stderr is already closed
@@ -114,7 +124,7 @@ module RubyLsp
         raise InitializationError, @stderr.read
       end
 
-      sig { params(server_addon_path: String).void }
+      #: (String server_addon_path) -> void
       def register_server_addon(server_addon_path)
         send_notification("server_addon/register", server_addon_path: server_addon_path)
       rescue MessageError
@@ -125,7 +135,7 @@ module RubyLsp
         nil
       end
 
-      sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: (String name) -> Hash[Symbol, untyped]?
       def model(name)
         make_request("model", name: name)
       rescue MessageError
@@ -136,12 +146,7 @@ module RubyLsp
         nil
       end
 
-      sig do
-        params(
-          model_name: String,
-          association_name: String,
-        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
-      end
+      #: (model_name: String, association_name: String) -> Hash[Symbol, untyped]?
       def association_target_location(model_name:, association_name:)
         make_request(
           "association_target_location",
@@ -156,7 +161,7 @@ module RubyLsp
         nil
       end
 
-      sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: (String name) -> Hash[Symbol, untyped]?
       def route_location(name)
         make_request("route_location", name: name)
       rescue MessageError
@@ -167,7 +172,7 @@ module RubyLsp
         nil
       end
 
-      sig { params(controller: String, action: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: (controller: String, action: String) -> Hash[Symbol, untyped]?
       def route(controller:, action:)
         make_request("route_info", controller: controller, action: action)
       rescue MessageError
@@ -179,7 +184,7 @@ module RubyLsp
       end
 
       # Delegates a notification to a server add-on
-      sig { params(server_addon_name: String, request_name: String, params: T.untyped).void }
+      #: (server_addon_name: String, request_name: String, **untyped params) -> void
       def delegate_notification(server_addon_name:, request_name:, **params)
         send_notification(
           "server_addon/delegate",
@@ -189,7 +194,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def pending_migrations_message
         response = make_request("pending_migrations_message")
         response[:pending_migrations_message] if response
@@ -201,7 +206,7 @@ module RubyLsp
         nil
       end
 
-      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: -> Hash[Symbol, untyped]?
       def run_migrations
         make_request("run_migrations")
       rescue MessageError
@@ -213,13 +218,7 @@ module RubyLsp
       end
 
       # Delegates a request to a server add-on
-      sig do
-        params(
-          server_addon_name: String,
-          request_name: String,
-          params: T.untyped,
-        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
-      end
+      #: (server_addon_name: String, request_name: String, **untyped params) -> Hash[Symbol, untyped]?
       def delegate_request(server_addon_name:, request_name:, **params)
         make_request(
           "server_addon/delegate",
@@ -231,7 +230,7 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def trigger_reload
         log_message("Reloading Rails application")
         send_notification("reload")
@@ -243,7 +242,7 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def shutdown
         log_message("Ruby LSP Rails shutting down server")
         send_message("shutdown")
@@ -254,29 +253,30 @@ module RubyLsp
         force_kill
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def stopped?
         [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive?
       end
 
-      sig do
-        params(
-          request: String,
-          params: T.untyped,
-        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
+      #: -> bool
+      def connected?
+        true
       end
+
+      private
+
+      #: (String request, **untyped params) -> Hash[Symbol, untyped]?
       def make_request(request, **params)
         send_message(request, **params)
         read_response
       end
 
       # Notifications are like messages, but one-way, with no response sent back.
-      sig { params(request: String, params: T.untyped).void }
+      #: (String request, **untyped params) -> void
       def send_notification(request, **params) = send_message(request, **params)
 
-      private
-
-      sig { overridable.params(request: String, params: T.untyped).void }
+      # @overridable
+      #: (String request, **untyped params) -> void
       def send_message(request, **params)
         message = { method: request }
         message[:params] = params
@@ -289,7 +289,8 @@ module RubyLsp
         # The server connection died
       end
 
-      sig { overridable.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      # @overridable
+      #: -> Hash[Symbol, untyped]?
       def read_response
         raw_response = @mutex.synchronize do
           content_length = read_content_length
@@ -315,20 +316,20 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def force_kill
         # Windows does not support the `TERM` signal, so we're forced to use `KILL` here
         Process.kill(T.must(Signal.list["KILL"]), @wait_thread.pid)
       end
 
-      sig { params(message: ::String, type: ::Integer).void }
+      #: (::String message, ?type: ::Integer) -> void
       def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
         return if @outgoing_queue.closed?
 
         @outgoing_queue << RubyLsp::Notification.window_log_message(message, type: type)
       end
 
-      sig { returns(T.nilable(Integer)) }
+      #: -> Integer?
       def read_content_length
         headers = @stdout.gets("\r\n\r\n")
         return unless headers
@@ -338,43 +339,73 @@ module RubyLsp
 
         length.to_i
       end
+
+      # Read a server notification from stderr. Only intended to be used by notifier thread
+      #: -> Hash[Symbol, untyped]?
+      def read_notification
+        headers = @stderr.gets("\r\n\r\n")
+        return unless headers
+
+        length = headers[/Content-Length: (\d+)/i, 1]
+        return unless length
+
+        raw_content = @stderr.read(length.to_i)
+        return unless raw_content
+
+        JSON.parse(raw_content, symbolize_names: true)
+      end
+
+      #: (GlobalState global_state) -> String
+      def server_relevant_capabilities(global_state)
+        {
+          supports_progress: global_state.client_capabilities.supports_progress,
+        }.to_json
+      end
     end
 
     class NullClient < RunnerClient
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def initialize # rubocop:disable Lint/MissingSuper
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def shutdown
         # no-op
       end
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def stopped?
         true
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def rails_root
         Dir.pwd
       end
 
+      #: -> bool
+      def connected?
+        false
+      end
+
       private
 
-      sig { params(message: ::String, type: ::Integer).void }
+      #: (::String message, ?type: ::Integer) -> void
       def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
         # no-op
       end
 
-      sig { override.params(request: String, params: T.untyped).void }
+      # @override
+      #: (String request, **untyped params) -> void
       def send_message(request, **params)
         # no-op
       end
 
-      sig { override.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      # @override
+      #: -> Hash[Symbol, untyped]?
       def read_response
         # no-op
       end