ruby-lsp-rails 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175aa77410d6d479169ab7c5c212d12d56ec2c6624d7766bd8e1575da706d7a9
-  data.tar.gz: 76799c42df0346b1628479e61c86914a7f52b96c656ddf39975bed904e13e459
+  metadata.gz: 6bb6fcc96e3d0fd9357e7f8700acbae09e0d792499ed0d8b92fd577a97949108
+  data.tar.gz: cbb971feed21416f187195d0b23295801dbbc5c875c5d64961f2591e253f375a
 SHA512:
-  metadata.gz: 59a4059ffdeb381dd3b8c4858e91b64a624df5e424807540b99aa6182f908f944cc6ea0ddf677776eb2d4680f8bc7c7944883fea2eb346da8252125eedd2c788
-  data.tar.gz: 8bdc777be1f0663cc6d7e2a450b42ceef091f5e75769cf74570ce536bc914de2c2b559cbdcd05989b55d3fc6a58a843f637b2caaf1ec165a97b4c3d0b2c7db11
+  metadata.gz: dc8c684b4900726219d73c2855a1afe159e0ba02f8a953de86356e1cfb9667fe11dff4cbaf3446d5dd471689151f34072f1a099f82033c959516db30dcf81ce7
+  data.tar.gz: 72b8a8ba741fbccd174dc46bb86ef683634630866f209f0968eb6d228992f4986f46bac7f0de249a936649eef80a799c5505f9c8a3514f76d44e77a511b70325

data/README.md

@@ -1,3 +1,5 @@
+[![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)
+
 # Ruby LSP Rails
 
 Ruby LSP Rails is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) addon for extra Rails editor features, such as:
@@ -6,6 +8,7 @@ Ruby LSP Rails is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) addon for ex
 * Run or debug a test by clicking on the code lens which appears above the test class, or an individual test.
 * Navigate to associations, validations, callbacks and test cases using your editor's "Go to Symbol" feature, or outline view.
 * Jump to the definition of callbacks using your editor's "Go to Definition" feature.
+* Jump to the declaration of a route.
 
 ## Installation
 
@@ -36,9 +39,7 @@ When extension is stopped (e.g. by quitting the editor), the server instance is
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/ruby-lsp-rails. This project is
-intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the
-[Contributor Covenant](https://github.com/Shopify/ruby-lsp-rails/blob/main/CODE_OF_CONDUCT.md) code of conduct.
+See [CONTRIBUTING.md](https://github.com/Shopify/ruby-lsp-rails/blob/main/CONTRIBUTING.md)
 
 ## License
 

data/Rakefile

@@ -30,4 +30,4 @@ end
 
 RubyLsp::CheckDocs.new(FileList["#{__dir__}/lib/ruby_lsp/**/*.rb"], FileList["#{__dir__}/misc/**/*.gif"])
 
-task default: :test
+task default: [:"db:setup", :test]

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -3,8 +3,11 @@
 
 require "ruby_lsp/addon"
 
+require_relative "../../ruby_lsp_rails/version"
 require_relative "support/active_support_test_case_helper"
+require_relative "support/associations"
 require_relative "support/callbacks"
+require_relative "support/location_builder"
 require_relative "runner_client"
 require_relative "hover"
 require_relative "code_lens"
@@ -31,6 +34,7 @@ module RubyLsp
         $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 { @client = RunnerClient.create_client }
+        register_additional_file_watchers(global_state: global_state, message_queue: message_queue)
       end
 
       sig { override.void }
@@ -55,12 +59,12 @@ module RubyLsp
       sig do
         override.params(
           response_builder: ResponseBuilders::Hover,
-          nesting: T::Array[String],
+          node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def create_hover_listener(response_builder, nesting, dispatcher)
-        Hover.new(@client, response_builder, nesting, T.must(@global_state), dispatcher)
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        Hover.new(@client, response_builder, node_context, T.must(@global_state), dispatcher)
       end
 
       sig do
@@ -77,13 +81,13 @@ module RubyLsp
         override.params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
           uri: URI::Generic,
-          nesting: T::Array[String],
+          node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def create_definition_listener(response_builder, uri, nesting, dispatcher)
+      def create_definition_listener(response_builder, uri, node_context, dispatcher)
         index = T.must(@global_state).index
-        Definition.new(response_builder, nesting, index, dispatcher)
+        Definition.new(@client, response_builder, node_context, index, dispatcher)
       end
 
       sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
@@ -95,6 +99,32 @@ module RubyLsp
         end
       end
 
+      sig { params(global_state: GlobalState, message_queue: Thread::Queue).void }
+      def register_additional_file_watchers(global_state:, message_queue:)
+        return unless global_state.supports_watching_files
+
+        message_queue << Request.new(
+          id: "ruby-lsp-rails-file-watcher",
+          method: "client/registerCapability",
+          params: Interface::RegistrationParams.new(
+            registrations: [
+              Interface::Registration.new(
+                id: "workspace/didChangeWatchedFilesRails",
+                method: "workspace/didChangeWatchedFiles",
+                register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                  watchers: [
+                    Interface::FileSystemWatcher.new(
+                      glob_pattern: "**/*structure.sql",
+                      kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        )
+      end
+
       sig { override.returns(String) }
       def name
         "Ruby LSP Rails"

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -6,6 +6,7 @@ module RubyLsp
     # ![CodeLens demo](../../code_lens.gif)
     #
     # This feature adds several CodeLens features for Rails applications using Active Support test cases:
+    #
     # - Run tests in the VS Terminal
     # - Run tests in the VS Code Test Explorer
     # - Debug tests
@@ -42,8 +43,6 @@ module RubyLsp
       include Requests::Support::Common
       include ActiveSupportTestCaseHelper
 
-      BASE_COMMAND = "bin/rails test"
-
       sig do
         params(
           response_builder:  ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
@@ -67,7 +66,7 @@ module RubyLsp
         return unless content
 
         line_number = node.location.start_line
-        command = "#{BASE_COMMAND} #{@path}:#{line_number}"
+        command = "#{test_command} #{@path}:#{line_number}"
         add_test_code_lens(node, name: content, command: command, kind: :example)
       end
 
@@ -77,7 +76,7 @@ module RubyLsp
         method_name = node.name.to_s
         if method_name.start_with?("test_")
           line_number = node.location.start_line
-          command = "#{BASE_COMMAND} #{@path}:#{line_number}"
+          command = "#{test_command} #{@path}:#{line_number}"
           add_test_code_lens(node, name: method_name, command: command, kind: :example)
         end
       end
@@ -86,7 +85,7 @@ module RubyLsp
       def on_class_node_enter(node)
         class_name = node.constant_path.slice
         if class_name.end_with?("Test")
-          command = "#{BASE_COMMAND} #{@path}"
+          command = "#{test_command} #{@path}"
           add_test_code_lens(node, name: class_name, command: command, kind: :group)
           @group_id_stack.push(@group_id)
           @group_id += 1
@@ -103,6 +102,15 @@ module RubyLsp
 
       private
 
+      sig { returns(String) }
+      def test_command
+        if Gem.win_platform?
+          "ruby bin/rails test"
+        else
+          "bin/rails test"
+        end
+      end
+
       sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         return unless @path

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -10,28 +10,40 @@ module RubyLsp
     # definition of the symbol under the cursor.
     #
     # Currently supported targets:
+    #
     # - Callbacks
+    # - Named routes (e.g. `users_path`)
     #
     # # Example
     #
     # ```ruby
     # before_action :foo # <- Go to definition on this symbol will jump to the method if it is defined in the same class
     # ```
+    #
+    # Notes for named routes:
+    #
+    # - It is available only in Rails 7.1 or newer.
+    # - Route may be defined across multiple files, e.g. using `draw`, rather than in `routes.rb`.
+    # - Routes won't be found if not defined for the Rails development environment.
+    # - If using `constraints`, the route can only be found if the constraints are met.
+    # - Changes to routes won't be picked up until the server is restarted.
     class Definition
       extend T::Sig
       include Requests::Support::Common
 
       sig do
         params(
+          client: RunnerClient,
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
-          nesting: T::Array[String],
+          node_context: NodeContext,
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, nesting, index, dispatcher)
+      def initialize(client, response_builder, node_context, index, dispatcher)
+        @client = client
         @response_builder = response_builder
-        @nesting = nesting
+        @nesting = T.let(node_context.nesting, T::Array[String])
         @index = index
 
         dispatcher.register(self, :on_call_node_enter)
@@ -43,8 +55,21 @@ module RubyLsp
 
         message = node.message
 
-        return unless message && Support::Callbacks::ALL.include?(message)
+        return unless message
+
+        if Support::Associations::ALL.include?(message)
+          handle_association(node)
+        elsif Support::Callbacks::ALL.include?(message)
+          handle_callback(node)
+        elsif message.end_with?("_path") || message.end_with?("_url")
+          handle_route(node)
+        end
+      end
+
+      private
 
+      sig { params(node: Prism::CallNode).void }
+      def handle_callback(node)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
 
@@ -62,7 +87,30 @@ module RubyLsp
         end
       end
 
-      private
+      sig { params(node: Prism::CallNode).void }
+      def handle_association(node)
+        first_argument = node.arguments&.arguments&.first
+        return unless first_argument.is_a?(Prism::SymbolNode)
+
+        association_name = first_argument.unescaped
+
+        result = @client.association_target_location(
+          model_name: @nesting.join("::"),
+          association_name: association_name,
+        )
+
+        return unless result
+
+        @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_route(node)
+        result = @client.route_location(T.must(node.message))
+        return unless result
+
+        @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
+      end
 
       sig { params(name: String).void }
       def collect_definitions(name)

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -21,12 +21,22 @@ module RubyLsp
       end
       def initialize(response_builder, dispatcher)
         @response_builder = response_builder
-
-        dispatcher.register(self, :on_call_node_enter)
+        @namespace_stack = T.let([], T::Array[String])
+
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+        )
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
+        return if @namespace_stack.empty?
+
         content = extract_test_case_name(node)
 
         if content
@@ -44,15 +54,46 @@ module RubyLsp
         case message
         when *Support::Callbacks::ALL, "validate"
           handle_all_arg_types(node, T.must(message))
-        when "validates", "validates!", "validates_each", "belongs_to", "has_one", "has_many", "has_and_belongs_to_many"
+        when "validates", "validates!", "validates_each", "belongs_to", "has_one", "has_many",
+          "has_and_belongs_to_many", "attr_readonly", "scope"
           handle_symbol_and_string_arg_types(node, T.must(message))
         when "validates_with"
           handle_class_arg_types(node, T.must(message))
         end
       end
 
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        add_to_namespace_stack(node)
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_leave(node)
+        remove_from_namespace_stack(node)
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        add_to_namespace_stack(node)
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_leave(node)
+        remove_from_namespace_stack(node)
+      end
+
       private
 
+      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      def add_to_namespace_stack(node)
+        @namespace_stack << node.constant_path.slice
+      end
+
+      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      def remove_from_namespace_stack(node)
+        @namespace_stack.delete(node.constant_path.slice)
+      end
+
       sig { params(node: Prism::CallNode, message: String).void }
       def handle_all_arg_types(node, message)
         block = node.block

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -24,15 +24,15 @@ module RubyLsp
         params(
           client: RunnerClient,
           response_builder: ResponseBuilders::Hover,
-          nesting: T::Array[String],
+          node_context: NodeContext,
           global_state: GlobalState,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(client, response_builder, nesting, global_state, dispatcher)
+      def initialize(client, response_builder, node_context, global_state, dispatcher)
         @client = client
         @response_builder = response_builder
-        @nesting = nesting
+        @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)
       end
@@ -77,13 +77,14 @@ module RubyLsp
         schema_file = model[:schema_file]
 
         @response_builder.push(
-          "[Schema](#{URI::Generic.build(scheme: "file", path: schema_file)})",
+          "[Schema](#{URI::Generic.from_path(path: schema_file)})",
           category: :links,
         ) if schema_file
 
         @response_builder.push(
           model[:columns].map do |name, type|
-            "**#{name}**: #{type}\n"
+            primary_key_suffix = " (PK)" if model[:primary_keys].include?(name)
+            "**#{name}**: #{type}#{primary_key_suffix}\n"
           end.join("\n"),
           category: :documentation,
         )

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -46,14 +46,15 @@ module RubyLsp
           Process.setsid
         rescue Errno::EPERM
           # If we can't set the session ID, continue
+        rescue NotImplementedError
+          # setpgrp() may be unimplemented on some platform
+          # https://github.com/Shopify/ruby-lsp-rails/issues/348
+        end
+
+        stdin, stdout, stderr, wait_thread = Bundler.with_original_env do
+          Open3.popen3("bundle", "exec", "rails", "runner", "#{__dir__}/server.rb", "start")
         end
 
-        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)
@@ -79,7 +80,9 @@ module RubyLsp
             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
-              Process.kill(T.must(Signal.list["TERM"]), @wait_thread.pid)
+
+              # 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
           end
         end
@@ -95,6 +98,30 @@ module RubyLsp
         nil
       end
 
+      sig do
+        params(
+          model_name: String,
+          association_name: String,
+        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
+      end
+      def association_target_location(model_name:, association_name:)
+        make_request(
+          "association_target_location",
+          model_name: model_name,
+          association_name: association_name,
+        )
+      rescue => e
+        $stderr.puts("Ruby LSP Rails failed with #{e.message}: #{@stderr.read}")
+      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}")
+        nil
+      end
+
       sig { void }
       def trigger_reload
         $stderr.puts("Reloading Rails application")

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -1,24 +1,8 @@
-# typed: strict
+# typed: false
 # 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
-
 # 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.
 
@@ -27,17 +11,19 @@ module RubyLsp
     class Server
       VOID = Object.new
 
-      extend T::Sig
-
-      sig { void }
       def initialize
         $stdin.sync = true
         $stdout.sync = true
-        @running = T.let(true, T::Boolean)
+        $stdin.binmode
+        $stdout.binmode
+        @running = true
       end
 
-      sig { void }
       def start
+        # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
+        routes_reloader = ::Rails.application.routes_reloader
+        routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
+
         initialize_result = { result: { message: "ok" } }.to_json
         $stdout.write("Content-Length: #{initialize_result.length}\r\n\r\n#{initialize_result}")
 
@@ -54,22 +40,20 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          request: String,
-          params: T.nilable(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(T.must(params).fetch(:name))
+          resolve_database_info_from_model(params.fetch(:name))
+        when "association_target_location"
+          resolve_association_target(params)
         when "reload"
           ::Rails.application.reloader.reload!
           VOID
+        when "route_location"
+          route_location(params.fetch(:name))
         else
           VOID
         end
@@ -79,10 +63,37 @@ module RubyLsp
 
       private
 
-      sig { params(model_name: String).returns(T::Hash[Symbol, T.untyped]) }
+      # Older versions of Rails don't support `route_source_locations`.
+      # We also check that it's enabled.
+      if ActionDispatch::Routing::Mapper.respond_to?(:route_source_locations) &&
+          ActionDispatch::Routing::Mapper.route_source_locations
+        def route_location(name)
+          match_data = name.match(/^(.+)(_path|_url)$/)
+          return { result: nil } unless match_data
+
+          key = match_data[1]
+
+          # A token could match the _path or _url pattern, but not be an actual route.
+          route = ::Rails.application.routes.named_routes.get(key)
+          return { result: nil } unless route&.source_location
+
+          {
+            result: {
+              location: ::Rails.root.join(route.source_location).to_s,
+            },
+          }
+        rescue => e
+          { error: e.full_message(highlight: false) }
+        end
+      else
+        def route_location(name)
+          { result: nil }
+        end
+      end
+
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
-        unless const && defined?(ActiveRecord) && const < ActiveRecord::Base && !const.abstract_class?
+        unless active_record_model?(const)
           return {
             result: nil,
           }
@@ -91,6 +102,7 @@ module RubyLsp
         info = {
           result: {
             columns: const.columns.map { |column| [column.name, column.type] },
+            primary_keys: Array(const.primary_key),
           },
         }
 
@@ -103,6 +115,38 @@ module RubyLsp
       rescue => e
         { error: e.full_message(highlight: false) }
       end
+
+      def resolve_association_target(params)
+        const = ActiveSupport::Inflector.safe_constantize(params[:model_name])
+        unless active_record_model?(const)
+          return {
+            result: nil,
+          }
+        end
+
+        association_klass = const.reflect_on_association(params[:association_name].intern).klass
+
+        source_location = Object.const_source_location(association_klass.to_s)
+
+        {
+          result: {
+            location: source_location.first + ":" + source_location.second.to_s,
+          },
+        }
+      rescue NameError
+        {
+          result: nil,
+        }
+      end
+
+      def active_record_model?(const)
+        !!(
+          const &&
+            defined?(ActiveRecord) &&
+            ActiveRecord::Base > const && # We do this 'backwards' in case the class overwrites `<`
+          !const.abstract_class?
+        )
+      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module Support
+      module Associations
+        ALL = T.let(
+          [
+            "belongs_to",
+            "has_many",
+            "has_one",
+            "has_and_belongs_to_many",
+          ].freeze,
+          T::Array[String],
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module Support
+      class LocationBuilder
+        class << self
+          extend T::Sig
+
+          sig { params(location_string: String).returns(Interface::Location) }
+          def line_location_from_s(location_string)
+            *file_parts, line = location_string.split(":")
+
+            raise ArgumentError, "Invalid location string given" unless file_parts
+
+            # On Windows, file paths will look something like `C:/path/to/file.rb:123`. Only the last colon is the line
+            # number and all other parts compose the file path
+            file_path = file_parts.join(":")
+
+            Interface::Location.new(
+              uri: URI::Generic.from_path(path: file_path).to_s,
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: Integer(line) - 1, character: 0),
+                end: Interface::Position.new(line: Integer(line) - 1, character: 0),
+              ),
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -66,18 +66,25 @@ module RubyLsp
           private def build_search_index
             return unless RAILTIES_VERSION
 
-            $stderr.puts("Fetching Rails Documents...")
+            $stderr.puts("Fetching search index for Rails documentation")
 
-            response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+            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"))
-              response.body if response.is_a?(Net::HTTPSuccess)
+              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

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.5"
+    VERSION = "0.3.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-05 00:00:00.000000000 Z
+date: 2024-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -16,34 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.17.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: 0.18.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.16.0
-    - - "<"
       - !ruby/object:Gem::Version
         version: 0.17.0
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.9897
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.9897
+        version: 0.18.0
 description: A Ruby LSP addon that adds extra editor functionality for Rails applications
 email:
 - ruby@shopify.com
@@ -63,7 +49,9 @@ files:
 - 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/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
@@ -91,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.7
+rubygems_version: 3.5.10
 signing_key: 
 specification_version: 4
 summary: A Ruby LSP addon for Rails