ruby-lsp-rails 0.3.26 → 0.3.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df7c6791cb1fc007fc4705e034eb60cde1d5905a1771b145c2d4bb6f36224658
-  data.tar.gz: 1fdd80b7787bf31a237aa9f9f196c3170ee5e612ce8105c2fc20a63fd9027f73
+  metadata.gz: 231b488bf88047c642f2556980d6c0ce96edbeafbf2ded65a4104515584a5100
+  data.tar.gz: 207b91a283859f74804b4e825d4ca71ee645b0f73ac84e5d7e7348b382bf2745
 SHA512:
-  metadata.gz: 8de8df639f440b7bcedb854e03ead56eb56517569dc31938759593cce32ff87d968b07b88598de01939fab8d3e1b8bb73108cf21b85c7f30493093d1f8d2973a
-  data.tar.gz: 69550bcd5575bf7d8f6f82e7e738e53392fd776534dc88495274ab500e9ea3e11472e1008d05fe27de3ae40beee9a43d039be49866902e569ec7fdd0c91af161
+  metadata.gz: 8ef4e5363a31a1821da8d43738c5049239e827d609ffa8c8214f9e8fae148739770614a4f06af082da98a755bfd3522426560936d1ac57f0c14092ace8ced86b
+  data.tar.gz: 348fab1dc3ada6a6a2672c4c9b54e0ae0f67f2f056023929af7c76dac5d66583c32c9fbdcc1347fc3913cb59a3e30ae7e495977b762228aad6a52f502254a930

data/lib/ruby-lsp-rails.rb

@@ -2,15 +2,3 @@
 # frozen_string_literal: true
 
 require "ruby_lsp_rails/version"
-require "ruby_lsp_rails/railtie"
-
-module RubyLsp
-  # # Supported features
-  #
-  # - [Hover](rdoc-ref:RubyLsp::Rails::Hover)
-  # - [CodeLens](rdoc-ref:RubyLsp::Rails::CodeLens)
-  # - [DocumentSymbol](rdoc-ref:RubyLsp::Rails::DocumentSymbol)
-  # - [Definition](rdoc-ref:RubyLsp::Rails::Definition)
-  module Rails
-  end
-end

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -13,6 +13,7 @@ require_relative "hover"
 require_relative "code_lens"
 require_relative "document_symbol"
 require_relative "definition"
+require_relative "completion"
 require_relative "indexing_enhancement"
 
 module RubyLsp
@@ -56,7 +57,6 @@ module RubyLsp
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
 
         register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
-        @global_state.index.register_enhancement(IndexingEnhancement.new(@global_state.index))
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
         @client_mutex.unlock
@@ -120,6 +120,18 @@ module RubyLsp
         Definition.new(@rails_runner_client, response_builder, node_context, index, dispatcher)
       end
 
+      sig do
+        override.params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
+          node_context: NodeContext,
+          dispatcher: Prism::Dispatcher,
+          uri: URI::Generic,
+        ).void
+      end
+      def create_completion_listener(response_builder, node_context, dispatcher, uri)
+        Completion.new(@rails_runner_client, response_builder, node_context, dispatcher, uri)
+      end
+
       sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
       def workspace_did_change_watched_files(changes)
         if changes.any? { |c| c[:uri].end_with?("db/schema.rb") || c[:uri].end_with?("structure.sql") }

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -254,7 +254,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run",
+          title: "▶ Run",
           command_name: "rubyLsp.runTask",
           arguments: [command],
           data: { type: "migrate" },
@@ -283,7 +283,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run",
+          title: "▶ Run",
           command_name: "rubyLsp.runTest",
           arguments: arguments,
           data: { type: "test", **grouping_data },
@@ -291,7 +291,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run In Terminal",
+          title: "▶ Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
           arguments: arguments,
           data: { type: "test_in_terminal", **grouping_data },

data/lib/ruby_lsp/ruby_lsp_rails/completion.rb

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    class Completion
+      extend T::Sig
+      include Requests::Support::Common
+
+      sig do
+        override.params(
+          client: RunnerClient,
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
+          node_context: NodeContext,
+          dispatcher: Prism::Dispatcher,
+          uri: URI::Generic,
+        ).void
+      end
+      def initialize(client, response_builder, node_context, dispatcher, uri)
+        @response_builder = response_builder
+        @client = client
+        @node_context = node_context
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+        )
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        call_node = @node_context.call_node
+        return unless call_node
+
+        receiver = call_node.receiver
+        if call_node.name == :where && receiver.is_a?(Prism::ConstantReadNode)
+          handle_active_record_where_completions(node: node, receiver: receiver)
+        end
+      end
+
+      private
+
+      sig { params(node: Prism::CallNode, receiver: Prism::ConstantReadNode).void }
+      def handle_active_record_where_completions(node:, receiver:)
+        resolved_class = @client.model(receiver.name.to_s)
+        return if resolved_class.nil?
+
+        arguments = T.must(@node_context.call_node).arguments&.arguments
+        indexed_call_node_args = T.let({}, T::Hash[String, Prism::Node])
+
+        if arguments
+          indexed_call_node_args = index_call_node_args(arguments: arguments)
+          return if indexed_call_node_args.values.any? { |v| v == node }
+        end
+
+        range = range_from_location(node.location)
+
+        resolved_class[:columns].each do |column|
+          next unless column[0].start_with?(node.name.to_s)
+          next if indexed_call_node_args.key?(column[0])
+
+          @response_builder << Interface::CompletionItem.new(
+            label: column[0],
+            filter_text: column[0],
+            label_details: Interface::CompletionItemLabelDetails.new(
+              description: "Filter #{receiver.name} records by #{column[0]}",
+            ),
+            text_edit: Interface::TextEdit.new(range: range, new_text: "#{column[0]}: "),
+            kind: Constant::CompletionItemKind::FIELD,
+          )
+        end
+      end
+
+      sig { params(arguments: T::Array[Prism::Node]).returns(T::Hash[String, Prism::Node]) }
+      def index_call_node_args(arguments:)
+        indexed_call_node_args = {}
+        arguments.each do |argument|
+          next unless argument.is_a?(Prism::KeywordHashNode)
+
+          argument.elements.each do |e|
+            next unless e.is_a?(Prism::AssocNode)
+
+            key = e.key
+            if key.is_a?(Prism::SymbolNode)
+              indexed_call_node_args[key.value] = e.value
+            end
+          end
+        end
+        indexed_call_node_args
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -144,15 +144,9 @@ module RubyLsp
         return unless methods
 
         methods.each do |target_method|
-          location = target_method.location
-          file_path = target_method.file_path
-
           @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: file_path).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
+            uri: target_method.uri.to_s,
+            range: range_from_location(target_method.location),
           )
         end
       end

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -8,25 +8,32 @@ module RubyLsp
 
       sig do
         override.params(
-          owner: T.nilable(RubyIndexer::Entry::Namespace),
-          node: Prism::CallNode,
-          file_path: String,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
+          call_node: Prism::CallNode,
         ).void
       end
-      def on_call_node_enter(owner, node, file_path, code_units_cache)
+      def on_call_node_enter(call_node)
+        owner = @listener.current_owner
         return unless owner
 
-        name = node.name
-
-        case name
+        case call_node.name
         when :extend
-          handle_concern_extend(owner, node)
+          handle_concern_extend(owner, call_node)
         when :has_one, :has_many, :belongs_to, :has_and_belongs_to_many
-          handle_association(owner, node, file_path, code_units_cache)
+          handle_association(owner, call_node)
+        # for `class_methods do` blocks within concerns
+        when :class_methods
+          handle_class_methods(owner, call_node)
+        end
+      end
+
+      sig do
+        override.params(
+          call_node: Prism::CallNode,
+        ).void
+      end
+      def on_call_node_leave(call_node)
+        if call_node.name == :class_methods && call_node.block
+          @listener.pop_namespace_stack
         end
       end
 
@@ -35,16 +42,11 @@ module RubyLsp
       sig do
         params(
           owner: RubyIndexer::Entry::Namespace,
-          node: Prism::CallNode,
-          file_path: String,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
+          call_node: Prism::CallNode,
         ).void
       end
-      def handle_association(owner, node, file_path, code_units_cache)
-        arguments = node.arguments&.arguments
+      def handle_association(owner, call_node)
+        arguments = call_node.arguments&.arguments
         return unless arguments
 
         name_arg = arguments.first
@@ -58,41 +60,22 @@ module RubyLsp
 
         return unless name
 
-        loc = RubyIndexer::Location.from_prism_location(name_arg.location, code_units_cache)
+        loc = name_arg.location
 
         # Reader
-        @index.add(RubyIndexer::Entry::Method.new(
-          name,
-          file_path,
-          loc,
-          loc,
-          nil,
-          [RubyIndexer::Entry::Signature.new([])],
-          RubyIndexer::Entry::Visibility::PUBLIC,
-          owner,
-        ))
+        reader_signatures = [RubyIndexer::Entry::Signature.new([])]
+        @listener.add_method(name, loc, reader_signatures)
 
         # Writer
-        @index.add(RubyIndexer::Entry::Method.new(
-          "#{name}=",
-          file_path,
-          loc,
-          loc,
-          nil,
-          [RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)])],
-          RubyIndexer::Entry::Visibility::PUBLIC,
-          owner,
-        ))
+        writer_signatures = [
+          RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)]),
+        ]
+        @listener.add_method("#{name}=", loc, writer_signatures)
       end
 
-      sig do
-        params(
-          owner: RubyIndexer::Entry::Namespace,
-          node: Prism::CallNode,
-        ).void
-      end
-      def handle_concern_extend(owner, node)
-        arguments = node.arguments&.arguments
+      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      def handle_concern_extend(owner, call_node)
+        arguments = call_node.arguments&.arguments
         return unless arguments
 
         arguments.each do |node|
@@ -101,7 +84,7 @@ module RubyLsp
           module_name = node.full_name
           next unless module_name == "ActiveSupport::Concern"
 
-          @index.register_included_hook(owner.name) do |index, base|
+          @listener.register_included_hook do |index, base|
             class_methods_name = "#{owner.name}::ClassMethods"
 
             if index.indexed?(class_methods_name)
@@ -114,6 +97,13 @@ module RubyLsp
           # Do nothing
         end
       end
+
+      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      def handle_class_methods(owner, call_node)
+        return unless call_node.block
+
+        @listener.add_module("ClassMethods", call_node.location, call_node.location)
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -27,7 +27,7 @@ module RubyLsp
 
             NullClient.new
           end
-        rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
+        rescue StandardError => e
           unless outgoing_queue.closed?
             outgoing_queue << RubyLsp::Notification.window_log_message(
               <<~MESSAGE.chomp,
@@ -44,7 +44,6 @@ module RubyLsp
 
       class InitializationError < StandardError; end
       class MessageError < StandardError; end
-      class IncompleteMessageError < MessageError; end
       class EmptyMessageError < MessageError; end
 
       extend T::Sig
@@ -109,7 +108,7 @@ module RubyLsp
           end,
           Thread,
         )
-      rescue Errno::EPIPE, IncompleteMessageError
+      rescue StandardError
         raise InitializationError, @stderr.read
       end
 
@@ -282,7 +281,7 @@ module RubyLsp
         json = message.to_json
 
         @mutex.synchronize do
-          @stdin.write("Content-Length: #{json.length}\r\n\r\n", json)
+          @stdin.write("Content-Length: #{json.bytesize}\r\n\r\n", json)
         end
       rescue Errno::EPIPE
         # The server connection died

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -13,13 +13,49 @@ module RubyLsp
       # Write a message to the client. Can be used for sending notifications to the editor
       def send_message(message)
         json_message = message.to_json
-        @stdout.write("Content-Length: #{json_message.length}\r\n\r\n#{json_message}")
+        @stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
 
       # Log a message to the editor's output panel
       def log_message(message)
         $stderr.puts(message)
-        send_message({ result: nil })
+      end
+
+      # Sends an error result to a request, if the request failed. DO NOT INVOKE THIS METHOD FOR NOTIFICATIONS! Use
+      # `log_message` instead, otherwise the client/server communication will go out of sync
+      def send_error_response(message)
+        send_message({ error: message })
+      end
+
+      # Sends a result back to the client
+      def send_result(result)
+        send_message({ result: result })
+      end
+
+      # Handle possible errors for a request. This should only be used for requests, which means messages that return a
+      # response back to the client. Errors are returned as an error object back to the client
+      def with_request_error_handling(request_name, &block)
+        block.call
+      rescue ActiveRecord::ConnectionNotEstablished
+        # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
+        send_error_response("Request #{request_name} failed because database connection was not established.")
+      rescue ActiveRecord::NoDatabaseError
+        send_error_response("Request #{request_name} failed because the database does not exist.")
+      rescue => e
+        send_error_response("Request #{request_name} failed:\n#{e.full_message(highlight: false)}")
+      end
+
+      # Handle possible errors for a notification. This should only be used for notifications, which means messages that
+      # do not return a response back to the client. Errors are logged to the editor's output panel
+      def with_notification_error_handling(notification_name, &block)
+        block.call
+      rescue ActiveRecord::ConnectionNotEstablished
+        # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
+        log_message("Request #{notification_name} failed because database connection was not established.")
+      rescue ActiveRecord::NoDatabaseError
+        log_message("Request #{notification_name} failed because the database does not exist.")
+      rescue => e
+        log_message("Request #{notification_name} failed:\n#{e.full_message(highlight: false)}")
       end
     end
 
@@ -88,11 +124,8 @@ module RubyLsp
       end
 
       def start
-        # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
-        routes_reloader = ::Rails.application.routes_reloader
-        routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
-
-        send_message({ result: { message: "ok", root: ::Rails.root.to_s } })
+        load_routes
+        send_result({ message: "ok", root: ::Rails.root.to_s })
 
         while @running
           headers = @stdin.gets("\r\n\r\n")
@@ -104,41 +137,50 @@ module RubyLsp
       end
 
       def execute(request, params)
-        request_name = request
-        request_name = "#{params[:server_addon_name]}##{params[:request_name]}" if request == "server_addon/delegate"
-
         case request
         when "shutdown"
           @running = false
         when "model"
-          send_message(resolve_database_info_from_model(params.fetch(:name)))
+          with_request_error_handling(request) do
+            send_result(resolve_database_info_from_model(params.fetch(:name)))
+          end
         when "association_target_location"
-          send_message(resolve_association_target(params))
+          with_request_error_handling(request) do
+            send_result(resolve_association_target(params))
+          end
         when "pending_migrations_message"
-          send_message({ result: { pending_migrations_message: pending_migrations_message } })
+          with_request_error_handling(request) do
+            send_result({ pending_migrations_message: pending_migrations_message })
+          end
         when "run_migrations"
-          send_message({ result: run_migrations })
+          with_request_error_handling(request) do
+            send_result(run_migrations)
+          end
         when "reload"
-          ::Rails.application.reloader.reload!
+          with_notification_error_handling(request) do
+            ::Rails.application.reloader.reload!
+          end
         when "route_location"
-          send_message(route_location(params.fetch(:name)))
+          with_request_error_handling(request) do
+            send_result(route_location(params.fetch(:name)))
+          end
         when "route_info"
-          send_message(resolve_route_info(params))
+          with_request_error_handling(request) do
+            send_result(resolve_route_info(params))
+          end
         when "server_addon/register"
-          require params[:server_addon_path]
-          ServerAddon.finalize_registrations!(@stdout)
+          with_notification_error_handling(request) do
+            require params[:server_addon_path]
+            ServerAddon.finalize_registrations!(@stdout)
+          end
         when "server_addon/delegate"
           server_addon_name = params[:server_addon_name]
           request_name = params[:request_name]
+
+          # Do not wrap this in error handlers. Server add-ons need to have the flexibility to choose if they want to
+          # include a response or not as part of error handling, so a blanket approach is not appropriate.
           ServerAddon.delegate(server_addon_name, request_name, params.except(:request_name, :server_addon_name))
         end
-      # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
-      rescue ActiveRecord::ConnectionNotEstablished
-        log_message("Request #{request_name} failed because database connection was not established.")
-      rescue ActiveRecord::NoDatabaseError
-        log_message("Request #{request_name} failed because the database does not exist.")
-      rescue => e
-        log_message("Request #{request_name} failed:\n" + e.full_message(highlight: false))
       end
 
       private
@@ -156,19 +198,15 @@ module RubyLsp
         end
 
         source_location = route&.respond_to?(:source_location) && route.source_location
+        return unless source_location
 
-        if source_location
-          file, _, line = source_location.rpartition(":")
-          body = {
-            source_location: [::Rails.root.join(file).to_s, line],
-            verb: route.verb,
-            path: route.path.spec.to_s,
-          }
+        file, _, line = source_location.rpartition(":")
 
-          { result: body }
-        else
-          { result: nil }
-        end
+        {
+          source_location: [::Rails.root.join(file).to_s, line],
+          verb: route.verb,
+          path: route.path.spec.to_s,
+        }
       end
 
       # Older versions of Rails don't support `route_source_locations`.
@@ -182,74 +220,48 @@ module RubyLsp
           end
 
           match_data = name.match(/^(.+)(_path|_url)$/)
-          return { result: nil } unless match_data
+          return unless match_data
 
           key = match_data[1]
 
           # A token could match the _path or _url pattern, but not be an actual route.
           route = ::Rails.application.routes.named_routes.get(key)
-          return { result: nil } unless route&.source_location
-
-          {
-            result: {
-              location: ::Rails.root.join(route.source_location).to_s,
-            },
-          }
-        rescue => e
-          { error: e.full_message(highlight: false) }
+          return unless route&.source_location
+
+          { location: ::Rails.root.join(route.source_location).to_s }
         end
       else
         def route_location(name)
-          { result: nil }
+          nil
         end
       end
 
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
-        unless active_record_model?(const)
-          return {
-            result: nil,
-          }
-        end
+        return unless active_record_model?(const)
 
         info = {
-          result: {
-            columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
-            primary_keys: Array(const.primary_key),
-          },
+          columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
+          primary_keys: Array(const.primary_key),
         }
 
         if ActiveRecord::Tasks::DatabaseTasks.respond_to?(:schema_dump_path)
-          info[:result][:schema_file] =
-            ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
-
+          info[:schema_file] = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
         end
+
         info
-      rescue => e
-        { error: e.full_message(highlight: false) }
       end
 
       def resolve_association_target(params)
         const = ActiveSupport::Inflector.safe_constantize(params[:model_name])
-        unless active_record_model?(const)
-          return {
-            result: nil,
-          }
-        end
+        return unless active_record_model?(const)
 
         association_klass = const.reflect_on_association(params[:association_name].intern).klass
-
         source_location = Object.const_source_location(association_klass.to_s)
 
-        {
-          result: {
-            location: source_location.first + ":" + source_location.second.to_s,
-          },
-        }
+        { location: source_location.first + ":" + source_location.second.to_s }
       rescue NameError
-        {
-          result: nil,
-        }
+        nil
       end
 
       def active_record_model?(const)
@@ -282,6 +294,14 @@ module RubyLsp
 
         { message: stdout, status: status.exitstatus }
       end
+
+      def load_routes
+        with_notification_error_handling("initial_load_routes") do
+          # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
+          routes_reloader = ::Rails.application.routes_reloader
+          routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.26"
+    VERSION = "0.3.28"
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.26
+  version: 0.3.28
 platform: ruby
 authors:
 - Shopify
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-08 00:00:00.000000000 Z
+date: 2025-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -16,20 +15,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.2
+        version: 0.23.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.2
+        version: 0.23.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.24.0
 description: A Ruby LSP addon that adds extra editor functionality for Rails applications
 email:
 - ruby@shopify.com
@@ -43,6 +42,7 @@ files:
 - lib/ruby-lsp-rails.rb
 - lib/ruby_lsp/ruby_lsp_rails/addon.rb
 - lib/ruby_lsp/ruby_lsp_rails/code_lens.rb
+- lib/ruby_lsp/ruby_lsp_rails/completion.rb
 - lib/ruby_lsp/ruby_lsp_rails/definition.rb
 - lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.rb
@@ -53,7 +53,6 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/support/associations.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/callbacks.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/location_builder.rb
-- lib/ruby_lsp_rails/railtie.rb
 - lib/ruby_lsp_rails/version.rb
 - lib/tasks/ruby_lsp_rails_tasks.rake
 homepage: https://github.com/Shopify/ruby-lsp-rails
@@ -65,7 +64,6 @@ metadata:
   source_code_uri: https://github.com/Shopify/ruby-lsp-rails
   changelog_uri: https://github.com/Shopify/ruby-lsp-rails/releases
   documentation_uri: https://shopify.github.io/ruby-lsp/rails-add-on.html
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -80,8 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A Ruby LSP addon for Rails
 test_files: []

data/lib/ruby_lsp_rails/railtie.rb

@@ -1,21 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "rails"
-
-module RubyLsp
-  module Rails
-    class Railtie < ::Rails::Railtie
-      config.ruby_lsp_rails = ActiveSupport::OrderedOptions.new
-
-      initializer "ruby_lsp_rails.setup" do |_app|
-        config.after_initialize do |_app|
-          unless config.ruby_lsp_rails.server.nil?
-            ActiveSupport::Deprecation.new.warn("The `ruby_lsp_rails.server` configuration option is no longer " \
-              "needed and will be removed in a future release.")
-          end
-        end
-      end
-    end
-  end
-end