ruby-lsp-rails 0.3.31 → 0.4.8

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -1,36 +1,66 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "json"
 require "open3"
+require "delegate"
 
 module RubyLsp
   module Rails
+    # @requires_ancestor: ServerComponent
     module Common
-      # Write a message to the client. Can be used for sending notifications to the editor
-      def send_message(message)
-        json_message = message.to_json
-        @stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+      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
+
+          json_message = {
+            method: "$/progress",
+            params: {
+              token: @id,
+              value: {
+                kind: "report",
+                percentage: percentage,
+                message: message,
+              },
+            },
+          }.to_json
+
+          @stderr.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+        end
       end
 
-      # Log a message to the editor's output panel
-      def log_message(message)
-        $stderr.puts(message)
+      # 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
@@ -38,12 +68,15 @@ module RubyLsp
         send_error_response("Request #{request_name} failed because database connection was not established.")
       rescue ActiveRecord::NoDatabaseError
         send_error_response("Request #{request_name} failed because the database does not exist.")
-      rescue => e
-        send_error_response("Request #{request_name} failed:\n#{e.full_message(highlight: false)}")
+      rescue NotImplementedError, LoadError, SyntaxError, SystemExit, SystemStackError => e
+        send_error_response("Request #{request_name} failed with #{e.class}:\n#{e.full_message(highlight: false)}")
+      rescue StandardError => e
+        send_error_response("Request #{request_name} failed with StandardError:\n#{e.full_message(highlight: false)}")
       end
 
       # 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
@@ -51,60 +84,188 @@ module RubyLsp
         log_message("Request #{notification_name} failed because database connection was not established.")
       rescue ActiveRecord::NoDatabaseError
         log_message("Request #{notification_name} failed because the database does not exist.")
-      rescue => e
-        log_message("Request #{notification_name} failed:\n#{e.full_message(highlight: false)}")
+      rescue NotImplementedError, LoadError, SyntaxError, SystemExit, SystemStackError => e
+        log_message("Request #{notification_name} failed with #{e.class}:\n#{e.full_message(highlight: false)}")
+      rescue StandardError => e
+        log_message("Request #{notification_name} failed with StandardError:\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]
+
+        # 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
+        send_notification({
+          id: "progress-request-#{id}",
+          method: "window/workDoneProgress/create",
+          params: { token: id },
+        })
+
+        send_notification({
+          method: "$/progress",
+          params: {
+            token: id,
+            value: {
+              kind: "begin",
+              title: title,
+              percentage: percentage,
+              message: message,
+            },
+          },
+        })
+      end
+
+      #: (String, ?percentage: Integer?, ?message: String?) -> void
+      def report_progress(id, percentage: nil, message: nil)
+        return unless capabilities[:supports_progress]
+
+        send_notification({
+          method: "$/progress",
+          params: {
+            token: id,
+            value: {
+              kind: "report",
+              percentage: percentage,
+              message: message,
+            },
+          },
+        })
+      end
+
+      #: (String) -> void
+      def end_progress(id)
+        return unless capabilities[:supports_progress]
+
+        send_notification({
+          method: "$/progress",
+          params: {
+            token: id,
+            value: { kind: "end" },
+          },
+        })
+      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]
+
+        begin_progress(id, title, percentage: percentage, message: message)
+        block.call(progress_block)
+        end_progress(id)
+      end
+
+      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}")
+      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}")
+      end
+    end
+
+    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
+    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
-        def finalize_registrations!(stdout)
+        #: (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)
+            addon = @server_addon_classes.shift #: as !nil
+              .new(stdout, stderr, capabilities)
             @server_addons[addon.name] = addon
           end
         end
       end
 
-      def initialize(stdout)
-        @stdout = stdout
-      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 Server
+    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
+
+        self #: as untyped # rubocop:disable Style/RedundantSelf
+          .write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+      end
+    end
+
+    class Server < ServerComponent
       include Common
 
-      def initialize(stdout: $stdout, override_default_output_device: true)
+      #: (?stdout: IO | StringIO, ?stderr: IO | StringIO, ?override_default_output_device: bool, ?capabilities: 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
@@ -115,25 +276,28 @@ module RubyLsp
         # # 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
-        $> = $stderr if override_default_output_device
+        $> = 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"
@@ -142,7 +306,7 @@ module RubyLsp
           with_request_error_handling(request) do
             send_result(resolve_database_info_from_model(params.fetch(:name)))
           end
-        when "association_target_location"
+        when "association_target"
           with_request_error_handling(request) do
             send_result(resolve_association_target(params))
           end
@@ -155,8 +319,10 @@ module RubyLsp
             send_result(run_migrations)
           end
         when "reload"
-          with_notification_error_handling(request) do
-            ::Rails.application.reloader.reload!
+          with_progress("rails-reload", "Reloading Ruby LSP Rails instance") do
+            with_notification_error_handling(request) do
+              ::Rails.application.reloader.reload!
+            end
           end
         when "route_location"
           with_request_error_handling(request) do
@@ -169,7 +335,7 @@ module RubyLsp
         when "server_addon/register"
           with_notification_error_handling(request) do
             require params[:server_addon_path]
-            ServerAddon.finalize_registrations!(@stdout)
+            ServerAddon.finalize_registrations!(@stdout, @stderr, @capabilities)
           end
         when "server_addon/delegate"
           server_addon_name = params[:server_addon_name]
@@ -183,6 +349,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")
@@ -211,6 +378,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)
@@ -229,18 +397,22 @@ 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)
+        const = ActiveSupport::Inflector.safe_constantize(model_name) # rubocop:disable Sorbet/ConstantsFromStrings
         return unless active_record_model?(const)
 
         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)
@@ -250,28 +422,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])
+        const = ActiveSupport::Inflector.safe_constantize(params[:model_name]) # rubocop:disable Sorbet/ConstantsFromStrings
         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]}", name: association_klass.name }
       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!)
@@ -282,6 +459,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
@@ -293,6 +471,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).
@@ -305,6 +484,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)
 
@@ -312,8 +492,43 @@ 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
 
-RubyLsp::Rails::Server.new.start if ARGV.first == "start"
+if ARGV.first == "start"
+  RubyLsp::Rails::Server.new(capabilities: JSON.parse(ARGV[1], symbolize_names: true)).start
+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,63 @@ 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])
+        MAILBOX = [
+          "after_processing",
+          "before_processing",
+          "around_processing",
+        ].freeze
+
+        ALL = (MODELS + CONTROLLERS + JOBS + MAILBOX).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?