ruby-lsp-rails 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc8c1b4cd4569bdb9c816f842a90f0dfb1122931adcd9c96d1e2eb8a3799471
-  data.tar.gz: 3c1bcc4f69a361ae6a26b635331f6475413fed38bac9a88c7ed45ffea02129eb
+  metadata.gz: 7b68f8a0b2e4d7d4fa32aa2712865dea5c4734c86aa6a490c2a7ace718e3405a
+  data.tar.gz: a146d2ff4091073a9517147dffd3f5326337b947563ed39848d3a823662b5fdc
 SHA512:
-  metadata.gz: eff545775dfa463c99b301a94ab450070f683d3f70a3c974683ac1b311a53d10da57acbd051a6fd0e4c8b005629c1d18bd8d61e33c94548e2fcf2b22b70df606
-  data.tar.gz: 927c991dc2d499be19c626b4a64cfcc11064f2bbadad41abb71ebea13e1e33592810c7fe6135393d7a1c2140d760e8518eee085d3a2d596942af5e031ff8f272
+  metadata.gz: 8902056649daff38b9c6e73231ecc0fb55485d4789d52b9dbf92afe4983104082a959b242b1a9f898d3697344663a678da952b0c0a4f76db026ef07c4744fe52
+  data.tar.gz: 7550880a0a82da99734d38178c5aa47a1909b1787f2070bbf960f2b70ea177a3dd330484428b220de10d3d511a93b7f87a736dfbaf5c47bd12c50f547da15858

data/README.md

@@ -15,19 +15,6 @@ group :development do
   gem "ruby-lsp-rails"
 end
 ```
-Some features rely on server introspection, and use a Rack server which is automatically mounted by using a Railtie.
-
-For applications with specialized routing requirements, such as custom sharding, this may not be compatible. It can
-be disabled with:
-
-```ruby
-# config/environments/development.rb
-Rails.application.configure do
-  # ...
-  config.ruby_lsp_rails.server = false
-  # ...
-end
-```
 
 ## Usage
 
@@ -53,7 +40,7 @@ See the [documentation](https://shopify.github.io/ruby-lsp-rails) for more in-de
 ## How It Works
 
 When Ruby LSP Rails starts, it spawns a `rails runner` instance which runs
-`[server.rb](https://github.com/Shopify/ruby-lsp-rails/blob/main/lib/ruby_lsp/ruby_lsp_rails/server.rb)`.
+[`server.rb`](https://github.com/Shopify/ruby-lsp-rails/blob/main/lib/ruby_lsp/ruby_lsp_rails/server.rb).
 The addon communicates with this process over a pipe (i.e. `stdin` and `stdout`) to fetch runtime information about the application.
 
 When extension is stopped (e.g. by quitting the editor), the server instance is shut down.

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -3,26 +3,35 @@
 
 require "ruby_lsp/addon"
 
+require_relative "support/active_support_test_case_helper"
 require_relative "runner_client"
 require_relative "hover"
 require_relative "code_lens"
+require_relative "document_symbol"
 
 module RubyLsp
   module Rails
     class Addon < ::RubyLsp::Addon
       extend T::Sig
 
-      sig { returns(RunnerClient) }
-      def client
-        @client ||= T.let(RunnerClient.new, T.nilable(RunnerClient))
+      sig { void }
+      def initialize
+        super
+
+        # We first initialize the client as a NullClient, so that we can start the server in a background thread. Until
+        # the real client is initialized, features that depend on it will not be blocked by using the NullClient
+        @client = T.let(NullClient.new, RunnerClient)
       end
 
       sig { override.params(message_queue: Thread::Queue).void }
-      def activate(message_queue); end
+      def activate(message_queue)
+        # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
+        Thread.new { @client = RunnerClient.create_client }
+      end
 
       sig { override.void }
       def deactivate
-        client.shutdown
+        @client.shutdown
       end
 
       # Creates a new CodeLens listener. This method is invoked on every CodeLens request
@@ -46,7 +55,17 @@ module RubyLsp
         ).void
       end
       def create_hover_listener(response_builder, nesting, index, dispatcher)
-        Hover.new(client, response_builder, nesting, index, dispatcher)
+        Hover.new(@client, response_builder, nesting, index, dispatcher)
+      end
+
+      sig do
+        override.params(
+          response_builder: ResponseBuilders::DocumentSymbol,
+          dispatcher: Prism::Dispatcher,
+        ).returns(Object)
+      end
+      def create_document_symbol_listener(response_builder, dispatcher)
+        DocumentSymbol.new(response_builder, dispatcher)
       end
 
       sig { override.returns(String) }

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -35,6 +35,7 @@ module RubyLsp
     class CodeLens
       extend T::Sig
       include Requests::Support::Common
+      include ActiveSupportTestCaseHelper
 
       BASE_COMMAND = "bin/rails test"
 
@@ -56,26 +57,9 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        message_value = node.message
-        return unless message_value == "test"
+        content = extract_test_case_name(node)
 
-        arguments = node.arguments&.arguments
-        return unless arguments&.any?
-
-        first_argument = arguments.first
-
-        content = case first_argument
-        when Prism::InterpolatedStringNode
-          parts = first_argument.parts
-
-          if parts.all? { |part| part.is_a?(Prism::StringNode) }
-            T.cast(parts, T::Array[Prism::StringNode]).map(&:content).join
-          end
-        when Prism::StringNode
-          first_argument.content
-        end
-
-        return unless content && !content.empty?
+        return unless content
 
         line_number = node.location.start_line
         command = "#{BASE_COMMAND} #{@path}:#{line_number}"

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    # ![Document Symbol demo](../../document_symbol.gif)
+    #
+    # The [document symbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol)
+    # request allows users to navigate between ActiveSupport test cases with VS Code's "Go to Symbol" feature.
+    class DocumentSymbol
+      extend T::Sig
+      include Requests::Support::Common
+      include ActiveSupportTestCaseHelper
+
+      sig do
+        params(
+          response_builder: ResponseBuilders::DocumentSymbol,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(response_builder, dispatcher)
+        @response_builder = response_builder
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        content = extract_test_case_name(node)
+
+        return unless content
+
+        @response_builder.last.children << RubyLsp::Interface::DocumentSymbol.new(
+          name: content,
+          kind: LanguageServer::Protocol::Constant::SymbolKind::METHOD,
+          selection_range: range_from_node(node),
+          range: range_from_node(node),
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -4,17 +4,39 @@
 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
     class RunnerClient
+      class << self
+        extend T::Sig
+
+        sig { returns(RunnerClient) }
+        def create_client
+          new
+        rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
+          warn("Ruby LSP Rails failed to initialize server: #{e.message}\n#{e.backtrace&.join("\n")}")
+          warn("Server dependent features will not be available")
+          NullClient.new
+        end
+      end
+
+      class InitializationError < StandardError; end
+      class IncompleteMessageError < StandardError; end
+
       extend T::Sig
 
       sig { void }
       def initialize
+        # 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
+        # set its own session ID
+        begin
+          Process.setpgrp
+          Process.setsid
+        rescue Errno::EPERM
+          # If we can't set the session ID, continue
+        end
+
         stdin, stdout, stderr, wait_thread = Open3.popen3(
           "bin/rails",
           "runner",
@@ -27,17 +49,37 @@ module RubyLsp
         @wait_thread = T.let(wait_thread, Process::Waiter)
         @stdin.binmode # for Windows compatibility
         @stdout.binmode # for Windows compatibility
+
+        warn("Ruby LSP Rails booting server")
+        read_response
+        warn("Finished booting Ruby LSP Rails server")
+
+        unless ENV["RAILS_ENV"] == "test"
+          at_exit do
+            if @wait_thread.alive?
+              warn("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
+              Process.kill(T.must(Signal.list["TERM"]), @wait_thread.pid)
+            end
+          end
+        end
+      rescue Errno::EPIPE, IncompleteMessageError
+        raise InitializationError, @stderr.read
       end
 
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def model(name)
         make_request("model", name: name)
+      rescue IncompleteMessageError
+        warn("Ruby LSP Rails failed to get model information: #{@stderr.read}")
+        nil
       end
 
       sig { void }
       def shutdown
-        send_notification("shutdown")
-        Thread.pass while @wait_thread.alive?
+        warn("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)
       end
 
@@ -48,13 +90,18 @@ module RubyLsp
 
       private
 
-      sig { params(request: T.untyped, params: T.untyped).returns(T.untyped) }
+      sig do
+        params(
+          request: String,
+          params: T.nilable(T::Hash[Symbol, T.untyped]),
+        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
+      end
       def make_request(request, params = nil)
         send_message(request, params)
         read_response
       end
 
-      sig { params(request: T.untyped, params: T.untyped).void }
+      sig { params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
       def send_message(request, params = nil)
         message = { method: request }
         message[:params] = params if params
@@ -68,8 +115,9 @@ module RubyLsp
       sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def read_response
         headers = @stdout.gets("\r\n\r\n")
-        raw_response = @stdout.read(T.must(headers)[/Content-Length: (\d+)/i, 1].to_i)
+        raise IncompleteMessageError unless headers
 
+        raw_response = @stdout.read(headers[/Content-Length: (\d+)/i, 1].to_i)
         response = JSON.parse(T.must(raw_response), symbolize_names: true)
 
         if response[:error]
@@ -80,5 +128,35 @@ module RubyLsp
         response.fetch(:result)
       end
     end
+
+    class NullClient < RunnerClient
+      extend T::Sig
+
+      sig { void }
+      def initialize # rubocop:disable Lint/MissingSuper
+      end
+
+      sig { override.void }
+      def shutdown
+        # no-op
+      end
+
+      sig { override.returns(T::Boolean) }
+      def stopped?
+        true
+      end
+
+      private
+
+      sig { override.params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
+      def send_message(request, params = nil)
+        # no-op
+      end
+
+      sig { override.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def read_response
+        # no-op
+      end
+    end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -19,6 +19,9 @@ rescue
   nil
 end
 
+# 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
     class Server
@@ -26,59 +29,76 @@ module RubyLsp
 
       extend T::Sig
 
-      sig { params(model_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      sig { void }
+      def initialize
+        $stdin.sync = true
+        $stdout.sync = true
+        @running = T.let(true, T::Boolean)
+      end
+
+      sig { void }
+      def start
+        initialize_result = { result: { message: "ok" } }.to_json
+        $stdout.write("Content-Length: #{initialize_result.length}\r\n\r\n#{initialize_result}")
+
+        while @running
+          headers = $stdin.gets("\r\n\r\n")
+          json = $stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i)
+
+          request = JSON.parse(json, symbolize_names: true)
+          response = execute(request.fetch(:method), request[:params])
+          next if response == VOID
+
+          json_response = response.to_json
+          $stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
+        end
+      end
+
+      sig do
+        params(
+          request: String,
+          params: T::Hash[Symbol, T.untyped],
+        ).returns(T.any(Object, T::Hash[Symbol, T.untyped]))
+      end
+      def execute(request, params = {})
+        case request
+        when "shutdown"
+          @running = false
+          VOID
+        when "model"
+          resolve_database_info_from_model(params.fetch(:name))
+        else
+          VOID
+        end
+      rescue => e
+        { error: e.full_message(highlight: false) }
+      end
+
+      private
+
+      sig { params(model_name: String).returns(T::Hash[Symbol, T.untyped]) }
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
-        unless const && const < ActiveRecord::Base && !const.abstract_class?
+        unless const && defined?(ActiveRecord) && const < ActiveRecord::Base && !const.abstract_class?
           return {
             result: nil,
           }
         end
 
-        schema_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
-
-        {
+        info = {
           result: {
             columns: const.columns.map { |column| [column.name, column.type] },
-            schema_file: ::Rails.root + schema_file,
           },
         }
-      rescue => e
-        {
-          error: e.message,
-        }
-      end
-
-      sig { void }
-      def start
-        $stdin.sync = true
-        $stdout.sync = true
-
-        running = T.let(true, T::Boolean)
-
-        while running
-          headers = $stdin.gets("\r\n\r\n")
-          request = $stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i)
-
-          json = JSON.parse(request, symbolize_names: true)
-          request_method = json.fetch(:method)
-          params = json[:params]
-
-          response = case request_method
-          when "shutdown"
-            running = false
-            VOID
-          when "model"
-            resolve_database_info_from_model(params.fetch(:name))
-          else
-            VOID
-          end
 
-          next if response == VOID
+        if ActiveRecord::Tasks::DatabaseTasks.respond_to?(:schema_dump_path)
+          info[:result][:schema_file] =
+            ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
 
-          json_response = response.to_json
-          $stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
         end
+        info
+      rescue => e
+        { error: e.full_message(highlight: false) }
       end
     end
   end

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

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module ActiveSupportTestCaseHelper
+      extend T::Sig
+
+      sig { params(node: Prism::CallNode).returns(T.nilable(String)) }
+      def extract_test_case_name(node)
+        message_value = node.message
+        return unless message_value == "test" || message_value == "it"
+
+        return unless node.arguments
+
+        arguments = node.arguments&.arguments
+        return unless arguments&.any?
+
+        first_argument = arguments.first
+
+        content = case first_argument
+        when Prism::InterpolatedStringNode
+          parts = first_argument.parts
+
+          if parts.all? { |part| part.is_a?(Prism::StringNode) }
+            T.cast(parts, T::Array[Prism::StringNode]).map(&:content).join
+          end
+        when Prism::StringNode
+          first_argument.content
+        end
+
+        if content && !content.empty?
+          content
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.0"
+    VERSION = "0.3.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-15 00:00:00.000000000 Z
+date: 2024-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.14.2
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.15.0
@@ -68,7 +68,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.14.2
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.15.0
@@ -99,9 +99,11 @@ files:
 - lib/ruby-lsp-rails.rb
 - lib/ruby_lsp/ruby_lsp_rails/addon.rb
 - lib/ruby_lsp/ruby_lsp_rails/code_lens.rb
+- lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.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
 - lib/ruby_lsp/ruby_lsp_rails/support/rails_document_client.rb
 - lib/ruby_lsp_rails/railtie.rb
 - lib/ruby_lsp_rails/version.rb