Implement document symbol for validations

Author: Aryan Soni

lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -93,25 +93,29 @@ def on_call_node_enter(node)
           )
         end
 
-        extract_callbacks(node)
-      end
-
-      private
-
-      sig { params(node: Prism::CallNode).void }
-      def extract_callbacks(node)
         receiver = node.receiver
         return if receiver && !receiver.is_a?(Prism::SelfNode)
 
-        message_value = node.message
+        message = node.message
+        case message
+        when *CALLBACKS, "validate"
+          handle_all_arg_types(node, T.must(message))
+        when "validates", "validates!", "validates_each"
+          handle_symbol_and_string_arg_types(node, T.must(message))
+        when "validates_with"
+          handle_class_arg_types(node, T.must(message))
+        end
+      end
 
-        return unless CALLBACKS.include?(message_value)
+      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_value}(<anonymous>)",
+            name: "#{message}(<anonymous>)",
             range: range_from_location(node.location),
             selection_range: range_from_location(block.location),
           )
@@ -128,7 +132,7 @@ def extract_callbacks(node)
             next unless name
 
             append_document_symbol(
-              name: "#{message_value}(#{name})",
+              name: "#{message}(#{name})",
               range: range_from_location(argument.location),
               selection_range: range_from_location(T.must(argument.value_loc)),
             )
@@ -137,13 +141,13 @@ def extract_callbacks(node)
             next if name.empty?
 
             append_document_symbol(
-              name: "#{message_value}(#{name})",
+              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_value}(<anonymous>)",
+              name: "#{message}(<anonymous>)",
               range: range_from_location(node.location),
               selection_range: range_from_location(argument.location),
             )
@@ -157,7 +161,7 @@ def extract_callbacks(node)
             next unless name
 
             append_document_symbol(
-              name: "#{message_value}(#{name})",
+              name: "#{message}(#{name})",
               range: range_from_location(argument.location),
               selection_range: range_from_location(argument.location),
             )
@@ -166,7 +170,65 @@ def extract_callbacks(node)
             next if name.empty?
 
             append_document_symbol(
-              name: "#{message_value}(#{name})",
+              name: "#{message}(#{name})",
+              range: range_from_location(argument.location),
+              selection_range: range_from_location(argument.location),
+            )
+          when 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
+            name = argument.name
+            next if name.empty?
+
+            append_document_symbol(
+              name: "#{message}(#{name})",
               range: range_from_location(argument.location),
               selection_range: range_from_location(argument.location),
             )
@@ -175,7 +237,7 @@ def extract_callbacks(node)
             next if name.empty?
 
             append_document_symbol(
-              name: "#{message_value}(#{name})",
+              name: "#{message}(#{name})",
               range: range_from_location(argument.location),
               selection_range: range_from_location(argument.location),
             )

test/dummy/app/models/user.rb

@@ -3,4 +3,5 @@
 
 class User < ApplicationRecord
   before_create :foo_arg, -> () {}
+  validates :name, presence: true
 end

test/ruby_lsp_rails/document_symbol_test.rb

@@ -287,6 +287,68 @@ class FooJob < ApplicationJob
         assert_empty(response[0].children)
       end
 
+      test "correctly handles validate method with all argument types" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          class FooModel < ApplicationRecord
+            validate "foo_arg", :bar_arg, -> () {}, Foo::BazClass.new("blah"), FooClass, Foo::BarClass
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+        assert_equal("FooModel", response[0].name)
+        assert_equal(6, response[0].children.size)
+        assert_equal("validate(foo_arg)", response[0].children[0].name)
+        assert_equal("validate(bar_arg)", response[0].children[1].name)
+        assert_equal("validate(<anonymous>)", response[0].children[2].name)
+        assert_equal("validate(Foo::BazClass)", response[0].children[3].name)
+        assert_equal("validate(FooClass)", response[0].children[4].name)
+        assert_equal("validate(Foo::BarClass)", response[0].children[5].name)
+      end
+
+      test "correctly handles validates method with Prism::StringNode and Prism::SymbolNode argument types" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          class FooModel < ApplicationRecord
+            validates "foo_arg", :bar_arg
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+        assert_equal("FooModel", response[0].name)
+        assert_equal(2, response[0].children.size)
+        assert_equal("validates(foo_arg)", response[0].children[0].name)
+        assert_equal("validates(bar_arg)", response[0].children[1].name)
+      end
+
+      test "correctly handles validates_each method with Prism::StringNode and Prism::SymbolNode argument types" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          class FooModel < ApplicationRecord
+            validates_each "foo_arg", :bar_arg do
+              puts "Foo"
+            end
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+        assert_equal("FooModel", response[0].name)
+        assert_equal(2, response[0].children.size)
+        assert_equal("validates_each(foo_arg)", response[0].children[0].name)
+        assert_equal("validates_each(bar_arg)", response[0].children[1].name)
+      end
+
+      test "correctly handles validates_with method with Prism::ConstantReadNode and Prism::ConstantPathNode argument types" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          class FooModel < ApplicationRecord
+            validates_with FooClass, Foo::BarClass
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+        assert_equal("FooModel", response[0].name)
+        assert_equal(2, response[0].children.size)
+        assert_equal("validates_with(FooClass)", response[0].children[0].name)
+        assert_equal("validates_with(Foo::BarClass)", response[0].children[1].name)
+      end
+
       private
 
       def generate_document_symbols_for_source(source)