ruby-lsp-rails 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3d8b40085e6c7ca1e23283423a0966da489180e36e4fb50415f41b1a37f5294
-  data.tar.gz: e98455cb80f6c386e9aa1c3fa516a29cbf0027826aed8c5af029cc1de61aaa05
+  metadata.gz: 41272ca8c9212dc08dc09beeef481c282656946e182e0c62c72585ecc6cfe658
+  data.tar.gz: 0dc3c80ab252123291ab7b77a02b22fff1f27dd5bc07eb49ea51dfdbff4310f2
 SHA512:
-  metadata.gz: ff23cfda2194b449136438eee3475801c4568d7efa9dea08c9c60bd11f732af31c10a30b95014c7d366fbf5ad86dd7471dd3419ef4ef2808f031307d1ffc841e
-  data.tar.gz: 4a776b1c73b4c2683ba6db906afc3dccd2221f0dd4943a56d1a7fd1f0b4c43f92a789231d82e85aec2ba664fd505013c3c3a594a7b57d6931b35bfd433998ca0
+  metadata.gz: fb753c4c3a4282faeefbd254840be186969179e6eaff83320a79e6fd5d2149e4d35acd68f7c38d8bd436e07b233f5e3cebf553c53317576333b83c4b81582dc0
+  data.tar.gz: 881b3d77f931f890ed68a12b478b7762ea491165e70c4cd61af078eccdeb139c28d9f9eed83406b7fa01927e6b0ea3a07993e0d73ae4c0eede146c6fb124a4aa

data/README.md

@@ -36,8 +36,6 @@ end
 1. Start your Rails server
 1. Hover over an ActiveRecord model to see its details
 
-Nested models (e.g. `Admin::User`) are not yet supported.
-
 ### Documentation
 
 See the [documentation](https://shopify.github.io/ruby-lsp-rails) for more in-depth details about the
@@ -48,8 +46,9 @@ See the [documentation](https://shopify.github.io/ruby-lsp-rails) for more in-de
 1. Open a test which inherits from `ActiveSupport::TestCase` or one of its descendants, such as `ActionDispatch::IntegrationTest`.
 2. Click on the "Run", "Run in Terminal" or "Debug" code lens which appears above the test class, or an individual test.
 
-Note: When using the Test Explorer view, if your code contains a statement to pause execution (e.g. `debugger`) it will
-cause the test runner to hang.
+> [!NOTE]
+> When using the Test Explorer view, if your code contains a statement to pause execution (e.g. `debugger`) it will
+> cause the test runner to hang.
 
 ## How It Works
 
@@ -60,8 +59,7 @@ This gem consists of two components that enable enhanced Rails functionality in
 
 This is why the Rails server needs to be running for some features to work.
 
-> **Note**
->
+> [!NOTE]
 > There is no need to restart the Ruby LSP every time the Rails server is booted.
 > If the server is shut down, the extra features will temporarily disappear and reappear once the server is running again.
 

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -28,23 +28,25 @@ module RubyLsp
       # Creates a new CodeLens listener. This method is invoked on every CodeLens request
       sig do
         override.params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
           uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
-        ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
+        ).void
       end
-      def create_code_lens_listener(uri, dispatcher)
-        CodeLens.new(uri, dispatcher)
+      def create_code_lens_listener(response_builder, uri, dispatcher)
+        CodeLens.new(response_builder, uri, dispatcher)
       end
 
       sig do
         override.params(
+          response_builder: ResponseBuilders::Hover,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
-        ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
+        ).void
       end
-      def create_hover_listener(nesting, index, dispatcher)
-        Hover.new(client, nesting, index, dispatcher)
+      def create_hover_listener(response_builder, nesting, index, dispatcher)
+        Hover.new(client, response_builder, nesting, index, dispatcher)
       end
 
       sig { override.returns(String) }

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -32,26 +32,26 @@ module RubyLsp
     # ````
     #
     # The code lenses will be displayed above the class and above each test method.
-    class CodeLens < ::RubyLsp::Listener
+    class CodeLens
       extend T::Sig
-      extend T::Generic
+      include Requests::Support::Common
 
-      ResponseType = type_member { { fixed: T::Array[::RubyLsp::Interface::CodeLens] } }
       BASE_COMMAND = "bin/rails test"
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
-      def initialize(uri, dispatcher)
-        @_response = T.let([], ResponseType)
+      sig do
+        params(
+          response_builder:  ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+          uri: URI::Generic,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(response_builder, uri, dispatcher)
+        @response_builder = response_builder
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
 
         dispatcher.register(self, :on_call_node_enter, :on_class_node_enter, :on_def_node_enter, :on_class_node_leave)
-
-        super(dispatcher)
       end
 
       sig { params(node: Prism::CallNode).void }
@@ -131,7 +131,7 @@ module RubyLsp
         grouping_data = { group_id: @group_id_stack.last, kind: kind }
         grouping_data[:id] = @group_id if kind == :group
 
-        @_response << create_code_lens(
+        @response_builder << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
@@ -139,7 +139,7 @@ module RubyLsp
           data: { type: "test", **grouping_data },
         )
 
-        @_response << create_code_lens(
+        @response_builder << create_code_lens(
           node,
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
@@ -147,7 +147,7 @@ module RubyLsp
           data: { type: "test_in_terminal", **grouping_data },
         )
 
-        @_response << create_code_lens(
+        @response_builder << create_code_lens(
           node,
           title: "Debug",
           command_name: "rubyLsp.debugTest",

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -16,28 +16,22 @@ module RubyLsp
     # User.all
     # # ^ hovering here will show information about the User model
     # ```
-    class Hover < ::RubyLsp::Listener
+    class Hover
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T.nilable(::RubyLsp::Interface::Hover) } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      include Requests::Support::Common
 
       sig do
         params(
           client: RailsClient,
+          response_builder: ResponseBuilders::Hover,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(client, nesting, index, dispatcher)
-        super(dispatcher)
-
-        @_response = T.let(nil, ResponseType)
+      def initialize(client, response_builder, nesting, index, dispatcher)
         @client = client
+        @response_builder = response_builder
         @nesting = nesting
         @index = index
         dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter, :on_call_node_enter)
@@ -49,16 +43,10 @@ module RubyLsp
         return unless entries
 
         name = T.must(entries.first).name
-        content = +""
-        column_info = generate_column_content(name)
-        content << column_info if column_info
 
-        urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
-        content << urls.join("\n\n") unless urls.empty?
-        return if content.empty?
+        generate_column_content(name)
 
-        contents = RubyLsp::Interface::MarkupContent.new(kind: "markdown", value: content)
-        @_response = RubyLsp::Interface::Hover.new(range: range_from_location(node.location), contents: contents)
+        generate_rails_document_link_hover(name, node.location)
       end
 
       sig { params(node: Prism::ConstantReadNode).void }
@@ -66,11 +54,7 @@ module RubyLsp
         entries = @index.resolve(node.name.to_s, @nesting)
         return unless entries
 
-        content = generate_column_content(T.must(entries.first).name)
-        return unless content
-
-        contents = RubyLsp::Interface::MarkupContent.new(kind: "markdown", value: content)
-        @_response = RubyLsp::Interface::Hover.new(range: range_from_location(node.location), contents: contents)
+        generate_column_content(T.must(entries.first).name)
       end
 
       sig { params(node: Prism::CallNode).void }
@@ -80,30 +64,37 @@ module RubyLsp
 
         return unless message_value && message_loc
 
-        @_response = generate_rails_document_link_hover(message_value, message_loc)
+        generate_rails_document_link_hover(message_value, message_loc)
       end
 
       private
 
-      sig { params(name: String).returns(T.nilable(String)) }
+      sig { params(name: String).void }
       def generate_column_content(name)
         model = @client.model(name)
         return if model.nil?
 
         schema_file = model[:schema_file]
-        content = +""
-        content << "[Schema](#{URI::Generic.build(scheme: "file", path: schema_file)})\n\n" if schema_file
-        content << model[:columns].map { |name, type| "**#{name}**: #{type}\n" }.join("\n")
-        content
+
+        @response_builder.push(
+          "[Schema](#{URI::Generic.build(scheme: "file", path: schema_file)})",
+          category: :links,
+        ) if schema_file
+
+        @response_builder.push(
+          model[:columns].map do |name, type|
+            "**#{name}**: #{type}\n"
+          end.join("\n"),
+          category: :documentation,
+        )
       end
 
-      sig { params(name: String, location: Prism::Location).returns(T.nilable(Interface::Hover)) }
+      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?
 
-        contents = RubyLsp::Interface::MarkupContent.new(kind: "markdown", value: urls.join("\n\n"))
-        RubyLsp::Interface::Hover.new(range: range_from_location(location), contents: contents)
+        @response_builder.push(urls.join("\n\n"), category: :links)
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# 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
+    class RunnerClient
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        stdin, stdout, stderr, wait_thread = Open3.popen3(
+          "bin/rails",
+          "runner",
+          "#{__dir__}/server.rb",
+          "start",
+        )
+        @stdin = T.let(stdin, IO)
+        @stdout = T.let(stdout, IO)
+        @stderr = T.let(stderr, IO)
+        @wait_thread = T.let(wait_thread, Process::Waiter)
+        @stdin.binmode # for Windows compatibility
+        @stdout.binmode # for Windows compatibility
+      end
+
+      sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def model(name)
+        make_request("model", name: name)
+      end
+
+      sig { void }
+      def shutdown
+        send_notification("shutdown")
+        Thread.pass while @wait_thread.alive?
+        [@stdin, @stdout, @stderr].each(&:close)
+      end
+
+      sig { returns(T::Boolean) }
+      def stopped?
+        [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive?
+      end
+
+      private
+
+      sig { params(request: T.untyped, params: T.untyped).returns(T.untyped) }
+      def make_request(request, params = nil)
+        send_message(request, params)
+        read_response
+      end
+
+      sig { params(request: T.untyped, params: T.untyped).void }
+      def send_message(request, params = nil)
+        message = { method: request }
+        message[:params] = params if params
+        json = message.to_json
+
+        @stdin.write("Content-Length: #{json.length}\r\n\r\n", json)
+      end
+
+      alias_method :send_notification, :send_message
+
+      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)
+
+        response = JSON.parse(T.must(raw_response), symbolize_names: true)
+
+        if response[:error]
+          warn("Ruby LSP Rails error: " + response[:error])
+          return
+        end
+
+        response.fetch(:result)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "json"
+
+begin
+  T::Configuration.default_checked_level = :never
+  # Suppresses call validation errors
+  T::Configuration.call_validation_error_handler = ->(*) {}
+  # Suppresses errors caused by T.cast, T.let, T.must, etc.
+  T::Configuration.inline_type_error_handler = ->(*) {}
+  # Suppresses errors caused by incorrect parameter ordering
+  T::Configuration.sig_validation_error_handler = ->(*) {}
+rescue
+  # Need this rescue so that if another gem has
+  # already set the checked level by the time we
+  # get to it, we don't fail outright.
+  nil
+end
+
+module RubyLsp
+  module Rails
+    class Server
+      VOID = Object.new
+
+      extend T::Sig
+
+      sig { params(model_name: String).returns(T.nilable(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?
+          return {
+            result: nil,
+          }
+        end
+
+        schema_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
+
+        {
+          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
+
+          json_response = response.to_json
+          $stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
+        end
+      end
+    end
+  end
+end
+
+RubyLsp::Rails::Server.new.start if ARGV.first == "start"

data/lib/ruby_lsp_rails/rack_app.rb

@@ -31,7 +31,7 @@ module RubyLsp
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
 
-        if const && const < ActiveRecord::Base
+        if const && const < ActiveRecord::Base && !const.abstract_class?
           begin
             schema_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
           rescue => e

data/lib/ruby_lsp_rails/railtie.rb

@@ -12,15 +12,13 @@ module RubyLsp
 
       initializer "ruby_lsp_rails.setup" do |_app|
         config.after_initialize do |app|
-          unless config.ruby_lsp_rails.server == false
+          # If we start the app with `bin/rails console` then `Rails::Server` is not defined.
+          if defined?(::Rails::Server) && config.ruby_lsp_rails.server
             app.routes.prepend do
               T.bind(self, ActionDispatch::Routing::Mapper)
               mount(RackApp.new => RackApp::BASE_PATH)
             end
-          end
 
-          # If we start the app with `bin/rails console` then `Rails::Server` is not defined.
-          if defined?(::Rails::Server)
             ssl_enable, host, port = ::Rails::Server::Options.new.parse!(ARGV).values_at(:SSLEnable, :Host, :Port)
             app_uri = "#{ssl_enable ? "https" : "http"}://#{host}:#{port}"
             app_uri_path = ::Rails.root.join("tmp", "app_uri.txt")

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.2.8"
+    VERSION = "0.2.10"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.10
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-04 00:00:00.000000000 Z
+date: 2024-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -58,20 +58,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.15.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -101,6 +101,8 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/code_lens.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.rb
 - lib/ruby_lsp/ruby_lsp_rails/rails_client.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/rails_document_client.rb
 - lib/ruby_lsp_rails/rack_app.rb
 - lib/ruby_lsp_rails/railtie.rb
@@ -129,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: A Ruby LSP addon for Rails