Enable definitions for dsl method arguments

Author: Aryan Soni

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -8,6 +8,7 @@
 require_relative "hover"
 require_relative "code_lens"
 require_relative "document_symbol"
+require_relative "definition"
 
 module RubyLsp
   module Rails
@@ -68,6 +69,19 @@ def create_document_symbol_listener(response_builder, dispatcher)
         DocumentSymbol.new(response_builder, dispatcher)
       end
 
+      sig do
+        override.params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          uri: URI::Generic,
+          nesting: T::Array[String],
+          index: RubyIndexer::Index,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def create_definition_listener(response_builder, uri, nesting, index, dispatcher)
+        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|

lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -0,0 +1,150 @@
+# 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:
+    # - Classes
+    # - Modules
+    # - Constants
+    # - Require paths
+    # - Methods invoked on self only
+    #
+    # # Example
+    #
+    # ```ruby
+    # require "some_gem/file" # <- Request go to definition on this string will take you to the file
+    # Product.new # <- Request go to definition on this class name will take you to its declaration.
+    # ```
+    class Definition
+      extend T::Sig
+      include Requests::Support::Common
+      include ActiveSupportTestCaseHelper
+
+      MODEL_CALLBACKS = 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],
+      )
+
+      CONTROLLER_CALLBACKS = 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],
+      )
+
+      JOB_CALLBACKS = T.let(
+        [
+          "after_enqueue",
+          "after_perform",
+          "around_enqueue",
+          "around_perform",
+          "before_enqueue",
+          "before_perform",
+        ].freeze,
+        T::Array[String],
+      )
+
+      CALLBACKS = T.let((MODEL_CALLBACKS + CONTROLLER_CALLBACKS + JOB_CALLBACKS).freeze, T::Array[String])
+
+      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 && CALLBACKS.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

misc/definition.gif

@@ -2,6 +2,12 @@
 # frozen_string_literal: true
 
 class User < ApplicationRecord
-  before_create :foo_arg, -> () {}
+  before_create :foo, -> () {}
   validates :name, presence: true
+
+  private
+
+  def foo
+    puts "test"
+  end
 end

test/dummy/app/models/user.rb

@@ -0,0 +1,125 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyLsp
+  module Rails
+    class DefinitionTest < ActiveSupport::TestCase
+      setup do
+        @message_queue = Thread::Queue.new
+
+        # Build the Rails documents index ahead of time
+        capture_io do
+          Support::RailsDocumentClient.send(:search_index)
+        end
+      end
+
+      def teardown
+        T.must(@message_queue).close
+      end
+
+      test "recognizes model callback with multiple symbol arguments" do
+        response = generate_definitions_for_source(<<~RUBY, { line: 3, character: 10 })
+          # typed: false
+
+          class TestModel
+            before_create :foo, :baz
+
+            def foo; end
+            def baz; end
+          end
+        RUBY
+
+        assert_equal(2, response.size)
+
+        assert_equal("file:///fake.rb", response[0].uri)
+        assert_equal(5, response[0].range.start.line)
+        assert_equal(2, response[0].range.start.character)
+        assert_equal(5, response[0].range.end.line)
+        assert_equal(14, response[0].range.end.character)
+
+        assert_equal("file:///fake.rb", response[1].uri)
+        assert_equal(6, response[1].range.start.line)
+        assert_equal(2, response[1].range.start.character)
+        assert_equal(6, response[1].range.end.line)
+        assert_equal(14, response[1].range.end.character)
+      end
+
+      test "recognizes controller callback with string argument" do
+        response = generate_definitions_for_source(<<~RUBY, { line: 3, character: 10 })
+          # typed: false
+
+          class TestController
+            before_action "foo"
+
+            def foo; end
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+
+        assert_equal("file:///fake.rb", response[0].uri)
+        assert_equal(5, response[0].range.start.line)
+        assert_equal(2, response[0].range.start.character)
+        assert_equal(5, response[0].range.end.line)
+        assert_equal(14, response[0].range.end.character)
+      end
+
+      test "recognizes job callback with string and symbol arguments" do
+        response = generate_definitions_for_source(<<~RUBY, { line: 3, character: 10 })
+          # typed: false
+
+          class TestJob
+            before_perform :foo, "baz"
+
+            def foo; end
+            def baz; end
+          end
+        RUBY
+
+        assert_equal(2, response.size)
+
+        assert_equal("file:///fake.rb", response[0].uri)
+        assert_equal(5, response[0].range.start.line)
+        assert_equal(2, response[0].range.start.character)
+        assert_equal(5, response[0].range.end.line)
+        assert_equal(14, response[0].range.end.character)
+
+        assert_equal("file:///fake.rb", response[1].uri)
+        assert_equal(6, response[1].range.start.line)
+        assert_equal(2, response[1].range.start.character)
+        assert_equal(6, response[1].range.end.line)
+        assert_equal(14, response[1].range.end.character)
+      end
+
+      private
+
+      def generate_definitions_for_source(source, position)
+        uri = URI("file:///fake.rb")
+        store = RubyLsp::Store.new
+        store.set(uri: uri, source: source, version: 1)
+
+        executor = RubyLsp::Executor.new(store, @message_queue)
+        executor.instance_variable_get(:@index).index_single(
+          RubyIndexer::IndexablePath.new(nil, T.must(uri.to_standardized_path)), source
+        )
+
+        capture_subprocess_io do
+          RubyLsp::Executor.new(store, @message_queue).execute({
+            method: "initialized",
+            params: {},
+          })
+        end
+
+        response = executor.execute({
+          method: "textDocument/definition",
+          params: { textDocument: { uri: uri }, position: position },
+        })
+
+        assert_nil(response.error)
+        response.response
+      end
+    end
+  end
+end