ruby-lsp-rails 0.3.31 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1d9f0d516dcad6d833e05e05defd6ba7ea0bbb3fb2b0c48e7edb9709306d854
-  data.tar.gz: 41b2f9dec0e1ba1d3d4d92a5eb1b4ad5dfd6b6d8c3e62b69822ac156f3232bfd
+  metadata.gz: 6995848edfaf04a9ff896c3e5b26704ff27e32e459154da3cf5d1340acb032b3
+  data.tar.gz: 9af25b875fe37dab802e813a7018bef86cc9b5cad0163d8d2d7031f40083779f
 SHA512:
-  metadata.gz: f4421fb81f4cffaa89abe05244ec8bcc2da8ffa0e27b5f7c310c49747d7b2e20a6eec85b58dfe77f5107bd8281ca9d2e61a5f70b2d100c5938f4a2932deedfd0
-  data.tar.gz: aa8476c6f72a66782d9d8b3225944c862f708cd9fc60fd17cf871d9f3332885bd0b7060cbf778710e9213686d5e24c1e415327c14a00a738e28f934dfae156c7
+  metadata.gz: 1b1cffaabe1cfe7db5c063d79cefdedaf4c00f79d9f1af561a8dc45976e8b731b750642722cdd89a84891e28f721e8074f86a58934e2e728e60863f2122ba7a4
+  data.tar.gz: 617030501d5184109d42400bed761b213dcc8b66ccd9528bae1ab795c2f96e220710de3df94e4425e9e76c4a9584514bff67e220c8bdae27004b1fc001724165

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -32,6 +32,12 @@ module RubyLsp
         @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))
+        @settings = T.let(
+          {
+            enablePendingMigrationsPrompt: true,
+          },
+          T::Hash[Symbol, T.untyped],
+        )
         @addon_mutex = T.let(Mutex.new, Mutex)
         @client_mutex = T.let(Mutex.new, Mutex)
         @client_mutex.lock
@@ -39,7 +45,9 @@ 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(T.must(@outgoing_queue)) }
+            @client_mutex.synchronize do
+              @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue), T.must(@global_state))
+            end
             offer_to_run_pending_migrations
           end
         end
@@ -56,6 +64,9 @@ module RubyLsp
         @outgoing_queue = outgoing_queue
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
 
+        addon_settings = @global_state.settings_for_addon(name)
+        @settings.merge!(addon_settings) if addon_settings
+
         register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
@@ -81,7 +92,9 @@ module RubyLsp
         ).void
       end
       def create_code_lens_listener(response_builder, uri, dispatcher)
-        CodeLens.new(@rails_runner_client, T.must(@global_state), response_builder, uri, dispatcher)
+        return unless @global_state
+
+        CodeLens.new(@rails_runner_client, @global_state, response_builder, uri, dispatcher)
       end
 
       sig do
@@ -92,7 +105,9 @@ module RubyLsp
         ).void
       end
       def create_hover_listener(response_builder, node_context, dispatcher)
-        Hover.new(@rails_runner_client, response_builder, node_context, T.must(@global_state), dispatcher)
+        return unless @global_state
+
+        Hover.new(@rails_runner_client, response_builder, node_context, @global_state, dispatcher)
       end
 
       sig do
@@ -116,8 +131,9 @@ module RubyLsp
         ).void
       end
       def create_definition_listener(response_builder, uri, node_context, dispatcher)
-        index = T.must(@global_state).index
-        Definition.new(@rails_runner_client, response_builder, node_context, index, dispatcher)
+        return unless @global_state
+
+        Definition.new(@rails_runner_client, response_builder, node_context, @global_state.index, dispatcher)
       end
 
       sig do
@@ -251,6 +267,7 @@ module RubyLsp
       def offer_to_run_pending_migrations
         return unless @outgoing_queue
         return unless @global_state&.client_capabilities&.window_show_message_supports_extra_properties
+        return unless @settings[:enablePendingMigrationsPrompt]
 
         migration_message = @rails_runner_client.pending_migrations_message
         return unless migration_message

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -10,10 +10,10 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { params(outgoing_queue: Thread::Queue).returns(RunnerClient) }
-        def create_client(outgoing_queue)
+        sig { params(outgoing_queue: Thread::Queue, global_state: RubyLsp::GlobalState).returns(RunnerClient) }
+        def create_client(outgoing_queue, global_state)
           if File.exist?("bin/rails")
-            new(outgoing_queue)
+            new(outgoing_queue, global_state)
           else
             unless outgoing_queue.closed?
               outgoing_queue << RubyLsp::Notification.window_log_message(
@@ -51,8 +51,8 @@ module RubyLsp
       sig { returns(String) }
       attr_reader :rails_root
 
-      sig { params(outgoing_queue: Thread::Queue).void }
-      def initialize(outgoing_queue)
+      sig { params(outgoing_queue: Thread::Queue, global_state: RubyLsp::GlobalState).void }
+      def initialize(outgoing_queue, global_state)
         @outgoing_queue = T.let(outgoing_queue, Thread::Queue)
         @mutex = T.let(Mutex.new, Mutex)
         # Spring needs a Process session ID. It uses this ID to "attach" itself to the parent process, so that when the
@@ -71,7 +71,15 @@ module RubyLsp
         log_message("Ruby LSP Rails booting server")
 
         stdin, stdout, stderr, wait_thread = Bundler.with_original_env do
-          Open3.popen3("bundle", "exec", "rails", "runner", "#{__dir__}/server.rb", "start")
+          Open3.popen3(
+            "bundle",
+            "exec",
+            "rails",
+            "runner",
+            "#{__dir__}/server.rb",
+            "start",
+            server_relevant_capabilities(global_state),
+          )
         end
 
         @stdin = T.let(stdin, IO)
@@ -100,10 +108,16 @@ module RubyLsp
           end
         end
 
-        @logger_thread = T.let(
+        # Responsible for transmitting notifications coming from the server to the outgoing queue, so that we can do
+        # things such as showing progress notifications initiated by the server
+        @notifier_thread = T.let(
           Thread.new do
-            while (content = @stderr.gets("\n"))
-              log_message(content, type: RubyLsp::Constant::MessageType::LOG)
+            until @stderr.closed?
+              notification = read_notification
+
+              unless @outgoing_queue.closed? || !notification
+                @outgoing_queue << notification
+              end
             end
           rescue IOError
             # The server was shutdown and stderr is already closed
@@ -259,6 +273,13 @@ module RubyLsp
         [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive?
       end
 
+      sig { returns(T::Boolean) }
+      def connected?
+        true
+      end
+
+      private
+
       sig do
         params(
           request: String,
@@ -274,8 +295,6 @@ module RubyLsp
       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.untyped).void }
       def send_message(request, **params)
         message = { method: request }
@@ -338,6 +357,28 @@ module RubyLsp
 
         length.to_i
       end
+
+      # Read a server notification from stderr. Only intended to be used by notifier thread
+      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def read_notification
+        headers = @stderr.gets("\r\n\r\n")
+        return unless headers
+
+        length = headers[/Content-Length: (\d+)/i, 1]
+        return unless length
+
+        raw_content = @stderr.read(length.to_i)
+        return unless raw_content
+
+        JSON.parse(raw_content, symbolize_names: true)
+      end
+
+      sig { params(global_state: GlobalState).returns(String) }
+      def server_relevant_capabilities(global_state)
+        {
+          supports_progress: global_state.client_capabilities.supports_progress,
+        }.to_json
+      end
     end
 
     class NullClient < RunnerClient
@@ -362,6 +403,11 @@ module RubyLsp
         Dir.pwd
       end
 
+      sig { returns(T::Boolean) }
+      def connected?
+        false
+      end
+
       private
 
       sig { params(message: ::String, type: ::Integer).void }

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -3,19 +3,42 @@
 
 require "json"
 require "open3"
+require "delegate"
 
 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.bytesize}\r\n\r\n#{json_message}")
+      class Progress
+        def initialize(stderr, id, supports_progress)
+          @stderr = stderr
+          @id = id
+          @supports_progress = supports_progress
+        end
+
+        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
+      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
@@ -54,6 +77,82 @@ module RubyLsp
       rescue => e
         log_message("Request #{notification_name} failed:\n#{e.full_message(highlight: false)}")
       end
+
+      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
+
+      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
+
+      def end_progress(id)
+        return unless @capabilities[:supports_progress]
+
+        send_notification({
+          method: "$/progress",
+          params: {
+            token: id,
+            value: { kind: "end" },
+          },
+        })
+      end
+
+      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
+      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
+      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 ServerAddon
@@ -76,16 +175,18 @@ module RubyLsp
         end
 
         # Instantiate all server addons and store them in a hash for easy access after we have discovered the classes
-        def finalize_registrations!(stdout)
+        def finalize_registrations!(stdout, stderr, capabilities)
           until @server_addon_classes.empty?
-            addon = @server_addon_classes.shift.new(stdout)
+            addon = @server_addon_classes.shift.new(stdout, stderr, capabilities)
             @server_addons[addon.name] = addon
           end
         end
       end
 
-      def initialize(stdout)
+      def initialize(stdout, stderr, capabilities)
         @stdout = stdout
+        @stderr = stderr
+        @capabilities = capabilities
       end
 
       def name
@@ -97,14 +198,31 @@ module RubyLsp
       end
     end
 
+    class IOWrapper < SimpleDelegator
+      def puts(*args)
+        args.each { |arg| log("#{arg}\n") }
+      end
+
+      def print(*args)
+        args.each { |arg| log(arg.to_s) }
+      end
+
+      private
+
+      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}")
+      end
+    end
+
     class Server
       include Common
 
-      def initialize(stdout: $stdout, override_default_output_device: true)
+      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
+        @stderr = stderr
         @stdin.sync = true
         @stdout.sync = true
         @stderr.sync = true
@@ -112,10 +230,13 @@ 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
-        $> = $stderr if override_default_output_device
+        $> = IOWrapper.new(@stderr) if override_default_output_device
 
         @running = true
       end
@@ -155,8 +276,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 +292,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]
@@ -316,4 +439,6 @@ module RubyLsp
   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_rails/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.31
+  version: 0.4.0
 platform: ruby
 authors:
 - Shopify
 bindir: bin
 cert_chain: []
-date: 2025-01-23 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A Ruby LSP addon for Rails
 test_files: []