Make template lookup more robust by calling server

Also add missing type annotations.

Author: janko

lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -194,7 +194,14 @@ def add_jump_to_view(node)
         action_name = node.name
         controller_name = underscore(class_name.delete_suffix("Controller"))
 
-        view_uris = Dir.glob("#{@client.views_dir}/#{controller_name}/#{action_name}*").filter_map do |path|
+        controller_info = @client.controller(class_name)
+        return unless controller_info
+
+        view_paths = controller_info[:view_paths].select do |path|
+          path.start_with?(@client.rails_root)
+        end
+
+        view_uris = Dir.glob("{#{view_paths.join(",")}}/#{controller_name}/#{action_name}*").filter_map do |path|
           # it's possible we could have a directory with the same name as the action, so we need to skip those
           next if File.directory?(path)
 

lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "pathname"
-
 module RubyLsp
   module Rails
     # ![Definition demo](../../definition.gif)
@@ -33,8 +31,8 @@ class Definition
       include Requests::Support::Common
       include Inflections
 
-      #: (RunnerClient client, RubyLsp::ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, NodeContext node_context, RubyIndexer::Index index, Prism::Dispatcher dispatcher) -> void
-      def initialize(client, response_builder, uri, node_context, index, dispatcher)
+      #: (RunnerClient client, RubyLsp::ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, RubyIndexer::Index index, Prism::Dispatcher dispatcher) -> void
+      def initialize(client, response_builder, uri, node_context, index, dispatcher) # rubocop:disable Metrics/ParameterLists
         @client = client
         @response_builder = response_builder
         @path = uri.to_standardized_path #: String?
@@ -147,45 +145,37 @@ def handle_association(node)
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
+      #: (Prism::StringNode node) -> void
       def handle_possible_render(node)
         return unless @path&.end_with?(".html.erb")
 
         call_node = @node_context.call_node
         return unless call_node
         return unless self_receiver?(call_node)
 
-        message = call_node.message
-        return unless message == "render"
+        return unless call_node.message == "render"
 
         arguments = call_node.arguments&.arguments
         return unless arguments
 
         argument = view_template_argument(arguments, node)
         return unless argument
 
-        template = node.content
-        template_options = view_template_options(arguments)
-
-        formats_pattern = template_options[:formats] ? "{#{template_options[:formats].join(",")}}" : "html"
-        variants_pattern = "{#{template_options[:variants].map { |variant| "+#{variant}" }.join(",")},}" if template_options[:variants]
-        handlers_pattern = template_options[:handlers] ? "{#{template_options[:handlers].join(",")}}" : "*"
+        controller_name = controller_for_template(@path)
+        return unless controller_name
 
-        extension_pattern = "#{formats_pattern}#{variants_pattern}.#{handlers_pattern}"
+        template_name = node.content
+        template_details = view_template_details(arguments)
 
-        template_pattern = if argument == "template"
-          File.join(@client.views_dir, "#{template}.#{extension_pattern}")
-        elsif template.include?("/")
-          *partial_dir, partial_name = template.split("/")
-
-          File.join(@client.views_dir, *partial_dir, "_#{partial_name}.#{extension_pattern}")
-        else
-          File.join(@client.views_dir, "{#{view_prefixes.join(",")}}", "_#{template}.#{extension_pattern}")
-        end
-
-        template_path = Dir.glob(template_pattern).first
-        return unless template_path
+        template = @client.find_template(
+          controller_name: controller_name,
+          template_name: template_name,
+          partial: argument != "template",
+          details: template_details,
+        )
+        return unless template
 
-        @response_builder << Support::LocationBuilder.line_location_from_s("#{template_path}:1")
+        @response_builder << Support::LocationBuilder.line_location_from_s("#{template[:path]}:1")
       end
 
       #: (Prism::CallNode node) -> void
@@ -241,48 +231,69 @@ def handle_if_unless_conditional(node, call_node, arguments)
         collect_definitions(method_name)
       end
 
+      #: (Array[Prism::Node] arguments, Prism::StringNode node) -> String?
       def view_template_argument(arguments, node)
         return "partial" if arguments.first == node
 
-        kwargs = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) }
-        return unless kwargs
+        keyword_arguments = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) } #: as Prism::KeywordHashNode?
+        return unless keyword_arguments
 
-        kwarg = kwargs.elements.find do |pair|
-          ["partial", "layout", "spacer_template", "template"].include?(pair.key.value) && pair.value == node
-        end
+        element = keyword_arguments.elements.find do |element|
+          next unless element.is_a?(Prism::AssocNode)
+
+          key = element.key
+          next unless key.is_a?(Prism::SymbolNode)
+
+          next unless element.value == node
 
-        kwarg&.key&.value
+          ["partial", "layout", "spacer_template", "template"].include?(key.value)
+        end #: as Prism::AssocNode?
+
+        return unless element
+
+        key = element.key #: as Prism::SymbolNode
+        key.value
       end
 
-      def view_template_options(arguments)
-        kwargs = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) }
-        return {} unless kwargs
+      #: (Array[Prism::Node] arguments) -> Hash[String, (String | Array[String])]
+      def view_template_details(arguments)
+        keyword_arguments = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) } #: as Prism::KeywordHashNode?
+        return {} unless keyword_arguments
+
+        keyword_arguments.elements.each_with_object({}) do |element, options|
+          next unless element.is_a?(Prism::AssocNode)
+
+          key = element.key
+          next unless key.is_a?(Prism::SymbolNode)
 
-        kwargs.elements.each_with_object({}) do |pair, options|
-          next unless ["formats", "variants", "handlers"].include?(pair.key.value)
+          key_value = key.value
+          next unless ["formats", "variants", "handlers"].include?(key_value)
 
-          value = [pair.value.value] if pair.value.is_a?(Prism::SymbolNode)
-          value = pair.value.elements.map(&:value) if pair.value.is_a?(Prism::ArrayNode)
+          value = element.value
 
-          options[pair.key.value.to_sym] = value
+          if value.is_a?(Prism::SymbolNode)
+            options[key_value] = value.value
+          elsif value.is_a?(Prism::ArrayNode) && value.elements.all?(Prism::SymbolNode)
+            elements = value.elements #: as Array[Prism::SymbolNode]
+            options[key_value] = elements.map(&:value)
+          end
         end
       end
 
-      # Resolve available directories from which the controller can render relative
-      # partials based on its ancestry chain.
-      def view_prefixes
-        controller_dir = Pathname(@path).dirname.relative_path_from(@client.views_dir).to_s
-        controller_class = "#{camelize(controller_dir)}Controller"
-        controller_ancestors = [controller_class]
-
-        controller_entry = @index.resolve(controller_class, [])&.find(&:parent_class)
-        while controller_entry
-          controller_entry = @index.resolve(controller_entry.parent_class, controller_entry.nesting)&.find(&:parent_class)
-          break unless controller_entry && not_in_dependencies?(controller_entry.file_path)
-          controller_ancestors << controller_entry.name
-        end
+      #: (String template_path) -> String?
+      def controller_for_template(template_path)
+        controller_info = @client.controller("ActionController::Base")
+        return unless controller_info
+
+        view_paths = controller_info[:view_paths]
+        template_directory = File.dirname(template_path)
+
+        view_path = view_paths.find { |path| template_directory.start_with?(path + "/") }
+        return unless view_path
+
+        controller_path = template_directory.delete_prefix(view_path + "/")
 
-        controller_ancestors.map { |ancestor| underscore(ancestor.delete_suffix("Controller")) }
+        camelize(controller_path) + "Controller"
       end
     end
   end

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -159,6 +159,34 @@ def association_target(model_name:, association_name:)
         nil
       end
 
+      #: (String name) -> Hash[Symbol, untyped]?
+      def controller(name)
+        make_request("controller", name: name)
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to get controller view paths",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
+      #: (controller_name: String, template_name: String, partial: bool, details: Hash[String, String | Array[String]]) -> Hash[Symbol, untyped]?
+      def find_template(controller_name:, template_name:, partial:, details:)
+        make_request(
+          "find_template",
+          controller_name: controller_name,
+          template_name: template_name,
+          partial: partial,
+          details: details,
+        )
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to find view template for controller",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
       #: (String name) -> Hash[Symbol, untyped]?
       def route_location(name)
         make_request("route_location", name: name)
@@ -261,10 +289,6 @@ def connected?
         true
       end
 
-      def views_dir
-        File.join(@rails_root, "app/views")
-      end
-
       private
 
       #: (String request, **untyped params) -> Hash[Symbol, untyped]?

lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -310,6 +310,14 @@ def execute(request, params)
           with_request_error_handling(request) do
             send_result(resolve_association_target(params))
           end
+        when "controller"
+          with_request_error_handling(request) do
+            send_result(controller_info(params.fetch(:name)))
+          end
+        when "find_template"
+          with_request_error_handling(request) do
+            send_result(lookup_view_template(params))
+          end
         when "pending_migrations_message"
           with_request_error_handling(request) do
             send_result({ pending_migrations_message: pending_migrations_message })
@@ -436,6 +444,36 @@ def resolve_association_target(params)
         nil
       end
 
+      #: (String controller_name) -> Hash[Symbol | String, untyped]?
+      def controller_info(controller_name)
+        const = ActiveSupport::Inflector.safe_constantize(controller_name) # rubocop:disable Sorbet/ConstantsFromStrings
+        return unless controller?(const)
+
+        { view_paths: const.view_paths.map(&:to_s) }
+      end
+
+      #: (Hash[Symbol | String, untyped]) -> Hash[Symbol | String, untyped]?
+      def lookup_view_template(params)
+        const = ActiveSupport::Inflector.safe_constantize(params[:controller_name]) # rubocop:disable Sorbet/ConstantsFromStrings
+        return unless controller?(const)
+
+        path = params[:template_name]
+        partial = params[:partial]
+        details = params[:details].transform_values { |value| Array(value).map(&:to_sym) }
+
+        lookup_context = const.new.lookup_context
+        prefixes = path.include?("/") || !partial ? [] : lookup_context.prefixes
+
+        # Disable the lookup cache to ensure template changes are reflected
+        template = lookup_context.disable_cache do
+          lookup_context.find_template(path, prefixes, partial, [], details)
+        end
+
+        { path: template.identifier }
+      rescue ActionView::MissingTemplate
+        nil
+      end
+
       #: (Module?) -> bool
       def active_record_model?(const)
         !!(
@@ -448,6 +486,16 @@ def active_record_model?(const)
         )
       end
 
+      #: (Module?) -> bool
+      def controller?(const)
+        !!(
+          const &&
+            defined?(ActionController) &&
+            const.is_a?(Class) &&
+            ActionController::Base >= const
+        )
+      end
+
       #: -> String?
       def pending_migrations_message
         # `check_all_pending!` is only available since Rails 7.1

lib/ruby_lsp/ruby_lsp_rails/support/inflections.rb

@@ -4,15 +4,15 @@
 module RubyLsp
   module Rails
     module Inflections
-      #: String -> String
+      #: (String) -> String
       def camelize(string)
         string
-          .gsub(/_([a-z])/) { $1.upcase }
-          .gsub(/(^|\/)[a-z]/) { $&.upcase }
+          .gsub(%r{(?:^|_|/)[a-z]}, &:upcase)
+          .tr("_", "")
           .gsub("/", "::")
       end
 
-      #: String -> String
+      #: (String) -> String
       def underscore(string)
         string
           .gsub(/([a-z])([A-Z])/, "\\1_\\2")