Upgrade Ruby LSP requirement and fix breaking changes

Gemfile.lock

@@ -104,7 +104,7 @@ PATH
   specs:
     ruby-lsp-rails (0.2.6)
       rails (>= 6.0)
-      ruby-lsp (>= 0.11.0, < 0.12.0)
+      ruby-lsp (>= 0.12.0, < 0.13.0)
       sorbet-runtime (>= 0.5.9897)
 
 GEM
@@ -168,6 +168,7 @@ GEM
       ast (~> 2.4.1)
       racc
     prettier_print (1.2.1)
+    prism (0.15.1)
     psych (5.1.1.1)
       stringio
     puma (6.4.0)
@@ -221,10 +222,10 @@ GEM
       rubocop (~> 1.51)
     rubocop-sorbet (0.7.4)
       rubocop (>= 0.90.0)
-    ruby-lsp (0.11.2)
+    ruby-lsp (0.12.0)
       language_server-protocol (~> 3.17.0)
+      prism (>= 0.15.1, < 0.16)
       sorbet-runtime (>= 0.5.5685)
-      yarp (>= 0.12, < 0.13)
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
     sorbet (0.5.11074)

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -29,24 +29,24 @@ def deactivate; end
       sig do
         override.params(
           uri: URI::Generic,
-          emitter: EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
       end
-      def create_code_lens_listener(uri, emitter, message_queue)
-        CodeLens.new(uri, emitter, message_queue)
+      def create_code_lens_listener(uri, dispatcher, message_queue)
+        CodeLens.new(uri, dispatcher, message_queue)
       end
 
       sig do
         override.params(
           nesting: T::Array[String],
           index: RubyIndexer::Index,
-          emitter: EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
       end
-      def create_hover_listener(nesting, index, emitter, message_queue)
-        Hover.new(client, nesting, index, emitter, message_queue)
+      def create_hover_listener(nesting, index, dispatcher, message_queue)
+        Hover.new(client, nesting, index, dispatcher, message_queue)
       end
 
       sig { override.returns(String) }

lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -42,17 +42,17 @@ class CodeLens < ::RubyLsp::Listener
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
+      def initialize(uri, dispatcher, message_queue)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
-        emitter.register(self, :on_call, :on_class, :on_def)
+        dispatcher.register(self, :on_call_node_enter, :on_class_node_enter, :on_def_node_enter)
 
-        super(emitter, message_queue)
+        super(dispatcher, message_queue)
       end
 
-      sig { params(node: YARP::CallNode).void }
-      def on_call(node)
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
         message_value = node.message
         return unless message_value == "test"
 
@@ -62,15 +62,15 @@ def on_call(node)
         first_argument = arguments.first
 
         content = case first_argument
-        when YARP::StringConcatNode
+        when Prism::StringConcatNode
           left = first_argument.left
           right = first_argument.right
           # We only support two lines of concatenation on test names
-          if left.is_a?(YARP::StringNode) &&
-              right.is_a?(YARP::StringNode)
+          if left.is_a?(Prism::StringNode) &&
+              right.is_a?(Prism::StringNode)
             left.content + right.content
           end
-        when YARP::StringNode
+        when Prism::StringNode
           first_argument.content
         end
 
@@ -82,8 +82,8 @@ def on_call(node)
       end
 
       # Although uncommon, Rails tests can be written with the classic "def test_name" syntax.
-      sig { params(node: YARP::DefNode).void }
-      def on_def(node)
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
         method_name = node.name.to_s
         if method_name.start_with?("test_")
           line_number = node.location.start_line
@@ -92,8 +92,8 @@ def on_def(node)
         end
       end
 
-      sig { params(node: YARP::ClassNode).void }
-      def on_class(node)
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
         class_name = node.constant_path.slice
         if class_name.end_with?("Test")
           command = "#{BASE_COMMAND} #{@path}"
@@ -103,7 +103,7 @@ def on_class(node)
 
       private
 
-      sig { params(node: YARP::Node, name: String, command: String, kind: Symbol).void }
+      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         return unless @path
 

lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -30,22 +30,22 @@ class Hover < ::RubyLsp::Listener
           client: RailsClient,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
-          emitter: RubyLsp::EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).void
       end
-      def initialize(client, nesting, index, emitter, message_queue)
-        super(emitter, message_queue)
+      def initialize(client, nesting, index, dispatcher, message_queue)
+        super(dispatcher, message_queue)
 
         @_response = T.let(nil, ResponseType)
         @client = client
         @nesting = nesting
         @index = index
-        emitter.register(self, :on_constant_path, :on_constant_read, :on_call)
+        dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter, :on_call_node_enter)
       end
 
-      sig { params(node: YARP::ConstantPathNode).void }
-      def on_constant_path(node)
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
         entries = @index.resolve(node.slice, @nesting)
         return unless entries
 
@@ -62,8 +62,8 @@ def on_constant_path(node)
         @_response = RubyLsp::Interface::Hover.new(range: range_from_location(node.location), contents: contents)
       end
 
-      sig { params(node: YARP::ConstantReadNode).void }
-      def on_constant_read(node)
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
         entries = @index.resolve(node.name.to_s, @nesting)
         return unless entries
 
@@ -74,8 +74,8 @@ def on_constant_read(node)
         @_response = RubyLsp::Interface::Hover.new(range: range_from_location(node.location), contents: contents)
       end
 
-      sig { params(node: YARP::CallNode).void }
-      def on_call(node)
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
         message_value = node.message
         message_loc = node.message_loc
 
@@ -98,7 +98,7 @@ def generate_column_content(name)
         content
       end
 
-      sig { params(name: String, location: YARP::Location).returns(T.nilable(Interface::Hover)) }
+      sig { params(name: String, location: Prism::Location).returns(T.nilable(Interface::Hover)) }
       def generate_rails_document_link_hover(name, location)
         urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
         return if urls.empty?

ruby-lsp-rails.gemspec

@@ -22,6 +22,6 @@ Gem::Specification.new do |spec|
   end
 
   spec.add_dependency("rails", ">= 6.0")
-  spec.add_dependency("ruby-lsp", ">= 0.11.0", "< 0.12.0")
+  spec.add_dependency("ruby-lsp", ">= 0.12.0", "< 0.13.0")
   spec.add_dependency("sorbet-runtime", ">= 0.5.9897")
 end