ruby-lsp 0.23.15 → 0.26.9

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -52,9 +52,9 @@ module RubyIndexer
       comments = comments_to_string(declaration)
       entry = if declaration.is_a?(RBS::AST::Declarations::Class)
         parent_class = declaration.super_class&.name&.name&.to_s
-        Entry::Class.new(nesting, uri, location, location, comments, parent_class)
+        Entry::Class.new(@index.configuration, nesting, uri, location, location, comments, parent_class)
       else
-        Entry::Module.new(nesting, uri, location, location, comments)
+        Entry::Module.new(@index.configuration, nesting, uri, location, location, comments)
       end
 
       add_declaration_mixins_to_entry(declaration, entry)
@@ -103,29 +103,21 @@ module RubyIndexer
     #: (RBS::AST::Members::MethodDefinition member, Entry::Namespace owner) -> void
     def handle_method(member, owner)
       name = member.name.name
-      uri = URI::Generic.from_path(path: member.location.buffer.name)
+      uri = URI::Generic.from_path(path: member.location.buffer.name.to_s)
       location = to_ruby_indexer_location(member.location)
       comments = comments_to_string(member)
 
-      visibility = case member.visibility
-      when :private
-        Entry::Visibility::PRIVATE
-      when :protected
-        Entry::Visibility::PROTECTED
-      else
-        Entry::Visibility::PUBLIC
-      end
-
       real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
       signatures = signatures(member)
       @index.add(Entry::Method.new(
+        @index.configuration,
         name,
         uri,
         location,
         location,
         comments,
         signatures,
-        visibility,
+        member.visibility || :public,
         real_owner,
       ))
     end
@@ -252,6 +244,7 @@ module RubyIndexer
     def handle_constant(declaration, nesting, uri)
       fully_qualified_name = [*nesting, declaration.name.name.to_s].join("::")
       @index.add(Entry::Constant.new(
+        @index.configuration,
         fully_qualified_name,
         uri,
         to_ruby_indexer_location(declaration.location),
@@ -267,6 +260,7 @@ module RubyIndexer
       comments = comments_to_string(declaration)
 
       @index.add(Entry::GlobalVariable.new(
+        @index.configuration,
         name,
         uri,
         location,
@@ -276,10 +270,11 @@ module RubyIndexer
 
     #: (RBS::AST::Members::Alias member, Entry::Namespace owner_entry) -> void
     def handle_signature_alias(member, owner_entry)
-      uri = URI::Generic.from_path(path: member.location.buffer.name)
+      uri = URI::Generic.from_path(path: member.location.buffer.name.to_s)
       comments = comments_to_string(member)
 
       entry = Entry::UnresolvedMethodAlias.new(
+        @index.configuration,
         member.new_name.to_s,
         member.old_name.to_s,
         owner_entry,

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -3,11 +3,8 @@
 
 module RubyIndexer
   class ReferenceFinder
-    class Target
-      extend T::Helpers
-
-      abstract!
-    end
+    # @abstract
+    class Target; end
 
     class ConstTarget < Target
       #: String
@@ -35,10 +32,14 @@ module RubyIndexer
       #: String
       attr_reader :name
 
-      #: (String name) -> void
-      def initialize(name)
+      #: Array[String]
+      attr_reader :owner_ancestors
+
+      #: (String name, Array[String] owner_ancestors) -> void
+      def initialize(name, owner_ancestors)
         super()
         @name = name
+        @owner_ancestors = owner_ancestors
       end
     end
 
@@ -325,7 +326,10 @@ module RubyIndexer
     def collect_instance_variable_references(name, location, declaration)
       return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
 
-      @references << Reference.new(name, location, declaration: declaration)
+      receiver_type = Index.actual_nesting(@stack, nil).join("::")
+      if @target.owner_ancestors.include?(receiver_type)
+        @references << Reference.new(name, location, declaration: declaration)
+      end
     end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -8,7 +8,7 @@ module RubyIndexer
     class << self
       #: -> instance
       def module_function_scope
-        new(module_func: true, visibility: Entry::Visibility::PRIVATE)
+        new(module_func: true, visibility: :private)
       end
 
       #: -> instance
@@ -17,14 +17,14 @@ module RubyIndexer
       end
     end
 
-    #: Entry::Visibility
+    #: Symbol
     attr_reader :visibility
 
     #: bool
     attr_reader :module_func
 
-    #: (?visibility: Entry::Visibility, ?module_func: bool) -> void
-    def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
+    #: (?visibility: Symbol, ?module_func: bool) -> void
+    def initialize(visibility: :public, module_func: false)
       @visibility = visibility
       @module_func = module_func
     end

data/lib/ruby_lsp/addon.rb

@@ -19,12 +19,8 @@ module RubyLsp
   #   end
   # end
   # ```
+  # @abstract
   class Addon
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     @addons = [] #: Array[Addon]
     @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
@@ -60,7 +56,28 @@ module RubyLsp
         addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
 
         if include_project_addons
-          addon_files.concat(Dir.glob(File.join(global_state.workspace_path, "**", "ruby_lsp/**/addon.rb")))
+          project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
+          bundle_path = Bundler.bundle_path.to_s
+          gems_dir = Bundler.bundle_path.join("gems")
+
+          # Create an array of rejection glob patterns to ignore add-ons already discovered through Gem.find_files if
+          # they are also copied inside the workspace for whatever reason. We received reports of projects having gems
+          # installed in vendor/bundle despite BUNDLE_PATH pointing elsewhere. Without this mechanism, we will
+          # double-require the same add-on, potentially for different versions of the same gem, which leads to incorrect
+          # behavior
+          reject_glob_patterns = addon_files.map do |path|
+            relative_gem_path = Pathname.new(path).relative_path_from(gems_dir)
+            first_part, *parts = relative_gem_path.to_s.split(File::SEPARATOR)
+            first_part&.gsub!(/-([0-9.]+)$/, "*")
+            "**/#{first_part}/#{parts.join("/")}"
+          end
+
+          project_addons.reject! do |path|
+            path.start_with?(bundle_path) ||
+              reject_glob_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::Constants::FNM_PATHNAME) }
+          end
+
+          addon_files.concat(project_addons)
         end
 
         errors = addon_files.filter_map do |addon_path|
@@ -178,22 +195,34 @@ module RubyLsp
 
     # Each add-on should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
-    def activate(global_state, outgoing_queue); end
+    # @abstract
+    #: (GlobalState, Thread::Queue) -> void
+    def activate(global_state, outgoing_queue)
+      raise AbstractMethodInvokedError
+    end
 
-    # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
+    # Each add-on must implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
-    sig { abstract.void }
-    def deactivate; end
+    # @abstract
+    #: -> void
+    def deactivate
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `name` method to return the add-on name
-    sig { abstract.returns(String) }
-    def name; end
+    # @abstract
+    #: -> String
+    def name
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `version` method to return a semantic version string representing the add-on's
     # version. This is used for compatibility checks
-    sig { abstract.returns(String) }
-    def version; end
+    # @abstract
+    #: -> String
+    def version
+      raise AbstractMethodInvokedError
+    end
 
     # Handle a response from a window/showMessageRequest request. Add-ons must include the addon_name as part of the
     # original request so that the response is delegated to the correct add-on and must override this method to handle

data/lib/ruby_lsp/base_server.rb

@@ -2,19 +2,15 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   class BaseServer
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     #: (**untyped options) -> void
     def initialize(**options)
+      @reader = MessageReader.new(options[:reader] || $stdin) #: MessageReader
+      @writer = MessageWriter.new(options[:writer] || $stdout) #: MessageWriter
       @test_mode = options[:test_mode] #: bool?
       @setup_error = options[:setup_error] #: StandardError?
       @install_error = options[:install_error] #: StandardError?
-      @writer = Transport::Stdio::Writer.new #: Transport::Stdio::Writer
-      @reader = Transport::Stdio::Reader.new #: Transport::Stdio::Reader
       @incoming_queue = Thread::Queue.new #: Thread::Queue
       @outgoing_queue = Thread::Queue.new #: Thread::Queue
       @cancelled_requests = [] #: Array[Integer]
@@ -40,7 +36,7 @@ module RubyLsp
 
     #: -> void
     def start
-      @reader.read do |message|
+      @reader.each_message do |message|
         method = message[:method]
 
         # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
@@ -87,8 +83,7 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
-          "rubyLsp/diagnoseState"
+        when "initialize", "initialized", "rubyLsp/diagnoseState", "$/cancelRequest"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -98,13 +93,36 @@ module RubyLsp
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
         when "exit"
-          @global_state.synchronize { exit(@incoming_queue.closed? ? 0 : 1) }
+          exit(@incoming_queue.closed? ? 0 : 1)
         else
           @incoming_queue << message
         end
       end
     end
 
+    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
+    #: -> untyped
+    def pop_response
+      @outgoing_queue.pop(timeout: 20) || raise("No message received from server")
+    end
+
+    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
+    #: (Hash[Symbol, untyped] message) -> void
+    def push_message(message)
+      @incoming_queue << message
+    end
+
+    # @abstract
+    #: (Hash[Symbol, untyped] message) -> void
+    def process_message(message)
+      raise AbstractMethodInvokedError
+    end
+
+    #: -> bool?
+    def test_mode?
+      @test_mode
+    end
+
     #: -> void
     def run_shutdown
       @incoming_queue.clear
@@ -118,24 +136,14 @@ module RubyLsp
       @store.clear
     end
 
-    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
-    #: -> untyped
-    def pop_response
-      @outgoing_queue.pop
-    end
+    private
 
-    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
-    #: (Hash[Symbol, untyped] message) -> void
-    def push_message(message)
-      @incoming_queue << message
+    # @abstract
+    #: -> void
+    def shutdown
+      raise AbstractMethodInvokedError
     end
 
-    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
-    def process_message(message); end
-
-    sig { abstract.void }
-    def shutdown; end
-
     #: (Integer id, String message, ?type: Integer) -> void
     def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
       send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))
@@ -146,20 +154,31 @@ module RubyLsp
     def new_worker
       Thread.new do
         while (message = @incoming_queue.pop)
-          id = message[:id]
+          handle_incoming_message(message)
+        end
+      end
+    end
 
-          # Check if the request was cancelled before trying to process it
-          @global_state.synchronize do
-            if id && @cancelled_requests.include?(id)
-              send_message(Result.new(id: id, response: nil))
-              @cancelled_requests.delete(id)
-              next
-            end
-          end
+    #: (Hash[Symbol, untyped]) -> void
+    def handle_incoming_message(message)
+      id = message[:id]
 
-          process_message(message)
+      # Check if the request was cancelled before trying to process it
+      @global_state.synchronize do
+        if id && @cancelled_requests.delete(id)
+          send_message(Error.new(
+            id: id,
+            code: Constant::ErrorCodes::REQUEST_CANCELLED,
+            message: "Request #{id} was cancelled",
+          ))
+
+          return
         end
       end
+
+      process_message(message)
+      # Ensure we remove the request if it got cancelled while it was being processed
+      @cancelled_requests.delete(id)
     end
 
     #: ((Result | Error | Notification | Request) message) -> void
@@ -180,7 +199,7 @@ module RubyLsp
 
     #: (String message, ?type: Integer) -> void
     def send_log_message(message, type: Constant::MessageType::LOG)
-      send_message(Notification.window_log_message(message, type: Constant::MessageType::LOG))
+      send_message(Notification.window_log_message(message, type: type))
     end
   end
 end

data/lib/ruby_lsp/client_capabilities.rb

@@ -10,7 +10,8 @@ module RubyLsp
       :supports_request_delegation,
       :window_show_message_supports_extra_properties,
       :supports_progress,
-      :supports_diagnostic_refresh
+      :supports_diagnostic_refresh,
+      :supports_code_lens_refresh
 
     #: -> void
     def initialize
@@ -34,6 +35,9 @@ module RubyLsp
 
       # The editor supports server initiated refresh for diagnostics
       @supports_diagnostic_refresh = false #: bool
+
+      # The editor supports server initiated refresh for code lenses
+      @supports_code_lens_refresh = false #: bool
     end
 
     #: (Hash[Symbol, untyped] capabilities) -> void
@@ -61,6 +65,7 @@ module RubyLsp
       @supports_progress = progress if progress
 
       @supports_diagnostic_refresh = workspace_capabilities.dig(:diagnostics, :refreshSupport) || false
+      @supports_code_lens_refresh = workspace_capabilities.dig(:codeLens, :refreshSupport) || false
     end
 
     #: -> bool