ruby-lsp-rails 0.4.0 → 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,9 +8,7 @@ module RubyLsp
   module Rails
     class RunnerClient
       class << self
-        extend T::Sig
-
-        sig { params(outgoing_queue: Thread::Queue, global_state: RubyLsp::GlobalState).returns(RunnerClient) }
+        #: (Thread::Queue outgoing_queue, RubyLsp::GlobalState global_state) -> RunnerClient
         def create_client(outgoing_queue, global_state)
           if File.exist?("bin/rails")
             new(outgoing_queue, global_state)
@@ -46,12 +44,10 @@ 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, global_state: RubyLsp::GlobalState).void }
+      #: (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)
@@ -128,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
@@ -139,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
@@ -150,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",
@@ -170,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
@@ -181,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
@@ -193,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",
@@ -203,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
@@ -215,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
@@ -227,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",
@@ -245,7 +230,7 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def trigger_reload
         log_message("Reloading Rails application")
         send_notification("reload")
@@ -257,7 +242,7 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def shutdown
         log_message("Ruby LSP Rails shutting down server")
         send_message("shutdown")
@@ -268,34 +253,30 @@ module RubyLsp
         force_kill
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def stopped?
         [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive?
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def connected?
         true
       end
 
       private
 
-      sig do
-        params(
-          request: String,
-          params: T.untyped,
-        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
-      end
+      #: (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)
 
-      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
@@ -308,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
@@ -334,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
@@ -359,7 +341,7 @@ module RubyLsp
       end
 
       # Read a server notification from stderr. Only intended to be used by notifier thread
-      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: -> Hash[Symbol, untyped]?
       def read_notification
         headers = @stderr.gets("\r\n\r\n")
         return unless headers
@@ -373,7 +355,7 @@ module RubyLsp
         JSON.parse(raw_content, symbolize_names: true)
       end
 
-      sig { params(global_state: GlobalState).returns(String) }
+      #: (GlobalState global_state) -> String
       def server_relevant_capabilities(global_state)
         {
           supports_progress: global_state.client_capabilities.supports_progress,
@@ -382,45 +364,48 @@ module RubyLsp
     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
 
-      sig { returns(T::Boolean) }
+      #: -> 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

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -364,6 +364,8 @@ module RubyLsp
         info = {
           columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
           primary_keys: Array(const.primary_key),
+          foreign_keys: collect_model_foreign_keys(const),
+          indexes: collect_model_indexes(const),
         }
 
         if ActiveRecord::Tasks::DatabaseTasks.respond_to?(:schema_dump_path)
@@ -435,6 +437,36 @@ module RubyLsp
           ::ActionView::PathRegistry.file_system_resolver_hooks.clear
         end
       end
+
+      def collect_model_foreign_keys(model)
+        return [] unless model.connection.respond_to?(:supports_foreign_keys?) &&
+          model.connection.supports_foreign_keys?
+
+        model.connection.foreign_keys(model.table_name).map do |key_definition|
+          key_definition.options[:column]
+        end
+      end
+
+      def collect_model_indexes(model)
+        return [] unless database_supports_indexing?(model)
+
+        model.connection.indexes(model.table_name).map do |index_definition|
+          {
+            name: index_definition.name,
+            columns: index_definition.columns,
+            unique: index_definition.unique,
+          }
+        end
+      end
+
+      def database_supports_indexing?(model)
+        return @database_supports_indexing if instance_variable_defined?(:@database_supports_indexing)
+
+        model.connection.indexes(model.table_name)
+        @database_supports_indexing = true
+      rescue NotImplementedError
+        @database_supports_indexing = false
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/support/active_support_test_case_helper.rb

@@ -4,9 +4,7 @@
 module RubyLsp
   module Rails
     module ActiveSupportTestCaseHelper
-      extend T::Sig
-
-      sig { params(node: Prism::CallNode).returns(T.nilable(String)) }
+      #: (Prism::CallNode node) -> String?
       def extract_test_case_name(node)
         message_value = node.message
         return unless message_value == "test" || message_value == "it"

data/lib/ruby_lsp/ruby_lsp_rails/support/location_builder.rb

@@ -6,9 +6,7 @@ module RubyLsp
     module Support
       class LocationBuilder
         class << self
-          extend T::Sig
-
-          sig { params(location_string: String).returns(Interface::Location) }
+          #: (String location_string) -> Interface::Location
           def line_location_from_s(location_string)
             *file_parts, line = location_string.split(":")
             raise ArgumentError, "Invalid location string given" if file_parts.empty?

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.4.0"
+    VERSION = "0.4.1"
   end
 end