ruby-lsp 0.17.17 → 0.18.3

data/lib/ruby_lsp/ruby_document.rb

@@ -121,12 +121,13 @@ module RubyLsp
       end
     end
 
-    sig { override.returns(ParseResultType) }
-    def parse
-      return @parse_result unless @needs_parsing
+    sig { override.returns(T::Boolean) }
+    def parse!
+      return false unless @needs_parsing
 
       @needs_parsing = false
       @parse_result = Prism.parse(@source)
+      true
     end
 
     sig { override.returns(T::Boolean) }

data/lib/ruby_lsp/server.rb

@@ -9,12 +9,6 @@ module RubyLsp
     sig { returns(GlobalState) }
     attr_reader :global_state
 
-    sig { params(test_mode: T::Boolean).void }
-    def initialize(test_mode: false)
-      super
-      @global_state = T.let(GlobalState.new, GlobalState)
-    end
-
     sig { override.params(message: T::Hash[Symbol, T.untyped]).void }
     def process_message(message)
       case message[:method]
@@ -98,6 +92,8 @@ module RubyLsp
       when "$/cancelRequest"
         @mutex.synchronize { @cancelled_requests << message[:params][:id] }
       end
+    rescue DelegateRequestError
+      send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
     rescue StandardError, LoadError => e
       # If an error occurred in a request, we have to return an error response or else the editor will hang
       if message[:id]
@@ -284,7 +280,15 @@ module RubyLsp
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
       if defined?(Requests::Support::RuboCopFormatter)
-        @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
+        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_error(
+            "RuboCop configuration error: #{e.message}. Formatting will not be available.",
+          ))
+        end
       end
       if defined?(Requests::Support::SyntaxTreeFormatter)
         @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
@@ -407,6 +411,7 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
+      inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
       dispatcher.dispatch(parse_result.value)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -415,6 +420,7 @@ module RubyLsp
       document.cache_set("textDocument/documentSymbol", document_symbol.perform)
       document.cache_set("textDocument/documentLink", document_link.perform)
       document.cache_set("textDocument/codeLens", code_lens.perform)
+      document.cache_set("textDocument/inlayHint", inlay_hint.perform)
 
       send_message(Result.new(id: message[:id], response: document.cache_get(message[:method])))
     end
@@ -543,7 +549,7 @@ module RubyLsp
         return
       end
 
-      request = Requests::DocumentHighlight.new(document, params[:position], dispatcher)
+      request = Requests::DocumentHighlight.new(@global_state, document, params[:position], dispatcher)
       dispatcher.dispatch(document.parse_result.value)
       send_message(Result.new(id: message[:id], response: request.perform))
     end
@@ -607,18 +613,35 @@ module RubyLsp
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_inlay_hint(message)
       params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+      range = params.dig(:range, :start, :line)..params.dig(:range, :end, :line)
+
+      cached_response = document.cache_get("textDocument/inlayHint")
+      if cached_response != Document::EMPTY_CACHE
+
+        send_message(
+          Result.new(
+            id: message[:id],
+            response: cached_response.select { |hint| range.cover?(hint.position[:line]) },
+          ),
+        )
+        return
+      end
+
       hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
       dispatcher = Prism::Dispatcher.new
-      document = @store.get(params.dig(:textDocument, :uri))
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
         send_empty_response(message[:id])
         return
       end
 
-      request = Requests::InlayHints.new(document, params[:range], hints_configurations, dispatcher)
+      request = Requests::InlayHints.new(document, hints_configurations, dispatcher)
       dispatcher.visit(document.parse_result.value)
-      send_message(Result.new(id: message[:id], response: request.perform))
+      result = request.perform
+      document.cache_set("textDocument/inlayHint", result)
+
+      send_message(Result.new(id: message[:id], response: result.select { |hint| range.cover?(hint.position[:line]) }))
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -740,6 +763,17 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_completion_item_resolve(message)
+      # When responding to a delegated completion request, it means we're handling a completion item that isn't related
+      # to Ruby (probably related to an ERB host language like HTML). We need to return the original completion item
+      # back to the editor so that it's displayed correctly
+      if message.dig(:params, :data, :delegateCompletion)
+        send_message(Result.new(
+          id: message[:id],
+          response: message[:params],
+        ))
+        return
+      end
+
       send_message(Result.new(
         id: message[:id],
         response: Requests::CompletionResolve.new(@global_state, message[:params]).perform,

data/lib/ruby_lsp/setup_bundler.rb

@@ -27,7 +27,6 @@ module RubyLsp
     def initialize(project_path, **options)
       @project_path = project_path
       @branch = T.let(options[:branch], T.nilable(String))
-      @experimental = T.let(options[:experimental], T.nilable(T::Boolean))
 
       # Regular bundle paths
       @gemfile = T.let(
@@ -56,7 +55,7 @@ module RubyLsp
 
     # Sets up the custom bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
     # used for running the server
-    sig { returns([String, T.nilable(String), T.nilable(String)]) }
+    sig { returns(T::Hash[String, String]) }
     def setup!
       raise BundleNotLocked if @gemfile&.exist? && !@lockfile&.exist?
 
@@ -176,22 +175,18 @@ module RubyLsp
       dependencies
     end
 
-    sig { params(bundle_gemfile: T.nilable(Pathname)).returns([String, T.nilable(String), T.nilable(String)]) }
+    sig { params(bundle_gemfile: T.nilable(Pathname)).returns(T::Hash[String, String]) }
     def run_bundle_install(bundle_gemfile = @gemfile)
+      env = bundler_settings_as_env
+      env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
+
       # If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not
       # relative version of it when running `bundle install`. This is necessary to avoid installing the gems under the
       # `.ruby-lsp` folder, which is not the user's intention. For example, if the path is configured as `vendor`, we
       # want to install it in the top level `vendor` and not `.ruby-lsp/vendor`
-      path = Bundler.settings["path"]
-      expanded_path = File.expand_path(path, @project_path) if path
-
-      # Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
-      env = {}
-      env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
-      env["BUNDLE_PATH"] = expanded_path if expanded_path
-
-      local_config_path = File.join(@project_path, ".bundle")
-      env["BUNDLE_APP_CONFIG"] = local_config_path if Dir.exist?(local_config_path)
+      if env["BUNDLE_PATH"]
+        env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
+      end
 
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
       # to upgrade them or else we'll produce undesired source control changes. If the custom bundle was just created
@@ -211,7 +206,6 @@ module RubyLsp
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
-        command << "--pre" if @experimental
         command.delete_suffix!(" ")
         command << ")"
 
@@ -238,7 +232,31 @@ module RubyLsp
         return setup!
       end
 
-      [bundle_gemfile.to_s, expanded_path, env["BUNDLE_APP_CONFIG"]]
+      env
+    end
+
+    # Gather all Bundler settings (global and local) and return them as a hash that can be used as the environment
+    sig { returns(T::Hash[String, String]) }
+    def bundler_settings_as_env
+      local_config_path = File.join(@project_path, ".bundle")
+
+      # If there's no Gemfile or if the local config path does not exist, we return an empty setting set (which has the
+      # global settings included). Otherwise, we also load the local settings
+      settings = begin
+        Dir.exist?(local_config_path) ? Bundler::Settings.new(local_config_path) : Bundler::Settings.new
+      rescue Bundler::GemfileNotFound
+        Bundler::Settings.new
+      end
+
+      # Map all settings to their environment variable names with `key_for` and their values. For example, the if the
+      # setting name `e` is `path` with a value of `vendor/bundle`, then it will return `"BUNDLE_PATH" =>
+      # "vendor/bundle"`
+      settings.all.to_h do |e|
+        key = Bundler::Settings.key_for(e)
+        value = Array(settings[e]).join(":").tr(" ", ":")
+
+        [key, value]
+      end
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/type_inferrer.rb

@@ -7,13 +7,9 @@ module RubyLsp
   class TypeInferrer
     extend T::Sig
 
-    sig { params(experimental_features: T::Boolean).returns(T::Boolean) }
-    attr_writer :experimental_features
-
-    sig { params(index: RubyIndexer::Index, experimental_features: T::Boolean).void }
-    def initialize(index, experimental_features = true)
+    sig { params(index: RubyIndexer::Index).void }
+    def initialize(index)
       @index = index
-      @experimental_features = experimental_features
     end
 
     sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
@@ -93,8 +89,6 @@ module RubyLsp
 
         Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
       else
-        return unless @experimental_features
-
         raw_receiver = node.receiver&.slice
 
         if raw_receiver
@@ -121,8 +115,12 @@ module RubyLsp
       return Type.new(node_context.fully_qualified_name) if node_context.surrounding_method
 
       # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-      # context
-      Type.new("#{nesting.join("::")}::<Class:#{nesting.last}>")
+      # context.
+      #
+      # If the class/module definition is using compact style (e.g.: `class Foo::Bar`), then we need to split the name
+      # into its individual parts to build the correct singleton name
+      parts = nesting.flat_map { |part| part.split("::") }
+      Type.new("#{parts.join("::")}::<Class:#{parts.last}>")
     end
 
     sig do

data/lib/ruby_lsp/utils.rb

@@ -25,7 +25,17 @@ module RubyLsp
     end,
     String,
   )
-  GUESSED_TYPES_URL = "https://github.com/Shopify/ruby-lsp/blob/main/DESIGN_AND_ROADMAP.md#guessed-types"
+  GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/design-and-roadmap.html#guessed-types"
+
+  # Request delegation for embedded languages is not yet standardized into the language server specification. Here we
+  # use this custom error class as a way to return a signal to the client that the request should be delegated to the
+  # language server for the host language. The support for delegation is custom built on the client side, so each editor
+  # needs to implement their own until this becomes a part of the spec
+  class DelegateRequestError < StandardError
+    # A custom error code that clients can use to handle delegate requests. This is past the range of error codes listed
+    # by the specification to avoid conflicting with other error types
+    CODE = -32900
+  end
 
   # A notification to be sent to the client
   class Message

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.17
+  version: 0.18.3
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-29 00:00:00.000000000 Z
+date: 2024-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -112,7 +112,6 @@ files:
 - lib/ruby_indexer/test/test_case.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
-- lib/ruby_lsp/check_docs.rb
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/erb_document.rb
 - lib/ruby_lsp/global_state.rb
@@ -132,7 +131,6 @@ files:
 - lib/ruby_lsp/node_context.rb
 - lib/ruby_lsp/parameter_scope.rb
 - lib/ruby_lsp/rbs_document.rb
-- lib/ruby_lsp/requests.rb
 - lib/ruby_lsp/requests/code_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
 - lib/ruby_lsp/requests/code_lens.rb
@@ -166,7 +164,6 @@ files:
 - lib/ruby_lsp/requests/support/syntax_tree_formatter.rb
 - lib/ruby_lsp/requests/type_hierarchy_supertypes.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
-- lib/ruby_lsp/response_builders.rb
 - lib/ruby_lsp/response_builders/collection_response_builder.rb
 - lib/ruby_lsp/response_builders/document_symbol.rb
 - lib/ruby_lsp/response_builders/hover.rb
@@ -201,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.18
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby

data/lib/ruby_lsp/check_docs.rb

@@ -1,130 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "ruby_lsp/internal"
-require "objspace"
-
-module RubyLsp
-  # This rake task checks that all requests or addons are fully documented. Add the rake task to your Rakefile and
-  # specify the absolute path for all files that must be required in order to discover all requests and their related
-  # GIFs
-  #
-  #   # Rakefile
-  #   request_files = FileList.new("#{__dir__}/lib/ruby_lsp/requests/*.rb") do |fl|
-  #     fl.exclude(/base_request\.rb/)
-  #   end
-  #   gif_files = FileList.new("#{__dir__}/**/*.gif")
-  #   RubyLsp::CheckDocs.new(request_files, gif_files)
-  #   # Run with bundle exec rake ruby_lsp:check_docs
-  class CheckDocs < Rake::TaskLib
-    extend T::Sig
-
-    sig { params(require_files: Rake::FileList, gif_files: Rake::FileList).void }
-    def initialize(require_files, gif_files)
-      super()
-
-      @name = T.let("ruby_lsp:check_docs", String)
-      @file_list = require_files
-      @gif_list = gif_files
-      define_task
-    end
-
-    private
-
-    sig { void }
-    def define_task
-      desc("Checks if all Ruby LSP requests are documented")
-      task(@name) { run_task }
-    end
-
-    sig { params(request_path: String).returns(T::Boolean) }
-    def gif_exists?(request_path)
-      request_gif = request_path.gsub(".rb", ".gif").split("/").last
-
-      @gif_list.any? { |gif_path| gif_path.end_with?(request_gif) }
-    end
-
-    sig { void }
-    def run_task
-      # Require all files configured to make sure all requests are loaded
-      @file_list.each { |f| require(f.delete_suffix(".rb")) }
-
-      # Find all classes that inherit from BaseRequest, which are the ones we want to make sure are
-      # documented
-      features = ObjectSpace.each_object(Class).select do |k|
-        klass = T.unsafe(k)
-        klass < Requests::Request
-      end
-
-      missing_docs = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
-
-      features.each do |klass|
-        class_name = T.unsafe(klass).name
-        file_path, line_number = Module.const_source_location(class_name)
-        next unless file_path && line_number
-
-        # Adjust the line number to start searching right above the class definition
-        line_number -= 2
-
-        lines = File.readlines(file_path)
-        docs = []
-
-        # Extract the documentation on top of the request constant
-        while (line = lines[line_number]&.strip) && line.start_with?("#")
-          docs.unshift(line)
-          line_number -= 1
-        end
-
-        documentation = docs.join("\n")
-
-        if docs.empty?
-          T.must(missing_docs[class_name]) << "No documentation found"
-        elsif !%r{\(https://microsoft.github.io/language-server-protocol/specification#.*\)}.match?(documentation)
-          T.must(missing_docs[class_name]) << <<~DOCS
-            Missing specification link. Requests and addons should include a link to the LSP specification for the
-            related feature. For example:
-
-            [Inlay hint](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
-          DOCS
-        elsif !documentation.include?("# Example")
-          T.must(missing_docs[class_name]) << <<~DOCS
-            Missing example. Requests and addons should include a code example that explains what the feature does.
-
-            # # Example
-            # ```ruby
-            # class Foo # <- information is shown here
-            # end
-            # ```
-          DOCS
-        elsif !/\[.* demo\]\(.*\.gif\)/.match?(documentation)
-          T.must(missing_docs[class_name]) << <<~DOCS
-            Missing demonstration GIF. Each request and addon must be documented with a GIF that shows the feature
-            working. For example:
-
-            # [Inlay hint demo](../../inlay_hint.gif)
-          DOCS
-        elsif !gif_exists?(file_path)
-          T.must(missing_docs[class_name]) << <<~DOCS
-            The GIF for the request documentation does not exist. Make sure to add it,
-            with the same naming as the request. For example:
-
-            # lib/ruby_lsp/requests/code_lens.rb
-            # foo/bar/code_lens.gif
-          DOCS
-        end
-      end
-
-      if missing_docs.any?
-        $stderr.puts(<<~WARN)
-          The following requests are missing documentation:
-
-          #{missing_docs.map { |k, v| "#{k}\n\n#{v.join("\n")}" }.join("\n\n")}
-        WARN
-
-        abort
-      end
-
-      puts "All requests are documented!"
-    end
-  end
-end

data/lib/ruby_lsp/requests.rb

@@ -1,64 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # Supported features
-  #
-  # - [DocumentSymbol](rdoc-ref:RubyLsp::Requests::DocumentSymbol)
-  # - [DocumentLink](rdoc-ref:RubyLsp::Requests::DocumentLink)
-  # - [Hover](rdoc-ref:RubyLsp::Requests::Hover)
-  # - [FoldingRange](rdoc-ref:RubyLsp::Requests::FoldingRanges)
-  # - [SelectionRange](rdoc-ref:RubyLsp::Requests::SelectionRanges)
-  # - [SemanticHighlighting](rdoc-ref:RubyLsp::Requests::SemanticHighlighting)
-  # - [Formatting](rdoc-ref:RubyLsp::Requests::Formatting)
-  # - [OnTypeFormatting](rdoc-ref:RubyLsp::Requests::OnTypeFormatting)
-  # - [Diagnostic](rdoc-ref:RubyLsp::Requests::Diagnostics)
-  # - [CodeAction](rdoc-ref:RubyLsp::Requests::CodeActions)
-  # - [CodeActionResolve](rdoc-ref:RubyLsp::Requests::CodeActionResolve)
-  # - [DocumentHighlight](rdoc-ref:RubyLsp::Requests::DocumentHighlight)
-  # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
-  # - [Completion](rdoc-ref:RubyLsp::Requests::Completion)
-  # - [CompletionResolve](rdoc-ref:RubyLsp::Requests::CompletionResolve)
-  # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
-  # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
-  # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
-  # - [WorkspaceSymbol](rdoc-ref:RubyLsp::Requests::WorkspaceSymbol)
-  # - [SignatureHelp](rdoc-ref:RubyLsp::Requests::SignatureHelp)
-
-  module Requests
-    autoload :Request, "ruby_lsp/requests/request"
-    autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
-    autoload :DocumentLink, "ruby_lsp/requests/document_link"
-    autoload :Hover, "ruby_lsp/requests/hover"
-    autoload :FoldingRanges, "ruby_lsp/requests/folding_ranges"
-    autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
-    autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
-    autoload :Formatting, "ruby_lsp/requests/formatting"
-    autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
-    autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
-    autoload :CodeActions, "ruby_lsp/requests/code_actions"
-    autoload :CodeActionResolve, "ruby_lsp/requests/code_action_resolve"
-    autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
-    autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
-    autoload :Completion, "ruby_lsp/requests/completion"
-    autoload :CompletionResolve, "ruby_lsp/requests/completion_resolve"
-    autoload :CodeLens, "ruby_lsp/requests/code_lens"
-    autoload :Definition, "ruby_lsp/requests/definition"
-    autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
-    autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
-    autoload :SignatureHelp, "ruby_lsp/requests/signature_help"
-    autoload :PrepareTypeHierarchy, "ruby_lsp/requests/prepare_type_hierarchy"
-    autoload :TypeHierarchySupertypes, "ruby_lsp/requests/type_hierarchy_supertypes"
-
-    # :nodoc:
-    module Support
-      autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
-      autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
-      autoload :Annotation, "ruby_lsp/requests/support/annotation"
-      autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
-      autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
-      autoload :Common, "ruby_lsp/requests/support/common"
-      autoload :Formatter, "ruby_lsp/requests/support/formatter"
-    end
-  end
-end

data/lib/ruby_lsp/response_builders.rb

@@ -1,13 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module ResponseBuilders
-    autoload :CollectionResponseBuilder, "ruby_lsp/response_builders/collection_response_builder"
-    autoload :DocumentSymbol, "ruby_lsp/response_builders/document_symbol"
-    autoload :Hover, "ruby_lsp/response_builders/hover"
-    autoload :ResponseBuilder, "ruby_lsp/response_builders/response_builder"
-    autoload :SemanticHighlighting, "ruby_lsp/response_builders/semantic_highlighting"
-    autoload :SignatureHelp, "ruby_lsp/response_builders/signature_help"
-  end
-end