ruby-lsp 0.18.4 → 0.19.0

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -40,6 +40,8 @@ module RubyLsp
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
         label = @item[:label].dup
+        return keyword_resolve(@item) if @item.dig(:data, :keyword)
+
         entries = @index[label] || []
 
         owner_name = @item.dig(:data, :owner_name)
@@ -72,6 +74,33 @@ module RubyLsp
 
         @item
       end
+
+      private
+
+      sig { params(item: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def keyword_resolve(item)
+        keyword = item[:label]
+        content = KEYWORD_DOCS[keyword]
+
+        if content
+          doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+
+          @item[:documentation] = Interface::MarkupContent.new(
+            kind: "markdown",
+            value: <<~MARKDOWN.chomp,
+              ```ruby
+              #{keyword}
+              ```
+
+              [Read more](#{doc_path})
+
+              #{content}
+            MARKDOWN
+          )
+        end
+
+        item
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/rename.rb

@@ -0,0 +1,189 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_rename)
+    # request renames all instances of a symbol in a document.
+    class Rename < Request
+      extend T::Sig
+      include Support::Common
+
+      class InvalidNameError < StandardError; end
+
+      sig do
+        params(
+          global_state: GlobalState,
+          store: Store,
+          document: T.any(RubyDocument, ERBDocument),
+          params: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(global_state, store, document, params)
+        super()
+        @global_state = global_state
+        @store = store
+        @document = document
+        @position = T.let(params[:position], T::Hash[Symbol, Integer])
+        @new_name = T.let(params[:newName], String)
+      end
+
+      sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
+      def perform
+        char_position = @document.create_scanner.find_char_position(@position)
+
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          char_position,
+          node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return if !target || target.is_a?(Prism::ProgramNode)
+
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            @position,
+          )
+        end
+
+        target = T.cast(
+          target,
+          T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
+        )
+
+        name = constant_name(target)
+        return unless name
+
+        entries = @global_state.index.resolve(name, node_context.nesting)
+        return unless entries
+
+        if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
+          raise InvalidNameError, "The new name is already in use by #{T.must(conflict_entries.first).name}"
+        end
+
+        fully_qualified_name = T.must(entries.first).name
+        changes = collect_text_edits(fully_qualified_name, name)
+
+        # 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")
+          return Interface::WorkspaceEdit.new(changes: changes)
+        end
+
+        # Text edits must be applied before any resource operations, such as renaming files. Otherwise, the file is
+        # renamed and then the URI associated to the text edit no longer exists, causing it to be dropped
+        document_changes = changes.map do |uri, edits|
+          Interface::TextDocumentEdit.new(
+            text_document: Interface::VersionedTextDocumentIdentifier.new(uri: uri, version: nil),
+            edits: edits,
+          )
+        end
+
+        collect_file_renames(fully_qualified_name, document_changes)
+        Interface::WorkspaceEdit.new(document_changes: document_changes)
+      end
+
+      private
+
+      sig do
+        params(
+          fully_qualified_name: String,
+          document_changes: T::Array[T.any(Interface::RenameFile, Interface::TextDocumentEdit)],
+        ).void
+      end
+      def collect_file_renames(fully_qualified_name, document_changes)
+        # Check if the declarations of the symbol being renamed match the file name. In case they do, we automatically
+        # rename the files for the user.
+        #
+        # We also look for an associated test file and rename it too
+        short_name = T.must(fully_qualified_name.split("::").last)
+
+        T.must(@global_state.index[fully_qualified_name]).each do |entry|
+          # Do not rename files that are not part of the workspace
+          next unless entry.file_path.start_with?(@global_state.workspace_path)
+
+          case entry
+          when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,
+               RubyIndexer::Entry::ConstantAlias, RubyIndexer::Entry::UnresolvedConstantAlias
+
+            file_name = file_from_constant_name(short_name)
+
+            if "#{file_name}.rb" == entry.file_name
+              new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
+
+              old_uri = URI::Generic.from_path(path: entry.file_path).to_s
+              new_uri = URI::Generic.from_path(path: File.join(
+                File.dirname(entry.file_path),
+                "#{new_file_name}.rb",
+              )).to_s
+
+              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: old_uri, new_uri: new_uri)
+            end
+          end
+        end
+      end
+
+      sig { params(fully_qualified_name: String, name: String).returns(T::Hash[String, T::Array[Interface::TextEdit]]) }
+      def collect_text_edits(fully_qualified_name, name)
+        changes = {}
+
+        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
+          uri = URI::Generic.from_path(path: path)
+          # If the document is being managed by the client, then we should use whatever is present in the store instead
+          # of reading from disk
+          next if @store.key?(uri)
+
+          parse_result = Prism.parse_file(path)
+          edits = collect_changes(fully_qualified_name, parse_result, name, uri)
+          changes[uri.to_s] = edits unless edits.empty?
+        end
+
+        @store.each do |uri, document|
+          edits = collect_changes(fully_qualified_name, document.parse_result, name, document.uri)
+          changes[uri] = edits unless edits.empty?
+        end
+
+        changes
+      end
+
+      sig do
+        params(
+          fully_qualified_name: String,
+          parse_result: Prism::ParseResult,
+          name: String,
+          uri: URI::Generic,
+        ).returns(T::Array[Interface::TextEdit])
+      end
+      def collect_changes(fully_qualified_name, parse_result, name, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(fully_qualified_name, @global_state.index, dispatcher)
+        dispatcher.visit(parse_result.value)
+
+        finder.references.uniq(&:location).map do |reference|
+          adjust_reference_for_edit(name, reference)
+        end
+      end
+
+      sig { params(name: String, reference: RubyIndexer::ReferenceFinder::Reference).returns(Interface::TextEdit) }
+      def adjust_reference_for_edit(name, reference)
+        # The reference may include a namespace in front. We need to check if the rename new name includes namespaces
+        # and then adjust both the text and the location to produce the correct edit
+        location = reference.location
+        new_text = reference.name.sub(name, @new_name)
+
+        Interface::TextEdit.new(range: range_from_location(location), new_text: new_text)
+      end
+
+      sig { params(constant_name: String).returns(String) }
+      def file_from_constant_name(constant_name)
+        constant_name
+          .gsub(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/, '\1\3_\2\4')
+          .downcase
+      end
+    end
+  end
+end

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

@@ -19,6 +19,13 @@ module URI
       T::Array[Symbol],
     )
 
+    # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
+    # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
+    # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
+    # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
+    # have the uri gem in their own bundle and thus not use a compatible version.
+    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+
     T.unsafe(self).alias_method(:gem_name, :host)
     T.unsafe(self).alias_method(:line_number, :fragment)
 
@@ -41,7 +48,7 @@ module URI
           {
             scheme: "source",
             host: gem_name,
-            path: DEFAULT_PARSER.escape("/#{gem_version}/#{path}"),
+            path: PARSER.escape("/#{gem_version}/#{path}"),
             fragment: line_number,
           }
         )

data/lib/ruby_lsp/server.rb

@@ -67,6 +67,8 @@ module RubyLsp
         text_document_definition(message)
       when "textDocument/prepareTypeHierarchy"
         text_document_prepare_type_hierarchy(message)
+      when "textDocument/rename"
+        text_document_rename(message)
       when "typeHierarchy/supertypes"
         type_hierarchy_supertypes(message)
       when "typeHierarchy/subtypes"
@@ -123,9 +125,9 @@ module RubyLsp
       send_log_message("Error processing #{message[:method]}: #{e.full_message}", type: Constant::MessageType::ERROR)
     end
 
-    sig { void }
-    def load_addons
-      errors = Addon.load_addons(@global_state, @outgoing_queue)
+    sig { params(include_project_addons: T::Boolean).void }
+    def load_addons(include_project_addons: true)
+      errors = Addon.load_addons(@global_state, @outgoing_queue, include_project_addons: include_project_addons)
 
       if errors.any?
         send_log_message(
@@ -227,6 +229,7 @@ module RubyLsp
           workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.has_type_checker,
           signature_help_provider: signature_help_provider,
           type_hierarchy_provider: type_hierarchy_provider,
+          rename_provider: !@global_state.has_type_checker,
           experimental: {
             addon_detection: true,
           },
@@ -320,14 +323,18 @@ module RubyLsp
           language_id: language_id,
         )
 
-        if document.past_expensive_limit?
+        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/showMessage",
-              params: Interface::ShowMessageParams.new(
+              method: "window/logMessage",
+              params: Interface::LogMessageParams.new(
                 type: Constant::MessageType::WARNING,
-                message: "This file is too long. For performance reasons, semantic highlighting and " \
-                  "diagnostics will be disabled",
+                message: log_message,
               ),
             ),
           )
@@ -609,6 +616,26 @@ module RubyLsp
       )
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_rename(message)
+      params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: Requests::Rename.new(@global_state, @store, document, params).perform,
+        ),
+      )
+    rescue Requests::Rename::InvalidNameError => e
+      send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
+    end
+
     sig { params(document: Document[T.untyped]).returns(RubyDocument::SorbetLevel) }
     def sorbet_level(document)
       return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker

data/lib/ruby_lsp/static_docs.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # The path to the `static_docs` directory, where we keep long-form static documentation
+  STATIC_DOCS_PATH = T.let(File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs"), String)
+
+  # A map of keyword => short documentation to be displayed on hover or completion
+  KEYWORD_DOCS = T.let(
+    {
+      "yield" => "Invokes the passed block with the given arguments",
+    }.freeze,
+    T::Hash[String, String],
+  )
+end

data/lib/ruby_lsp/store.rb

@@ -99,6 +99,18 @@ module RubyLsp
       @state.delete(uri.to_s)
     end
 
+    sig { params(uri: URI::Generic).returns(T::Boolean) }
+    def key?(uri)
+      @state.key?(uri.to_s)
+    end
+
+    sig { params(block: T.proc.params(uri: String, document: Document[T.untyped]).void).void }
+    def each(&block)
+      @state.each do |uri, document|
+        block.call(uri, document)
+      end
+    end
+
     sig do
       type_parameters(:T)
         .params(

data/lib/ruby_lsp/test_helper.rb

@@ -42,7 +42,7 @@ module RubyLsp
         RubyIndexer::IndexablePath.new(nil, T.must(uri.to_standardized_path)),
         source,
       )
-      server.load_addons if load_addons
+      server.load_addons(include_project_addons: false) if load_addons
       block.call(server, uri)
     ensure
       if load_addons

data/lib/ruby_lsp/type_inferrer.rb

@@ -89,7 +89,12 @@ module RubyLsp
 
         Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
       else
-        raw_receiver = node.receiver&.slice
+
+        raw_receiver = if receiver.is_a?(Prism::CallNode)
+          receiver.message
+        else
+          receiver&.slice
+        end
 
         if raw_receiver
           guessed_name = raw_receiver

data/static_docs/yield.md

@@ -0,0 +1,81 @@
+# Yield
+
+In Ruby, every method implicitly accepts a block, even when not included in the parameters list.
+
+```ruby
+def foo
+end
+
+foo { 123 } # works!
+```
+
+The `yield` keyword is used to invoke the block that was passed with arguments.
+
+```ruby
+# Consider this method call. The block being passed to the method `foo` accepts an argument called `a`.
+# It then takes whatever argument was passed and multiplies it by 2
+foo do |a|
+  a * 2
+end
+
+# In the `foo` method declaration, we can use `yield` to invoke the block that was passed and provide the block
+# with the value for the `a` argument
+def foo
+  # Invoke the block passed to `foo` with the number 10 as the argument `a`
+  result = yield(10)
+  puts result # Will print 20
+end
+```
+
+If `yield` is used to invoke the block, but no block was passed, that will result in a local jump error.
+
+```ruby
+# If we invoke `foo` without a block, trying to `yield` will fail
+foo
+
+# `foo': no block given (yield) (LocalJumpError)
+```
+
+We can decide to use `yield` conditionally by using Ruby's `block_given?` method, which will return `true` if a block
+was passed to the method.
+
+```ruby
+def foo
+  # If a block is passed when invoking `foo`, call the block with argument 10 and print the result.
+  # Otherwise, just print that no block was passed
+  if block_given?
+    result = yield(10)
+    puts result
+  else
+    puts "No block passed!"
+  end
+end
+
+foo do |a|
+  a * 2
+end
+# => 20
+
+foo
+# => No block passed!
+```
+
+## Block parameter
+
+In addition to implicit blocks, Ruby also allows developers to use explicit block parameters as part of the method's
+signature. In this scenario, we can use the reference to the block directly instead of relying on the `yield` keyword.
+
+```ruby
+# Block parameters are prefixed with & and a name
+def foo(&my_block_param)
+  # If a block was passed to `foo`, `my_block_param` will be a `Proc` object. Otherwise, it will be `nil`. We can use
+  # that to check for its presence
+  if my_block_param
+    # Explicit block parameters are invoked using the method `call`, which is present in all `Proc` objects
+    result = my_block_param.call(10)
+    puts result
+  else
+    puts "No block passed!"
+  end
+end
+```

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.18.4
+  version: 0.19.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-30 00:00:00.000000000 Z
+date: 2024-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -28,16 +28,22 @@ dependencies:
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -99,6 +105,7 @@ files:
 - lib/ruby_indexer/lib/ruby_indexer/location.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
 - lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
+- lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb
 - lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
@@ -109,6 +116,7 @@ files:
 - lib/ruby_indexer/test/method_test.rb
 - lib/ruby_indexer/test/prefix_tree_test.rb
 - lib/ruby_indexer/test/rbs_indexer_test.rb
+- lib/ruby_indexer/test/reference_finder_test.rb
 - lib/ruby_indexer/test/test_case.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
@@ -146,6 +154,7 @@ files:
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
 - lib/ruby_lsp/requests/prepare_type_hierarchy.rb
+- lib/ruby_lsp/requests/rename.rb
 - lib/ruby_lsp/requests/request.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
@@ -173,10 +182,12 @@ files:
 - lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
+- lib/ruby_lsp/static_docs.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
 - lib/ruby_lsp/type_inferrer.rb
 - lib/ruby_lsp/utils.rb
+- static_docs/yield.md
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:
 - MIT
@@ -198,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby