Add go to definition in validations and if/unless conditionals (#638)

Add go to definition in validations

Author: domingo2000

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -7,6 +7,7 @@
 require_relative "support/active_support_test_case_helper"
 require_relative "support/associations"
 require_relative "support/callbacks"
+require_relative "support/validations"
 require_relative "support/location_builder"
 require_relative "runner_client"
 require_relative "hover"

lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -51,55 +51,78 @@ def on_string_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
-      def handle_possible_dsl(node)
-        node = @node_context.call_node
-        return unless node
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
         return unless self_receiver?(node)
 
         message = node.message
 
         return unless message
 
-        if Support::Associations::ALL.include?(message)
-          handle_association(node)
-        elsif Support::Callbacks::ALL.include?(message)
-          handle_callback(node)
+        if message.end_with?("_path") || message.end_with?("_url")
+          handle_route(node)
         end
       end
 
-      #: (Prism::CallNode node) -> void
-      def on_call_node_enter(node)
-        return unless self_receiver?(node)
+      private
 
-        message = node.message
+      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
+      def handle_possible_dsl(node)
+        call_node = @node_context.call_node
+        return unless call_node
+        return unless self_receiver?(call_node)
+
+        message = call_node.message
 
         return unless message
 
-        if message.end_with?("_path") || message.end_with?("_url")
-          handle_route(node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        if Support::Associations::ALL.include?(message)
+          handle_association(call_node)
+        elsif Support::Callbacks::ALL.include?(message)
+          handle_callback(node, call_node, arguments)
+          handle_if_unless_conditional(node, call_node, arguments)
+        elsif Support::Validations::ALL.include?(message)
+          handle_validation(node, call_node, arguments)
+          handle_if_unless_conditional(node, call_node, arguments)
         end
       end
 
-      private
+      #: ((Prism::SymbolNode | Prism::StringNode) node, Prism::CallNode call_node, Array[Prism::Node] arguments) -> void
+      def handle_callback(node, call_node, arguments)
+        focus_argument = arguments.find { |argument| argument == node }
 
-      #: (Prism::CallNode node) -> void
-      def handle_callback(node)
-        arguments = node.arguments&.arguments
-        return unless arguments&.any?
+        name = case focus_argument
+        when Prism::SymbolNode
+          focus_argument.value
+        when Prism::StringNode
+          focus_argument.content
+        end
+
+        return unless name
 
-        arguments.each do |argument|
-          name = case argument
-          when Prism::SymbolNode
-            argument.value
-          when Prism::StringNode
-            argument.content
-          end
+        collect_definitions(name)
+      end
 
-          next unless name
+      #: ((Prism::SymbolNode | Prism::StringNode) node, Prism::CallNode call_node, Array[Prism::Node] arguments) -> void
+      def handle_validation(node, call_node, arguments)
+        message = call_node.message
+        return unless message
 
-          collect_definitions(name)
-        end
+        focus_argument = arguments.find { |argument| argument == node }
+        return unless focus_argument
+
+        return unless node.is_a?(Prism::SymbolNode)
+
+        name = node.value
+        return unless name
+
+        # validates_with uses constants, not symbols - skip (handled by constant resolution)
+        return if message == "validates_with"
+
+        collect_definitions(name)
       end
 
       #: (Prism::CallNode node) -> void
@@ -141,6 +164,36 @@ def collect_definitions(name)
           )
         end
       end
+
+      #: ((Prism::SymbolNode | Prism::StringNode) node, Prism::CallNode call_node, Array[Prism::Node] arguments) -> void
+      def handle_if_unless_conditional(node, call_node, arguments)
+        keyword_arguments = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) } #: as Prism::KeywordHashNode?
+        return unless keyword_arguments
+
+        element = keyword_arguments.elements.find do |element|
+          next false unless element.is_a?(Prism::AssocNode)
+
+          key = element.key
+          next false unless key.is_a?(Prism::SymbolNode)
+
+          key_value = key.value
+          next false unless key_value == "if" || key_value == "unless"
+
+          value = element.value
+          next false unless value.is_a?(Prism::SymbolNode)
+
+          value == node
+        end #: as Prism::AssocNode?
+
+        return unless element
+
+        value = element.value #: as Prism::SymbolNode
+        method_name = value.value
+
+        return unless method_name
+
+        collect_definitions(method_name)
+      end
     end
   end
 end

lib/ruby_lsp/ruby_lsp_rails/support/validations.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module Support
+      module Validations
+        ALL = [
+          "validate",
+          "validates",
+          "validates!",
+          "validates_each",
+          "validates_with",
+          "validates_absence_of",
+          "validates_acceptance_of",
+          "validates_comparison_of",
+          "validates_confirmation_of",
+          "validates_exclusion_of",
+          "validates_format_of",
+          "validates_inclusion_of",
+          "validates_length_of",
+          "validates_numericality_of",
+          "validates_presence_of",
+          "validates_size_of",
+        ].freeze
+      end
+    end
+  end
+end