ruby-lsp-extras 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2245486ea8620c7e791732dfe10b35959f2423b61a24379d3285b1a7fdf4a10
-  data.tar.gz: caad46b7af10f6c480be0a02ce4587c02de59dfaae58cf284a3689f0c41ea95f
+  metadata.gz: c8efd636d699d2b97731469135f307359822327a3f6277ebc04f58868b531c93
+  data.tar.gz: 2d05242a2ed15aa74f96bbc0cce194126a3dac0b28515877042b47bb0ef0c757
 SHA512:
-  metadata.gz: 5c72e4b84314738fc3a848db19c0633bedacb00afe2307059b04f9f2a2c10bb89d61399361a24295c32e0ae79c5b5afca7c01a9a192f1ca7761b6307d4ed07bd
-  data.tar.gz: 26e145c025bc6d0113b7b97847678e0b13019f5587315bf89c9fe592cf6bb3ef700c7683cbd816179304e9257f38e5d5912521fcc63a8560afa37e83a62364ef
+  metadata.gz: 99f0c383f3371b462454512643c1b6677d58a643587f13aa76e3d85b51459116a41acfb3b0630da384411089a8d6cc8438e73e8e8bd85cb760fec7bdb6ce60cf
+  data.tar.gz: 6822f14538bddac7bbf72b0fa0563e0049853176bd16ee9debdbafba736e2b57fb91d1bea84fead5c3f944f854de55b4a33288c758d7408773e457bba5068201

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased changes
 
+## 0.2.0
+
+- Initial Release
+
 ## 0.1.1
 
 - Initial Setup

data/lib/ruby_lsp/ruby_lsp_extras/addon.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Ruby LSP add-on (auto-discovered by Ruby LSP; not loaded by Rails).
+#
+# Adds go-to-definition targets Ruby LSP/ruby-lsp-rails don't provide:
+# - Route helpers -> the routed controller action, alongside the route file location ruby-lsp-rails already provides.
+#   e.g. `companies_path` -> `CompaniesController#create`
+# - Route declarations in `config/routes.rb`/`config/routes/*.rb` -> the controller action (single-action lines) or
+#   controller class (multi-action lines). e.g. `resources :posts` -> `PostsController`
+# - View helpers (`app/helpers/`) called from controllers or views, when the method isn't on the current class.
+#   e.g. `my_post_helper_methd` / `helpers.my_post_helper_methd` -> `PostsHelper#my_post_helper_methd`
+# - Column attribute methods in models -> the column's line in `db/schema.rb`. e.g. `title` -> `t.string "title"`
+#
+# Relies on ruby-lsp-rails internals (`rails_runner_client`, server add-ons), so it's pinned to 0.4.x.
+#
+# NOTE: ActiveSupport isn't loaded in the Ruby LSP process -- stick to plain Ruby (no `presence`/`blank?`/`camelize`)
+
+require_relative 'definition'
+require_relative 'version'
+
+module RubyLsp
+  module Extras
+    RAILS_ADDON_NAME = 'Ruby LSP Rails'
+    RAILS_ADDON_VERSIONS = ['>= 0.4.0', '< 0.5.0'].freeze
+    # Must match `ServerAddon#name` (server_addon.rb runs in the Rails process, so it can't share this constant)
+    SERVER_ADDON_NAME = 'Extras'
+
+    # :nodoc:
+    class Addon < ::RubyLsp::Addon
+      # @see super
+      def activate(global_state, outgoing_queue)
+        @global_state = global_state
+        @outgoing_queue = outgoing_queue
+        @client = nil
+
+        # `rails_runner_client` blocks until the Rails process finishes booting
+        @boot_thread = Thread.new { register_server_addon }
+      end
+
+      # @see super
+      def deactivate
+        @boot_thread&.kill
+      end
+
+      # @see super
+      def name
+        'Ruby LSP Extras'
+      end
+
+      # @see super
+      def version
+        VERSION.to_s
+      end
+
+      # @see super
+      def create_definition_listener(response_builder, uri, node_context, dispatcher)
+        return if @global_state.nil?
+
+        Definition.new(@client, response_builder, uri, node_context, @global_state.index, dispatcher: dispatcher)
+      end
+
+      private
+
+        # @return [void]
+        def register_server_addon
+          rails_addon = ::RubyLsp::Addon.get(RAILS_ADDON_NAME, *RAILS_ADDON_VERSIONS)
+          client = rails_addon.rails_runner_client
+          client.register_server_addon(File.expand_path('server_addon.rb', __dir__))
+          @client = client
+        rescue ::RubyLsp::Addon::AddonNotFoundError, ::RubyLsp::Addon::IncompatibleApiError => e
+          log("#{name} add-on disabled: #{e.message}")
+        end
+
+        # @param message [String]
+        #
+        # @return [void]
+        #
+        def log(message)
+          @outgoing_queue << Notification.window_log_message(message)
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_extras/definition.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Extras
+    # Adds definitions for route helpers/declarations, view helpers, and model columns
+    class Definition
+      ROUTE_HELPER = /_(?:path|url)\z/
+      # Receivers that proxy to the view context, e.g. `helpers.my_helper` in a controller
+      HELPER_PROXIES = %w[helpers view_context].freeze
+      HELPERS_DIR = '/app/helpers/'
+      # ActiveRecord attribute methods -> column name, e.g. `title=`, `title?`, `title_was`, `saved_change_to_title?`
+      ATTRIBUTE_METHOD = /
+        \A
+        (?:saved_change_to_|will_save_change_to_)?
+        (?<column>\w+?)
+        (?:=|\?|_was|_changed\?|_before_last_save|_in_database)?
+        \z
+      /x
+
+      include ::RubyLsp::Requests::Support::Common
+
+      # @param client [RubyLsp::Rails::RunnerClient, nil] `nil` until the Rails server finishes booting
+      # @param response_builder [RubyLsp::ResponseBuilders::CollectionResponseBuilder]
+      # @param uri [URI::Generic] the document the request came from
+      # @param node_context [RubyLsp::NodeContext]
+      # @param index [RubyIndexer::Index]
+      # @param dispatcher [Prism::Dispatcher]
+      #
+      def initialize(client, response_builder, uri, node_context, index, dispatcher:)
+        @client = client
+        @response_builder = response_builder
+        @path = uri.to_s
+        @nesting = node_context.nesting
+        @index = index
+
+        dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
+      end
+
+      # e.g. `:posts` in `resources :posts`, or `:download_attachment` in `get '...', action: :download_attachment`
+      #
+      # @param node [Prism::SymbolNode]
+      #
+      # @return [void]
+      #
+      def on_symbol_node_enter(node)
+        handle_route_declaration(node)
+      end
+
+      # e.g. `'static_pages#test_service'` in `get 'test_service', to: 'static_pages#test_service'`
+      #
+      # @param node [Prism::StringNode]
+      #
+      # @return [void]
+      #
+      def on_string_node_enter(node)
+        handle_route_declaration(node)
+      end
+
+      # @param node [Prism::CallNode]
+      #
+      # @return [void]
+      #
+      def on_call_node_enter(node)
+        message = node.message
+        return if message.nil?
+
+        if self_receiver?(node) && message.match?(ROUTE_HELPER)
+          handle_route(message)
+        elsif self_receiver?(node) && in_model?
+          handle_column(message)
+        elsif self_receiver?(node) || proxy_receiver?(node)
+          handle_helper(node, message)
+        end
+      end
+
+      private
+
+        # @param message [String] e.g. `companies_path`
+        #
+        # @return [void]
+        #
+        def handle_route(message)
+          return if @client.nil?
+
+          result = @client.delegate_request(
+            server_addon_name: SERVER_ADDON_NAME,
+            request_name: 'controller_action',
+            name: message,
+          )
+          return if result.nil?
+
+          add_route_locations(result[:controller], result[:action])
+        end
+
+        # In a routes file, jumps to whatever the routes declared on this line point at: the action for single-action
+        # lines (`get 'x', to: 'foo#bar'`), the controller class for multi-action lines (`resources :posts`)
+        #
+        # @param node [Prism::SymbolNode, Prism::StringNode]
+        #
+        # @return [void]
+        #
+        def handle_route_declaration(node)
+          return if @client.nil? || !in_routes_file?
+
+          result = @client.delegate_request(
+            server_addon_name: SERVER_ADDON_NAME,
+            request_name: 'routes_at',
+            file: URI(@path).path,
+            line: node.location.start_line,
+          )
+          return if result.nil?
+
+          result[:routes].each do |route|
+            if route[:action].nil?
+              add_locations(@index[route[:controller]])
+            else
+              add_route_locations(route[:controller], route[:action])
+            end
+          end
+        end
+
+        # In a model, a column's attribute method (`title`, `self.title = ...`, `title_changed?`) -> its line in the
+        # schema file. Skipped when the method really exists (e.g. an overridden attribute), so we don't duplicate
+        # Ruby LSP.
+        #
+        # @param message [String]
+        #
+        # @return [void]
+        #
+        def handle_column(message)
+          return if @client.nil? || resolves_on_current_class?(message)
+
+          column = message[ATTRIBUTE_METHOD, :column]
+          return if column.nil?
+
+          result = @client.delegate_request(
+            server_addon_name: SERVER_ADDON_NAME,
+            request_name: 'column_location',
+            model: @nesting.join('::'),
+            column: column,
+          )
+          return if result.nil?
+
+          path, line = result[:location].split(/:(?=\d+\z)/)
+          @response_builder << Interface::Location.new(
+            uri: URI::Generic.from_path(path: path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: line.to_i - 1, character: 0),
+              end: Interface::Position.new(line: line.to_i - 1, character: 0),
+            ),
+          )
+        end
+
+        # @return [Boolean]
+        def in_model?
+          @path.include?('/app/models/') && !@nesting.empty?
+        end
+
+        # @return [Boolean] `config/routes.rb` or a `draw`n file under `config/routes/`
+        def in_routes_file?
+          @path.match?(%r{/config/routes(?:\.rb\z|/.+\.rb\z)})
+        end
+
+        # Prefers the action method; falls back to the controller class (e.g. an implicit, view-only action)
+        #
+        # @param controller [String] e.g. `Api::V1::CompaniesController`
+        # @param action [String]
+        #
+        # @return [void]
+        #
+        def add_route_locations(controller, action)
+          entries = @index.resolve_method(action, controller)
+          entries = @index[controller] if entries.nil? || entries.empty?
+          add_locations(entries)
+        end
+
+        # Only from controllers/views. For a plain call in a controller, only when the method doesn't exist on the
+        # controller (so we don't duplicate what Ruby LSP already found)
+        #
+        # @param node [Prism::CallNode] `foo`, `self.foo`, `helpers.foo`, or `view_context.foo`
+        # @param message [String]
+        #
+        # @return [void]
+        #
+        def handle_helper(node, message)
+          return if !in_controller? && !in_view?
+          return if in_controller? && !proxy_receiver?(node) && resolves_on_current_class?(message)
+
+          entries = (@index[message] || []).select { |entry| helper_method?(entry) }
+          add_locations(sort_helpers(entries))
+        end
+
+        # @param node [Prism::CallNode]
+        #
+        # @return [Boolean] `helpers.foo` or `view_context.foo`
+        #
+        def proxy_receiver?(node)
+          receiver = node.receiver
+          receiver.is_a?(Prism::CallNode) && self_receiver?(receiver) && HELPER_PROXIES.include?(receiver.message)
+        end
+
+        # @return [Boolean]
+        def resolves_on_current_class?(message)
+          return false if @nesting.empty?
+
+          entries = @index.resolve_method(message, @nesting.join('::'))
+          !entries.nil? && !entries.empty?
+        end
+
+        # @return [Boolean]
+        def helper_method?(entry)
+          entry.is_a?(RubyIndexer::Entry::Member) && entry.uri.to_s.include?(HELPERS_DIR)
+        end
+
+        # The helper named after the current controller/view folder (e.g. `PostsHelper`) first, then alphabetical
+        #
+        # @param entries [Array<RubyIndexer::Entry::Member>]
+        #
+        # @return [Array<RubyIndexer::Entry::Member>]
+        #
+        def sort_helpers(entries)
+          matching = matching_helper_name
+
+          entries.sort_by { |entry| [(entry.owner&.name == matching) ? 0 : 1, entry.owner&.name.to_s] }
+        end
+
+        # @return [String, nil] e.g. `PostsHelper` for `PostsController` or `app/views/posts/index.html.erb`
+        def matching_helper_name
+          if in_controller?
+            @nesting.join('::').sub(/Controller\z/, 'Helper')
+          elsif in_view?
+            folder = @path[%r{/app/views/(.+)/[^/]+\z}, 1]
+            return if folder.nil?
+
+            "#{folder.split('/').map { |part| part.split('_').map(&:capitalize).join }.join('::')}Helper"
+          end
+        end
+
+        # @return [Boolean]
+        def in_controller?
+          @path.include?('/app/controllers/') && !@nesting.empty? && @nesting.last.end_with?('Controller')
+        end
+
+        # @return [Boolean]
+        def in_view?
+          @path.include?('/app/views/') && @path.end_with?('.erb')
+        end
+
+        # Skips locations already in the response -- Ruby LSP's own listener runs first and, for receivers it can't
+        # type (`helpers.foo`, ERB), already matches methods by name
+        #
+        # @param entries [Array<RubyIndexer::Entry>, nil]
+        #
+        # @return [void]
+        #
+        def add_locations(entries)
+          return if entries.nil?
+
+          entries.each do |entry|
+            uri = entry.uri.to_s
+            range = range_from_location(entry.location)
+            next if already_added?(uri, range.start.line)
+
+            @response_builder << Interface::Location.new(uri: uri, range: range)
+          end
+        end
+
+        # @param uri [String]
+        # @param line [Integer] 0-based
+        #
+        # @return [Boolean]
+        #
+        def already_added?(uri, line)
+          @response_builder.response.any? do |item|
+            item_uri, item_range =
+              if item.is_a?(Interface::LocationLink)
+                [item.target_uri, item.target_range]
+              else
+                [item.uri, item.range]
+              end
+
+            item_uri == uri && item_range.start.line == line
+          end
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_extras/server_addon.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Extras
+    # Runs inside the Rails process booted by ruby-lsp-rails. Resolves routes to the controller class and action they
+    # route to (by route helper name, e.g. `companies_path`, or by where the route is declared in a routes file), and
+    # model columns to their line in the schema file.
+    class ServerAddon < ::RubyLsp::Rails::ServerAddon
+      # Must match `RubyLsp::Extras::SERVER_ADDON_NAME` in addon.rb
+      #
+      # @return [String]
+      #
+      def name
+        'Extras'
+      end
+
+      # @param request [String]
+      # @param params [Hash]
+      #
+      # @return [void]
+      #
+      def execute(request, params)
+        case request
+        when 'controller_action'
+          with_request_error_handling(request) do
+            send_result(controller_action(params[:name]))
+          end
+        when 'routes_at'
+          with_request_error_handling(request) do
+            send_result(routes_at(params[:file], params[:line]))
+          end
+        when 'column_location'
+          with_request_error_handling(request) do
+            send_result(column_location(params[:model], params[:column]))
+          end
+        else
+          send_result(nil)
+        end
+      end
+
+      private
+
+        # @param helper_name [String] e.g. `companies_path` or `edit_company_url`
+        #
+        # @return [Hash, nil]
+        #
+        def controller_action(helper_name)
+          match_data = helper_name.to_s.match(/\A(.+)_(?:path|url)\z/)
+          return if match_data.nil?
+
+          # In Rails 8, `named_routes` is not populated by default
+          if ::Rails.application.respond_to?(:reload_routes_unless_loaded)
+            ::Rails.application.reload_routes_unless_loaded
+          end
+
+          route = ::Rails.application.routes.named_routes.get(match_data[1])
+          controller = route&.defaults&.dig(:controller)
+          return if controller.blank?
+
+          { controller: "#{controller}_controller".camelize, action: route.defaults[:action].to_s }
+        end
+
+        # Routes declared on `line` of `file`, grouped by controller. `action` is only set when the line declares a
+        # single action (e.g. `get 'x', to: 'foo#bar'`); multi-action lines (e.g. `resources :posts`) leave it `nil`.
+        #
+        # Relies on `ActionDispatch::Routing::Mapper.route_source_locations` (on in development since Rails 7.1)
+        #
+        # @param file [String] absolute path, e.g. `/Easy/config/routes.rb`
+        # @param line [Integer] 1-based
+        #
+        # @return [Hash] `{ routes: [{ controller: 'PostsController', action: nil }] }`
+        #
+        def routes_at(file, line)
+          # `source_location` is absolute here, but may be relative to Rails.root depending on Rails version
+          location = "#{file}:#{line}"
+
+          routes = ::Rails.application.routes.routes.select do |route|
+            next false unless route.respond_to?(:source_location)
+            next false unless route.source_location
+            next false unless route.defaults[:controller]
+
+            ::Rails.root.join(route.source_location).to_s == location
+          end
+
+          grouped = routes.group_by { |route| route.defaults[:controller] }.map do |controller, controller_routes|
+            actions = controller_routes.map { |route| route.defaults[:action].to_s }
+            actions.uniq!
+
+            { controller: "#{controller}_controller".camelize, action: (actions.one? ? actions.first : nil) }
+          end
+
+          { routes: grouped }
+        end
+
+        # Where `column` of `model`'s table is declared in the schema file (`db/schema.rb`). The primary key (and any
+        # column without its own `t.<type>` line) points at the `create_table` line.
+        #
+        # @param model [String] e.g. `Company`
+        # @param column [String] e.g. `name`
+        #
+        # @return [Hash, nil] `{ location: '/Easy/db/schema.rb:123' }`
+        #
+        def column_location(model, column)
+          const = ActiveSupport::Inflector.safe_constantize(model)
+          return unless const.is_a?(Class)
+          return unless const < ActiveRecord::Base
+
+          return if const.abstract_class?
+
+          return unless const.table_exists?
+          return unless const.column_names.include?(column)
+
+          db_config = const.connection.pool.db_config
+          schema_file =
+            if ActiveRecord::Tasks::DatabaseTasks.respond_to?(:schema_dump_path)
+              ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config)
+            else
+              # Rails 6.1
+              ActiveRecord::Tasks::DatabaseTasks.dump_filename(db_config.name)
+            end
+          return if schema_file.nil?
+
+          return unless File.exist?(schema_file)
+
+          line = schema_line(File.readlines(schema_file), const.table_name, column)
+          return if line.nil?
+
+          { location: "#{schema_file}:#{line}" }
+        end
+
+        # @param lines [Array<String>] schema.rb lines
+        # @param table [String]
+        # @param column [String]
+        #
+        # @return [Integer, nil] 1-based line
+        #
+        def schema_line(lines, table, column)
+          table_index = lines.index { |l| l.match?(/^\s*create_table\s+"#{Regexp.escape(table)}"/) }
+          return if table_index.nil?
+
+          column_pattern = /^\s*t\.\w+\s+"#{Regexp.escape(column)}"/
+          lines[(table_index + 1)..].each_with_index do |l, offset|
+            break if l.match?(/^\s*end\s*$/)
+
+            return table_index + offset + 2 if l.match?(column_pattern)
+          end
+
+          table_index + 1
+        end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_extras/version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Extras
+    module VERSION
+      MAJOR = 0
+      MINOR = 2
+      PATCH = 0
+      TINY = PATCH
+
+      # Set PRE to nil unless it's a pre-release (beta, rc, etc.)
+      PRE = nil
+
+      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.').freeze
+
+      # :nodoc:
+      def self.to_s
+        STRING
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails_partial/addon.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative 'completion'
+require_relative 'definition'
+require_relative 'hover'
+require_relative 'partial_index'
+require_relative 'partial_resolver'
+require_relative 'util'
+require_relative 'version'
+
+module RubyLsp
+  module RailsPartial
+    # Ruby LSP add-on that provides go-to-definition and completion for the partial name string of
+    # a render call.
+    #
+    # The view root is fixed to app/views (this add-on does not support prepend/append_view_path or
+    # independent engines).
+    class Addon < ::RubyLsp::Addon
+      WATCHER_REGISTRATION_ID = 'rails-partial-watcher'
+
+      # :nodoc:
+      def activate(global_state, outgoing_queue)
+        views_path = File.join(global_state.workspace_path, 'app', 'views')
+        @index = PartialIndex.new(views_path)
+        @resolver = PartialResolver.new(@index, views_path)
+
+        register_file_watcher(global_state, outgoing_queue)
+      end
+
+      # :nodoc:
+      def deactivate
+      end
+
+      # :nodoc:
+      def name
+        'Rails Partial'
+      end
+
+      # :nodoc:
+      def version
+        VERSION
+      end
+
+      # :nodoc:
+      def create_definition_listener(response_builder, uri, node_context, dispatcher)
+        return unless @resolver
+
+        Definition.new(response_builder, uri, node_context, @resolver, dispatcher)
+      end
+
+      # :nodoc:
+      def create_completion_listener(response_builder, node_context, dispatcher, uri)
+        return unless @resolver
+
+        Completion.new(response_builder, node_context, @resolver, uri, dispatcher)
+      end
+
+      # :nodoc:
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        return unless @resolver
+
+        Hover.new(response_builder, node_context, @resolver, dispatcher)
+      end
+
+      # Watches partial changes under app/views and updates the index incrementally.
+      def workspace_did_change_watched_files(changes)
+        return unless @index
+
+        changes.each do |change|
+          path = Util.uri_to_path(change[:uri])
+          next unless path
+
+          case change[:type]
+          when Constant::FileChangeType::CREATED, Constant::FileChangeType::CHANGED
+            @index.add(path)
+          when Constant::FileChangeType::DELETED
+            @index.remove(path)
+          end
+        end
+      end
+
+      private
+
+        # :nodoc:
+        def register_file_watcher(global_state, outgoing_queue)
+          return unless global_state.supports_watching_files
+
+          outgoing_queue << Request.register_watched_files(
+            1,
+            Interface::RelativePattern.new(
+              base_uri: global_state.workspace_uri.to_s,
+              pattern: 'app/views/**/_*',
+            ),
+            registration_id: WATCHER_REGISTRATION_ID,
+          )
+        end
+    end
+  end
+end