ruby-lsp-rails 0.3.16 → 0.3.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bab18094b00d6c5e6a61b22061f927fbca1f4b57ce40da04eca22081ab264385
-  data.tar.gz: 7a253986008708cb5d5af08b6409039aeba2b54d0d605270f652fba9178a99ac
+  metadata.gz: 159bd26f9edd1f611d7f13cb5864e63d8ecc1c6180bbf5a426b9e40a98ce25ba
+  data.tar.gz: 5266ed45904e0d62f074684a3a943ac1ef66b7827c4177ee7631d5ae46118553
 SHA512:
-  metadata.gz: b5021b0f2dadbb18464e473f26d9bfee94ed22b02b53eec5c1c44ade37f1ab989c0b80c4169f722ca4e38c498344ccd5e19334324508aac8f6d3c0e21bd6ec35
-  data.tar.gz: 26813fab8da91e99d6f708dadc1ef631df0d1791addb608e06a366bfebcac5643c5d0978d0bc0778d76c3d74572a78a0a8b361fba90f373db759b54a81f9a388
+  metadata.gz: ab185650a7d5d24f1d7e7faf29cea5eabc99d905525ea840b2000003059393c60be8b79ef9f97ef3a78bf58ae695a5d5f19aa5bbecc9ea367d48090c9614538c
+  data.tar.gz: ef04db908af2f8ce9ee58a0059e51736f969f487b769a421d7df141cfc0518f31c2aa503eace5cc5ad24db36f56a1855ba55ffc4d5990f1eccc5d8cea1a4931c

data/README.md

@@ -1,20 +1,20 @@
 [![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-2c8zjlir6-uUDJl8oIwcen_FS_aA~b6Q)
 
-# Rails addon
+# Rails add-on
 
-The Rails addon is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) [addon](https://shopify.github.io/ruby-lsp/addons.html) for extra [Rails editor features](https://shopify.github.io/ruby-lsp/rails-addon.html).
+The Rails add-on is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) [add-on](https://shopify.github.io/ruby-lsp/add-ons.html) for extra [Rails editor features](https://shopify.github.io/ruby-lsp/rails-add-on.html).
 
 ## Installation
 
 If you haven't already done so, you'll need to first [set up Ruby LSP](https://shopify.github.io/ruby-lsp/#usage).
 
-As of v0.3.0, Ruby LSP will automatically include the Ruby LSP Rails addon in its custom bundle when a Rails app is detected.
+As of v0.3.0, Ruby LSP will automatically include the Ruby LSP Rails add-on in its custom bundle when a Rails app is detected.
 There is no need to add the gem to your bundle.
 
 ## Documentation
 
-See the [documentation](https://shopify.github.io/ruby-lsp/rails-addon.html) for more in-depth details about the
-[supported features](https://shopify.github.io/ruby-lsp/rails-addon.html#features).
+See the [documentation](https://shopify.github.io/ruby-lsp/rails-add-on.html) for more in-depth details about the
+[supported features](https://shopify.github.io/ruby-lsp/rails-add-on.html#features).
 
 ## Contributing
 

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -28,20 +28,35 @@ 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
+
+        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)) }
+          end
+        end
       end
 
       sig { returns(RunnerClient) }
-      attr_reader :rails_runner_client
+      def rails_runner_client
+        @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 addon v#{VERSION}")
-        # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
-        Thread.new { @rails_runner_client = RunnerClient.create_client }
-        register_additional_file_watchers(global_state: global_state, message_queue: message_queue)
+        @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)
+
+        # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
+        @client_mutex.unlock
       end
 
       sig { override.void }
@@ -49,6 +64,11 @@ module RubyLsp
         @rails_runner_client.shutdown
       end
 
+      sig { override.returns(String) }
+      def version
+        VERSION
+      end
+
       # Creates a new CodeLens listener. This method is invoked on every CodeLens request
       sig do
         override.params(
@@ -106,11 +126,11 @@ module RubyLsp
         end
       end
 
-      sig { params(global_state: GlobalState, message_queue: Thread::Queue).void }
-      def register_additional_file_watchers(global_state:, message_queue:)
+      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      def register_additional_file_watchers(global_state:, outgoing_queue:)
         return unless global_state.supports_watching_files
 
-        message_queue << Request.new(
+        outgoing_queue << Request.new(
           id: "ruby-lsp-rails-file-watcher",
           method: "client/registerCapability",
           params: Interface::RegistrationParams.new(

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -198,9 +198,13 @@ module RubyLsp
           .gsub("::", "/")
           .downcase
 
-        view_uris = Dir.glob("#{@client.rails_root}/app/views/#{controller_name}/#{action_name}*").map! do |path|
+        view_uris = Dir.glob("#{@client.rails_root}/app/views/#{controller_name}/#{action_name}*").filter_map do |path|
+          # it's possible we could have a directory with the same name as the action, so we need to skip those
+          next if File.directory?(path)
+
           URI::Generic.from_path(path: path).to_s
         end
+
         return if view_uris.empty?
 
         @response_builder << create_code_lens(

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,8 +62,8 @@ 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(
@@ -89,14 +74,6 @@ module RubyLsp
           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)
-      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -60,6 +60,7 @@ module RubyLsp
           name_arg.location,
           name_arg.location,
           nil,
+          index.configuration.encoding,
           [RubyIndexer::Entry::Signature.new([])],
           RubyIndexer::Entry::Visibility::PUBLIC,
           owner,
@@ -72,6 +73,7 @@ module RubyLsp
           name_arg.location,
           name_arg.location,
           nil,
+          index.configuration.encoding,
           [RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)])],
           RubyIndexer::Entry::Visibility::PUBLIC,
           owner,

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -10,20 +10,34 @@ 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
@@ -39,8 +53,9 @@ module RubyLsp
       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
@@ -69,7 +84,7 @@ module RubyLsp
         @stdout.binmode
         @stderr.binmode
 
-        $stderr.puts("Ruby LSP Rails booting server")
+        log_message("Ruby LSP Rails booting server")
         count = 0
 
         begin
@@ -77,30 +92,52 @@ module RubyLsp
           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})")
+          log_message("Ruby LSP Rails is retrying initialize (#{count})")
           retry if count < MAX_RETRIES
         end
 
-        $stderr.puts("Finished booting Ruby LSP Rails server")
+        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
 
+      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
+        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}")
+        log_message(
+          "Ruby LSP Rails failed to get model information",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
@@ -116,15 +153,22 @@ module RubyLsp
           model_name: model_name,
           association_name: association_name,
         )
-      rescue => e
-        $stderr.puts("Ruby LSP Rails failed with #{e.message}: #{@stderr.read}")
+      rescue IncompleteMessageError
+        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}")
+        log_message(
+          "Ruby LSP Rails failed to get route location",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
@@ -132,22 +176,58 @@ module RubyLsp
       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}")
+        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
+
+      # 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 IncompleteMessageError
         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")
+        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)
@@ -164,24 +244,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
@@ -206,7 +286,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
 
@@ -221,6 +304,13 @@ 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
     end
 
     class NullClient < RunnerClient
@@ -247,8 +337,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

@@ -8,7 +8,63 @@ require "json"
 
 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 debug message to the editor's output
+      def debug_message(message)
+        $stderr.puts(message)
+      end
+    end
+
+    class ServerAddon
+      include Common
+
+      @server_addon_classes = []
+      @server_addons = {}
+
+      class << self
+        # We keep track of runtime server add-ons the same way we track other add-ons, by storing classes that inherit
+        # from the base one
+        def inherited(child)
+          @server_addon_classes << child
+          super
+        end
+
+        # Delegate `request` with `params` to the server add-on with the given `name`
+        def delegate(name, request, params)
+          @server_addons[name]&.execute(request, params)
+        end
+
+        # Instantiate all server addons and store them in a hash for easy access after we have discovered the classes
+        def finalize_registrations!(stdout)
+          until @server_addon_classes.empty?
+            addon = @server_addon_classes.shift.new(stdout)
+            @server_addons[addon.name] = addon
+          end
+        end
+      end
+
+      def initialize(stdout)
+        @stdout = stdout
+      end
+
+      def name
+        raise NotImplementedError, "Not implemented!"
+      end
+
+      def execute(request, params)
+        raise NotImplementedError, "Not implemented!"
+      end
+    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
@@ -34,8 +90,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")
@@ -51,27 +106,29 @@ 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 "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)
         end
       rescue => e
-        write_response({ error: e.full_message(highlight: false) })
+        send_message({ error: 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")

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.16"
+    VERSION = "0.3.18"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.16
+  version: 0.3.18
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-10-07 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.18.0
+        version: 0.19.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.20.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.20.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
@@ -65,7 +64,7 @@ metadata:
   homepage_uri: https://github.com/Shopify/ruby-lsp-rails
   source_code_uri: https://github.com/Shopify/ruby-lsp-rails
   changelog_uri: https://github.com/Shopify/ruby-lsp-rails/releases
-  documentation_uri: https://shopify.github.io/ruby-lsp/rails-addon.html
+  documentation_uri: https://shopify.github.io/ruby-lsp/rails-add-on.html
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -81,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
+rubygems_version: 3.5.20
 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