ruby-lsp-rails 0.4.0 → 0.4.2

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "json"
@@ -7,14 +7,17 @@ require "delegate"
 
 module RubyLsp
   module Rails
+    # @requires_ancestor: ServerComponent
     module Common
       class Progress
+        #: (IO | StringIO, String, bool) -> void
         def initialize(stderr, id, supports_progress)
           @stderr = stderr
           @id = id
           @supports_progress = supports_progress
         end
 
+        #: (percentage: Integer?, message: String?) -> void
         def report(percentage: nil, message: nil)
           return unless @supports_progress
           return unless percentage || message
@@ -37,23 +40,27 @@ module RubyLsp
 
       # Log a message to the editor's output panel. The type is the number of the message type, which can be found in
       # the specification https://microsoft.github.io/language-server-protocol/specification/#messageType
+      #: (String, type: Integer) -> void
       def log_message(message, type: 4)
         send_notification({ method: "window/logMessage", params: { type: type, message: message } })
       end
 
       # Sends an error result to a request, if the request failed. DO NOT INVOKE THIS METHOD FOR NOTIFICATIONS! Use
       # `log_message` instead, otherwise the client/server communication will go out of sync
+      #: (String) -> void
       def send_error_response(message)
         send_message({ error: message })
       end
 
       # Sends a result back to the client
+      #: (Hash[Symbol | String, untyped]?) -> void
       def send_result(result)
         send_message({ result: result })
       end
 
       # Handle possible errors for a request. This should only be used for requests, which means messages that return a
       # response back to the client. Errors are returned as an error object back to the client
+      #: (String) { () -> void } -> void
       def with_request_error_handling(request_name, &block)
         block.call
       rescue ActiveRecord::ConnectionNotEstablished
@@ -67,6 +74,7 @@ module RubyLsp
 
       # Handle possible errors for a notification. This should only be used for notifications, which means messages that
       # do not return a response back to the client. Errors are logged to the editor's output panel
+      #: (String) { () -> void } -> void
       def with_notification_error_handling(notification_name, &block)
         block.call
       rescue ActiveRecord::ConnectionNotEstablished
@@ -78,8 +86,9 @@ module RubyLsp
         log_message("Request #{notification_name} failed:\n#{e.full_message(highlight: false)}")
       end
 
+      #: (String, String, percentage: Integer?, message: String?) -> void
       def begin_progress(id, title, percentage: nil, message: nil)
-        return unless @capabilities[:supports_progress]
+        return unless capabilities[:supports_progress]
 
         # This is actually a request, but it is sent asynchronously and we do not return the response back to the
         # server, so we consider it a notification from the perspective of the client/runtime server dynamic
@@ -103,8 +112,9 @@ module RubyLsp
         })
       end
 
+      #: (String, percentage: Integer?, message: String?) -> void
       def report_progress(id, percentage: nil, message: nil)
-        return unless @capabilities[:supports_progress]
+        return unless capabilities[:supports_progress]
 
         send_notification({
           method: "$/progress",
@@ -119,8 +129,9 @@ module RubyLsp
         })
       end
 
+      #: (String) -> void
       def end_progress(id)
-        return unless @capabilities[:supports_progress]
+        return unless capabilities[:supports_progress]
 
         send_notification({
           method: "$/progress",
@@ -131,9 +142,10 @@ module RubyLsp
         })
       end
 
+      #: (String, String, percentage: Integer?, message: String?) { (Progress) -> void } -> void
       def with_progress(id, title, percentage: nil, message: nil, &block)
-        progress_block = Progress.new(@stderr, id, @capabilities[:supports_progress])
-        return block.call(progress_block) unless @capabilities[:supports_progress]
+        progress_block = Progress.new(stderr, id, capabilities[:supports_progress])
+        return block.call(progress_block) unless capabilities[:supports_progress]
 
         begin_progress(id, title, percentage: percentage, message: message)
         block.call(progress_block)
@@ -143,86 +155,113 @@ module RubyLsp
       private
 
       # Write a response message back to the client
+      #: (Hash[String | Symbol, untyped]) -> void
       def send_message(message)
         json_message = message.to_json
-        @stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+        stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
 
       # Write a notification to the client to be transmitted to the editor
+      #: (Hash[String | Symbol, untyped]) -> void
       def send_notification(message)
         json_message = message.to_json
-        @stderr.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+        stderr.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
     end
 
-    class ServerAddon
+    class ServerComponent
+      #: IO | StringIO
+      attr_reader :stdout
+
+      #: IO | StringIO
+      attr_reader :stderr
+
+      #: Hash[Symbol | String, untyped]
+      attr_reader :capabilities
+
+      #: (IO | StringIO, IO | StringIO, Hash[Symbol | String, untyped]) -> void
+      def initialize(stdout, stderr, capabilities)
+        @stdout = stdout
+        @stderr = stderr
+        @capabilities = capabilities
+      end
+    end
+
+    class ServerAddon < ServerComponent
       include Common
 
-      @server_addon_classes = []
-      @server_addons = {}
+      @server_addon_classes = [] #: Array[singleton(ServerAddon)]
+      @server_addons = {} #: Hash[String, ServerAddon]
 
       class << self
         # We keep track of runtime server add-ons the same way we track other add-ons, by storing classes that inherit
         # from the base one
+        #: (singleton(ServerAddon)) -> void
         def inherited(child)
           @server_addon_classes << child
           super
         end
 
         # Delegate `request` with `params` to the server add-on with the given `name`
+        #: (String, String, Hash[Symbol | String, untyped]) -> void
         def delegate(name, request, params)
           @server_addons[name]&.execute(request, params)
         end
 
         # Instantiate all server addons and store them in a hash for easy access after we have discovered the classes
+        #: (IO | StringIO, IO | StringIO, Hash[Symbol | String, untyped]) -> void
         def finalize_registrations!(stdout, stderr, capabilities)
           until @server_addon_classes.empty?
-            addon = @server_addon_classes.shift.new(stdout, stderr, capabilities)
+            addon = @server_addon_classes.shift #: as !nil
+              .new(stdout, stderr, capabilities)
             @server_addons[addon.name] = addon
           end
         end
       end
 
-      def initialize(stdout, stderr, capabilities)
-        @stdout = stdout
-        @stderr = stderr
-        @capabilities = capabilities
-      end
-
+      #: -> String
       def name
         raise NotImplementedError, "Not implemented!"
       end
 
+      #: (String, Hash[String | Symbol, untyped]) -> untyped
       def execute(request, params)
         raise NotImplementedError, "Not implemented!"
       end
     end
 
     class IOWrapper < SimpleDelegator
+      #: (untyped) -> void
       def puts(*args)
         args.each { |arg| log("#{arg}\n") }
       end
 
+      #: (untyped) -> void
       def print(*args)
         args.each { |arg| log(arg.to_s) }
       end
 
       private
 
+      #: (untyped) -> void
       def log(message)
         json_message = { method: "window/logMessage", params: { type: 4, message: message } }.to_json
-        write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+
+        self #: as untyped # rubocop:disable Style/RedundantSelf
+          .write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
     end
 
-    class Server
+    class Server < ServerComponent
       include Common
 
+      #: (IO | StringIO, IO | StringIO, bool, Hash[Symbol | String, untyped]) -> void
       def initialize(stdout: $stdout, stderr: $stderr, override_default_output_device: true, capabilities: {})
         # Grab references to the original pipes so that we can change the default output device further down
-        @stdin = $stdin
-        @stdout = stdout
-        @stderr = stderr
+
+        @stdin = $stdin #: IO
+        super(stdout, stderr, capabilities)
+
         @stdin.sync = true
         @stdout.sync = true
         @stderr.sync = true
@@ -230,31 +269,31 @@ module RubyLsp
         @stdout.binmode
         @stderr.binmode
 
-        # A hash containing the capabilities of the editor that may be relevant for the runtime server
-        @capabilities = capabilities
-
         # # Set the default output device to be $stderr. This means that using `puts` by itself will default to printing
         # # to $stderr and only explicit `$stdout.puts` will go to $stdout. This reduces the chance that output coming
         # # from the Rails app will be accidentally sent to the client
         $> = IOWrapper.new(@stderr) if override_default_output_device
 
-        @running = true
+        @running = true #: bool
+        @database_supports_indexing = nil #: bool?
       end
 
+      #: -> void
       def start
         load_routes
         clear_file_system_resolver_hooks
         send_result({ message: "ok", root: ::Rails.root.to_s })
 
         while @running
-          headers = @stdin.gets("\r\n\r\n")
-          json = @stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i)
+          headers = @stdin.gets("\r\n\r\n") #: as String
+          json = @stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i) #: as String
 
           request = JSON.parse(json, symbolize_names: true)
           execute(request.fetch(:method), request[:params])
         end
       end
 
+      #: (String, Hash[Symbol | String, untyped]) -> void
       def execute(request, params)
         case request
         when "shutdown"
@@ -306,6 +345,7 @@ module RubyLsp
 
       private
 
+      #: (Hash[Symbol | String, untyped]) -> Hash[Symbol | String, untyped]?
       def resolve_route_info(requirements)
         if requirements[:controller]
           requirements[:controller] = requirements.fetch(:controller).underscore.delete_suffix("_controller")
@@ -334,6 +374,7 @@ module RubyLsp
       # We also check that it's enabled.
       if ActionDispatch::Routing::Mapper.respond_to?(:route_source_locations) &&
           ActionDispatch::Routing::Mapper.route_source_locations
+        #: (String) -> Hash[Symbol | String, untyped]?
         def route_location(name)
           # In Rails 8, Rails.application.routes.named_routes is not populated by default
           if ::Rails.application.respond_to?(:reload_routes_unless_loaded)
@@ -352,11 +393,13 @@ module RubyLsp
           { location: ::Rails.root.join(route.source_location).to_s }
         end
       else
+        #: (String) -> Hash[Symbol | String, untyped]?
         def route_location(name)
           nil
         end
       end
 
+      #: (String) -> Hash[Symbol | String, untyped]?
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
         return unless active_record_model?(const)
@@ -364,6 +407,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)
@@ -373,28 +418,33 @@ module RubyLsp
         info
       end
 
+      #: (Hash[Symbol | String, untyped]) -> Hash[Symbol | String, untyped]?
       def resolve_association_target(params)
         const = ActiveSupport::Inflector.safe_constantize(params[:model_name])
         return unless active_record_model?(const)
 
         association_klass = const.reflect_on_association(params[:association_name].intern).klass
         source_location = Object.const_source_location(association_klass.to_s)
+        return unless source_location
 
-        { location: source_location.first + ":" + source_location.second.to_s }
+        { location: "#{source_location[0]}:#{source_location[1]}" }
       rescue NameError
         nil
       end
 
+      #: (Module?) -> bool
       def active_record_model?(const)
         !!(
           const &&
             defined?(ActiveRecord) &&
             const.is_a?(Class) &&
             ActiveRecord::Base > const && # We do this 'backwards' in case the class overwrites `<`
-          !const.abstract_class?
+          !const #: as singleton(ActiveRecord::Base)
+            .abstract_class?
         )
       end
 
+      #: -> String?
       def pending_migrations_message
         # `check_all_pending!` is only available since Rails 7.1
         return unless defined?(ActiveRecord) && ActiveRecord::Migration.respond_to?(:check_all_pending!)
@@ -405,6 +455,7 @@ module RubyLsp
         e.message
       end
 
+      #: -> Hash[Symbol | String, untyped]
       def run_migrations
         # Running migrations invokes `load` which will repeatedly load the same files. It's not designed to be invoked
         # multiple times within the same process. To avoid any memory bloat, we run migrations in a separate process
@@ -416,6 +467,7 @@ module RubyLsp
         { message: stdout, status: status.exitstatus }
       end
 
+      #: -> void
       def load_routes
         with_notification_error_handling("initial_load_routes") do
           # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
@@ -428,6 +480,7 @@ module RubyLsp
       # watches files. Since the Rails application is already booted by the time we reach this script, we can't no-op
       # the file watcher implementation. Instead, we clear the hooks to prevent the registered file watchers from being
       # instantiated
+      #: -> void
       def clear_file_system_resolver_hooks
         return unless defined?(::ActionView::PathRegistry)
 
@@ -435,6 +488,39 @@ module RubyLsp
           ::ActionView::PathRegistry.file_system_resolver_hooks.clear
         end
       end
+
+      #: (singleton(ActiveRecord::Base)) -> Array[String]
+      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
+
+      #: (singleton(ActiveRecord::Base)) -> Array[Hash[Symbol, untyped]]
+      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
+
+      #: (singleton(ActiveRecord::Base)) -> bool
+      def database_supports_indexing?(model)
+        return @database_supports_indexing unless @database_supports_indexing.nil?
+
+        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"
@@ -21,7 +19,8 @@ module RubyLsp
           parts = first_argument.parts
 
           if parts.all? { |part| part.is_a?(Prism::StringNode) }
-            T.cast(parts, T::Array[Prism::StringNode]).map(&:content).join
+            parts #: as Array[Prism::StringNode]
+              .map(&:content).join
           end
         when Prism::StringNode
           first_argument.content

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

@@ -5,15 +5,12 @@ module RubyLsp
   module Rails
     module Support
       module Associations
-        ALL = T.let(
-          [
-            "belongs_to",
-            "has_many",
-            "has_one",
-            "has_and_belongs_to_many",
-          ].freeze,
-          T::Array[String],
-        )
+        ALL = [
+          "belongs_to",
+          "has_many",
+          "has_one",
+          "has_and_belongs_to_many",
+        ].freeze
       end
     end
   end

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

@@ -5,66 +5,57 @@ module RubyLsp
   module Rails
     module Support
       module Callbacks
-        MODELS = T.let(
-          [
-            "before_validation",
-            "after_validation",
-            "before_save",
-            "around_save",
-            "after_save",
-            "before_create",
-            "around_create",
-            "after_create",
-            "after_commit",
-            "after_create_commit",
-            "after_update_commit",
-            "after_destroy_commit",
-            "after_save_commit",
-            "after_rollback",
-            "before_update",
-            "around_update",
-            "after_update",
-            "before_destroy",
-            "around_destroy",
-            "after_destroy",
-            "after_initialize",
-            "after_find",
-            "after_touch",
-          ].freeze,
-          T::Array[String],
-        )
+        MODELS = [
+          "before_validation",
+          "after_validation",
+          "before_save",
+          "around_save",
+          "after_save",
+          "before_create",
+          "around_create",
+          "after_create",
+          "after_commit",
+          "after_create_commit",
+          "after_update_commit",
+          "after_destroy_commit",
+          "after_save_commit",
+          "after_rollback",
+          "before_update",
+          "around_update",
+          "after_update",
+          "before_destroy",
+          "around_destroy",
+          "after_destroy",
+          "after_initialize",
+          "after_find",
+          "after_touch",
+        ].freeze
 
-        CONTROLLERS = T.let(
-          [
-            "after_action",
-            "append_after_action",
-            "append_around_action",
-            "append_before_action",
-            "around_action",
-            "before_action",
-            "prepend_after_action",
-            "prepend_around_action",
-            "prepend_before_action",
-            "skip_after_action",
-            "skip_around_action",
-            "skip_before_action",
-          ].freeze,
-          T::Array[String],
-        )
+        CONTROLLERS = [
+          "after_action",
+          "append_after_action",
+          "append_around_action",
+          "append_before_action",
+          "around_action",
+          "before_action",
+          "prepend_after_action",
+          "prepend_around_action",
+          "prepend_before_action",
+          "skip_after_action",
+          "skip_around_action",
+          "skip_before_action",
+        ].freeze
 
-        JOBS = T.let(
-          [
-            "after_enqueue",
-            "after_perform",
-            "around_enqueue",
-            "around_perform",
-            "before_enqueue",
-            "before_perform",
-          ].freeze,
-          T::Array[String],
-        )
+        JOBS = [
+          "after_enqueue",
+          "after_perform",
+          "around_enqueue",
+          "around_perform",
+          "before_enqueue",
+          "before_perform",
+        ].freeze
 
-        ALL = T.let((MODELS + CONTROLLERS + JOBS).freeze, T::Array[String])
+        ALL = (MODELS + CONTROLLERS + JOBS).freeze #: Array[String]
       end
     end
   end

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.2"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Shopify
 bindir: bin
 cert_chain: []
-date: 2025-02-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: 0.23.16
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.24.0
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: 0.23.16
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.24.0
@@ -47,6 +47,7 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.rb
 - lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb
+- lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb
 - lib/ruby_lsp/ruby_lsp_rails/runner_client.rb
 - lib/ruby_lsp/ruby_lsp_rails/server.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/active_support_test_case_helper.rb
@@ -78,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.8
 specification_version: 4
 summary: A Ruby LSP addon for Rails
 test_files: []