ruby-lsp 0.23.2 → 0.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d295233e64f7b79aa061f243c61c6d5bfb69cbdc5dac64474106473d7033bc8
-  data.tar.gz: 559fbc2fb40b2a8043fefbf332cb4bf94ce8e3953299d6740d1d21034b79e92b
+  metadata.gz: 95642b8034d20684e2596755f391591d6dfffc9021e23a6e2efd0b9a0e500eb0
+  data.tar.gz: 6db469fda24144ce71eb0c2d8434251b3bf01a800035d85bea5e8e6801cf5120
 SHA512:
-  metadata.gz: 52e0176c0e9516801f94d9bd387ad6acfcd640c500443527448b69f3b55e2627aafa3bea75a60e131c21c0b06b309aba28a98b263344d20ce6406e1e66b69a37
-  data.tar.gz: 52b47878d9c5a71dadd618a5562a30901abf3fe167f71e08d92f1a5418710a4e360043ae08d553975ad7008d7f1fb657a9b650d05a311ddcfc92157a7283ec6c
+  metadata.gz: 69365797e36c6597b43b5067da2e10b6c634cdb9121081db0e7c16c657fe12e2aa72042ba7beb07480b1cbb4a24c9a37a7a71f5a49a1be42923adb7a85a80715
+  data.tar.gz: 22695e4a4fd4e72738b43c32e9a693ed9895033e82240317700cde5583537b0ad6e7d8ce530a110624c57278d5a08c4eeb207ae010a4db99b3885bc241c5caa4

data/VERSION

@@ -1 +1 @@
-0.23.2
+0.23.3

data/exe/ruby-lsp-launcher

@@ -45,6 +45,12 @@ rescue Errno::ECHILD
   # In theory, the child process can finish before we even get to the wait call, but that is not an error
 end
 
+error_path = File.join(".ruby-lsp", "install_error")
+
+install_error = if File.exist?(error_path)
+  Marshal.load(File.read(error_path))
+end
+
 begin
   bundle_env_path = File.join(".ruby-lsp", "bundle_env")
   # We can't require `bundler/setup` because that file prematurely exits the process if setup fails. However, we can't
@@ -67,21 +73,21 @@ begin
 rescue StandardError => e
   # If installing gems failed for any reason, we don't want to exit the process prematurely. We can still provide most
   # features in a degraded mode. We simply save the error so that we can report to the user that certain gems might be
-  # missing, but we respect the LSP life cycle
-  setup_error = e
-  $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+  # missing, but we respect the LSP life cycle.
+  #
+  # If an install error occurred and one of the gems is not installed, Bundler.setup is guaranteed to fail with
+  # `Bundler::GemNotFound`. We don't set `setup_error` here because that would essentially report the same problem twice
+  # to telemetry, which is not useful
+  unless install_error && e.is_a?(Bundler::GemNotFound)
+    setup_error = e
+    $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+  end
 
   # If Bundler.setup fails, we need to restore the original $LOAD_PATH so that we can still require the Ruby LSP server
   # in degraded mode
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 end
 
-error_path = File.join(".ruby-lsp", "install_error")
-
-install_error = if File.exist?(error_path)
-  Marshal.load(File.read(error_path))
-end
-
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -287,7 +287,6 @@ module RubyIndexer
       when :module_function
         handle_module_function(node)
       when :private_class_method
-        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
         handle_private_class_method(node)
       end
 
@@ -975,39 +974,42 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_private_class_method(node)
-      node.arguments&.arguments&.each do |argument|
-        string_or_symbol_nodes = case argument
-        when Prism::StringNode, Prism::SymbolNode
-          [argument]
-        when Prism::ArrayNode
-          argument.elements
-        else
-          []
-        end
+      arguments = node.arguments&.arguments
+      return unless arguments
 
-        unless string_or_symbol_nodes.empty?
-          # pop the visibility off since there isn't a method definition following `private_class_method`
-          @visibility_stack.pop
-        end
+      # If we're passing a method definition directly to `private_class_method`, push a new private scope. That will be
+      # applied when the indexer finds the method definition and then popped on `call_node_leave`
+      if arguments.first.is_a?(Prism::DefNode)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
+        return
+      end
 
-        string_or_symbol_nodes.each do |string_or_symbol_node|
-          method_name = case string_or_symbol_node
-          when Prism::StringNode
-            string_or_symbol_node.content
-          when Prism::SymbolNode
-            string_or_symbol_node.value
-          end
-          next unless method_name
+      owner_name = @owner_stack.last&.name
+      return unless owner_name
 
-          owner_name = @owner_stack.last&.name
-          next unless owner_name
+      # private_class_method accepts strings, symbols or arrays of strings and symbols as arguments. Here we build a
+      # single list of all of the method names that have to be made private
+      arrays, others = T.cast(
+        arguments.partition { |argument| argument.is_a?(Prism::ArrayNode) },
+        [T::Array[Prism::ArrayNode], T::Array[Prism::Node]],
+      )
+      arrays.each { |array| others.concat(array.elements) }
 
-          entries = @index.resolve_method(method_name, @index.existing_or_new_singleton_class(owner_name).name)
-          next unless entries
+      names = others.filter_map do |argument|
+        case argument
+        when Prism::StringNode
+          argument.unescaped
+        when Prism::SymbolNode
+          argument.value
+        end
+      end
 
-          entries.each do |entry|
-            entry.visibility = Entry::Visibility::PRIVATE
-          end
+      names.each do |name|
+        entries = @index.resolve_method(name, @index.existing_or_new_singleton_class(owner_name).name)
+        next unless entries
+
+        entries.each do |entry|
+          entry.visibility = Entry::Visibility::PRIVATE
         end
       end
     end

data/lib/ruby_indexer/test/method_test.rb

@@ -909,6 +909,21 @@ module RubyIndexer
       assert_equal("Foo", T.must(entry.owner).name)
     end
 
+    def test_making_several_class_methods_private
+      index(<<~RUBY)
+        class Foo
+          def self.bar; end
+          def self.baz; end
+          def self.qux; end
+
+          private_class_method :bar, :baz, :qux
+
+          def initialize
+          end
+        end
+      RUBY
+    end
+
     private
 
     sig { params(entry: Entry::Method, call_string: String).void }

data/lib/ruby_lsp/base_server.rb

@@ -90,8 +90,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",
-             "$/cancelRequest"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do

data/lib/ruby_lsp/document.rb

@@ -97,33 +97,31 @@ module RubyLsp
 
     sig { params(edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
     def push_edits(edits, version:)
-      @global_state.synchronize do
-        edits.each do |edit|
-          range = edit[:range]
-          scanner = create_scanner
+      edits.each do |edit|
+        range = edit[:range]
+        scanner = create_scanner
 
-          start_position = scanner.find_char_position(range[:start])
-          end_position = scanner.find_char_position(range[:end])
+        start_position = scanner.find_char_position(range[:start])
+        end_position = scanner.find_char_position(range[:end])
 
-          @source[start_position...end_position] = edit[:text]
-        end
+        @source[start_position...end_position] = edit[:text]
+      end
 
-        @version = version
-        @needs_parsing = true
-        @cache.clear
+      @version = version
+      @needs_parsing = true
+      @cache.clear
 
-        last_edit = edits.last
-        return unless last_edit
+      last_edit = edits.last
+      return unless last_edit
 
-        last_edit_range = last_edit[:range]
+      last_edit_range = last_edit[:range]
 
-        @last_edit = if last_edit_range[:start] == last_edit_range[:end]
-          Insert.new(last_edit_range)
-        elsif last_edit[:text].empty?
-          Delete.new(last_edit_range)
-        else
-          Replace.new(last_edit_range)
-        end
+      @last_edit = if last_edit_range[:start] == last_edit_range[:end]
+        Insert.new(last_edit_range)
+      elsif last_edit[:text].empty?
+        Delete.new(last_edit_range)
+      else
+        Replace.new(last_edit_range)
       end
     end
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -330,7 +330,8 @@ module RubyLsp
 
         methods.each do |target_method|
           uri = target_method.uri
-          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(T.must(uri.full_path))
+          full_path = uri.full_path
+          next if sorbet_level_true_or_higher?(@sorbet_level) && (!full_path || not_in_dependencies?(full_path))
 
           @response_builder << Interface::LocationLink.new(
             target_uri: uri.to_s,
@@ -403,7 +404,11 @@ module RubyLsp
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
           uri = entry.uri
-          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(T.must(uri.full_path))
+          full_path = uri.full_path
+
+          if @sorbet_level != RubyDocument::SorbetLevel::Ignore && (!full_path || not_in_dependencies?(full_path))
+            next
+          end
 
           @response_builder << Interface::LocationLink.new(
             target_uri: uri.to_s,

data/lib/ruby_lsp/requests/rename.rb

@@ -116,8 +116,8 @@ module RubyLsp
         T.must(@global_state.index[fully_qualified_name]).each do |entry|
           # Do not rename files that are not part of the workspace
           uri = entry.uri
-          file_path = T.must(uri.full_path)
-          next unless file_path.start_with?(@global_state.workspace_path)
+          file_path = uri.full_path
+          next unless file_path&.start_with?(@global_state.workspace_path)
 
           case entry
           when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -22,10 +22,10 @@ module RubyLsp
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
           uri = entry.uri
-          file_path = T.must(uri.full_path)
+          file_path = uri.full_path
 
           # We only show symbols declared in the workspace
-          in_dependencies = !not_in_dependencies?(file_path)
+          in_dependencies = file_path && !not_in_dependencies?(file_path)
           next if in_dependencies
 
           # We should never show private symbols when searching the entire workspace

data/lib/ruby_lsp/server.rb

@@ -359,48 +359,52 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_did_open(message)
-      text_document = message.dig(:params, :textDocument)
-      language_id = case text_document[:languageId]
-      when "erb", "eruby"
-        Document::LanguageId::ERB
-      when "rbs"
-        Document::LanguageId::RBS
-      else
-        Document::LanguageId::Ruby
-      end
+      @global_state.synchronize do
+        text_document = message.dig(:params, :textDocument)
+        language_id = case text_document[:languageId]
+        when "erb", "eruby"
+          Document::LanguageId::ERB
+        when "rbs"
+          Document::LanguageId::RBS
+        else
+          Document::LanguageId::Ruby
+        end
 
-      document = @store.set(
-        uri: text_document[:uri],
-        source: text_document[:text],
-        version: text_document[:version],
-        language_id: language_id,
-      )
+        document = @store.set(
+          uri: text_document[:uri],
+          source: text_document[:text],
+          version: text_document[:version],
+          language_id: language_id,
+        )
 
-      if document.past_expensive_limit? && text_document[:uri].scheme == "file"
-        log_message = <<~MESSAGE
-          The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
-          diagnostics will be disabled.
-        MESSAGE
+        if document.past_expensive_limit? && text_document[:uri].scheme == "file"
+          log_message = <<~MESSAGE
+            The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
+            diagnostics will be disabled.
+          MESSAGE
 
-        send_message(
-          Notification.new(
-            method: "window/logMessage",
-            params: Interface::LogMessageParams.new(
-              type: Constant::MessageType::WARNING,
-              message: log_message,
+          send_message(
+            Notification.new(
+              method: "window/logMessage",
+              params: Interface::LogMessageParams.new(
+                type: Constant::MessageType::WARNING,
+                message: log_message,
+              ),
             ),
-          ),
-        )
+          )
+        end
       end
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_did_close(message)
-      uri = message.dig(:params, :textDocument, :uri)
-      @store.delete(uri)
+      @global_state.synchronize do
+        uri = message.dig(:params, :textDocument, :uri)
+        @store.delete(uri)
 
-      # Clear diagnostics for the closed file, so that they no longer appear in the problems tab
-      send_message(Notification.publish_diagnostics(uri.to_s, []))
+        # Clear diagnostics for the closed file, so that they no longer appear in the problems tab
+        send_message(Notification.publish_diagnostics(uri.to_s, []))
+      end
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -408,7 +412,9 @@ module RubyLsp
       params = message[:params]
       text_document = params[:textDocument]
 
-      @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
+      @global_state.synchronize do
+        @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
+      end
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -1254,10 +1260,10 @@ module RubyLsp
         return
       end
 
-      return unless indexing_options
-
       configuration = @global_state.index.configuration
       configuration.workspace_path = @global_state.workspace_path
+      return unless indexing_options
+
       # The index expects snake case configurations, but VS Code standardizes on camel case settings
       configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
     end

data/lib/ruby_lsp/store.rb

@@ -65,15 +65,13 @@ module RubyLsp
       ).returns(Document[T.untyped])
     end
     def set(uri:, source:, version:, language_id:)
-      @global_state.synchronize do
-        @state[uri.to_s] = case language_id
-        when Document::LanguageId::ERB
-          ERBDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
-        when Document::LanguageId::RBS
-          RBSDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
-        else
-          RubyDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
-        end
+      @state[uri.to_s] = case language_id
+      when Document::LanguageId::ERB
+        ERBDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
+      when Document::LanguageId::RBS
+        RBSDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
+      else
+        RubyDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
       end
     end
 
@@ -94,9 +92,7 @@ module RubyLsp
 
     sig { params(uri: URI::Generic).void }
     def delete(uri)
-      @global_state.synchronize do
-        @state.delete(uri.to_s)
-      end
+      @state.delete(uri.to_s)
     end
 
     sig { params(uri: URI::Generic).returns(T::Boolean) }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.2
+  version: 0.23.3
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-08 00:00:00.000000000 Z
+date: 2025-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol