ruby-lsp 0.14.6 → 0.16.5

data/lib/ruby_lsp/base_server.rb

@@ -0,0 +1,149 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class BaseServer
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { params(test_mode: T::Boolean).void }
+    def initialize(test_mode: false)
+      @test_mode = T.let(test_mode, T::Boolean)
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
+      @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
+      @cancelled_requests = T.let([], T::Array[Integer])
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+      @current_request_id = T.let(1, Integer)
+      @store = T.let(Store.new, Store)
+      @outgoing_dispatcher = T.let(
+        Thread.new do
+          unless test_mode
+            while (message = @outgoing_queue.pop)
+              @mutex.synchronize { @writer.write(message.to_hash) }
+            end
+          end
+        end,
+        Thread,
+      )
+
+      Thread.main.priority = 1
+    end
+
+    sig { void }
+    def start
+      @reader.read do |message|
+        method = message[:method]
+
+        # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
+        # source. Altering the source reference during parsing will put the parser in an invalid internal state, since
+        # it started parsing with one source but then it changed in the middle. We don't want to do this for text
+        # synchronization notifications
+        @mutex.synchronize do
+          uri = message.dig(:params, :textDocument, :uri)
+
+          if uri
+            begin
+              parsed_uri = URI(uri)
+              message[:params][:textDocument][:uri] = parsed_uri
+
+              # We don't want to try to parse documents on text synchronization notifications
+              @store.get(parsed_uri).parse unless method.start_with?("textDocument/did")
+            rescue Errno::ENOENT
+              # If we receive a request for a file that no longer exists, we don't want to fail
+            end
+          end
+        end
+
+        # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
+        # else is pushed into the incoming queue
+        case method
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+          process_message(message)
+        when "shutdown"
+          $stderr.puts("Shutting down Ruby LSP...")
+
+          shutdown
+
+          @mutex.synchronize do
+            run_shutdown
+            @writer.write(Result.new(id: message[:id], response: nil).to_hash)
+          end
+        when "exit"
+          @mutex.synchronize do
+            status = @incoming_queue.closed? ? 0 : 1
+            $stderr.puts("Shutdown complete with status #{status}")
+            exit(status)
+          end
+        else
+          @incoming_queue << message
+        end
+      end
+    end
+
+    sig { void }
+    def run_shutdown
+      @incoming_queue.clear
+      @outgoing_queue.clear
+      @incoming_queue.close
+      @outgoing_queue.close
+      @cancelled_requests.clear
+
+      @worker.join
+      @outgoing_dispatcher.join
+      @store.clear
+    end
+
+    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
+    sig { returns(T.untyped) }
+    def pop_response
+      @outgoing_queue.pop
+    end
+
+    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
+    def process_message(message); end
+
+    sig { abstract.void }
+    def shutdown; end
+
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
+          id = message[:id]
+
+          # Check if the request was cancelled before trying to process it
+          @mutex.synchronize do
+            if id && @cancelled_requests.include?(id)
+              send_message(Result.new(id: id, response: nil))
+              @cancelled_requests.delete(id)
+              next
+            end
+          end
+
+          process_message(message)
+        end
+      end
+    end
+
+    sig { params(message: T.any(Result, Error, Notification, Request)).void }
+    def send_message(message)
+      # When we're shutting down the server, there's a small race condition between closing the thread queues and
+      # finishing remaining requests. We may close the queue in the middle of processing a request, which will then fail
+      # when trying to send a response back
+      return if @outgoing_queue.closed?
+
+      @outgoing_queue << message
+      @current_request_id += 1 if message.is_a?(Request)
+    end
+
+    sig { params(id: Integer).void }
+    def send_empty_response(id)
+      send_message(Result.new(id: id, response: nil))
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -20,13 +20,13 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_reader :uri
 
-    sig { returns(String) }
+    sig { returns(Encoding) }
     attr_reader :encoding
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: String).void }
-    def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
+    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
       @cache = T.let({}, T::Hash[String, T.untyped])
-      @encoding = T.let(encoding, String)
+      @encoding = T.let(encoding, Encoding)
       @source = T.let(source, String)
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
@@ -180,11 +180,6 @@ module RubyLsp
       end
     end
 
-    sig { returns(T::Boolean) }
-    def typechecker_enabled?
-      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
-    end
-
     class Scanner
       extend T::Sig
 
@@ -192,7 +187,7 @@ module RubyLsp
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
       SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
 
-      sig { params(source: String, encoding: String).void }
+      sig { params(source: String, encoding: Encoding).void }
       def initialize(source, encoding)
         @current_line = T.let(0, Integer)
         @pos = T.let(0, Integer)
@@ -214,7 +209,7 @@ module RubyLsp
         # need to adjust for surrogate pairs
         requested_position = @pos + position[:character]
 
-        if @encoding == Constant::PositionEncodingKind::UTF16
+        if @encoding == Encoding::UTF_16LE
           requested_position -= utf_16_character_position_correction(@pos, requested_position)
         end
 

data/lib/ruby_lsp/global_state.rb

@@ -0,0 +1,180 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class GlobalState
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :test_library
+
+    sig { returns(String) }
+    attr_accessor :formatter
+
+    sig { returns(T::Boolean) }
+    attr_reader :typechecker
+
+    sig { returns(RubyIndexer::Index) }
+    attr_reader :index
+
+    sig { returns(Encoding) }
+    attr_reader :encoding
+
+    sig { returns(T::Boolean) }
+    attr_reader :supports_watching_files
+
+    sig { void }
+    def initialize
+      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
+      @encoding = T.let(Encoding::UTF_8, Encoding)
+
+      @formatter = T.let("auto", String)
+      @linters = T.let([], T::Array[String])
+      @test_library = T.let("minitest", String)
+      @typechecker = T.let(true, T::Boolean)
+      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+      @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
+      @supports_watching_files = T.let(false, T::Boolean)
+    end
+
+    sig { params(identifier: String, instance: Requests::Support::Formatter).void }
+    def register_formatter(identifier, instance)
+      @supported_formatters[identifier] = instance
+    end
+
+    sig { returns(T.nilable(Requests::Support::Formatter)) }
+    def active_formatter
+      @supported_formatters[@formatter]
+    end
+
+    sig { returns(T::Array[Requests::Support::Formatter]) }
+    def active_linters
+      @linters.filter_map { |name| @supported_formatters[name] }
+    end
+
+    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    def apply_options(options)
+      dependencies = gather_dependencies
+      workspace_uri = options.dig(:workspaceFolders, 0, :uri)
+      @workspace_uri = URI(workspace_uri) if workspace_uri
+
+      specified_formatter = options.dig(:initializationOptions, :formatter)
+      @formatter = specified_formatter if specified_formatter
+      @formatter = detect_formatter(dependencies) if @formatter == "auto"
+
+      specified_linters = options.dig(:initializationOptions, :linters)
+      @linters = specified_linters || detect_linters(dependencies)
+      @test_library = detect_test_library(dependencies)
+      @typechecker = detect_typechecker(dependencies)
+
+      encodings = options.dig(:capabilities, :general, :positionEncodings)
+      @encoding = if !encodings || encodings.empty?
+        Encoding::UTF_16LE
+      elsif encodings.include?(Constant::PositionEncodingKind::UTF8)
+        Encoding::UTF_8
+      elsif encodings.include?(Constant::PositionEncodingKind::UTF16)
+        Encoding::UTF_16LE
+      else
+        Encoding::UTF_32
+      end
+
+      file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
+      if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+        @supports_watching_files = true
+      end
+    end
+
+    sig { returns(String) }
+    def workspace_path
+      T.must(@workspace_uri.to_standardized_path)
+    end
+
+    sig { returns(String) }
+    def encoding_name
+      case @encoding
+      when Encoding::UTF_8
+        Constant::PositionEncodingKind::UTF8
+      when Encoding::UTF_16LE
+        Constant::PositionEncodingKind::UTF16
+      else
+        Constant::PositionEncodingKind::UTF32
+      end
+    end
+
+    private
+
+    sig { params(dependencies: T::Array[String]).returns(String) }
+    def detect_formatter(dependencies)
+      # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
+      if dependencies.any?(/^rubocop/)
+        "rubocop"
+      elsif dependencies.any?(/^syntax_tree$/)
+        "syntax_tree"
+      else
+        "none"
+      end
+    end
+
+    # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
+    # single linter. To have multiple linters running, the user must configure them manually
+    sig { params(dependencies: T::Array[String]).returns(T::Array[String]) }
+    def detect_linters(dependencies)
+      linters = []
+      linters << "rubocop" if dependencies.any?(/^rubocop/)
+      linters
+    end
+
+    sig { params(dependencies: T::Array[String]).returns(String) }
+    def detect_test_library(dependencies)
+      if dependencies.any?(/^rspec/)
+        "rspec"
+      # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
+      # by ruby-lsp-rails. A Rails app doesn't need to depend on the rails gem itself, individual components like
+      # activestorage may be added to the gemfile so that other components aren't downloaded. Check for the presence
+      #  of bin/rails to support these cases.
+      elsif File.exist?(File.join(workspace_path, "bin/rails"))
+        "rails"
+      # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
+      elsif dependencies.any?(/^minitest$/)
+        "minitest"
+      elsif dependencies.any?(/^test-unit/)
+        "test-unit"
+      else
+        "unknown"
+      end
+    end
+
+    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    def detect_typechecker(dependencies)
+      return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
+
+      # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
+      ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
+      Bundler.with_original_env do
+        sorbet_static_detected = dependencies.any?(/^sorbet-static/)
+        # Don't show message while running tests, since it's noisy
+        if sorbet_static_detected && !ruby_lsp_env_is_test
+          $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
+        end
+        sorbet_static_detected
+      end
+    rescue Bundler::GemfileNotFound
+      false
+    end
+
+    sig { returns(T::Array[String]) }
+    def gather_dependencies
+      Bundler.with_original_env { Bundler.default_gemfile }
+      Bundler.locked_gems.dependencies.keys + gemspec_dependencies
+    rescue Bundler::GemfileNotFound
+      []
+    end
+
+    sig { returns(T::Array[String]) }
+    def gemspec_dependencies
+      Bundler.locked_gems.sources
+        .grep(Bundler::Source::Gemspec)
+        .flat_map { _1.gemspec&.dependencies&.map(&:name) }
+    end
+  end
+end

data/lib/ruby_lsp/internal.rb

@@ -20,12 +20,13 @@ require "prism/visitor"
 require "language_server-protocol"
 
 require "ruby-lsp"
+require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
+require "ruby_lsp/global_state"
 require "ruby_lsp/server"
-require "ruby_lsp/executor"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
 require "ruby_lsp/document"
@@ -33,3 +34,5 @@ require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
+require "ruby_lsp/requests/support/rubocop_formatter"
+require "ruby_lsp/requests/support/syntax_tree_formatter"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -27,12 +27,14 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+          global_state: GlobalState,
           uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, uri, dispatcher)
+      def initialize(response_builder, global_state, uri, dispatcher)
         @response_builder = response_builder
+        @global_state = global_state
         @uri = T.let(uri, URI::Generic)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
@@ -66,17 +68,22 @@ module RubyLsp
             command: generate_test_command(group_stack: @group_stack),
             kind: :group,
           )
-        end
 
-        @group_id_stack.push(@group_id)
-        @group_id += 1
+          @group_id_stack.push(@group_id)
+          @group_id += 1
+        end
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
         @visibility_stack.pop
         @group_stack.pop
-        @group_id_stack.pop
+
+        class_name = node.constant_path.slice
+
+        if @path && class_name.end_with?("Test")
+          @group_id_stack.pop
+        end
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -156,7 +163,7 @@ module RubyLsp
       sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(DependencyDetector.instance.detected_test_library) && @path
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
 
         arguments = [
           @path,
@@ -208,7 +215,7 @@ module RubyLsp
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
         command = BASE_COMMAND + T.must(@path)
 
-        case DependencyDetector.instance.detected_test_library
+        case @global_state.test_library
         when "minitest"
           last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
           command += if last_dynamic_reference_index
@@ -264,12 +271,14 @@ module RubyLsp
 
         return unless name
 
-        add_test_code_lens(
-          node,
-          name: name,
-          command: generate_test_command(spec_name: name),
-          kind: kind,
-        )
+        if @path
+          add_test_code_lens(
+            node,
+            name: name,
+            command: generate_test_command(spec_name: name),
+            kind: kind,
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/listeners/completion.rb

@@ -10,16 +10,17 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           nesting: T::Array[String],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
         ).void
       end
-      def initialize(response_builder, index, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
-        @index = index
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @nesting = nesting
         @typechecker_enabled = typechecker_enabled
         @uri = uri
@@ -35,7 +36,7 @@ module RubyLsp
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?
@@ -56,7 +57,7 @@ module RubyLsp
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?
@@ -77,7 +78,10 @@ module RubyLsp
 
         real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
-        candidates = @index.prefix_search("#{real_namespace}::#{incomplete_name}", top_level_reference ? [] : @nesting)
+        candidates = @index.prefix_search(
+          "#{real_namespace}::#{incomplete_name}",
+          top_level_reference ? [] : @nesting,
+        )
         candidates.each do |entries|
           # The only time we may have a private constant reference from outside of the namespace is if we're dealing
           # with ConstantPath and the entry name doesn't start with the current nesting
@@ -124,7 +128,9 @@ module RubyLsp
 
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        @index.search_require_paths(path_node_to_complete.content).map!(&:require_path).sort!.each do |path|
+        matched_indexable_paths = @index.search_require_paths(path_node_to_complete.content)
+
+        matched_indexable_paths.map!(&:require_path).sort!.each do |path|
           @response_builder << build_completion(T.must(path), path_node_to_complete)
         end
       end
@@ -284,13 +290,6 @@ module RubyLsp
             new_text: insertion_text,
           ),
           kind: kind,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entries.map(&:file_name).join(","),
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(real_name, entries),
-          ),
         )
       end
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -7,21 +7,24 @@ module RubyLsp
       extend T::Sig
       include Requests::Support::Common
 
+      MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER = 10
+
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          global_state: GlobalState,
           uri: URI::Generic,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, uri, nesting, index, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @uri = uri
         @nesting = nesting
-        @index = index
         @typechecker_enabled = typechecker_enabled
 
         dispatcher.register(
@@ -63,12 +66,17 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def handle_method_definition(node)
-        return unless self_receiver?(node)
-
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @nesting.join("::"))
+        methods = if self_receiver?(node)
+          @index.resolve_method(message, @nesting.join("::"))
+        else
+          # If the method doesn't have a receiver, then we provide a few candidates to jump to
+          # But we don't want to provide too many candidates, as it can be overwhelming
+          @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
+        end
+
         return unless methods
 
         methods.each do |target_method|