ruby-lsp-extras 0.1.1 → 0.2.0

data/lib/ruby_lsp/ruby_lsp_rails_partial/completion.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsPartial
+    # Completes partial names while typing the partial name string of a render call.
+    # Candidates are always offered in path form (e.g. 'admin/areas/form').
+    #
+    # NOTE: A completion request dispatches only the single node directly under the cursor, and the
+    # target node types do not include StringNode. When the cursor is inside the string, what gets
+    # dispatched is the enclosing CallNode (render), so this is handled in `on_call_node_enter`
+    # rather than `on_string_node_enter`.
+    class Completion
+      include Requests::Support::Common
+
+      # uri is part of the fixed listener signature but unused: candidates do not depend on the
+      # current file's directory (always path form).
+      def initialize(response_builder, node_context, resolver, _uri, dispatcher)
+        @response_builder = response_builder
+        @node_context = node_context
+        @resolver = resolver
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      # :nodoc:
+      def on_call_node_enter(node)
+        return unless Util.render_call?(node)
+
+        string_node = Util.partial_string_argument(node)
+        return unless string_node
+
+        edit_range = content_range(string_node)
+        prefix = string_node.unescaped
+
+        @resolver.completion_candidates.each do |key, path|
+          # label, new_text, and the implicit filter_text (defaults to label) are all the path-form
+          # key, so the item survives the client-side filter regardless of how the user typed the
+          # reference. Mirrors ruby-lsp's require completion (build_completion).
+          next unless key.start_with?(prefix)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: key,
+            kind: Constant::CompletionItemKind::FILE,
+            text_edit: Interface::TextEdit.new(range: edit_range, new_text: key),
+            detail: relative_detail(path),
+          )
+        end
+      end
+
+      private
+
+        # Range pointing at the inside of the string node's quotes. Falls back to the whole node if
+        # content_loc is absent.
+        def content_range(node)
+          location = node.content_loc || node.location
+          range_from_location(location)
+        end
+
+        # :nodoc:
+        def relative_detail(path)
+          return unless path
+
+          Util.relative_to_views(path)
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/definition.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsPartial
+    # When the cursor is on the partial name string of a render call, provides go-to-definition
+    # to the matching partial file. When multiple formats match, returns all Locations and lets
+    # ruby-lsp present the candidate picker.
+    class Definition
+      include Requests::Support::Common
+
+      def initialize(response_builder, uri, node_context, resolver, dispatcher)
+        @response_builder = response_builder
+        @uri = uri
+        @node_context = node_context
+        @resolver = resolver
+
+        dispatcher.register(self, :on_string_node_enter)
+      end
+
+      # :nodoc:
+      def on_string_node_enter(node)
+        return unless render_partial_argument?(node)
+
+        reference = node.unescaped
+        return if reference.empty?
+
+        # Highlight range of the origin. Pointing at the whole partial name (inside the quotes)
+        # makes the entire string a link even for names containing `/` like `admin/areas/form`.
+        origin_range = range_from_location(node.content_loc || node.location)
+
+        # The partial body is not parsed, so a leading zero-width range is reused as the target for
+        # all candidates. target_selection_range must be contained within target_range, so both are
+        # made identical.
+        target_range = Interface::Range.new(
+          start: Interface::Position.new(line: 0, character: 0),
+          end: Interface::Position.new(line: 0, character: 0),
+        )
+
+        @resolver.resolve(reference, @uri.to_s).each do |path|
+          @response_builder << Interface::LocationLink.new(
+            target_uri: URI::Generic.from_path(path: path).to_s,
+            target_range: target_range,
+            target_selection_range: target_range,
+            origin_selection_range: origin_range,
+          )
+        end
+      end
+
+      private
+
+        # Whether this string node is the render call's partial argument (the first positional
+        # argument or the value of `partial:`). Decided by whether the StringNode under the cursor
+        # is identical to that render call's partial argument node.
+        def render_partial_argument?(node)
+          call_node = @node_context.call_node
+          return false unless call_node
+          return false unless Util.render_call?(call_node)
+
+          Util.partial_string_argument(call_node).equal?(node)
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/hover.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsPartial
+    # When the cursor is on the partial name string of a render call, shows the list of resolved
+    # file paths in a tooltip (Markdown).
+    #
+    # NOTE: A hover request does not pass a uri to the listener (unlike definition/completion).
+    # A bare name `render 'form'` needs a uri to infer the current directory, so it is out of
+    # scope; only slash-qualified names like `render 'admin/areas/form'` are resolved.
+    class Hover
+      def initialize(response_builder, node_context, resolver, dispatcher)
+        @response_builder = response_builder
+        @node_context = node_context
+        @resolver = resolver
+
+        dispatcher.register(self, :on_string_node_enter)
+      end
+
+      # :nodoc:
+      def on_string_node_enter(node)
+        return unless render_partial_argument?(node)
+
+        reference = node.unescaped
+        return if reference.empty?
+
+        paths = @resolver.resolve_without_context(reference)
+        return if paths.empty?
+
+        @response_builder.push("**Rails partial: `#{reference}`**", category: :title)
+        @response_builder.push(links_markdown(paths), category: :links)
+      end
+
+      private
+
+        # Renders each resolved file as a Markdown bullet link with its view-root-relative path.
+        def links_markdown(given_paths)
+          paths = given_paths.sort
+          paths.map { |path| link_line(path) }.join("\n")
+        end
+
+        # :nodoc:
+        def link_line(path)
+          uri = URI::Generic.from_path(path: path).to_s
+          "- [#{Util.relative_to_views(path)}](#{uri})"
+        end
+
+        # Whether this string node is the render call's partial argument.
+        # This duplicates Definition's logic, but it is intentionally re-stated here so that the
+        # behavior can be followed within a single file (explicit duplication over implicit
+        # abstraction).
+        def render_partial_argument?(node)
+          call_node = @node_context.call_node
+          return false unless call_node
+          return false unless Util.render_call?(call_node)
+
+          Util.partial_string_argument(call_node).equal?(node)
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/partial_index.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsPartial
+    # In-memory index of partials (`_*.*`) under the view root.
+    #
+    # ## Key normalization
+    # The path relative to the view root is normalized to "directory + basename without the
+    # leading underscore". All qualifiers that follow the partial name (format, handler, locale,
+    # variant) are dropped.
+    #   app/views/admin/areas/_form.html.erb        -> 'admin/areas/form'
+    #   app/views/admin/areas/_form.en.html.erb     -> 'admin/areas/form' (locale variant shares the key)
+    #   app/views/admin/areas/_form.html+phone.erb  -> 'admin/areas/form' (variant shares the key)
+    # Since multiple formats can map to the same key, the value is always an array of file paths.
+    #
+    # The index is updated incrementally via file-watching events rather than re-globbing on every
+    # request (performance requirement).
+    class PartialIndex
+      def initialize(views_path)
+        @views_path = views_path
+        # normalized key => Array[absolute path]
+        @entries = Hash.new { |hash, key| hash[key] = [] }
+        build
+      end
+
+      # Returns the array of partial file paths for the normalized key, or an empty array if none.
+      def lookup(key)
+        @entries.fetch(key, [])
+      end
+
+      # :nodoc:
+      def all_entries
+        @entries
+      end
+
+      # Incremental update from a file-watching event. Paths that are not partials are ignored.
+      def add(absolute_path)
+        key = key_for(absolute_path)
+        return unless key
+
+        paths = @entries[key]
+        paths << absolute_path unless paths.include?(absolute_path)
+      end
+
+      # Opposite of +add+
+      def remove(absolute_path)
+        key = key_for(absolute_path)
+        return unless key
+
+        paths = @entries[key]
+        paths.delete(absolute_path)
+        @entries.delete(key) if paths.empty?
+      end
+
+      private
+
+        # Builds the list
+        def build
+          Dir.glob(File.join(@views_path, '**', '_*.*')).each { |path| add(path) }
+        end
+
+        # Converts an absolute path to a normalized key. Returns nil unless it is a partial
+        # (basename starts with `_`).
+        def key_for(absolute_path)
+          relative = relative_from_views(absolute_path)
+          return unless relative
+
+          dir = File.dirname(relative)
+          basename = File.basename(relative)
+          return unless basename.start_with?('_')
+
+          # Strip the leading `_` and drop everything after the first `.`
+          # (format/handler/locale/variant).
+          name = basename[1..].split('.').first
+          return unless name
+
+          (dir == '.') ? name : "#{dir}/#{name}"
+        end
+
+        # :nodoc:
+        def relative_from_views(absolute_path)
+          prefix = "#{@views_path}/"
+          return unless absolute_path.start_with?(prefix)
+
+          absolute_path[(prefix.length)..]
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/partial_resolver.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsPartial
+    # Resolves the partial reference string of a `render` call to a PartialIndex key.
+    # Because resolution depends on the reference form and on the context of "which file the
+    # render is called from", this class is responsible only for bridging to the index's
+    # normalized key.
+    class PartialResolver
+      def initialize(index, views_path)
+        @index = index
+        @views_path = views_path
+      end
+
+      # Resolves a partial reference string ("foo" / "dir/foo") in the context of the current file
+      # and returns the array of absolute paths of the matching partial files.
+      def resolve(reference, current_uri)
+        key = key_for(reference, current_uri)
+        return [] unless key
+
+        @index.lookup(key)
+      end
+
+      # For contexts without a uri (hover). Only resolves references that contain a slash.
+      # Bare names are out of scope (they need a uri for directory inference) and return [].
+      def resolve_without_context(reference)
+        return [] unless reference.include?('/')
+
+        @index.lookup(reference)
+      end
+
+      # Returns completion candidates as an array of [key (path form), representative path].
+      # The key is always the normalized path form so that the display label, filter text, and
+      # inserted text all match, which keeps the item past the client-side filter regardless of
+      # how the user typed the reference.
+      def completion_candidates
+        @index.all_entries.map { |key, paths| [key, paths.first] }
+      end
+
+      private
+
+        # Converts a reference string to a normalized key.
+        # A slash means root-relative; otherwise it is relative to the current file's directory.
+        def key_for(reference, current_uri)
+          return if reference.empty?
+
+          if reference.include?('/')
+            reference
+          else
+            dir = current_dir(current_uri)
+            dir ? "#{dir}/#{reference}" : reference
+          end
+        end
+
+        # Derives the view-root-relative directory from the current file's URI.
+        # A view (under the view root) uses its own directory; a controller derives it from the
+        # controller name.
+        def current_dir(current_uri)
+          path = Util.uri_to_path(current_uri)
+          return unless path
+
+          if path.start_with?("#{@views_path}/")
+            relative = path[(@views_path.length + 1)..]
+            dir = File.dirname(relative)
+            (dir == '.') ? nil : dir
+          elsif path.include?('/app/controllers/')
+            controller_dir_from(path)
+          end
+        end
+
+        # Derives the view prefix from a controller file path.
+        #   app/controllers/admin/areas_controller.rb -> "admin/areas"
+        def controller_dir_from(path)
+          relative = path.split('/app/controllers/', 2).last
+          return unless relative
+
+          dir = relative.delete_suffix('_controller.rb')
+          dir.empty? ? nil : dir
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/util.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RubyLsp
+  module RailsPartial
+    # AST inspection / path conversion helpers. Shared by the Definition / Completion / Hover
+    # listeners and by Addon / PartialResolver.
+    module Util
+      RENDER_METHODS = %i[render render_to_string].freeze
+      VIEWS_MARKER = '/app/views/'
+
+      class << self
+        # Converts a file:// URI to a filesystem path. Non-file:// URIs are returned as-is.
+        def uri_to_path(uri)
+          return uri unless uri.start_with?('file://')
+
+          URI.parse(uri).path
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        # Returns the path relative to the app/views root. Falls back to the basename if the path
+        # is not under views.
+        def relative_to_views(path)
+          index = path.index(VIEWS_MARKER)
+          index ? path[(index + VIEWS_MARKER.length)..] : File.basename(path)
+        end
+
+        # Whether call_node is a render call with no receiver (or self).
+        def render_call?(call_node)
+          return false unless RENDER_METHODS.include?(call_node.message&.to_sym)
+
+          receiver = call_node.receiver
+          receiver.nil? || receiver.is_a?(Prism::SelfNode)
+        end
+
+        # Returns the string node of the render call's partial argument.
+        # The target is (1) the first positional argument, or (2) the value of the `partial:`
+        # keyword. Returns nil if neither is present.
+        def partial_string_argument(call_node)
+          arguments = call_node.arguments&.arguments
+          return unless arguments&.any?
+
+          first = arguments.first
+          return first if first.is_a?(Prism::StringNode)
+
+          found_via_keyword = partial_keyword_value(arguments)
+          return found_via_keyword if found_via_keyword.is_a?(Prism::StringNode)
+
+          partial_hash_value(arguments)
+        end
+
+        private
+
+          # Returns the string node for the `partial:` keyword.
+          def partial_keyword_value(arguments)
+            keyword_node = arguments.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+            return if keyword_node.nil?
+
+            assoc = keyword_node.elements.find do |element|
+              element.is_a?(Prism::AssocNode) &&
+                partial_key?(element.key) &&
+                element.value.is_a?(Prism::StringNode)
+            end
+            assoc&.value
+          end
+
+          # Returns the string node for the `partial:` keyword.
+          def partial_hash_value(arguments)
+            hash_node = arguments.find { |arg| arg.is_a?(Prism::HashNode) }
+            return if hash_node.nil?
+
+            assoc = hash_node.elements.find do |element|
+              element.is_a?(Prism::AssocNode) &&
+                partial_key?(element.key) &&
+                element.value.is_a?(Prism::StringNode)
+            end
+            assoc&.value
+          end
+
+          # :nodoc:
+          def partial_key?(key)
+            key.is_a?(Prism::SymbolNode) && key.unescaped == 'partial'
+          end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsPartial
+    VERSION = '0.1.0'
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_routes/addon.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'definition'
+require_relative 'util'
+require_relative 'version'
+# NOTE: server_addon.rb is intentionally NOT required here. Its base class
+# RubyLsp::Rails::ServerAddon only exists in the rails runner process, which loads the file via
+# register_server_addon. Requiring it here would fail to load this add-on in the LSP process.
+
+module RubyLsp
+  module RailsRoutes
+    # Ruby LSP add-on that adds go-to-definition from *_path / *_url route helpers to the
+    # controller action the named route maps to. Works alongside ruby-lsp-rails, whose own
+    # Definition listener contributes the routes.rb declaration; this add-on only adds the action
+    # location as an extra candidate.
+    class Addon < ::RubyLsp::Addon
+      SERVER_ADDON_NAME = 'Rails Routes'
+
+      # @see super
+      def activate(_global_state, _outgoing_queue)
+        @server_addon_registered = false
+      end
+
+      # @see super
+      def deactivate
+      end
+
+      # @see super
+      def name
+        'Rails Routes'
+      end
+
+      # @see super
+      def version
+        VERSION
+      end
+
+      # Invoked on every definition request. The ruby-lsp-rails client is resolved lazily here
+      # (not in #activate) because add-on activation order is not guaranteed, and because the
+      # runner client boots asynchronously - it is a NullClient until ready.
+      def create_definition_listener(response_builder, _uri, node_context, dispatcher)
+        client = rails_runner_client
+        return unless client
+
+        ensure_server_addon_registered(client)
+
+        Definition.new(client, SERVER_ADDON_NAME, response_builder, node_context, dispatcher)
+      end
+
+      private
+
+        # Returns the ruby-lsp-rails RunnerClient, or nil if the add-on is unavailable/incompatible.
+        def rails_runner_client
+          ::RubyLsp::Addon.get('Ruby LSP Rails', '>= 0.4.0').rails_runner_client
+        rescue ::RubyLsp::Addon::AddonNotFoundError, ::RubyLsp::Addon::IncompatibleApiError
+          nil
+        end
+
+        # Registers our server add-on exactly once. register_server_addon is a no-op on NullClient,
+        # so registering before the runner finishes booting would silently be lost. We therefore
+        # only register once the client is connected, guarded by an idempotency flag.
+        def ensure_server_addon_registered(client)
+          return if @server_addon_registered
+
+          # false for NullClient
+          return unless client.connected?
+
+          client.register_server_addon(File.expand_path('server_addon.rb', __dir__))
+          @server_addon_registered = true
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_routes/definition.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsRoutes
+    # When the cursor is on a *_path / *_url route helper call, asks the rails runner process to
+    # resolve the named route to its controller action, and adds that action's source location as
+    # a definition candidate. ruby-lsp-rails' own Definition listener still contributes the
+    # routes.rb declaration to the same response builder, so both candidates coexist.
+    class Definition
+      include ::RubyLsp::Requests::Support::Common
+
+      def initialize(client, server_addon_name, response_builder, node_context, dispatcher)
+        @client = client
+        @server_addon_name = server_addon_name
+        @response_builder = response_builder
+        @node_context = node_context
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      # Mirrors ruby-lsp-rails' own detection: self (or implicit) receiver, message ends with
+      # _path / _url.
+      def on_call_node_enter(node)
+        return unless self_receiver?(node)
+
+        message = node.message
+        return unless message
+        return unless message.end_with?('_path', '_url')
+
+        result = @client.delegate_request(
+          server_addon_name: @server_addon_name,
+          request_name: 'action_location',
+          name: message,
+        )
+        return unless result
+        return unless result[:location]
+
+        @response_builder << Util.location_from_s(result[:location])
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_routes/server_addon.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# This file is loaded inside the rails runner process via RunnerClient#register_server_addon.
+# The base class RubyLsp::Rails::ServerAddon only exists in that process, so this file must never
+# be required from the LSP process (do not require_relative it from addon.rb).
+module RubyLsp
+  module RailsRoutes
+    # Runs inside the rails runner process. Resolves a named route to its controller action's
+    # source location by inspecting the application's routes, and returns it to the LSP process.
+    class ServerAddon < ::RubyLsp::Rails::ServerAddon
+      # @see super
+      def name
+        'Rails Routes'
+      end
+
+      # @see super
+      def execute(request, params)
+        case request
+        when 'action_location'
+          with_request_error_handling(request) do
+            send_result(action_location(params[:name]))
+          end
+        end
+      end
+
+      private
+
+        # Resolves a route helper name (e.g. 'users_path') to its controller action's source
+        # location, returned as { location: 'file:line' }. Returns nil when the route does not map
+        # to a resolvable controller action. Mirrors ruby-lsp-rails Server#route_location for the
+        # route lookup, then continues on to the action method's source_location.
+        def action_location(name)
+          # Rails 8 does not populate named_routes until the routes are loaded.
+          if ::Rails.application.respond_to?(:reload_routes_unless_loaded)
+            ::Rails.application.reload_routes_unless_loaded
+          end
+
+          match_data = name.match(/^(.+)(_path|_url)$/)
+          return unless match_data
+
+          route = ::Rails.application.routes.named_routes.get(match_data[1])
+          return unless route
+
+          controller = route.defaults[:controller]
+          action = route.defaults[:action]
+          return unless controller
+          return unless action
+
+          # camelize also converts a namespaced controller ('members/x') into 'Members::X'.
+          controller_class = "#{controller}_controller".camelize.constantize
+          # MVP assumes the action has an explicit `def` in the controller. instance_method may
+          # resolve to an inherited method; refining this is deferred to a later phase.
+          source_location = controller_class.instance_method(action).source_location
+          return unless source_location
+
+          file, line = source_location
+          { location: "#{file}:#{line}" }
+        rescue NameError
+          nil
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_routes/util.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RubyLsp
+  module RailsRoutes
+    # Helpers shared by the LSP-side listeners. Kept dependency-light so they can be unit tested
+    # without booting Ruby LSP.
+    module Util
+      class << self
+        # Converts a 'path:line' string (1-based line, as returned by Method#source_location) into
+        # an Interface::Location (0-based line). The last segment is treated as the line only when
+        # it is numeric, so Windows drive letters ("C:/foo.rb:42") survive the split and a string
+        # without a line suffix falls back to line 0.
+        def location_from_s(location_string)
+          file_path, _, line = location_string.rpartition(':')
+          if file_path.empty? || line !~ /\A\d+\z/
+            file_path = location_string
+            line = nil
+          end
+          line_as_number = line ? line.to_i - 1 : 0
+
+          ::RubyLsp::Interface::Location.new(
+            uri: URI::Generic.from_path(path: file_path).to_s,
+            range: ::RubyLsp::Interface::Range.new(
+              start: ::RubyLsp::Interface::Position.new(line: line_as_number, character: 0),
+              end: ::RubyLsp::Interface::Position.new(line: line_as_number, character: 0),
+            ),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_routes/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RailsRoutes
+    VERSION = '0.1.0'
+  end
+end