ruby-lsp 0.20.0 → 0.21.0

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -121,7 +121,7 @@ module RubyLsp
         return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
 
         closest_node_loc = closest_node.location
-        # If the parent expression is a single line block, then we have to extract it inside of the oneline block
+        # If the parent expression is a single line block, then we have to extract it inside of the one-line block
         if parent_statements.is_a?(Prism::BlockNode) &&
             parent_statements.location.start_line == parent_statements.location.end_line
 

data/lib/ruby_lsp/requests/completion.rb

@@ -17,7 +17,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'", ":", "@", ".", "=", "<"],
+            trigger_characters: ["/", "\"", "'", ":", "@", ".", "=", "<", "$"],
             completion_item: {
               labelDetailsSupport: true,
             },
@@ -50,6 +50,12 @@ module RubyLsp
             Prism::CallNode,
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
+            Prism::GlobalVariableAndWriteNode,
+            Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode,
+            Prism::GlobalVariableReadNode,
+            Prism::GlobalVariableTargetNode,
+            Prism::GlobalVariableWriteNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -34,7 +34,7 @@ module RubyLsp
 
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
-        # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might
+        # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behavior might
         # be broken.
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the

data/lib/ruby_lsp/requests/definition.rb

@@ -12,12 +12,6 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
-      SPECIAL_METHOD_CALLS = [
-        :require,
-        :require_relative,
-        :autoload,
-      ].freeze
-
       sig do
         params(
           document: T.any(RubyDocument, ERBDocument),
@@ -46,7 +40,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::BlockArgumentNode,
+            Prism::GlobalVariableAndWriteNode,
+            Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode,
             Prism::GlobalVariableReadNode,
+            Prism::GlobalVariableTargetNode,
+            Prism::GlobalVariableWriteNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,
@@ -72,11 +71,7 @@ module RubyLsp
             parent,
             position,
           )
-        elsif target.is_a?(Prism::CallNode) && !SPECIAL_METHOD_CALLS.include?(target.message) && !covers_position?(
-          target.message_loc, position
-        )
-          # If the target is a method call, we need to ensure that the requested position is exactly on top of the
-          # method identifier. Otherwise, we risk showing definitions for unrelated things
+        elsif position_outside_target?(position, target)
           target = nil
         # For methods with block arguments using symbol-to-proc
         elsif target.is_a?(Prism::SymbolNode) && parent.is_a?(Prism::BlockArgumentNode)
@@ -107,6 +102,26 @@ module RubyLsp
         @dispatcher.dispatch_once(@target) if @target
         @response_builder.response
       end
+
+      private
+
+      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def position_outside_target?(position, target)
+        case target
+        when Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableWriteNode,
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableWriteNode
+
+          !covers_position?(target.name_loc, position)
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -10,7 +10,8 @@ module RubyLsp
     # informs the editor of all the important symbols, such as classes, variables, and methods, defined in a file. With
     # this information, the editor can populate breadcrumbs, file outline and allow for fuzzy symbol searches.
     #
-    # In VS Code, fuzzy symbol search can be accessed by opening the command palette and inserting an `@` symbol.
+    # In VS Code, symbol search known as 'Go To Symbol in Editor' and can be accessed with Ctrl/Cmd-Shift-O,
+    # or by opening the command palette and inserting an `@` symbol.
     class DocumentSymbol < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/hover.rb

@@ -46,17 +46,13 @@ module RubyLsp
         target = node_context.node
         parent = node_context.parent
 
-        if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-            !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-            (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+        if should_refine_target?(parent, target)
           target = determine_target(
             T.must(target),
             T.must(parent),
             position,
           )
-        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
-            !covers_position?(target.message_loc, position)
-
+        elsif position_outside_target?(position, target)
           target = nil
         end
 
@@ -89,6 +85,28 @@ module RubyLsp
           ),
         )
       end
+
+      private
+
+      sig { params(parent: T.nilable(Prism::Node), target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def should_refine_target?(parent, target)
+        (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
+        !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+      end
+
+      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def position_outside_target?(position, target)
+        case target
+        when Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableWriteNode
+          !covers_position?(target.name_loc, position)
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/references.rb

@@ -78,6 +78,8 @@ module RubyLsp
 
           parse_result = Prism.parse_file(path)
           collect_references(reference_target, parse_result, uri)
+        rescue Errno::EISDIR, Errno::ENOENT
+          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |_uri, document|

data/lib/ruby_lsp/requests/rename.rb

@@ -72,7 +72,7 @@ module RubyLsp
 
         # If the client doesn't support resource operations, such as renaming files, then we can only return the basic
         # text changes
-        unless @global_state.supported_resource_operations.include?("rename")
+        unless @global_state.client_capabilities.supports_rename?
           return Interface::WorkspaceEdit.new(changes: changes)
         end
 
@@ -147,6 +147,8 @@ module RubyLsp
           parse_result = Prism.parse_file(path)
           edits = collect_changes(target, parse_result, name, uri)
           changes[uri.to_s] = edits unless edits.empty?
+        rescue Errno::EISDIR, Errno::ENOENT
+          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |uri, document|

data/lib/ruby_lsp/requests/request.rb

@@ -26,7 +26,7 @@ module RubyLsp
         ).void
       end
       def delegate_request_if_needed!(global_state, document, char_position)
-        if global_state.supports_request_delegation &&
+        if global_state.client_capabilities.supports_request_delegation &&
             document.is_a?(ERBDocument) &&
             document.inside_host_language?(char_position)
           raise DelegateRequestError

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -1,16 +1,26 @@
 # typed: strict
 # frozen_string_literal: true
 
+# If there's no top level Gemfile, don't load RuboCop from a global installation
+begin
+  Bundler.with_original_env { Bundler.default_gemfile }
+rescue Bundler::GemfileNotFound
+  return
+end
+
+# Ensure that RuboCop is available
 begin
   require "rubocop"
 rescue LoadError
   return
 end
 
+# Ensure that RuboCop is at least version 1.4.0
 begin
   gem("rubocop", ">= 1.4.0")
 rescue LoadError
-  raise StandardError, "Incompatible RuboCop version. Ruby LSP requires >= 1.4.0"
+  $stderr.puts "Incompatible RuboCop version. Ruby LSP requires >= 1.4.0"
+  return
 end
 
 if RuboCop.const_defined?(:LSP) # This condition will be removed when requiring RuboCop >= 1.61.

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+def compose(raw_initialize)
+  require_relative "../setup_bundler"
+  require "json"
+  require "uri"
+  require_relative "../../core_ext/uri"
+
+  initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
+  workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)
+  workspace_path = workspace_uri && URI(workspace_uri).to_standardized_path
+  workspace_path ||= Dir.pwd
+
+  env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
+  File.write(
+    File.join(".ruby-lsp", "bundle_env"),
+    env.map { |k, v| "#{k}=#{v}" }.join("\n"),
+  )
+end

data/lib/ruby_lsp/scripts/compose_bundle_windows.rb

@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "compose_bundle"
+
+# When this is invoked on Windows, we pass the raw initialize as an argument to this script. On other platforms, we
+# invoke the compose method from inside a forked process
+compose(ARGV.first)

data/lib/ruby_lsp/server.rb

@@ -81,6 +81,8 @@ module RubyLsp
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
         workspace_symbol(message)
+      when "window/showMessageRequest"
+        window_show_message_request(message)
       when "rubyLsp/textDocument/showSyntaxTree"
         text_document_show_syntax_tree(message)
       when "rubyLsp/workspace/dependencies"
@@ -140,6 +142,11 @@ module RubyLsp
 
     sig { params(include_project_addons: T::Boolean).void }
     def load_addons(include_project_addons: true)
+      # If invoking Bundler.setup failed, then the load path will not be configured properly and trying to load add-ons
+      # with Gem.find_files will find every single version installed of an add-on, leading to requiring several
+      # different versions of the same files. We cannot load add-ons if Bundler.setup failed
+      return if @setup_error
+
       errors = Addon.load_addons(@global_state, @outgoing_queue, include_project_addons: include_project_addons)
 
       if errors.any?
@@ -254,12 +261,13 @@ module RubyLsp
           version: VERSION,
         },
         formatter: @global_state.formatter,
+        degraded_mode: !!(@install_error || @setup_error),
       }
 
       send_message(Result.new(id: message[:id], response: response))
 
       # Not every client supports dynamic registration or file watching
-      if global_state.supports_watching_files
+      if @global_state.client_capabilities.supports_watching_files
         send_message(
           Request.new(
             id: @current_request_id,
@@ -290,6 +298,24 @@ module RubyLsp
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
 
       global_state_notifications.each { |notification| send_message(notification) }
+
+      if @setup_error
+        send_message(Notification.telemetry(
+          type: "error",
+          errorMessage: @setup_error.message,
+          errorClass: @setup_error.class,
+          stack: @setup_error.backtrace&.join("\n"),
+        ))
+      end
+
+      if @install_error
+        send_message(Notification.telemetry(
+          type: "error",
+          errorMessage: @install_error.message,
+          errorClass: @install_error.class,
+          stack: @install_error.backtrace&.join("\n"),
+        ))
+      end
     end
 
     sig { void }
@@ -297,20 +323,22 @@ module RubyLsp
       load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
-      if defined?(Requests::Support::RuboCopFormatter)
-        begin
-          @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
-        rescue RuboCop::Error => e
-          # The user may have provided unknown config switches in .rubocop or
-          # is trying to load a non-existant config file.
-          send_message(Notification.window_show_message(
-            "RuboCop configuration error: #{e.message}. Formatting will not be available.",
-            type: Constant::MessageType::ERROR,
-          ))
+      unless @setup_error
+        if defined?(Requests::Support::RuboCopFormatter)
+          begin
+            @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
+          rescue RuboCop::Error => e
+            # The user may have provided unknown config switches in .rubocop or
+            # is trying to load a non-existent config file.
+            send_message(Notification.window_show_message(
+              "RuboCop configuration error: #{e.message}. Formatting will not be available.",
+              type: Constant::MessageType::ERROR,
+            ))
+          end
+        end
+        if defined?(Requests::Support::SyntaxTreeFormatter)
+          @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
         end
-      end
-      if defined?(Requests::Support::SyntaxTreeFormatter)
-        @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
       end
 
       perform_initial_indexing
@@ -1017,7 +1045,7 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_dependencies(message)
-      response = begin
+      response = if @global_state.top_level_bundle
         Bundler.with_original_env do
           definition = Bundler.definition
           dep_keys = definition.locked_deps.keys.to_set
@@ -1031,7 +1059,7 @@ module RubyLsp
             }
           end
         end
-      rescue Bundler::GemfileNotFound
+      else
         []
       end
 
@@ -1138,6 +1166,7 @@ module RubyLsp
 
     sig { void }
     def check_formatter_is_available
+      return if @setup_error
       # Warn of an unavailable `formatter` setting, e.g. `rubocop` on a project which doesn't have RuboCop.
       # Syntax Tree will always be available via Ruby LSP so we don't need to check for it.
       return unless @global_state.formatter == "rubocop"
@@ -1194,5 +1223,14 @@ module RubyLsp
       # 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
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def window_show_message_request(message)
+      addon_name = message[:addon_name]
+      addon = Addon.addons.find { |addon| addon.name == addon_name }
+      return unless addon
+
+      addon.handle_window_show_message_response(message[:title])
+    end
   end
 end