ruby-lsp-rails 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b68f8a0b2e4d7d4fa32aa2712865dea5c4734c86aa6a490c2a7ace718e3405a
-  data.tar.gz: a146d2ff4091073a9517147dffd3f5326337b947563ed39848d3a823662b5fdc
+  metadata.gz: 463c37a3e7c9fef9c7b5433d2ef9519f41a29867a0089fe6508fc701a6cf1871
+  data.tar.gz: 0f3e7a164235e85b610f9e0855a0d57e9a25125999ff1c15ed31acc54880cad2
 SHA512:
-  metadata.gz: 8902056649daff38b9c6e73231ecc0fb55485d4789d52b9dbf92afe4983104082a959b242b1a9f898d3697344663a678da952b0c0a4f76db026ef07c4744fe52
-  data.tar.gz: 7550880a0a82da99734d38178c5aa47a1909b1787f2070bbf960f2b70ea177a3dd330484428b220de10d3d511a93b7f87a736dfbaf5c47bd12c50f547da15858
+  metadata.gz: 85cbe926939cac7051877d168de8164099265329ccb0cbe4ff6dbe9d1508ae64ce52b168a816d6cd538c79c384f04a1873654b692c98592cb032bc9c1470f318
+  data.tar.gz: c1023803f769de1d701788a85e17906b9626aa9fee89a7d36cabb849826ca68021c00402d8a3d7043cb3128ac7966195fb9ef5b0714109fff96ad907359d7ed5

data/README.md

@@ -7,37 +7,27 @@ Ruby LSP Rails is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) addon for ex
 
 ## Installation
 
-To install, add the following line to your application's Gemfile:
+If you haven't already done so, you'll need to first [set up Ruby LSP](https://github.com/Shopify/ruby-lsp#usage).
 
-```ruby
-# Gemfile
-group :development do
-  gem "ruby-lsp-rails"
-end
-```
+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.
+There is no need to add the gem to your bundle.
 
-## Usage
+## Features
 
-### Hover to reveal ActiveRecord schema
+* Hover over an ActiveRecord model to reveal its schema.
+* 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.
 
-1. Start your Rails server
-1. Hover over an ActiveRecord model to see its details
-
-### Documentation
+## Documentation
 
 See the [documentation](https://shopify.github.io/ruby-lsp-rails) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp-rails/RubyLsp/Rails.html).
 
-### Running Tests
-
-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.
+## How Runtime Introspection Works
 
-## How It Works
+LSP tooling is typically based on static analysis, but `ruby-lsp-rails` actually communicates with your Rails app for
+some features.
 
 When Ruby LSP Rails starts, it spawns a `rails runner` instance which runs
 [`server.rb`](https://github.com/Shopify/ruby-lsp-rails/blob/main/lib/ruby_lsp/ruby_lsp_rails/server.rb).
@@ -46,7 +36,7 @@ The addon communicates with this process over a pipe (i.e. `stdin` and `stdout`)
 When extension is stopped (e.g. by quitting the editor), the server instance is shut down.
 
 > [!NOTE]
-> Prior to v0.3, `ruby-lsp-rails` used a different approach which involved mounting a Rack application within the Rails app.
+> Prior to v0.3.0, `ruby-lsp-rails` used a different approach which involved mounting a Rack application within the Rails app.
 > That approach was brittle and susceptible to the application's configuration, such as routing and middleware.
 
 ## Contributing

data/Rakefile

@@ -23,6 +23,7 @@ RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include("*.md", "lib/**/*.rb")
   rdoc.rdoc_dir = "docs"
   rdoc.markup = "markdown"
+  rdoc.generator = "snapper"
   rdoc.options.push("--copy-files", "misc")
   rdoc.options.push("--copy-files", "LICENSE.txt")
 end

data/lib/ruby-lsp-rails.rb

@@ -9,6 +9,8 @@ module RubyLsp
   #
   # - [Hover](rdoc-ref:RubyLsp::Rails::Hover)
   # - [CodeLens](rdoc-ref:RubyLsp::Rails::CodeLens)
+  # - [DocumentSymbol](rdoc-ref:RubyLsp::Rails::DocumentSymbol)
+  # - [Definition](rdoc-ref:RubyLsp::Rails::Definition)
   module Rails
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -4,10 +4,12 @@
 require "ruby_lsp/addon"
 
 require_relative "support/active_support_test_case_helper"
+require_relative "support/callbacks"
 require_relative "runner_client"
 require_relative "hover"
 require_relative "code_lens"
 require_relative "document_symbol"
+require_relative "definition"
 
 module RubyLsp
   module Rails
@@ -23,8 +25,10 @@ module RubyLsp
         @client = T.let(NullClient.new, RunnerClient)
       end
 
-      sig { override.params(message_queue: Thread::Queue).void }
-      def activate(message_queue)
+      sig { override.params(global_state: GlobalState, message_queue: Thread::Queue).void }
+      def activate(global_state, message_queue)
+        @global_state = T.let(global_state, T.nilable(RubyLsp::GlobalState))
+        $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 }
       end
@@ -43,6 +47,8 @@ module RubyLsp
         ).void
       end
       def create_code_lens_listener(response_builder, uri, dispatcher)
+        return unless T.must(@global_state).test_library == "rails"
+
         CodeLens.new(response_builder, uri, dispatcher)
       end
 
@@ -50,12 +56,11 @@ module RubyLsp
         override.params(
           response_builder: ResponseBuilders::Hover,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def create_hover_listener(response_builder, nesting, index, dispatcher)
-        Hover.new(@client, response_builder, nesting, index, dispatcher)
+      def create_hover_listener(response_builder, nesting, dispatcher)
+        Hover.new(@client, response_builder, nesting, T.must(@global_state), dispatcher)
       end
 
       sig do
@@ -68,6 +73,28 @@ module RubyLsp
         DocumentSymbol.new(response_builder, dispatcher)
       end
 
+      sig do
+        override.params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          uri: URI::Generic,
+          nesting: T::Array[String],
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def create_definition_listener(response_builder, uri, nesting, dispatcher)
+        index = T.must(@global_state).index
+        Definition.new(response_builder, nesting, index, dispatcher)
+      end
+
+      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      def workspace_did_change_watched_files(changes)
+        if changes.any? do |change|
+             change[:uri].end_with?("db/schema.rb") || change[:uri].end_with?("structure.sql")
+           end
+          @client.trigger_reload
+        end
+      end
+
       sig { override.returns(String) }
       def name
         "Ruby LSP Rails"

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -12,7 +12,9 @@ module RubyLsp
     #
     # The
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
-    # request informs the editor of runnable commands such as tests
+    # request informs the editor of runnable commands such as tests.
+    # It's available for tests which inherit from `ActiveSupport::TestCase` or one of its descendants, such as
+    # `ActionDispatch::IntegrationTest`.
     #
     # # Example:
     #
@@ -32,6 +34,9 @@ module RubyLsp
     # ````
     #
     # The code lenses will be displayed above the class and above each test method.
+    #
+    # 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.
     class CodeLens
       extend T::Sig
       include Requests::Support::Common

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    # ![Definition demo](../../definition.gif)
+    #
+    # The [definition
+    # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
+    # definition of the symbol under the cursor.
+    #
+    # Currently supported targets:
+    # - Callbacks
+    #
+    # # Example
+    #
+    # ```ruby
+    # before_action :foo # <- Go to definition on this symbol will jump to the method if it is defined in the same class
+    # ```
+    class Definition
+      extend T::Sig
+      include Requests::Support::Common
+
+      sig do
+        params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          nesting: T::Array[String],
+          index: RubyIndexer::Index,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(response_builder, nesting, index, dispatcher)
+        @response_builder = response_builder
+        @nesting = nesting
+        @index = index
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return unless self_receiver?(node)
+
+        message = node.message
+
+        return unless message && Support::Callbacks::ALL.include?(message)
+
+        arguments = node.arguments&.arguments
+        return unless arguments&.any?
+
+        arguments.each do |argument|
+          name = case argument
+          when Prism::SymbolNode
+            argument.value
+          when Prism::StringNode
+            argument.content
+          end
+
+          next unless name
+
+          collect_definitions(name)
+        end
+      end
+
+      private
+
+      sig { params(name: String).void }
+      def collect_definitions(name)
+        methods = @index.resolve_method(name, @nesting.join("::"))
+        return unless methods
+
+        methods.each do |target_method|
+          location = target_method.location
+          file_path = target_method.file_path
+
+          @response_builder << Interface::Location.new(
+            uri: URI::Generic.from_path(path: file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -6,7 +6,8 @@ module RubyLsp
     # ![Document Symbol demo](../../document_symbol.gif)
     #
     # The [document symbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol)
-    # request allows users to navigate between ActiveSupport test cases with VS Code's "Go to Symbol" feature.
+    # request allows users to navigate between associations, validations, callbacks and ActiveSupport test cases with
+    # VS Code's "Go to Symbol" feature.
     class DocumentSymbol
       extend T::Sig
       include Requests::Support::Common
@@ -28,13 +29,161 @@ module RubyLsp
       def on_call_node_enter(node)
         content = extract_test_case_name(node)
 
-        return unless content
+        if content
+          append_document_symbol(
+            name: content,
+            selection_range: range_from_node(node),
+            range: range_from_node(node),
+          )
+        end
 
+        receiver = node.receiver
+        return if receiver && !receiver.is_a?(Prism::SelfNode)
+
+        message = node.message
+        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"
+          handle_symbol_and_string_arg_types(node, T.must(message))
+        when "validates_with"
+          handle_class_arg_types(node, T.must(message))
+        end
+      end
+
+      private
+
+      sig { params(node: Prism::CallNode, message: String).void }
+      def handle_all_arg_types(node, message)
+        block = node.block
+
+        if block
+          append_document_symbol(
+            name: "#{message} <anonymous>",
+            range: range_from_location(node.location),
+            selection_range: range_from_location(block.location),
+          )
+          return
+        end
+
+        arguments = node.arguments&.arguments
+        return unless arguments&.any?
+
+        arguments.each do |argument|
+          case argument
+          when Prism::SymbolNode
+            name = argument.value
+            next unless name
+
+            append_document_symbol(
+              name: "#{message} :#{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(T.must(argument.value_loc)),
+            )
+          when Prism::StringNode
+            name = argument.content
+            next if name.empty?
+
+            append_document_symbol(
+              name: "#{message} :#{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(argument.content_loc),
+            )
+          when Prism::LambdaNode
+            append_document_symbol(
+              name: "#{message} <anonymous>",
+              range: range_from_location(node.location),
+              selection_range: range_from_location(argument.location),
+            )
+          when Prism::CallNode
+            next unless argument.name == :new
+
+            arg_receiver = argument.receiver
+
+            name = arg_receiver.full_name if arg_receiver.is_a?(Prism::ConstantReadNode) ||
+              arg_receiver.is_a?(Prism::ConstantPathNode)
+            next unless name
+
+            append_document_symbol(
+              name: "#{message} #{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(argument.location),
+            )
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
+            name = argument.full_name
+            next if name.empty?
+
+            append_document_symbol(
+              name: "#{message} #{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(argument.location),
+            )
+          end
+        end
+      end
+
+      sig { params(node: Prism::CallNode, message: String).void }
+      def handle_symbol_and_string_arg_types(node, message)
+        arguments = node.arguments&.arguments
+        return unless arguments&.any?
+
+        arguments.each do |argument|
+          case argument
+          when Prism::SymbolNode
+            name = argument.value
+            next unless name
+
+            append_document_symbol(
+              name: "#{message} :#{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(T.must(argument.value_loc)),
+            )
+          when Prism::StringNode
+            name = argument.content
+            next if name.empty?
+
+            append_document_symbol(
+              name: "#{message} :#{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(argument.content_loc),
+            )
+          end
+        end
+      end
+
+      sig { params(node: Prism::CallNode, message: String).void }
+      def handle_class_arg_types(node, message)
+        arguments = node.arguments&.arguments
+        return unless arguments&.any?
+
+        arguments.each do |argument|
+          case argument
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
+            name = argument.full_name
+            next if name.empty?
+
+            append_document_symbol(
+              name: "#{message} #{name}",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(argument.location),
+            )
+          end
+        end
+      end
+
+      sig do
+        params(
+          name: String,
+          range: RubyLsp::Interface::Range,
+          selection_range: RubyLsp::Interface::Range,
+        ).void
+      end
+      def append_document_symbol(name:, range:, selection_range:)
         @response_builder.last.children << RubyLsp::Interface::DocumentSymbol.new(
-          name: content,
-          kind: LanguageServer::Protocol::Constant::SymbolKind::METHOD,
-          selection_range: range_from_node(node),
-          range: range_from_node(node),
+          name: name,
+          kind: RubyLsp::Constant::SymbolKind::METHOD,
+          range: range,
+          selection_range: selection_range,
         )
       end
     end

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -25,15 +25,15 @@ module RubyLsp
           client: RunnerClient,
           response_builder: ResponseBuilders::Hover,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(client, response_builder, nesting, index, dispatcher)
+      def initialize(client, response_builder, nesting, global_state, dispatcher)
         @client = client
         @response_builder = response_builder
         @nesting = nesting
-        @index = index
+        @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
 

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -12,16 +12,27 @@ module RubyLsp
 
         sig { returns(RunnerClient) }
         def create_client
-          new
+          if File.exist?("bin/rails")
+            new
+          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")
+            NullClient.new
+          end
         rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
-          warn("Ruby LSP Rails failed to initialize server: #{e.message}\n#{e.backtrace&.join("\n")}")
-          warn("Server dependent features will not be available")
+          $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")
           NullClient.new
         end
       end
 
       class InitializationError < StandardError; end
       class IncompleteMessageError < StandardError; end
+      class EmptyMessageError < StandardError; end
+
+      MAX_RETRIES = 5
 
       extend T::Sig
 
@@ -50,14 +61,23 @@ module RubyLsp
         @stdin.binmode # for Windows compatibility
         @stdout.binmode # for Windows compatibility
 
-        warn("Ruby LSP Rails booting server")
-        read_response
-        warn("Finished booting Ruby LSP Rails server")
+        $stderr.puts("Ruby LSP Rails booting server")
+        count = 0
+
+        begin
+          count += 1
+          read_response
+        rescue EmptyMessageError
+          $stderr.puts("Ruby LSP Rails is retrying initialize (#{count})")
+          retry if count < MAX_RETRIES
+        end
+
+        $stderr.puts("Finished booting Ruby LSP Rails server")
 
         unless ENV["RAILS_ENV"] == "test"
           at_exit do
             if @wait_thread.alive?
-              warn("Ruby LSP Rails is force killing the server")
+              $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)
             end
@@ -71,13 +91,22 @@ module RubyLsp
       def model(name)
         make_request("model", name: name)
       rescue IncompleteMessageError
-        warn("Ruby LSP Rails failed to get model information: #{@stderr.read}")
+        $stderr.puts("Ruby LSP Rails failed to get model information: #{@stderr.read}")
+        nil
+      end
+
+      sig { void }
+      def trigger_reload
+        $stderr.puts("Reloading Rails application")
+        send_notification("reload")
+      rescue IncompleteMessageError
+        $stderr.puts("Ruby LSP Rails failed to trigger reload")
         nil
       end
 
       sig { void }
       def shutdown
-        warn("Ruby LSP Rails shutting down server")
+        $stderr.puts("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)
@@ -117,11 +146,14 @@ module RubyLsp
         headers = @stdout.gets("\r\n\r\n")
         raise IncompleteMessageError unless headers
 
-        raw_response = @stdout.read(headers[/Content-Length: (\d+)/i, 1].to_i)
+        content_length = headers[/Content-Length: (\d+)/i, 1].to_i
+        raise EmptyMessageError if content_length.zero?
+
+        raw_response = @stdout.read(content_length)
         response = JSON.parse(T.must(raw_response), symbolize_names: true)
 
         if response[:error]
-          warn("Ruby LSP Rails error: " + response[:error])
+          $stderr.puts("Ruby LSP Rails error: " + response[:error])
           return
         end
 

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -57,16 +57,19 @@ module RubyLsp
       sig do
         params(
           request: String,
-          params: T::Hash[Symbol, T.untyped],
+          params: T.nilable(T::Hash[Symbol, T.untyped]),
         ).returns(T.any(Object, T::Hash[Symbol, T.untyped]))
       end
-      def execute(request, params = {})
+      def execute(request, params)
         case request
         when "shutdown"
           @running = false
           VOID
         when "model"
-          resolve_database_info_from_model(params.fetch(:name))
+          resolve_database_info_from_model(T.must(params).fetch(:name))
+        when "reload"
+          ::Rails.application.reloader.reload!
+          VOID
         else
           VOID
         end

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

@@ -11,8 +11,6 @@ module RubyLsp
         message_value = node.message
         return unless message_value == "test" || message_value == "it"
 
-        return unless node.arguments
-
         arguments = node.arguments&.arguments
         return unless arguments&.any?
 

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

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module Support
+      module Callbacks
+        MODELS = T.let(
+          [
+            "before_validation",
+            "after_validation",
+            "before_save",
+            "around_save",
+            "after_save",
+            "before_create",
+            "around_create",
+            "after_create",
+            "after_commit",
+            "after_rollback",
+            "before_update",
+            "around_update",
+            "after_update",
+            "before_destroy",
+            "around_destroy",
+            "after_destroy",
+            "after_initialize",
+            "after_find",
+            "after_touch",
+          ].freeze,
+          T::Array[String],
+        )
+
+        CONTROLLERS = T.let(
+          [
+            "after_action",
+            "append_after_action",
+            "append_around_action",
+            "append_before_action",
+            "around_action",
+            "before_action",
+            "prepend_after_action",
+            "prepend_around_action",
+            "prepend_before_action",
+            "skip_after_action",
+            "skip_around_action",
+            "skip_before_action",
+          ].freeze,
+          T::Array[String],
+        )
+
+        JOBS = T.let(
+          [
+            "after_enqueue",
+            "after_perform",
+            "around_enqueue",
+            "around_perform",
+            "before_enqueue",
+            "before_perform",
+          ].freeze,
+          T::Array[String],
+        )
+
+        ALL = T.let((MODELS + CONTROLLERS + JOBS).freeze, T::Array[String])
+      end
+    end
+  end
+end

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

@@ -66,7 +66,7 @@ module RubyLsp
           private def build_search_index
             return unless RAILTIES_VERSION
 
-            warn("Fetching Rails Documents...")
+            $stderr.puts("Fetching Rails Documents...")
 
             response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
 
@@ -79,13 +79,13 @@ module RubyLsp
               response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
               response.body if response.is_a?(Net::HTTPSuccess)
             else
-              warn("Response failed: #{response.inspect}")
+              $stderr.puts("Response failed: #{response.inspect}")
               nil
             end
 
             process_search_index(body) if body
           rescue StandardError => e
-            warn("Exception occurred when fetching Rails document index: #{e.inspect}")
+            $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]]]) }

data/lib/ruby_lsp_rails/version.rb

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

data/lib/tasks/ruby_lsp_rails_tasks.rake

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # desc "Explaining what the task does"
 # task :ruby_lsp_rails do
 #   # Task goes here

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-29 00:00:00.000000000 Z
+date: 2024-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -58,20 +58,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.2
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.2
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.17.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -99,11 +99,13 @@ files:
 - lib/ruby-lsp-rails.rb
 - lib/ruby_lsp/ruby_lsp_rails/addon.rb
 - lib/ruby_lsp/ruby_lsp_rails/code_lens.rb
+- lib/ruby_lsp/ruby_lsp_rails/definition.rb
 - lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.rb
 - lib/ruby_lsp/ruby_lsp_rails/runner_client.rb
 - lib/ruby_lsp/ruby_lsp_rails/server.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/active_support_test_case_helper.rb
+- lib/ruby_lsp/ruby_lsp_rails/support/callbacks.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/rails_document_client.rb
 - lib/ruby_lsp_rails/railtie.rb
 - lib/ruby_lsp_rails/version.rb
@@ -124,14 +126,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.7
 signing_key: 
 specification_version: 4
 summary: A Ruby LSP addon for Rails