ruby-lsp-rails 0.3.17 → 0.3.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba36df033667789339419a3ed19740d35ad9b91a3463cf2438bd390c4580aeb4
-  data.tar.gz: 7aa58db6217944f945ca3bb9bcdefeb4f018759acf8673e222ae8fb3b5c523ee
+  metadata.gz: 159bd26f9edd1f611d7f13cb5864e63d8ecc1c6180bbf5a426b9e40a98ce25ba
+  data.tar.gz: 5266ed45904e0d62f074684a3a943ac1ef66b7827c4177ee7631d5ae46118553
 SHA512:
-  metadata.gz: a4ddf589e0065c32ee9087a4cfd0347d4e3dbdf5d1d667f1ca6a440ac1c6b2d1c18f41acfa2264f72114ecc4bfafec4c3c40748a3f6639a80c86093ca8e51cef
-  data.tar.gz: 2dbb86bd0f701865f3d833fb13079cfd9bd27310cdca2410664c7112db73e9915c9b633de1f527220a64055d3956009a738c367c956c3c08cd5c3ae71e04d7f1
+  metadata.gz: ab185650a7d5d24f1d7e7faf29cea5eabc99d905525ea840b2000003059393c60be8b79ef9f97ef3a78bf58ae695a5d5f19aa5bbecc9ea367d48090c9614538c
+  data.tar.gz: ef04db908af2f8ce9ee58a0059e51736f969f487b769a421d7df141cfc0518f31c2aa503eace5cc5ad24db36f56a1855ba55ffc4d5990f1eccc5d8cea1a4931c

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -28,6 +28,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 +36,7 @@ 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)) }
           end
         end
       end
@@ -45,11 +46,13 @@ 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)
+        @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
@@ -123,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/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/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,21 +92,29 @@ 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
@@ -100,7 +123,10 @@ module RubyLsp
       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}")
+        log_message(
+          "Ruby LSP Rails failed to register server addon #{server_addon_path}",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
         nil
       end
 
@@ -108,7 +134,10 @@ module RubyLsp
       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
 
@@ -124,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
 
@@ -140,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)
@@ -172,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
@@ -214,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
 
@@ -229,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
@@ -255,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,22 @@ 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 = {}
 
@@ -38,12 +53,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 +63,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 +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")
@@ -96,15 +106,15 @@ 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)
@@ -114,16 +124,11 @@ module RubyLsp
           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.17"
+    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.17
+  version: 0.3.18
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2024-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -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

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