ruby-lsp 0.13.2 → 0.13.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2329129b74c75a0bb4113d1f1489463f666b74ef495d0ac65bad675fbd83d1d3
-  data.tar.gz: 2f31f495b9ca0b1a9f909758dabce816411d0b64a006577c93c7a80a253791e5
+  metadata.gz: 675bc1c9ddbcb8c05d591e184e2cf77914a6fcfa4af5db6178864063a910e0bd
+  data.tar.gz: 3f14554ce578fe5457ad90f2500b5267fded390e17b58142a2a174928630c53c
 SHA512:
-  metadata.gz: 9c3ab34cb3e7877105ca21df3f521589d9838bd15e77a3d17cc4df91ca1f93221ef845e514a902a03a63a1f82ad6b5cf90fa4f9a93037fbfb57af5f7a48b0ebe
-  data.tar.gz: d4867c86eb238abf039f40592d7ff48acd85749fcf9349ab72fdea218ff5201156fc0d511987ed768b1fb2dcc9fd55a76bfac611f3fc565b7b2ba8c8d1054a72
+  metadata.gz: 55fabbd6b161a499b378eead24ba073a7729d7772d702585b995efc3667c761a39544bb09c289c0ef16fa3300b907a7573173bbe7966b6656cddf912c60b7fd7
+  data.tar.gz: 85c9e57ae099be6fc957cf6a0ad63e07b6eb5e207770b3ea5cbd0cd328383ca9f76314c16f03f1a2707ce78991a6ce20dc382fb17ce4ed8ce1e7e4fdd6c5d5bb

data/README.md

@@ -46,6 +46,36 @@ See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth de
 For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
 documentation](SEMANTIC_HIGHLIGHTING.md).
 
+### Configuring code indexing
+
+By default, the Ruby LSP indexes all Ruby files defined in the current project and all of its dependencies, including
+default gems, except for
+
+- Gems that only appear under the `:development` group
+- All Ruby files under `test/**/*.rb`
+
+By creating a `.index.yml` file, these configurations can be overridden and tuned.
+
+```yaml
+# Exclude files based on a given pattern. Often used to exclude test files or fixtures
+excluded_patterns:
+  - "**/spec/**/*.rb"
+
+# Include files based on a given pattern. Can be used to index Ruby files that use different extensions
+included_patterns:
+  - "**/bin/*"
+
+# Exclude gems by name. If a gem is never referenced in the project's code and is only used as a tool, excluding it will
+# speed up indexing and reduce the amount of results in features like definition or completion
+excluded_gems:
+  - rubocop
+  - pathname
+
+# Include gems by name. Normally used to include development gems that are excluded by default
+included_gems:
+  - prism
+```
+
 ### Addons
 
 The Ruby LSP provides an addon system that allows other gems to enhance the base functionality with more editor

data/VERSION

@@ -1 +1 @@
-0.13.2
+0.13.4

data/lib/ruby_lsp/check_docs.rb

@@ -51,15 +51,15 @@ module RubyLsp
 
       # Find all classes that inherit from BaseRequest or Listener, which are the ones we want to make sure are
       # documented
-      features = ObjectSpace.each_object(Class).filter_map do |k|
+      features = ObjectSpace.each_object(Class).select do |k|
         klass = T.unsafe(k)
-        klass if klass < Requests::BaseRequest || (klass < Listener && klass != ExtensibleListener)
+        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.must(klass.name)
+        class_name = T.unsafe(klass).name
         file_path, line_number = Module.const_source_location(class_name)
         next unless file_path && line_number
 

data/lib/ruby_lsp/document.rb

@@ -173,6 +173,18 @@ module RubyLsp
       [closest, parent, nesting.map { |n| n.constant_path.location.slice }]
     end
 
+    sig { returns(T::Boolean) }
+    def sorbet_sigil_is_true_or_higher
+      parse_result.magic_comments.any? do |comment|
+        comment.key == "typed" && ["true", "strict", "strong"].include?(comment.value)
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def typechecker_enabled?
+      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
+    end
+
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/executor.rb

@@ -94,7 +94,7 @@ module RubyLsp
         cached_response = document.cache_get(request[:method])
         return cached_response if cached_response
 
-        # Run listeners for the document
+        # Run requests for the document
         dispatcher = Prism::Dispatcher.new
         folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
         document_symbol = Requests::DocumentSymbol.new(dispatcher)
@@ -107,13 +107,13 @@ module RubyLsp
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
         # we actually received
-        document.cache_set("textDocument/foldingRange", folding_range.response)
-        document.cache_set("textDocument/documentSymbol", document_symbol.response)
-        document.cache_set("textDocument/documentLink", document_link.response)
-        document.cache_set("textDocument/codeLens", code_lens.response)
+        document.cache_set("textDocument/foldingRange", folding_range.perform)
+        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/semanticTokens/full",
-          Requests::Support::SemanticTokenEncoder.new.encode(semantic_highlighting.response),
+          Requests::Support::SemanticTokenEncoder.new.encode(semantic_highlighting.perform),
         )
         document.cache_get(request[:method])
       when "textDocument/semanticTokens/range"
@@ -143,13 +143,30 @@ module RubyLsp
           nil
         end
       when "textDocument/documentHighlight"
-        document_highlight(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        request = Requests::DocumentHighlight.new(document, request.dig(:params, :position), dispatcher)
+        dispatcher.dispatch(document.tree)
+        request.perform
       when "textDocument/onTypeFormatting"
         on_type_formatting(uri, request.dig(:params, :position), request.dig(:params, :ch))
       when "textDocument/hover"
-        hover(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        Requests::Hover.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          dispatcher,
+          document.typechecker_enabled?,
+        ).perform
       when "textDocument/inlayHint"
-        inlay_hint(uri, request.dig(:params, :range))
+        hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        request = Requests::InlayHints.new(document, request.dig(:params, :range), hints_configurations, dispatcher)
+        dispatcher.visit(document.tree)
+        request.perform
       when "textDocument/codeAction"
         code_action(uri, request.dig(:params, :range), request.dig(:params, :context))
       when "codeAction/resolve"
@@ -169,11 +186,36 @@ module RubyLsp
           nil
         end
       when "textDocument/completion"
-        completion(uri, request.dig(:params, :position))
-      when "textDocument/definition"
-        definition(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        Requests::Completion.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          document.typechecker_enabled?,
+          dispatcher,
+        ).perform
       when "textDocument/signatureHelp"
-        signature_help(uri, request.dig(:params, :position), request.dig(:params, :context))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+
+        Requests::SignatureHelp.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          request.dig(:params, :context),
+          dispatcher,
+        ).perform
+      when "textDocument/definition"
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        Requests::Definition.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          dispatcher,
+          document.typechecker_enabled?,
+        ).perform
       when "workspace/didChangeWatchedFiles"
         did_change_watched_files(request.dig(:params, :changes))
       when "workspace/symbol"
@@ -243,96 +285,14 @@ module RubyLsp
       end
     end
 
-    sig do
-      params(
-        uri: URI::Generic,
-        position: T::Hash[Symbol, T.untyped],
-        context: T::Hash[Symbol, T.untyped],
-      ).returns(T.any(T.nilable(Interface::SignatureHelp), T::Hash[Symbol, T.untyped]))
-    end
-    def signature_help(uri, position, context)
-      current_signature = context[:activeSignatureHelp]
-      document = @store.get(uri)
-      target, parent, nesting = document.locate_node(
-        { line: position[:line], character: position[:character] - 2 },
-        node_types: [Prism::CallNode],
-      )
-
-      # If we're typing a nested method call (e.g.: `foo(bar)`), then we may end up locating `bar` as the target method
-      # call incorrectly. To correct that, we check if there's an active signature with the same name as the parent node
-      # and then replace the target
-      if current_signature && parent.is_a?(Prism::CallNode)
-        active_signature = current_signature[:activeSignature] || 0
-
-        if current_signature.dig(:signatures, active_signature, :label)&.start_with?(parent.message)
-          target = parent
-        end
-      end
-
-      dispatcher = Prism::Dispatcher.new
-      listener = Requests::SignatureHelp.new(context, nesting, @index, dispatcher)
-      dispatcher.dispatch_once(target)
-      listener.response
-    end
-
     sig { params(query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
     def workspace_symbol(query)
-      Requests::WorkspaceSymbol.new(query, @index).run
+      Requests::WorkspaceSymbol.new(query, @index).perform
     end
 
     sig { params(uri: URI::Generic, range: T.nilable(T::Hash[Symbol, T.untyped])).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
-      { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: T::Hash[Symbol, T.untyped],
-      ).returns(T.nilable(T.any(T::Array[Interface::Location], Interface::Location)))
-    end
-    def definition(uri, position)
-      document = @store.get(uri)
-      target, parent, nesting = document.locate_node(
-        position,
-        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
-      )
-
-      target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
-
-      dispatcher = Prism::Dispatcher.new
-      base_listener = Requests::Definition.new(uri, nesting, @index, dispatcher)
-      dispatcher.dispatch_once(target)
-      base_listener.response
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: T::Hash[Symbol, T.untyped],
-      ).returns(T.nilable(Interface::Hover))
-    end
-    def hover(uri, position)
-      document = @store.get(uri)
-      target, parent, nesting = document.locate_node(
-        position,
-        node_types: Requests::Hover::ALLOWED_TARGETS,
-      )
-
-      if (Requests::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-          !Requests::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
-        target = parent
-      end
-
-      # Instantiate all listeners
-      dispatcher = Prism::Dispatcher.new
-      hover = Requests::Hover.new(@index, nesting, dispatcher)
-
-      # Emit events for all listeners
-      dispatcher.dispatch_once(target)
-
-      hover.response
+      { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).perform }
     end
 
     sig do
@@ -363,7 +323,7 @@ module RubyLsp
     end
     def selection_range(uri, positions)
       ranges = @store.cache_fetch(uri, "textDocument/selectionRange") do |document|
-        Requests::SelectionRanges.new(document).run
+        Requests::SelectionRanges.new(document).perform
       end
 
       # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
@@ -390,7 +350,7 @@ module RubyLsp
       path = uri.to_standardized_path
       return unless path.nil? || path.start_with?(T.must(@store.workspace_uri.to_standardized_path))
 
-      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
+      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).perform
     end
 
     sig do
@@ -401,42 +361,7 @@ module RubyLsp
       ).returns(T::Array[Interface::TextEdit])
     end
     def on_type_formatting(uri, position, character)
-      Requests::OnTypeFormatting.new(@store.get(uri), position, character).run
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: T::Hash[Symbol, T.untyped],
-      ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
-    end
-    def document_highlight(uri, position)
-      document = @store.get(uri)
-
-      target, parent = document.locate_node(position)
-      dispatcher = Prism::Dispatcher.new
-      listener = Requests::DocumentHighlight.new(target, parent, dispatcher)
-      dispatcher.visit(document.tree)
-      listener.response
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        range: T::Hash[Symbol, T.untyped],
-      ).returns(T.nilable(T::Array[Interface::InlayHint]))
-    end
-    def inlay_hint(uri, range)
-      document = @store.get(uri)
-
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      dispatcher = Prism::Dispatcher.new
-      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
-      listener = Requests::InlayHints.new(start_line..end_line, hints_configurations, dispatcher)
-      dispatcher.visit(document.tree)
-      listener.response
+      Requests::OnTypeFormatting.new(@store.get(uri), position, character).perform
     end
 
     sig do
@@ -449,14 +374,14 @@ module RubyLsp
     def code_action(uri, range, context)
       document = @store.get(uri)
 
-      Requests::CodeActions.new(document, range, context).run
+      Requests::CodeActions.new(document, range, context).perform
     end
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
     def code_action_resolve(params)
       uri = URI(params.dig(:data, :uri))
       document = @store.get(uri)
-      result = Requests::CodeActionResolve.new(document, params).run
+      result = Requests::CodeActionResolve.new(document, params).perform
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
@@ -490,7 +415,7 @@ module RubyLsp
       return unless path.nil? || path.start_with?(T.must(@store.workspace_uri.to_standardized_path))
 
       response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
-        Requests::Diagnostics.new(document).run
+        Requests::Diagnostics.new(document).perform
       end
 
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response) if response
@@ -503,61 +428,10 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
+      request = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
       dispatcher.visit(document.tree)
 
-      Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: T::Hash[Symbol, T.untyped],
-      ).returns(T.nilable(T::Array[Interface::CompletionItem]))
-    end
-    def completion(uri, position)
-      document = @store.get(uri)
-
-      # Completion always receives the position immediately after the character that was just typed. Here we adjust it
-      # back by 1, so that we find the right node
-      char_position = document.create_scanner.find_char_position(position) - 1
-      matched, parent, nesting = document.locate(
-        document.tree,
-        char_position,
-        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
-      )
-      return unless matched && parent
-
-      target = case matched
-      when Prism::CallNode
-        message = matched.message
-
-        if message == "require"
-          args = matched.arguments&.arguments
-          return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
-
-          argument = args.first
-          return unless argument.is_a?(Prism::StringNode)
-          return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
-
-          argument
-        else
-          matched
-        end
-      when Prism::ConstantReadNode, Prism::ConstantPathNode
-        if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
-          parent
-        else
-          matched
-        end
-      end
-
-      return unless target
-
-      dispatcher = Prism::Dispatcher.new
-      listener = Requests::Completion.new(@index, nesting, dispatcher)
-      dispatcher.dispatch_once(target)
-      listener.response
+      Requests::Support::SemanticTokenEncoder.new.encode(request.perform)
     end
 
     sig { params(id: String, title: String, percentage: Integer).void }
@@ -663,81 +537,18 @@ module RubyLsp
         Hash.new(true)
       end
 
-      document_symbol_provider = if enabled_features["documentSymbols"]
-        Interface::DocumentSymbolClientCapabilities.new(
-          hierarchical_document_symbol_support: true,
-          symbol_kind: {
-            value_set: (Constant::SymbolKind::FILE..Constant::SymbolKind::TYPE_PARAMETER).to_a,
-          },
-        )
-      end
-
-      document_link_provider = if enabled_features["documentLink"]
-        Interface::DocumentLinkOptions.new(resolve_provider: false)
-      end
-
-      code_lens_provider = if enabled_features["codeLens"]
-        Interface::CodeLensOptions.new(resolve_provider: false)
-      end
-
-      hover_provider = if enabled_features["hover"]
-        Interface::HoverClientCapabilities.new(dynamic_registration: false)
-      end
-
-      folding_ranges_provider = if enabled_features["foldingRanges"]
-        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
-      end
-
-      semantic_tokens_provider = if enabled_features["semanticHighlighting"]
-        Interface::SemanticTokensRegistrationOptions.new(
-          document_selector: { scheme: "file", language: "ruby" },
-          legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys,
-          ),
-          range: true,
-          full: { delta: false },
-        )
-      end
-
-      diagnostics_provider = if enabled_features["diagnostics"]
-        {
-          interFileDependencies: false,
-          workspaceDiagnostics: false,
-        }
-      end
-
-      on_type_formatting_provider = if enabled_features["onTypeFormatting"]
-        Interface::DocumentOnTypeFormattingOptions.new(
-          first_trigger_character: "{",
-          more_trigger_character: ["\n", "|", "d"],
-        )
-      end
-
-      code_action_provider = if enabled_features["codeActions"]
-        Interface::CodeActionOptions.new(resolve_provider: true)
-      end
-
-      inlay_hint_provider = if enabled_features["inlayHint"]
-        Interface::InlayHintOptions.new(resolve_provider: false)
-      end
-
-      completion_provider = if enabled_features["completion"]
-        Interface::CompletionOptions.new(
-          resolve_provider: false,
-          trigger_characters: ["/"],
-          completion_item: {
-            labelDetailsSupport: true,
-          },
-        )
-      end
-
-      signature_help_provider = if enabled_features["signatureHelp"]
-        # Identifier characters are automatically included, such as A-Z, a-z, 0-9, _, * or :
-        Interface::SignatureHelpOptions.new(
-          trigger_characters: ["(", " ", ","],
-        )
-      end
+      document_symbol_provider = Requests::DocumentSymbol.provider if enabled_features["documentSymbols"]
+      document_link_provider = Requests::DocumentLink.provider if enabled_features["documentLink"]
+      code_lens_provider = Requests::CodeLens.provider if enabled_features["codeLens"]
+      hover_provider = Requests::Hover.provider if enabled_features["hover"]
+      folding_ranges_provider = Requests::FoldingRanges.provider if enabled_features["foldingRanges"]
+      semantic_tokens_provider = Requests::SemanticHighlighting.provider if enabled_features["semanticHighlighting"]
+      diagnostics_provider = Requests::Diagnostics.provider if enabled_features["diagnostics"]
+      on_type_formatting_provider = Requests::OnTypeFormatting.provider if enabled_features["onTypeFormatting"]
+      code_action_provider = Requests::CodeActions.provider if enabled_features["codeActions"]
+      inlay_hint_provider = Requests::InlayHints.provider if enabled_features["inlayHint"]
+      completion_provider = Requests::Completion.provider if enabled_features["completion"]
+      signature_help_provider = Requests::SignatureHelp.provider if enabled_features["signatureHelp"]
 
       # Dynamically registered capabilities
       file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)

data/lib/ruby_lsp/listener.rb

@@ -16,6 +16,7 @@ module RubyLsp
 
     sig { params(dispatcher: Prism::Dispatcher).void }
     def initialize(dispatcher)
+      super()
       @dispatcher = dispatcher
     end
 
@@ -29,54 +30,4 @@ module RubyLsp
     sig { abstract.returns(ResponseType) }
     def _response; end
   end
-
-  # ExtensibleListener is an abstract class to be used by requests that accept addons.
-  class ExtensibleListener < Listener
-    extend T::Sig
-    extend T::Generic
-
-    ResponseType = type_member
-
-    abstract!
-
-    # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
-    # ivars have been initialized. This is because the constructor of ExtensibleListener calls
-    # `initialize_external_listener` which may depend on the subclass's ivars.
-    sig { params(dispatcher: Prism::Dispatcher).void }
-    def initialize(dispatcher)
-      super
-      @response_merged = T.let(false, T::Boolean)
-      @external_listeners = T.let(
-        Addon.addons.filter_map do |ext|
-          initialize_external_listener(ext)
-        end,
-        T::Array[RubyLsp::Listener[ResponseType]],
-      )
-    end
-
-    # Merge responses from all external listeners into the base listener's response. We do this to return a single
-    # response to the editor including the results of all addons
-    sig { void }
-    def merge_external_listeners_responses!
-      @external_listeners.each { |l| merge_response!(l) }
-    end
-
-    sig { returns(ResponseType) }
-    def response
-      merge_external_listeners_responses! unless @response_merged
-      super
-    end
-
-    sig do
-      abstract.params(addon: RubyLsp::Addon).returns(T.nilable(RubyLsp::Listener[ResponseType]))
-    end
-    def initialize_external_listener(addon); end
-
-    # Does nothing by default. Requests that accept addons should override this method to define how to merge responses
-    # coming from external listeners
-    sig { abstract.params(other: Listener[T.untyped]).returns(T.self_type) }
-    def merge_response!(other)
-    end
-  end
-  private_constant(:ExtensibleListener)
 end