ruby-lsp-rails 0.3.17 → 0.3.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba36df033667789339419a3ed19740d35ad9b91a3463cf2438bd390c4580aeb4
-  data.tar.gz: 7aa58db6217944f945ca3bb9bcdefeb4f018759acf8673e222ae8fb3b5c523ee
+  metadata.gz: 03b28222188faf1ac819337e73c244ba0a3cb588acfb286554246151b4beaa1a
+  data.tar.gz: 5558fe8142c90eaa53991f99a54da04b1cf1fe2ded213ae737b55cc9ad8acd78
 SHA512:
-  metadata.gz: a4ddf589e0065c32ee9087a4cfd0347d4e3dbdf5d1d667f1ca6a440ac1c6b2d1c18f41acfa2264f72114ecc4bfafec4c3c40748a3f6639a80c86093ca8e51cef
-  data.tar.gz: 2dbb86bd0f701865f3d833fb13079cfd9bd27310cdca2410664c7112db73e9915c9b633de1f527220a64055d3956009a738c367c956c3c08cd5c3ae71e04d7f1
+  metadata.gz: fb20529701e3008b9f38ba4840446aed72aad85b9e623bc93f691a7bee1ce0418d0b2bfabef085d5446fced0f645c0f6325dd4e78925f2e3ab20cc43e1d34543
+  data.tar.gz: e8507ef9f18e3987c667f1c45a3419171677f318bfb4ba5572153efea73bf2ec2922a0ec62865d3aabc9e49117af8e86951975a9eadc68d7848ce6d57f75fdb2

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -20,6 +20,8 @@ module RubyLsp
     class Addon < ::RubyLsp::Addon
       extend T::Sig
 
+      RUN_MIGRATIONS_TITLE = "Run Migrations"
+
       sig { void }
       def initialize
         super
@@ -28,6 +30,7 @@ module RubyLsp
         # the real client is initialized, features that depend on it will not be blocked by using the NullClient
         @rails_runner_client = T.let(NullClient.new, RunnerClient)
         @global_state = T.let(nil, T.nilable(GlobalState))
+        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
         @addon_mutex = T.let(Mutex.new, Mutex)
         @client_mutex = T.let(Mutex.new, Mutex)
         @client_mutex.lock
@@ -35,7 +38,8 @@ module RubyLsp
         Thread.new do
           @addon_mutex.synchronize do
             # We need to ensure the Rails client is fully loaded before we activate the server addons
-            @client_mutex.synchronize { @rails_runner_client = RunnerClient.create_client }
+            @client_mutex.synchronize { @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue)) }
+            offer_to_run_pending_migrations
           end
         end
       end
@@ -45,12 +49,14 @@ module RubyLsp
         @addon_mutex.synchronize { @rails_runner_client }
       end
 
-      sig { override.params(global_state: GlobalState, message_queue: Thread::Queue).void }
-      def activate(global_state, message_queue)
+      sig { override.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      def activate(global_state, outgoing_queue)
         @global_state = global_state
-        $stderr.puts("Activating Ruby LSP Rails add-on v#{version}")
-        register_additional_file_watchers(global_state: global_state, message_queue: message_queue)
-        @global_state.index.register_enhancement(IndexingEnhancement.new)
+        @outgoing_queue = outgoing_queue
+        @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
+
+        register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
+        @global_state.index.register_enhancement(IndexingEnhancement.new(@global_state.index))
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
         @client_mutex.unlock
@@ -116,18 +122,87 @@ module RubyLsp
 
       sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
       def workspace_did_change_watched_files(changes)
-        if changes.any? do |change|
-             change[:uri].end_with?("db/schema.rb") || change[:uri].end_with?("structure.sql")
-           end
+        if changes.any? { |c| c[:uri].end_with?("db/schema.rb") || c[:uri].end_with?("structure.sql") }
           @rails_runner_client.trigger_reload
         end
+
+        if changes.any? do |c|
+             %r{db/migrate/.*\.rb}.match?(c[:uri]) && c[:type] != Constant::FileChangeType::CHANGED
+           end
+
+          offer_to_run_pending_migrations
+        end
+      end
+
+      sig { override.returns(String) }
+      def name
+        "Ruby LSP Rails"
+      end
+
+      sig { override.params(title: String).void }
+      def handle_window_show_message_response(title)
+        if title == RUN_MIGRATIONS_TITLE
+
+          begin_progress("run-migrations", "Running Migrations")
+          response = @rails_runner_client.run_migrations
+
+          if response && @outgoing_queue
+            if response[:status] == 0
+              # Both log the message and show it as part of progress because sometimes running migrations is so fast you
+              # can't see the progress notification
+              @outgoing_queue << Notification.window_log_message(response[:message])
+              report_progress("run-migrations", message: response[:message])
+            else
+              @outgoing_queue << Notification.window_show_message(
+                "Migrations failed to run\n\n#{response[:message]}",
+                type: Constant::MessageType::ERROR,
+              )
+            end
+          end
+
+          end_progress("run-migrations")
+        end
+      end
+
+      private
+
+      sig { params(id: String, title: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      def begin_progress(id, title, percentage: nil, message: nil)
+        return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
+
+        @outgoing_queue << Request.new(
+          id: "progress-request-#{id}",
+          method: "window/workDoneProgress/create",
+          params: Interface::WorkDoneProgressCreateParams.new(token: id),
+        )
+
+        @outgoing_queue << Notification.progress_begin(
+          id,
+          title,
+          percentage: percentage,
+          message: "#{percentage}% completed",
+        )
+      end
+
+      sig { params(id: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      def report_progress(id,  percentage: nil, message: nil)
+        return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
+
+        @outgoing_queue << Notification.progress_report(id, percentage: percentage, message: message)
       end
 
-      sig { params(global_state: GlobalState, message_queue: Thread::Queue).void }
-      def register_additional_file_watchers(global_state:, message_queue:)
-        return unless global_state.supports_watching_files
+      sig { params(id: String).void }
+      def end_progress(id)
+        return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
-        message_queue << Request.new(
+        @outgoing_queue << Notification.progress_end(id)
+      end
+
+      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      def register_additional_file_watchers(global_state:, outgoing_queue:)
+        return unless global_state.client_capabilities.supports_watching_files
+
+        outgoing_queue << Request.new(
           id: "ruby-lsp-rails-file-watcher",
           method: "client/registerCapability",
           params: Interface::RegistrationParams.new(
@@ -149,9 +224,26 @@ module RubyLsp
         )
       end
 
-      sig { override.returns(String) }
-      def name
-        "Ruby LSP Rails"
+      sig { void }
+      def offer_to_run_pending_migrations
+        return unless @outgoing_queue
+        return unless @global_state&.client_capabilities&.window_show_message_supports_extra_properties
+
+        migration_message = @rails_runner_client.pending_migrations_message
+        return unless migration_message
+
+        @outgoing_queue << Request.new(
+          id: "rails-pending-migrations",
+          method: "window/showMessageRequest",
+          params: {
+            type: Constant::MessageType::INFO,
+            message: migration_message,
+            actions: [
+              { title: RUN_MIGRATIONS_TITLE, addon_name: name, method: "window/showMessageRequest" },
+              { title: "Cancel", addon_name: name, method: "window/showMessageRequest" },
+            ],
+          },
+        )
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -141,7 +141,7 @@ module RubyLsp
 
             arg_receiver = argument.receiver
 
-            name = arg_receiver.full_name if arg_receiver.is_a?(Prism::ConstantReadNode) ||
+            name = constant_name(arg_receiver) if arg_receiver.is_a?(Prism::ConstantReadNode) ||
               arg_receiver.is_a?(Prism::ConstantPathNode)
             next unless name
 
@@ -201,8 +201,8 @@ module RubyLsp
         arguments.each do |argument|
           case argument
           when Prism::ConstantReadNode, Prism::ConstantPathNode
-            name = argument.full_name
-            next if name.empty?
+            name = constant_name(argument)
+            next unless name
 
             append_document_symbol(
               name: "#{message} #{name}",

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "support/rails_document_client"
-
 module RubyLsp
   module Rails
     # ![Hover demo](../../hover.gif)
@@ -34,7 +32,7 @@ module RubyLsp
         @response_builder = response_builder
         @nesting = T.let(node_context.nesting, T::Array[String])
         @index = T.let(global_state.index, RubyIndexer::Index)
-        dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter, :on_call_node_enter)
+        dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
@@ -43,10 +41,7 @@ module RubyLsp
         return unless entries
 
         name = T.must(entries.first).name
-
         generate_column_content(name)
-
-        generate_rails_document_link_hover(name, node.location)
       end
 
       sig { params(node: Prism::ConstantReadNode).void }
@@ -57,16 +52,6 @@ module RubyLsp
         generate_column_content(T.must(entries.first).name)
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        message_value = node.message
-        message_loc = node.message_loc
-
-        return unless message_value && message_loc
-
-        generate_rails_document_link_hover(message_value, message_loc)
-      end
-
       private
 
       sig { params(name: String).void }
@@ -77,25 +62,33 @@ module RubyLsp
         schema_file = model[:schema_file]
 
         @response_builder.push(
-          "[Schema](#{URI::Generic.from_path(path: schema_file)})",
-          category: :links,
+          "[Schema](#{URI::Generic.from_path(path: schema_file)})\n",
+          category: :documentation,
         ) if schema_file
 
         @response_builder.push(
-          model[:columns].map do |name, type|
+          model[:columns].map do |name, type, default_value, nullable|
             primary_key_suffix = " (PK)" if model[:primary_keys].include?(name)
-            "**#{name}**: #{type}#{primary_key_suffix}\n"
+            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,
         )
       end
 
-      sig { params(name: String, location: Prism::Location).void }
-      def generate_rails_document_link_hover(name, location)
-        urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
-        return if urls.empty?
-
-        @response_builder.push(urls.join("\n\n"), category: :links)
+      sig { params(default_value: String, type: String).returns(String) }
+      def format_default(default_value, type)
+        case type
+        when "boolean"
+          default_value == "true" ? "true" : "false"
+        when "string"
+          default_value.inspect
+        else
+          default_value
+        end
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -3,28 +3,30 @@
 
 module RubyLsp
   module Rails
-    class IndexingEnhancement
+    class IndexingEnhancement < RubyIndexer::Enhancement
       extend T::Sig
-      include RubyIndexer::Enhancement
 
       sig do
         override.params(
-          index: RubyIndexer::Index,
           owner: T.nilable(RubyIndexer::Entry::Namespace),
           node: Prism::CallNode,
           file_path: String,
+          code_units_cache: T.any(
+            T.proc.params(arg0: Integer).returns(Integer),
+            Prism::CodeUnitsCache,
+          ),
         ).void
       end
-      def on_call_node(index, owner, node, file_path)
+      def on_call_node_enter(owner, node, file_path, code_units_cache)
         return unless owner
 
         name = node.name
 
         case name
         when :extend
-          handle_concern_extend(index, owner, node)
+          handle_concern_extend(owner, node)
         when :has_one, :has_many, :belongs_to, :has_and_belongs_to_many
-          handle_association(index, owner, node, file_path)
+          handle_association(owner, node, file_path, code_units_cache)
         end
       end
 
@@ -32,13 +34,16 @@ module RubyLsp
 
       sig do
         params(
-          index: RubyIndexer::Index,
           owner: RubyIndexer::Entry::Namespace,
           node: Prism::CallNode,
           file_path: String,
+          code_units_cache: T.any(
+            T.proc.params(arg0: Integer).returns(Integer),
+            Prism::CodeUnitsCache,
+          ),
         ).void
       end
-      def handle_association(index, owner, node, file_path)
+      def handle_association(owner, node, file_path, code_units_cache)
         arguments = node.arguments&.arguments
         return unless arguments
 
@@ -53,27 +58,27 @@ module RubyLsp
 
         return unless name
 
+        loc = RubyIndexer::Location.from_prism_location(name_arg.location, code_units_cache)
+
         # Reader
-        index.add(RubyIndexer::Entry::Method.new(
+        @index.add(RubyIndexer::Entry::Method.new(
           name,
           file_path,
-          name_arg.location,
-          name_arg.location,
+          loc,
+          loc,
           nil,
-          index.configuration.encoding,
           [RubyIndexer::Entry::Signature.new([])],
           RubyIndexer::Entry::Visibility::PUBLIC,
           owner,
         ))
 
         # Writer
-        index.add(RubyIndexer::Entry::Method.new(
+        @index.add(RubyIndexer::Entry::Method.new(
           "#{name}=",
           file_path,
-          name_arg.location,
-          name_arg.location,
+          loc,
+          loc,
           nil,
-          index.configuration.encoding,
           [RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)])],
           RubyIndexer::Entry::Visibility::PUBLIC,
           owner,
@@ -82,12 +87,11 @@ module RubyLsp
 
       sig do
         params(
-          index: RubyIndexer::Index,
           owner: RubyIndexer::Entry::Namespace,
           node: Prism::CallNode,
         ).void
       end
-      def handle_concern_extend(index, owner, node)
+      def handle_concern_extend(owner, node)
         arguments = node.arguments&.arguments
         return unless arguments
 
@@ -97,7 +101,7 @@ module RubyLsp
           module_name = node.full_name
           next unless module_name == "ActiveSupport::Concern"
 
-          index.register_included_hook(owner.name) do |index, base|
+          @index.register_included_hook(owner.name) do |index, base|
             class_methods_name = "#{owner.name}::ClassMethods"
 
             if index.indexed?(class_methods_name)

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -10,37 +10,51 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(RunnerClient) }
-        def create_client
+        sig { params(outgoing_queue: Thread::Queue).returns(RunnerClient) }
+        def create_client(outgoing_queue)
           if File.exist?("bin/rails")
-            new
+            new(outgoing_queue)
           else
-            $stderr.puts(<<~MSG)
-              Ruby LSP Rails failed to locate bin/rails in the current directory: #{Dir.pwd}"
-            MSG
-            $stderr.puts("Server dependent features will not be available")
+            unless outgoing_queue.closed?
+              outgoing_queue << RubyLsp::Notification.window_log_message(
+                <<~MESSAGE.chomp,
+                  Ruby LSP Rails failed to locate bin/rails in the current directory: #{Dir.pwd}
+                  Server dependent features will not be available
+                MESSAGE
+                type: RubyLsp::Constant::MessageType::WARNING,
+              )
+            end
+
             NullClient.new
           end
         rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
-          $stderr.puts("Ruby LSP Rails failed to initialize server: #{e.message}\n#{e.backtrace&.join("\n")}")
-          $stderr.puts("Server dependent features will not be available")
+          unless outgoing_queue.closed?
+            outgoing_queue << RubyLsp::Notification.window_log_message(
+              <<~MESSAGE.chomp,
+                Ruby LSP Rails failed to initialize server: #{e.full_message}
+                Server dependent features will not be available
+              MESSAGE
+              type: Constant::MessageType::ERROR,
+            )
+          end
+
           NullClient.new
         end
       end
 
       class InitializationError < StandardError; end
-      class IncompleteMessageError < StandardError; end
-      class EmptyMessageError < StandardError; end
-
-      MAX_RETRIES = 5
+      class MessageError < StandardError; end
+      class IncompleteMessageError < MessageError; end
+      class EmptyMessageError < MessageError; end
 
       extend T::Sig
 
       sig { returns(String) }
       attr_reader :rails_root
 
-      sig { void }
-      def initialize
+      sig { params(outgoing_queue: Thread::Queue).void }
+      def initialize(outgoing_queue)
+        @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
         # parent ends, the spring process ends as well. If this is not set, Spring will throw an error while trying to
@@ -55,6 +69,8 @@ module RubyLsp
           # https://github.com/Shopify/ruby-lsp-rails/issues/348
         end
 
+        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")
         end
@@ -62,6 +78,9 @@ module RubyLsp
         @stdin = T.let(stdin, IO)
         @stdout = T.let(stdout, IO)
         @stderr = T.let(stderr, IO)
+        @stdin.sync = true
+        @stdout.sync = true
+        @stderr.sync = true
         @wait_thread = T.let(wait_thread, Process::Waiter)
 
         # We set binmode for Windows compatibility
@@ -69,29 +88,27 @@ module RubyLsp
         @stdout.binmode
         @stderr.binmode
 
-        $stderr.puts("Ruby LSP Rails booting server")
-        count = 0
-
-        begin
-          count += 1
-          initialize_response = T.must(read_response)
-          @rails_root = T.let(initialize_response[:root], String)
-        rescue EmptyMessageError
-          $stderr.puts("Ruby LSP Rails is retrying initialize (#{count})")
-          retry if count < MAX_RETRIES
-        end
-
-        $stderr.puts("Finished booting Ruby LSP Rails server")
+        initialize_response = T.must(read_response)
+        @rails_root = T.let(initialize_response[:root], String)
+        log_message("Finished booting Ruby LSP Rails server")
 
         unless ENV["RAILS_ENV"] == "test"
           at_exit do
             if @wait_thread.alive?
-              $stderr.puts("Ruby LSP Rails is force killing the server")
               sleep(0.5) # give the server a bit of time if we already issued a shutdown notification
               force_kill
             end
           end
         end
+
+        @logger_thread = T.let(
+          Thread.new do
+            while (content = @stderr.gets("\n"))
+              log_message(content, type: RubyLsp::Constant::MessageType::LOG)
+            end
+          end,
+          Thread,
+        )
       rescue Errno::EPIPE, IncompleteMessageError
         raise InitializationError, @stderr.read
       end
@@ -99,16 +116,22 @@ module RubyLsp
       sig { params(server_addon_path: String).void }
       def register_server_addon(server_addon_path)
         send_notification("server_addon/register", server_addon_path: server_addon_path)
-      rescue IncompleteMessageError
-        $stderr.puts("Ruby LSP Rails failed to register server addon #{server_addon_path}")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to register server addon #{server_addon_path}",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def model(name)
         make_request("model", name: name)
-      rescue IncompleteMessageError
-        $stderr.puts("Ruby LSP Rails failed to get model information: #{@stderr.read}")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to get model information",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
@@ -124,38 +147,104 @@ module RubyLsp
           model_name: model_name,
           association_name: association_name,
         )
-      rescue => e
-        $stderr.puts("Ruby LSP Rails failed with #{e.message}: #{@stderr.read}")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to get association location",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
       end
 
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def route_location(name)
         make_request("route_location", name: name)
-      rescue IncompleteMessageError
-        $stderr.puts("Ruby LSP Rails failed to get route location: #{@stderr.read}")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to get route location",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
       sig { params(controller: String, action: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def route(controller:, action:)
         make_request("route_info", controller: controller, action: action)
-      rescue IncompleteMessageError
-        $stderr.puts("Ruby LSP Rails failed to get route information: #{@stderr.read}")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to get route information",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
+      # Delegates a notification to a server add-on
+      sig { params(server_addon_name: String, request_name: String, params: T.untyped).void }
+      def delegate_notification(server_addon_name:, request_name:, **params)
+        send_notification(
+          "server_addon/delegate",
+          request_name: request_name,
+          server_addon_name: server_addon_name,
+          **params,
+        )
+      end
+
+      sig { returns(T.nilable(String)) }
+      def pending_migrations_message
+        response = make_request("pending_migrations_message")
+        response[:pending_migrations_message] if response
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed when checking for pending migrations",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def run_migrations
+        make_request("run_migrations")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to run migrations",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      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
+      def delegate_request(server_addon_name:, request_name:, **params)
+        make_request(
+          "server_addon/delegate",
+          server_addon_name: server_addon_name,
+          request_name: request_name,
+          **params,
+        )
+      rescue MessageError
         nil
       end
 
       sig { void }
       def trigger_reload
-        $stderr.puts("Reloading Rails application")
+        log_message("Reloading Rails application")
         send_notification("reload")
-      rescue IncompleteMessageError
-        $stderr.puts("Ruby LSP Rails failed to trigger reload")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to trigger reload",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
       sig { void }
       def shutdown
-        $stderr.puts("Ruby LSP Rails shutting down server")
+        log_message("Ruby LSP Rails shutting down server")
         send_message("shutdown")
         sleep(0.5) # give the server a bit of time to shutdown
         [@stdin, @stdout, @stderr].each(&:close)
@@ -172,24 +261,24 @@ module RubyLsp
       sig do
         params(
           request: String,
-          params: T.nilable(T::Hash[Symbol, T.untyped]),
+          params: T.untyped,
         ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
       end
-      def make_request(request, params = nil)
-        send_message(request, params)
+      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.nilable(T::Hash[Symbol, T.untyped])).void }
-      def send_notification(request, params = nil) = send_message(request, params)
+      sig { params(request: String, params: T.untyped).void }
+      def send_notification(request, **params) = send_message(request, **params)
 
       private
 
-      sig { overridable.params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
-      def send_message(request, params = nil)
+      sig { overridable.params(request: String, params: T.untyped).void }
+      def send_message(request, **params)
         message = { method: request }
-        message[:params] = params if params
+        message[:params] = params
         json = message.to_json
 
         @mutex.synchronize do
@@ -202,11 +291,9 @@ module RubyLsp
       sig { overridable.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def read_response
         raw_response = @mutex.synchronize do
-          headers = @stdout.gets("\r\n\r\n")
-          raise IncompleteMessageError unless headers
-
-          content_length = headers[/Content-Length: (\d+)/i, 1].to_i
-          raise EmptyMessageError if content_length.zero?
+          content_length = read_content_length
+          content_length = read_content_length unless content_length
+          raise EmptyMessageError unless content_length
 
           @stdout.read(content_length)
         end
@@ -214,7 +301,10 @@ module RubyLsp
         response = JSON.parse(T.must(raw_response), symbolize_names: true)
 
         if response[:error]
-          $stderr.puts("Ruby LSP Rails error: " + response[:error])
+          log_message(
+            "Ruby LSP Rails error: #{response[:error]}",
+            type: RubyLsp::Constant::MessageType::ERROR,
+          )
           return
         end
 
@@ -229,6 +319,24 @@ module RubyLsp
         # 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 }
+      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)) }
+      def read_content_length
+        headers = @stdout.gets("\r\n\r\n")
+        return unless headers
+
+        length = headers[/Content-Length: (\d+)/i, 1]
+        return unless length
+
+        length.to_i
+      end
     end
 
     class NullClient < RunnerClient
@@ -255,8 +363,13 @@ module RubyLsp
 
       private
 
-      sig { override.params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
-      def send_message(request, params = nil)
+      sig { params(message: ::String, type: ::Integer).void }
+      def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
+        # no-op
+      end
+
+      sig { override.params(request: String, params: T.untyped).void }
+      def send_message(request, **params)
         # no-op
       end
 

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -2,13 +2,29 @@
 # frozen_string_literal: true
 
 require "json"
+require "open3"
 
 # NOTE: We should avoid printing to stderr since it causes problems. We never read the standard error pipe from the
 # client, so it will become full and eventually hang or crash. Instead, return a response with an `error` key.
 
 module RubyLsp
   module Rails
+    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.length}\r\n\r\n#{json_message}")
+      end
+
+      # Log a message to the editor's output panel
+      def log_message(message)
+        $stderr.puts(message)
+      end
+    end
+
     class ServerAddon
+      include Common
+
       @server_addon_classes = []
       @server_addons = {}
 
@@ -38,12 +54,6 @@ module RubyLsp
         @stdout = stdout
       end
 
-      # Write a response back. Can be used for sending notifications to the editor
-      def write_response(response)
-        json_response = response.to_json
-        @stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
-      end
-
       def name
         raise NotImplementedError, "Not implemented!"
       end
@@ -54,6 +64,8 @@ module RubyLsp
     end
 
     class Server
+      include Common
+
       def initialize(stdout: $stdout, override_default_output_device: true)
         # Grab references to the original pipes so that we can change the default output device further down
         @stdin = $stdin
@@ -79,8 +91,7 @@ module RubyLsp
         routes_reloader = ::Rails.application.routes_reloader
         routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
 
-        initialize_result = { result: { message: "ok", root: ::Rails.root.to_s } }.to_json
-        @stdout.write("Content-Length: #{initialize_result.length}\r\n\r\n#{initialize_result}")
+        send_message({ result: { message: "ok", root: ::Rails.root.to_s } })
 
         while @running
           headers = @stdin.gets("\r\n\r\n")
@@ -96,34 +107,38 @@ module RubyLsp
         when "shutdown"
           @running = false
         when "model"
-          write_response(resolve_database_info_from_model(params.fetch(:name)))
+          send_message(resolve_database_info_from_model(params.fetch(:name)))
         when "association_target_location"
-          write_response(resolve_association_target(params))
+          send_message(resolve_association_target(params))
+        when "pending_migrations_message"
+          send_message({ result: { pending_migrations_message: pending_migrations_message } })
+        when "run_migrations"
+          send_message({ result: run_migrations })
         when "reload"
           ::Rails.application.reloader.reload!
         when "route_location"
-          write_response(route_location(params.fetch(:name)))
+          send_message(route_location(params.fetch(:name)))
         when "route_info"
-          write_response(resolve_route_info(params))
+          send_message(resolve_route_info(params))
         when "server_addon/register"
           require params[:server_addon_path]
           ServerAddon.finalize_registrations!(@stdout)
         when "server_addon/delegate"
-          server_addon_name = params.delete(:server_addon_name)
-          request_name = params.delete(:request_name)
-          ServerAddon.delegate(server_addon_name, request_name, params)
+          server_addon_name = params[:server_addon_name]
+          request_name = params[:request_name]
+          ServerAddon.delegate(server_addon_name, request_name, params.except(:request_name, :server_addon_name))
         end
+        request_name = request
+        request_name = "#{params[:server_addon_name]}##{params[:request_name]}" if request == "server_addon/delegate"
+      # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
+      rescue ActiveRecord::ConnectionNotEstablished
+        log_message("Request #{request_name} failed because database connection was not established.")
       rescue => e
-        write_response({ error: e.full_message(highlight: false) })
+        log_message("Request #{request_name} failed:\n" + e.full_message(highlight: false))
       end
 
       private
 
-      def write_response(response)
-        json_response = response.to_json
-        @stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
-      end
-
       def resolve_route_info(requirements)
         if requirements[:controller]
           requirements[:controller] = requirements.fetch(:controller).underscore.delete_suffix("_controller")
@@ -136,8 +151,10 @@ module RubyLsp
           ::Rails.application.routes.routes.find { |route| route.requirements == requirements }
         end
 
-        if route&.source_location
-          file, _, line = route.source_location.rpartition(":")
+        source_location = route&.respond_to?(:source_location) && route.source_location
+
+        if source_location
+          file, _, line = source_location.rpartition(":")
           body = {
             source_location: [::Rails.root.join(file).to_s, line],
             verb: route.verb,
@@ -155,6 +172,11 @@ module RubyLsp
       if ActionDispatch::Routing::Mapper.respond_to?(:route_source_locations) &&
           ActionDispatch::Routing::Mapper.route_source_locations
         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)
+            ::Rails.application.reload_routes_unless_loaded
+          end
+
           match_data = name.match(/^(.+)(_path|_url)$/)
           return { result: nil } unless match_data
 
@@ -188,7 +210,7 @@ module RubyLsp
 
         info = {
           result: {
-            columns: const.columns.map { |column| [column.name, column.type] },
+            columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
             primary_keys: Array(const.primary_key),
           },
         }
@@ -235,6 +257,27 @@ module RubyLsp
           !const.abstract_class?
         )
       end
+
+      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!)
+
+        ActiveRecord::Migration.check_all_pending!
+        nil
+      rescue ActiveRecord::PendingMigrationError => e
+        e.message
+      end
+
+      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
+        stdout, status = Open3.capture2(
+          { "VERBOSE" => "true" },
+          "bundle exec rails db:migrate",
+        )
+
+        { message: stdout, status: status.exitstatus }
+      end
     end
   end
 end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.17"
+    VERSION = "0.3.25"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.17
+  version: 0.3.25
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2024-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.21.2
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.21.2
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 0.22.0
 description: A Ruby LSP addon that adds extra editor functionality for Rails applications
 email:
 - ruby@shopify.com
@@ -53,7 +53,6 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/support/associations.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/callbacks.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/location_builder.rb
-- lib/ruby_lsp/ruby_lsp_rails/support/rails_document_client.rb
 - lib/ruby_lsp_rails/railtie.rb
 - lib/ruby_lsp_rails/version.rb
 - lib/tasks/ruby_lsp_rails_tasks.rake
@@ -81,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: A Ruby LSP addon for Rails

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

@@ -1,131 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "net/http"
-
-module RubyLsp
-  module Rails
-    module Support
-      class RailsDocumentClient
-        RAILS_DOC_HOST = "https://api.rubyonrails.org"
-
-        SUPPORTED_RAILS_DOC_NAMESPACES = T.let(
-          Regexp.union(
-            /ActionDispatch/,
-            /ActionController/,
-            /AbstractController/,
-            /ActiveRecord/,
-            /ActiveModel/,
-            /ActiveStorage/,
-            /ActionText/,
-            /ActiveJob/,
-          ).freeze,
-          Regexp,
-        )
-
-        RAILTIES_VERSION = T.let(
-          [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].find do |s|
-            s.name == "railties"
-          end&.version&.to_s,
-          T.nilable(String),
-        )
-
-        class << self
-          extend T::Sig
-
-          sig { params(name: String).returns(T::Array[String]) }
-          def generate_rails_document_urls(name)
-            docs = search_index&.fetch(name, nil)
-
-            return [] unless docs
-
-            docs.map do |doc|
-              owner = doc[:owner]
-
-              link_name =
-                # class/module name
-                if owner == name
-                  name
-                else
-                  "#{owner}##{name}"
-                end
-
-              "[Rails Document: `#{link_name}`](#{doc[:url]})"
-            end
-          end
-
-          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
-          private def search_index
-            @rails_documents ||= T.let(
-              build_search_index,
-              T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]]),
-            )
-          end
-
-          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
-          private def build_search_index
-            return unless RAILTIES_VERSION
-
-            $stderr.puts("Fetching search index for Rails documentation")
-
-            response = Net::HTTP.get_response(
-              URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"),
-              { "User-Agent" => "ruby-lsp-rails/#{RubyLsp::Rails::VERSION}" },
-            )
-
-            body = case response
-            when Net::HTTPSuccess
-              $stderr.puts("Finished fetching search index for Rails documentation")
-              response.body
-            when Net::HTTPRedirection
-              # If the version's doc is not found, e.g. Rails main, it'll be redirected
-              # In this case, we just fetch the latest doc
-              response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
-              if response.is_a?(Net::HTTPSuccess)
-                $stderr.puts("Finished fetching search index for Rails documentation")
-                response.body
-              end
-            else
-              $stderr.puts("Response failed: #{response.inspect}")
-              nil
-            end
-
-            process_search_index(body) if body
-          rescue StandardError => e
-            $stderr.puts("Exception occurred when fetching Rails document index: #{e.inspect}")
-          end
-
-          sig { params(js: String).returns(T::Hash[String, T::Array[T::Hash[Symbol, String]]]) }
-          private def process_search_index(js)
-            raw_data = js.sub("var search_data = ", "")
-            info = JSON.parse(raw_data).dig("index", "info")
-
-            # An entry looks like this:
-            #
-            # ["belongs_to",                                                              # method or module/class
-            #  "ActiveRecord::Associations::ClassMethods",                                # method owner
-            #  "classes/ActiveRecord/Associations/ClassMethods.html#method-i-belongs_to", # path to the document
-            #  "(name, scope = nil, **options)",                                          # method's parameters
-            #  "<p>Specifies a one-to-one association with another class..."]             # document preview
-            #
-            info.each_with_object({}) do |(method_or_class, method_owner, doc_path, _, doc_preview), table|
-              # If a method doesn't have documentation, there's no need to generate the link to it.
-              next if doc_preview.nil? || doc_preview.empty?
-
-              # If the method or class/module is not from the supported namespace, reject it
-              next unless [method_or_class, method_owner].any? do |elem|
-                            elem.match?(SUPPORTED_RAILS_DOC_NAMESPACES)
-                          end
-
-              owner = method_owner.empty? ? method_or_class : method_owner
-              table[method_or_class] ||= []
-              # It's possible to have multiple modules defining the same method name. For example,
-              # both `ActiveRecord::FinderMethods` and `ActiveRecord::Associations::CollectionProxy` defines `#find`
-              table[method_or_class] << { owner: owner, url: "#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/#{doc_path}" }
-            end
-          end
-        end
-      end
-    end
-  end
-end