ruby-lsp 0.14.6 → 0.16.0

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/requests/support/rubocop_formatting_runner"
-require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
-
 module RubyLsp
   module Requests
     # ![Formatting symbol demo](../../formatting.gif)
@@ -26,47 +23,24 @@ module RubyLsp
     # end
     # ```
     class Formatting < Request
-      class Error < StandardError; end
-      class InvalidFormatter < StandardError; end
-
-      @formatters = T.let({}, T::Hash[String, Support::FormatterRunner])
-
-      class << self
-        extend T::Sig
-
-        sig { returns(T::Hash[String, Support::FormatterRunner]) }
-        attr_reader :formatters
-
-        sig { params(identifier: String, instance: Support::FormatterRunner).void }
-        def register_formatter(identifier, instance)
-          @formatters[identifier] = instance
-        end
-      end
-
-      if defined?(Support::RuboCopFormattingRunner)
-        register_formatter("rubocop", Support::RuboCopFormattingRunner.instance)
-      end
-
-      if defined?(Support::SyntaxTreeFormattingRunner)
-        register_formatter("syntax_tree", Support::SyntaxTreeFormattingRunner.instance)
-      end
-
       extend T::Sig
 
-      sig { params(document: Document, formatter: String).void }
-      def initialize(document, formatter: "auto")
+      class Error < StandardError; end
+
+      sig { params(global_state: GlobalState, document: Document).void }
+      def initialize(global_state, document)
         super()
         @document = document
+        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
         @uri = T.let(document.uri, URI::Generic)
-        @formatter = formatter
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def perform
-        return if @formatter == "none"
+        return unless @active_formatter
         return if @document.syntax_error?
 
-        formatted_text = formatted_file
+        formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 
         size = @document.source.size
@@ -82,16 +56,6 @@ module RubyLsp
           ),
         ]
       end
-
-      private
-
-      sig { returns(T.nilable(String)) }
-      def formatted_file
-        formatter_runner = Formatting.formatters[@formatter]
-        raise InvalidFormatter, "Formatter is not available: #{@formatter}" unless formatter_runner
-
-        formatter_runner.run(@uri, @document)
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/hover.rb

@@ -33,13 +33,13 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(document, index, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @target, parent, nesting = document.locate_node(
@@ -62,9 +62,9 @@ module RubyLsp
 
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
-        Listeners::Hover.new(@response_builder, uri, nesting, index, dispatcher, typechecker_enabled)
+        Listeners::Hover.new(@response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled)
         Addon.addons.each do |addon|
-          addon.create_hover_listener(@response_builder, nesting, index, dispatcher)
+          addon.create_hover_listener(@response_builder, nesting, dispatcher)
         end
 
         @dispatcher = dispatcher

data/lib/ruby_lsp/requests/request.rb

@@ -8,6 +8,8 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
+      class InvalidFormatter < StandardError; end
+
       abstract!
 
       sig { abstract.returns(T.anything) }

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -29,7 +29,7 @@ module RubyLsp
         sig { returns(Interface::SemanticTokensRegistrationOptions) }
         def provider
           Interface::SemanticTokensRegistrationOptions.new(
-            document_selector: { scheme: "file", language: "ruby" },
+            document_selector: [{ language: "ruby" }],
             legend: Interface::SemanticTokensLegend.new(
               token_types: ResponseBuilders::SemanticHighlighting::TOKEN_TYPES.keys,
               token_modifiers: ResponseBuilders::SemanticHighlighting::TOKEN_MODIFIERS.keys,

data/lib/ruby_lsp/requests/signature_help.rb

@@ -42,13 +42,14 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(document, index, position, context, dispatcher)
+      def initialize(document, global_state, position, context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         super()
         target, parent, nesting = document.locate_node(
           { line: position[:line], character: position[:character] },
@@ -60,7 +61,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, nesting, index, dispatcher)
+        Listeners::SignatureHelp.new(@response_builder, global_state, nesting, dispatcher, typechecker_enabled)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

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

@@ -86,13 +86,16 @@ module RubyLsp
           params(
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
+            max_entries: T.nilable(Integer),
           ).returns(T::Hash[Symbol, String])
         end
-        def categorized_markdown_from_index_entries(title, entries)
+        def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
           content = +""
-          Array(entries).each do |entry|
+          entries = Array(entries)
+          entries_to_format = max_entries ? entries.take(max_entries) : entries
+          entries_to_format.each do |entry|
             loc = entry.location
 
             # We always handle locations as zero based. However, for file links in Markdown we need them to be one
@@ -108,9 +111,16 @@ module RubyLsp
             content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
           end
 
+          additional_entries_text = if max_entries && entries.length > max_entries
+            additional = entries.length - max_entries
+            " | #{additional} other#{additional > 1 ? "s" : ""}"
+          else
+            ""
+          end
+
           {
             title: markdown_title,
-            links: "**Definitions**: #{definitions.join(" | ")}",
+            links: "**Definitions**: #{definitions.join(" | ")}#{additional_entries_text}",
             documentation: content,
           }
         end
@@ -119,10 +129,11 @@ module RubyLsp
           params(
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
+            max_entries: T.nilable(Integer),
           ).returns(String)
         end
-        def markdown_from_index_entries(title, entries)
-          categorized_markdown = categorized_markdown_from_index_entries(title, entries)
+        def markdown_from_index_entries(title, entries, max_entries = nil)
+          categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
           <<~MARKDOWN.chomp
             #{categorized_markdown[:title]}

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

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      module Formatter
+        extend T::Sig
+        extend T::Helpers
+
+        interface!
+
+        sig { abstract.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        def run_formatting(uri, document); end
+
+        sig do
+          abstract.params(
+            uri: URI::Generic,
+            document: Document,
+          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        end
+        def run_diagnostic(uri, document); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
+
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      class RuboCopFormatter
+        extend T::Sig
+        include Formatter
+        include Singleton
+
+        sig { void }
+        def initialize
+          @diagnostic_runner = T.let(RuboCopRunner.new, RuboCopRunner)
+          # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
+          @format_runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
+        end
+
+        sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        def run_formatting(uri, document)
+          filename = T.must(uri.to_standardized_path || uri.opaque)
+
+          # Invoke RuboCop with just this file in `paths`
+          @format_runner.run(filename, document.source)
+          @format_runner.formatted_source
+        end
+
+        sig do
+          override.params(
+            uri: URI::Generic,
+            document: Document,
+          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        end
+        def run_diagnostic(uri, document)
+          filename = T.must(uri.to_standardized_path || uri.opaque)
+          # Invoke RuboCop with just this file in `paths`
+          @diagnostic_runner.run(filename, document.source)
+
+          @diagnostic_runner.offenses.map do |offense|
+            Support::RuboCopDiagnostic.new(document, offense, uri).to_lsp_diagnostic
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -92,6 +92,10 @@ module RubyLsp
           @options[:stdin] = contents
 
           super([path])
+
+          # RuboCop rescues interrupts and then sets the `@aborting` variable to true. We don't want them to be rescued,
+          # so here we re-raise in case RuboCop received an interrupt.
+          raise Interrupt if aborting?
         rescue RuboCop::Runner::InfiniteCorrectionLoop => error
           raise Formatting::Error, error.message
         rescue RuboCop::ValidationError => error

data/lib/ruby_lsp/requests/support/{syntax_tree_formatting_runner.rb → syntax_tree_formatter.rb}

@@ -14,10 +14,10 @@ module RubyLsp
   module Requests
     module Support
       # :nodoc:
-      class SyntaxTreeFormattingRunner
+      class SyntaxTreeFormatter
         extend T::Sig
         include Singleton
-        include Support::FormatterRunner
+        include Support::Formatter
 
         sig { void }
         def initialize
@@ -33,12 +33,22 @@ module RubyLsp
         end
 
         sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
-        def run(uri, document)
+        def run_formatting(uri, document)
           path = uri.to_standardized_path
           return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
 
           SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
+
+        sig do
+          override.params(
+            uri: URI::Generic,
+            document: Document,
+          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        end
+        def run_diagnostic(uri, document)
+          nil
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -22,11 +22,12 @@ module RubyLsp
       extend T::Sig
       include Support::Common
 
-      sig { params(query: T.nilable(String), index: RubyIndexer::Index).void }
-      def initialize(query, index)
+      sig { params(global_state: GlobalState, query: T.nilable(String)).void }
+      def initialize(global_state, query)
         super()
+        @global_state = global_state
         @query = query
-        @index = index
+        @index = T.let(global_state.index, RubyIndexer::Index)
       end
 
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
@@ -35,7 +36,7 @@ module RubyLsp
           # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
           # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          next if DependencyDetector.instance.typechecker && not_in_dependencies?(file_path)
+          next if @global_state.typechecker && not_in_dependencies?(file_path)
 
           # We should never show private symbols when searching the entire workspace
           next if entry.visibility == :private

data/lib/ruby_lsp/requests.rb

@@ -18,6 +18,7 @@ module RubyLsp
   # - [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)
@@ -40,6 +41,7 @@ module RubyLsp
     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"
@@ -54,7 +56,7 @@ module RubyLsp
       autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :Common, "ruby_lsp/requests/support/common"
-      autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"
+      autoload :Formatter, "ruby_lsp/requests/support/formatter"
     end
   end
 end