ruby-lsp 0.18.4 → 0.19.1

data/lib/ruby_lsp/addon.rb

@@ -32,6 +32,8 @@ module RubyLsp
 
     AddonNotFoundError = Class.new(StandardError)
 
+    class IncompatibleApiError < StandardError; end
+
     class << self
       extend T::Sig
 
@@ -53,13 +55,28 @@ module RubyLsp
 
       # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
       sig do
-        params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[StandardError])
+        params(
+          global_state: GlobalState,
+          outgoing_queue: Thread::Queue,
+          include_project_addons: T::Boolean,
+        ).returns(T::Array[StandardError])
       end
-      def load_addons(global_state, outgoing_queue)
+      def load_addons(global_state, outgoing_queue, include_project_addons: true)
         # Require all add-ons entry points, which should be placed under
-        # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
-        errors = Gem.find_files("ruby_lsp/**/addon.rb").filter_map do |addon|
-          require File.expand_path(addon)
+        # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb` or in the workspace under
+        # `your_project/ruby_lsp/project_name/addon.rb`
+        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")))
+        end
+
+        errors = addon_files.filter_map do |addon_path|
+          # Avoid requiring this file twice. This may happen if you're working on the Ruby LSP itself and at the same
+          # time have `ruby-lsp` installed as a vendored gem
+          next if File.basename(File.dirname(addon_path)) == "ruby_lsp"
+
+          require File.expand_path(addon_path)
           nil
         rescue => e
           e
@@ -80,13 +97,53 @@ module RubyLsp
         errors
       end
 
-      sig { params(addon_name: String).returns(Addon) }
-      def get(addon_name)
+      # Get a reference to another add-on object by name and version. If an add-on exports an API that can be used by
+      # other add-ons, this is the way to get access to that API.
+      #
+      # Important: if the add-on is not found, AddonNotFoundError will be raised. If the add-on is found, but its
+      # current version does not satisfy the given version constraint, then IncompatibleApiError will be raised. It is
+      # the responsibility of the add-ons using this API to handle these errors appropriately.
+      sig { params(addon_name: String, version_constraints: String).returns(Addon) }
+      def get(addon_name, *version_constraints)
+        if version_constraints.empty?
+          raise IncompatibleApiError, "Must specify version constraints when accessing other add-ons"
+        end
+
         addon = addons.find { |addon| addon.name == addon_name }
         raise AddonNotFoundError, "Could not find add-on '#{addon_name}'" unless addon
 
+        version_object = Gem::Version.new(addon.version)
+
+        unless version_constraints.all? { |constraint| Gem::Requirement.new(constraint).satisfied_by?(version_object) }
+          raise IncompatibleApiError,
+            "Constraints #{version_constraints.inspect} is incompatible with #{addon_name} version #{addon.version}"
+        end
+
         addon
       end
+
+      # Depend on a specific version of the Ruby LSP. This method should only be used if the add-on is distributed in a
+      # gem that does not have a runtime dependency on the ruby-lsp gem. This method should be invoked at the top of the
+      # `addon.rb` file before defining any classes or requiring any files. For example:
+      #
+      # ```ruby
+      # RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.18.0")
+      #
+      # module MyGem
+      #   class MyAddon < RubyLsp::Addon
+      #     # ...
+      #   end
+      # end
+      # ```
+      sig { params(version_constraints: String).void }
+      def depend_on_ruby_lsp!(*version_constraints)
+        version_object = Gem::Version.new(RubyLsp::VERSION)
+
+        unless version_constraints.all? { |constraint| Gem::Requirement.new(constraint).satisfied_by?(version_object) }
+          raise IncompatibleApiError,
+            "Add-on is not compatible with this version of the Ruby LSP. Skipping its activation"
+        end
+      end
     end
 
     sig { void }
@@ -132,6 +189,11 @@ module RubyLsp
     sig { abstract.returns(String) }
     def name; 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
+
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
     sig do
       overridable.params(

data/lib/ruby_lsp/erb_document.rb

@@ -27,8 +27,9 @@ module RubyLsp
       scanner = ERBScanner.new(@source)
       scanner.scan
       @host_language_source = scanner.host_language
-      # assigning empty scopes to turn Prism into eval mode
-      @parse_result = Prism.parse(scanner.ruby, scopes: [[]])
+      # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
+      # which they will be evaluated
+      @parse_result = Prism.parse(scanner.ruby, partial_script: true)
       true
     end
 
@@ -49,7 +50,12 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
-      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+      RubyDocument.locate(
+        @parse_result.value,
+        create_scanner.find_char_position(position),
+        node_types: node_types,
+        encoding: @encoding,
+      )
     end
 
     sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }

data/lib/ruby_lsp/global_state.rb

@@ -23,6 +23,9 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_reader :supports_watching_files, :experimental_features, :supports_request_delegation
 
+    sig { returns(T::Array[String]) }
+    attr_reader :supported_resource_operations
+
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
 
@@ -42,6 +45,7 @@ module RubyLsp
       @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @addon_settings = T.let({}, T::Hash[String, T.untyped])
       @supports_request_delegation = T.let(false, T::Boolean)
+      @supported_resource_operations = T.let([], T::Array[String])
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -117,6 +121,7 @@ module RubyLsp
       else
         Encoding::UTF_32
       end
+      @index.configuration.encoding = @encoding
 
       file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
       if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
@@ -132,6 +137,9 @@ module RubyLsp
       end
 
       @supports_request_delegation = options.dig(:capabilities, :experimental, :requestDelegation) || false
+      supported_resource_operations = options.dig(:capabilities, :workspace, :workspaceEdit, :resourceOperations)
+      @supported_resource_operations = supported_resource_operations if supported_resource_operations
+
       notifications
     end
 

data/lib/ruby_lsp/internal.rb

@@ -26,6 +26,7 @@ require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
+require "ruby_lsp/static_docs"
 require "ruby_lsp/scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
@@ -74,6 +75,9 @@ require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"
 require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/range_formatting"
+require "ruby_lsp/requests/references"
+require "ruby_lsp/requests/rename"
 require "ruby_lsp/requests/selection_ranges"
 require "ruby_lsp/requests/semantic_highlighting"
 require "ruby_lsp/requests/show_syntax_tree"

data/lib/ruby_lsp/listeners/completion.rb

@@ -438,7 +438,7 @@ module RubyLsp
             text_edit: Interface::TextEdit.new(range: range, new_text: keyword),
             kind: Constant::CompletionItemKind::KEYWORD,
             data: {
-              skip_resolve: true,
+              keyword: true,
             },
           )
         end

data/lib/ruby_lsp/listeners/hover.rb

@@ -24,6 +24,7 @@ module RubyLsp
           Prism::InterpolatedStringNode,
           Prism::SuperNode,
           Prism::ForwardingSuperNode,
+          Prism::YieldNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -71,6 +72,7 @@ module RubyLsp
           :on_forwarding_super_node_enter,
           :on_string_node_enter,
           :on_interpolated_string_node_enter,
+          :on_yield_node_enter,
         )
       end
 
@@ -166,6 +168,11 @@ module RubyLsp
         handle_super_node_hover
       end
 
+      sig { params(node: Prism::YieldNode).void }
+      def on_yield_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       private
 
       sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
@@ -193,6 +200,18 @@ module RubyLsp
         end
       end
 
+      sig { params(keyword: String).void }
+      def handle_keyword_documentation(keyword)
+        content = KEYWORD_DOCS[keyword]
+        return unless content
+
+        doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+
+        @response_builder.push("```ruby\n#{keyword}\n```", category: :title)
+        @response_builder.push("[Read more](#{doc_path})", category: :links)
+        @response_builder.push(content, category: :documentation)
+      end
+
       sig { void }
       def handle_super_node_hover
         # Sorbet can handle super hover on typed true or higher

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -23,10 +23,11 @@ module RubyLsp
         end
       end
 
-      sig { params(document: RubyDocument, code_action: T::Hash[Symbol, T.untyped]).void }
-      def initialize(document, code_action)
+      sig { params(document: RubyDocument, global_state: GlobalState, code_action: T::Hash[Symbol, T.untyped]).void }
+      def initialize(document, global_state, code_action)
         super()
         @document = document
+        @global_state = global_state
         @code_action = code_action
       end
 
@@ -191,7 +192,12 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
-        node_context = RubyDocument.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          start_index,
+          node_types: [Prism::DefNode],
+          encoding: @global_state.encoding,
+        )
         closest_node = node_context.node
         return Error::InvalidTargetRange unless closest_node
 

data/lib/ruby_lsp/requests/completion.rb

@@ -57,6 +57,7 @@ module RubyLsp
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
           ],
+          encoding: global_state.encoding,
         )
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,

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/definition.rb

@@ -57,6 +57,7 @@ module RubyLsp
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
           ],
+          encoding: global_state.encoding,
         )
 
         target = node_context.node

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -28,7 +28,7 @@ module RubyLsp
         char_position = document.create_scanner.find_char_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
-        node_context = RubyDocument.locate(document.parse_result.value, char_position)
+        node_context = RubyDocument.locate(document.parse_result.value, char_position, encoding: global_state.encoding)
 
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,

data/lib/ruby_lsp/requests/hover.rb

@@ -41,6 +41,7 @@ module RubyLsp
           document.parse_result.value,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
+          encoding: global_state.encoding,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/range_formatting.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The [range formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_rangeFormatting)
+    # is used to format a selection or to format on paste.
+    class RangeFormatting < Request
+      extend T::Sig
+
+      sig { params(global_state: GlobalState, document: RubyDocument, params: T::Hash[Symbol, T.untyped]).void }
+      def initialize(global_state, document, params)
+        super()
+        @document = document
+        @uri = T.let(document.uri, URI::Generic)
+        @params = params
+        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
+      end
+
+      sig { override.returns(T.nilable(T::Array[Interface::TextEdit])) }
+      def perform
+        return unless @active_formatter
+        return if @document.syntax_error?
+
+        target = @document.locate_first_within_range(@params[:range])
+        return unless target
+
+        location = target.location
+
+        formatted_text = @active_formatter.run_range_formatting(
+          @uri,
+          target.slice,
+          location.start_column / 2,
+        )
+        return unless formatted_text
+
+        [
+          Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
+                line: location.start_line - 1,
+                character: location.start_code_units_column(@document.encoding),
+              ),
+              end: Interface::Position.new(
+                line: location.end_line - 1,
+                character: location.end_code_units_column(@document.encoding),
+              ),
+            ),
+            new_text: formatted_text.strip,
+          ),
+        ]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/references.rb

@@ -0,0 +1,146 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [references](https://microsoft.github.io/language-server-protocol/specification#textDocument_references)
+    # request finds all references for the selected symbol.
+    class References < Request
+      extend T::Sig
+      include Support::Common
+
+      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
+        @params = params
+        @locations = T.let([], T::Array[Interface::Location])
+      end
+
+      sig { override.returns(T::Array[Interface::Location]) }
+      def perform
+        position = @params[:position]
+        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,
+            Prism::CallNode,
+            Prism::DefNode,
+          ],
+          encoding: @global_state.encoding,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return @locations 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,
+            Prism::CallNode,
+            Prism::DefNode,
+          ),
+        )
+
+        reference_target = create_reference_target(target, node_context)
+        return @locations unless reference_target
+
+        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)
+          collect_references(reference_target, parse_result, uri)
+        end
+
+        @store.each do |_uri, document|
+          collect_references(reference_target, document.parse_result, document.uri)
+        end
+
+        @locations
+      end
+
+      private
+
+      sig do
+        params(
+          target_node: T.any(
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ),
+          node_context: NodeContext,
+        ).returns(T.nilable(RubyIndexer::ReferenceFinder::Target))
+      end
+      def create_reference_target(target_node, node_context)
+        case target_node
+        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+          name = constant_name(target_node)
+          return unless name
+
+          entries = @global_state.index.resolve(name, node_context.nesting)
+          return unless entries
+
+          fully_qualified_name = T.must(entries.first).name
+          RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        when Prism::CallNode, Prism::DefNode
+          RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
+        end
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          parse_result: Prism::ParseResult,
+          uri: URI::Generic,
+        ).void
+      end
+      def collect_references(target, parse_result, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(
+          target,
+          @global_state.index,
+          dispatcher,
+          include_declarations: @params.dig(:context, :includeDeclaration) || true,
+        )
+        dispatcher.visit(parse_result.value)
+
+        finder.references.each do |reference|
+          @locations << Interface::Location.new(
+            uri: uri.to_s,
+            range: range_from_location(reference.location),
+          )
+        end
+      end
+    end
+  end
+end