ruby-lsp 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c21e90970f4cbf198609a42471cf554ce86a3b6af9296ded95994ad373317a
-  data.tar.gz: a28aa2c13ba4d79f53082160b0eca7e8461efad831b6c6cca2a6a4d34765a6c0
+  metadata.gz: 9762389a7b7979afb57d6e6d2cf0d65b0b0a0b31f5a1fdd7045311c33a0c21d6
+  data.tar.gz: 35cc2318946e650ee311129955d3674c7e693a87d25c5cc2f29c5a55e479d880
 SHA512:
-  metadata.gz: 5ab1bf48ae4943a710f34ef0aace64c1d8991271bdca71482a2367c3a103299c52ebaef203fa32945236d689dda67d2bb1b5cc5ca9ffa698f5dd057dd62e242f
-  data.tar.gz: 8b9453d71b65634e1ea275f3a2552548f530dc144acd18cdcbcee493f153b824a13bc60bbbe5ac937a993d9e9c56ce8cb70773d354b5cea7acda3f4f44722ffd
+  metadata.gz: 4735e18c297c992727d0a151ed7948cf6d4ea32b01fe411ed0774efdda7cdc0cf6533f5d71ad288aad9e6e717149932744376fdceda9fa4cd039b560934a9b47
+  data.tar.gz: bd6e0c9a81a373c509f2f96b480543657a8d241a6e58ea25ec21c62ac60094f299af1c5f85d1555ad6ca1908c325e46569119271d4c6b7117f33f9919cf40bca

data/CHANGELOG.md

@@ -6,32 +6,24 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
-## [0.2.3]
-
-- Resolve generic source URIs for jump to gem source (https://github.com/Shopify/ruby-lsp/pull/237)
-
-## [0.2.2]
-
-- Support document links (https://github.com/Shopify/ruby-lsp/pull/195)
-- Avoid returning on request blocks (https://github.com/Shopify/ruby-lsp/pull/232)
-- Better specify gemspec files (https://github.com/Shopify/ruby-lsp/pull/233)
-- Include Kernel instance methods as special methods for semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/231)
-- Fix call processing when message is a :call symbol literal (https://github.com/Shopify/ruby-lsp/pull/236)
-- Alert users about non auto-correctable diagnostics (https://github.com/Shopify/ruby-lsp/pull/230)
-- Let clients pull diagnostics instead of pushing on edits (https://github.com/Shopify/ruby-lsp/pull/242)
-
-## [0.2.1]
-
-- Implement the exit lifecycle request (https://github.com/Shopify/ruby-lsp/pull/198)
-- Remove the Sorbet runtime from the gem's default load path (https://github.com/Shopify/ruby-lsp/pull/214)
-- Return nil if the document is already formatted (https://github.com/Shopify/ruby-lsp/pull/216)
-- Handle nameless keyword rest parameters in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/222)
-- Display a warning on invalid RuboCop configuration (https://github.com/Shopify/ruby-lsp/pull/226)
-- Centralize request handling logic in server.rb (https://github.com/Shopify/ruby-lsp/pull/221)
-- Fix folding ranges for chained invocations involving an FCall (https://github.com/Shopify/ruby-lsp/pull/223)
-- Fix handling of argument fowarding in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/228)
-- Recover from initial syntax errors when opening documents (https://github.com/Shopify/ruby-lsp/pull/224)
-- Highlight occurrences and definitions in document highlight (https://github.com/Shopify/ruby-lsp/pull/187)
+## [0.3.1]
+
+- Resolve TODO for LSP v3.17 (https://github.com/Shopify/ruby-lsp/pull/268)
+- Add dependency constraint for LSP v3.17 (https://github.com/Shopify/ruby-lsp/pull/269)
+- Handle class/module declarations as a class token with declaration modifier (https://github.com/Shopify/ruby-lsp/pull/260)
+- Handle required parameters in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/271)
+- Add comment continuation via on type on_type_formatting (https://github.com/Shopify/ruby-lsp/pull/274)
+- Make RuboCop runner use composition instead of inheritance (https://github.com/Shopify/ruby-lsp/pull/278)
+- Protect worker against cancellation during popping (https://github.com/Shopify/ruby-lsp/pull/280)
+- Handle formatting errors in on_error block (https://github.com/Shopify/ruby-lsp/pull/279)
+- Fix on type formatting pipe completion for regular or expressions (https://github.com/Shopify/ruby-lsp/pull/282)
+- Do not fail on LoadError (https://github.com/Shopify/ruby-lsp/pull/292)
+
+## [0.3.0]
+- Add on type formatting completions (https://github.com/Shopify/ruby-lsp/pull/253)
+- Upgrade syntax_tree requirement to >= 3.4 (https://github.com/Shopify/ruby-lsp/pull/254)
+- Show error message when there's a InfiniteCorrectionLoop exception (https://github.com/Shopify/ruby-lsp/pull/252)
+- Add request cancellation (https://github.com/Shopify/ruby-lsp/pull/243)
 
 ## [0.2.0]
 

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.1

data/lib/ruby_lsp/handler.rb

@@ -3,7 +3,7 @@
 
 require "ruby_lsp/requests"
 require "ruby_lsp/store"
-require "benchmark"
+require "ruby_lsp/queue"
 
 module RubyLsp
   Interface = LanguageServer::Protocol::Interface
@@ -14,11 +14,35 @@ module RubyLsp
     extend T::Sig
     VOID = T.let(Object.new.freeze, Object)
 
-    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
-    def self.start(&blk)
-      handler = new
-      handler.instance_exec(&blk)
-      handler.start
+    class RequestHandler < T::Struct
+      extend T::Sig
+
+      const :action, T.proc.params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+      const :parallel, T::Boolean
+      prop :error_handler,
+        T.nilable(T.proc.params(error: Exception, request: T::Hash[Symbol, T.untyped]).void)
+
+      # A proc that runs in case a request has errored. Receives the error and the original request as arguments. Useful
+      # for displaying window messages on errors
+      sig do
+        params(
+          block: T.proc.bind(Handler).params(error: Exception, request: T::Hash[Symbol, T.untyped]).void
+        ).void
+      end
+      def on_error(&block)
+        self.error_handler = block
+      end
+    end
+
+    class << self
+      extend T::Sig
+
+      sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
+      def start(&blk)
+        handler = new
+        handler.instance_exec(&blk)
+        handler.start
+      end
     end
 
     sig { returns(Store) }
@@ -28,61 +52,50 @@ module RubyLsp
     def initialize
       @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
       @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
-      @handlers = T.let({}, T::Hash[String, T.proc.params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)])
+      @handlers = T.let({}, T::Hash[String, RequestHandler])
       @store = T.let(Store.new, Store)
+      @queue = T.let(Queue.new(@writer, @handlers), Queue)
     end
 
     sig { void }
     def start
       $stderr.puts "Starting Ruby LSP..."
-      @reader.read { |request| handle(request) }
+
+      @reader.read do |request|
+        handler = @handlers[request[:method]]
+        next if handler.nil?
+
+        if handler.parallel
+          @queue.push(request)
+        else
+          result = @queue.execute(request)
+          @queue.finalize_request(result, request)
+        end
+      end
     end
 
     private
 
+    sig { params(id: T.any(String, Integer)).void }
+    def cancel_request(id)
+      @queue.cancel(id)
+    end
+
     sig do
       params(
         msg: String,
+        parallel: T::Boolean,
         blk: T.proc.bind(Handler).params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
-      ).void
+      ).returns(RequestHandler)
     end
-    def on(msg, &blk)
-      @handlers[msg] = blk
-    end
-
-    sig { params(request: T::Hash[Symbol, T.untyped]).void }
-    def handle(request)
-      result = T.let(nil, T.untyped)
-      error = T.let(nil, T.nilable(StandardError))
-      handler = @handlers[request[:method]]
-
-      request_time = Benchmark.realtime do
-        if handler
-          begin
-            result = handler.call(request)
-          rescue StandardError => e
-            error = e
-          end
-
-          if error
-            @writer.write(
-              {
-                id: request[:id],
-                error: { code: Constant::ErrorCodes::INTERNAL_ERROR, message: error.inspect, data: request.to_json },
-              }
-            )
-          elsif result != VOID
-            @writer.write(id: request[:id], result: result)
-          end
-        end
-      end
-
-      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
+    def on(msg, parallel: false, &blk)
+      @handlers[msg] = RequestHandler.new(action: blk, parallel: parallel)
     end
 
     sig { void }
     def shutdown
       $stderr.puts "Shutting down Ruby LSP..."
+      @queue.shutdown
       store.clear
     end
 
@@ -101,30 +114,5 @@ module RubyLsp
         params: Interface::ShowMessageParams.new(type: type, message: message)
       )
     end
-
-    sig do
-      params(
-        request: T::Hash[Symbol, T.untyped],
-        request_time: Float,
-        error: T.nilable(StandardError)
-      ).returns(T::Hash[Symbol, T.any(String, Float)])
-    end
-    def telemetry_params(request, request_time, error)
-      uri = request.dig(:params, :textDocument, :uri)
-
-      params = {
-        request: request[:method],
-        lspVersion: RubyLsp::VERSION,
-        requestTime: request_time,
-      }
-
-      if error
-        params[:errorClass] = error.class.name
-        params[:errorMessage] = error.message
-      end
-
-      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
-      params
-    end
   end
 end

data/lib/ruby_lsp/queue.rb

@@ -0,0 +1,193 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "benchmark"
+
+module RubyLsp
+  class Queue
+    extend T::Sig
+
+    class Cancelled < StandardError; end
+
+    class Result < T::Struct
+      const :response, T.untyped # rubocop:disable Sorbet/ForbidUntypedStructProps
+      const :error, T.nilable(Exception)
+      const :request_time, T.nilable(Float)
+    end
+
+    class Job < T::Struct
+      extend T::Sig
+
+      const :request, T::Hash[Symbol, T.untyped]
+      prop :cancelled, T::Boolean
+
+      sig { void }
+      def cancel
+        self.cancelled = true
+      end
+    end
+
+    sig do
+      params(
+        writer: LanguageServer::Protocol::Transport::Stdio::Writer,
+        handlers: T::Hash[String, Handler::RequestHandler]
+      ).void
+    end
+    def initialize(writer, handlers)
+      @writer = writer
+      @handlers = handlers
+      # The job queue is the actual list of requests we have to process
+      @job_queue = T.let(Thread::Queue.new, Thread::Queue)
+      # The jobs hash is just a way of keeping a handle to jobs based on the request ID, so we can cancel them
+      @jobs = T.let({}, T::Hash[T.any(String, Integer), Job])
+      # The current job is a handle to cancel jobs that are currently being processed
+      @current_job = T.let(nil, T.nilable(Job))
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+
+      Thread.main.priority = 1
+    end
+
+    sig { params(request: T::Hash[Symbol, T.untyped]).void }
+    def push(request)
+      job = Job.new(request: request, cancelled: false)
+
+      # Remember a handle to the job, so that we can cancel it
+      @mutex.synchronize do
+        @jobs[request[:id]] = job
+      end
+
+      @job_queue << job
+    end
+
+    sig { params(id: T.any(String, Integer)).void }
+    def cancel(id)
+      @mutex.synchronize do
+        # Cancel the job if it's still in the queue
+        @jobs[id]&.cancel
+
+        # Cancel the job if we're in the middle of processing it
+        if @current_job&.request&.dig(:id) == id
+          @worker.raise(Cancelled)
+        end
+      end
+    end
+
+    sig { void }
+    def shutdown
+      # Close the queue so that we can no longer receive items
+      @job_queue.close
+      # Clear any remaining jobs so that the thread can terminate
+      @job_queue.clear
+      # Wait until the thread is finished
+      @worker.join
+    end
+
+    # Executes a request and returns a Queue::Result. No IO should happen in this method, because it can be cancelled in
+    # the middle with a raise
+    sig { params(request: T::Hash[Symbol, T.untyped]).returns(Queue::Result) }
+    def execute(request)
+      response = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(Exception))
+
+      request_time = Benchmark.realtime do
+        response = T.must(@handlers[request[:method]]).action.call(request)
+      rescue Cancelled
+        raise
+      rescue StandardError, LoadError => e
+        error = e
+      end
+
+      Queue::Result.new(response: response, error: error, request_time: request_time)
+    end
+
+    # Finalize a Queue::Result. All IO operations should happen here to avoid any issues with cancelling requests
+    sig do
+      params(
+        result: Result,
+        request: T::Hash[Symbol, T.untyped]
+      ).void
+    end
+    def finalize_request(result, request)
+      error = result.error
+      if error
+        T.must(@handlers[request[:method]]).error_handler&.call(error, request)
+
+        @writer.write(
+          id: request[:id],
+          error: {
+            code: LanguageServer::Protocol::Constant::ErrorCodes::INTERNAL_ERROR,
+            message: result.error.inspect,
+            data: request.to_json,
+          },
+        )
+      elsif result.response != Handler::VOID
+        @writer.write(id: request[:id], result: result.response)
+      end
+
+      request_time = result.request_time
+      if request_time
+        @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, result.error))
+      end
+    end
+
+    private
+
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        # Thread::Queue#pop is thread safe and will wait until an item is available
+        loop do
+          job = T.let(@job_queue.pop, T.nilable(Job))
+          break if job.nil?
+
+          # The only time when the job is nil is when the queue is closed and we can then terminate the thread
+
+          request = job.request
+          @mutex.synchronize do
+            @jobs.delete(request[:id])
+            @current_job = job
+          end
+
+          next if job.cancelled
+
+          result = execute(request)
+        rescue Cancelled
+          # We need to return nil to the client even if the request was cancelled
+          result = Queue::Result.new(response: nil, error: nil, request_time: nil)
+        ensure
+          @mutex.synchronize { @current_job = nil }
+
+          # If there's request, it means the worker was cancelled while waiting to pop from the queue or immediately
+          # after
+          finalize_request(result, request) unless result.nil? || request.nil?
+        end
+      end
+    end
+
+    sig do
+      params(
+        request: T::Hash[Symbol, T.untyped],
+        request_time: Float,
+        error: T.nilable(Exception)
+      ).returns(T::Hash[Symbol, T.any(String, Float)])
+    end
+    def telemetry_params(request, request_time, error)
+      uri = request.dig(:params, :textDocument, :uri)
+
+      params = {
+        request: request[:method],
+        lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
+      }
+
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
+      end
+
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
+      params
+    end
+  end
+end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -105,9 +105,13 @@ module RubyLsp
         sig { returns(Integer) }
         attr_reader :end_line
 
-        sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
-        def self.from(node, kind)
-          new(node.location.start_line - 1, node.location.end_line - 1, kind)
+        class << self
+          extend T::Sig
+
+          sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
+          def from(node, kind)
+            new(node.location.start_line - 1, node.location.end_line - 1, kind)
+          end
         end
 
         sig { params(start_line: Integer, end_line: Integer, kind: String).void }

data/lib/ruby_lsp/requests/formatting.rb

@@ -19,6 +19,8 @@ module RubyLsp
     # end
     # ```
     class Formatting < BaseRequest
+      class Error < StandardError; end
+
       extend T::Sig
 
       sig { params(uri: String, document: Document).void }

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -0,0 +1,149 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![On type formatting demo](../../misc/on_type_formatting.gif)
+    #
+    # The [on type formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_onTypeFormatting)
+    # request formats code as the user is typing. For example, automatically adding `end` to class definitions.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Foo # <-- upon adding a line break, on type formatting is triggered
+    #   # <-- cursor ends up here
+    # end # <-- end is automatically added
+    # ```
+    class OnTypeFormatting < BaseRequest
+      extend T::Sig
+
+      END_REGEXES = T.let([
+        /(if|unless|for|while|class|module|until|def|case).*/,
+        /.*\sdo/,
+      ], T::Array[Regexp])
+
+      sig { params(document: Document, position: Document::PositionShape, trigger_character: String).void }
+      def initialize(document, position, trigger_character)
+        super(document)
+
+        scanner = Document::Scanner.new(document.source)
+        line_begin = position[:line] == 0 ? 0 : scanner.find_position({ line: position[:line] - 1, character: 0 })
+        line_end = scanner.find_position(position)
+        line = T.must(@document.source[line_begin..line_end])
+
+        @indentation = T.let(find_indentation(line), Integer)
+        @previous_line = T.let(line.strip.chomp, String)
+        @position = position
+        @edits = T.let([], T::Array[Interface::TextEdit])
+        @trigger_character = trigger_character
+      end
+
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      def run
+        handle_comment_line
+
+        return @edits unless @document.syntax_errors?
+
+        case @trigger_character
+        when "{"
+          handle_curly_brace
+        when "|"
+          handle_pipe
+        when "\n"
+          handle_statement_end
+        end
+
+        @edits
+      end
+
+      private
+
+      sig { void }
+      def handle_pipe
+        return unless /((?<=do)|(?<={))\s+\|/.match?(@previous_line)
+
+        add_edit_with_text("|")
+        move_cursor_to(@position[:line], @position[:character])
+      end
+
+      sig { void }
+      def handle_curly_brace
+        return unless /".*#\{/.match?(@previous_line)
+
+        add_edit_with_text("}")
+        move_cursor_to(@position[:line], @position[:character])
+      end
+
+      sig { void }
+      def handle_statement_end
+        return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
+
+        indents = " " * @indentation
+
+        add_edit_with_text(" \n#{indents}end")
+        move_cursor_to(@position[:line], @indentation + 2)
+      end
+
+      sig { void }
+      def handle_comment_line
+        return unless @trigger_character == "\n"
+
+        is_comment_match = @previous_line.match(/^#(\s*)/)
+        return unless is_comment_match
+
+        spaces = T.must(is_comment_match[1])
+        add_edit_with_text("##{spaces}")
+        move_cursor_to(@position[:line], @indentation + spaces.size + 1)
+      end
+
+      sig { params(text: String).void }
+      def add_edit_with_text(text)
+        position = Interface::Position.new(
+          line: @position[:line],
+          character: @position[:character]
+        )
+
+        @edits << Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: position,
+            end: position
+          ),
+          new_text: text
+        )
+      end
+
+      sig { params(line: Integer, character: Integer).void }
+      def move_cursor_to(line, character)
+        position = Interface::Position.new(
+          line: line,
+          character: character
+        )
+
+        # The $0 is a special snippet anchor that moves the cursor to that given position. See the snippets
+        # documentation for more information:
+        # https://code.visualstudio.com/docs/editor/userdefinedsnippets#_create-your-own-snippets
+        @edits << Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: position,
+            end: position
+          ),
+          new_text: "$0"
+        )
+      end
+
+      sig { params(line: String).returns(Integer) }
+      def find_indentation(line)
+        count = 0
+
+        line.chars.each do |c|
+          break unless c == " "
+
+          count += 1
+        end
+
+        count
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -185,6 +185,10 @@ module RubyLsp
           add_token(location_without_colon(location), :variable)
         end
 
+        node.requireds.each do |required|
+          add_token(required.location, :variable)
+        end
+
         rest = node.keyword_rest
         return if rest.nil? || rest.is_a?(SyntaxTree::ArgsForward)
 
@@ -217,6 +221,19 @@ module RubyLsp
         add_token(node.value.location, :method) unless special_method?(node.value.value)
       end
 
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def visit_class(node)
+        add_token(node.constant.location, :class, [:declaration])
+        add_token(node.superclass.location, :class) if node.superclass
+        visit(node.bodystmt)
+      end
+
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      def visit_module(node)
+        add_token(node.constant.location, :class, [:declaration])
+        visit(node.bodystmt)
+      end
+
       sig { params(location: SyntaxTree::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
         length = location.end_char - location.start_char

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

@@ -1,11 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-begin
-  require "rubocop"
-rescue LoadError
-  return
-end
+require "ruby_lsp/requests/support/rubocop_runner"
+return unless defined?(::RubyLsp::Requests::Support::RuboCopRunner)
 
 require "cgi"
 require "singleton"
@@ -14,46 +11,24 @@ module RubyLsp
   module Requests
     module Support
       # :nodoc:
-      class RuboCopDiagnosticsRunner < RuboCop::Runner
+      class RuboCopDiagnosticsRunner
         extend T::Sig
         include Singleton
 
         sig { void }
         def initialize
-          @options = T.let({}, T::Hash[Symbol, T.untyped])
-          @uri = T.let(nil, T.nilable(String))
-          @diagnostics = T.let([], T::Array[Support::RuboCopDiagnostic])
-
-          super(
-            ::RuboCop::Options.new.parse([
-              "--stderr", # Print any output to stderr so that our stdout does not get polluted
-              "--force-exclusion",
-              "--format",
-              "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-            ]).first,
-            ::RuboCop::ConfigStore.new
-          )
+          @runner = T.let(RuboCopRunner.new, RuboCopRunner)
         end
 
         sig { params(uri: String, document: Document).returns(T::Array[Support::RuboCopDiagnostic]) }
         def run(uri, document)
-          @diagnostics.clear
-          @uri = uri
-
-          file = CGI.unescape(URI.parse(uri).path)
-          # We communicate with Rubocop via stdin
-          @options[:stdin] = document.source
-
+          filename = CGI.unescape(URI.parse(uri).path)
           # Invoke RuboCop with just this file in `paths`
-          super([file])
-          @diagnostics
-        end
-
-        private
+          @runner.run(filename, document.source)
 
-        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
-        def file_finished(_file, offenses)
-          @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, T.must(@uri)) }
+          @runner.offenses.map do |offense|
+            Support::RuboCopDiagnostic.new(offense, uri)
+          end
         end
       end
     end

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

@@ -1,11 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-begin
-  require "rubocop"
-rescue LoadError
-  return
-end
+require "ruby_lsp/requests/support/rubocop_runner"
+return unless defined?(::RubyLsp::Requests::Support::RuboCopRunner)
 
 require "cgi"
 require "singleton"
@@ -14,35 +11,24 @@ module RubyLsp
   module Requests
     module Support
       # :nodoc:
-      class RuboCopFormattingRunner < RuboCop::Runner
+      class RuboCopFormattingRunner
         extend T::Sig
         include Singleton
 
         sig { void }
         def initialize
-          @options = T.let({}, T::Hash[Symbol, T.untyped])
-
-          super(
-            ::RuboCop::Options.new.parse([
-              "--stderr", # Print any output to stderr so that our stdout does not get polluted
-              "--force-exclusion",
-              "--format",
-              "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-              "-a", # --auto-correct
-            ]).first,
-            ::RuboCop::ConfigStore.new
-          )
+          # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
+          @runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
         sig { params(uri: String, document: Document).returns(T.nilable(String)) }
         def run(uri, document)
-          file = CGI.unescape(URI.parse(uri).path)
-          # We communicate with Rubocop via stdin
-          @options[:stdin] = document.source
+          filename = CGI.unescape(URI.parse(uri).path)
 
           # Invoke RuboCop with just this file in `paths`
-          super([file])
-          @options[:stdin]
+          @runner.run(filename, document.source)
+
+          @runner.formatted_source
         end
       end
     end

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

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rubocop"
+rescue LoadError
+  return
+end
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class RuboCopRunner < RuboCop::Runner
+        extend T::Sig
+
+        sig { returns(T::Array[RuboCop::Cop::Offense]) }
+        attr_reader :offenses
+
+        DEFAULT_ARGS = T.let([
+          "--stderr", # Print any output to stderr so that our stdout does not get polluted
+          "--force-exclusion",
+          "--format",
+          "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+        ].freeze, T::Array[String])
+
+        sig { params(args: String).void }
+        def initialize(*args)
+          @options = T.let({}, T::Hash[Symbol, T.untyped])
+          @offenses = T.let([], T::Array[RuboCop::Cop::Offense])
+          @errors = T.let([], T::Array[String])
+          @warnings = T.let([], T::Array[String])
+
+          args += DEFAULT_ARGS
+          rubocop_options = ::RuboCop::Options.new.parse(args).first
+          config_store = ::RuboCop::ConfigStore.new
+
+          super(rubocop_options, config_store)
+        end
+
+        sig { params(path: String, contents: String).void }
+        def run(path, contents)
+          # Clear Runner state between runs since we get a single instance of this class
+          # on every use site.
+          @errors = []
+          @warnings = []
+          @offenses = []
+          @options[:stdin] = contents
+
+          super([path])
+        rescue RuboCop::Runner::InfiniteCorrectionLoop => error
+          raise Formatting::Error, error.message
+        end
+
+        sig { returns(String) }
+        def formatted_source
+          @options[:stdin]
+        end
+
+        private
+
+        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
+        def file_finished(_file, offenses)
+          @offenses = offenses
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -10,6 +10,7 @@ module RubyLsp
   # - {RubyLsp::Requests::SelectionRanges}
   # - {RubyLsp::Requests::SemanticHighlighting}
   # - {RubyLsp::Requests::Formatting}
+  # - {RubyLsp::Requests::OnTypeFormatting}
   # - {RubyLsp::Requests::Diagnostics}
   # - {RubyLsp::Requests::CodeActions}
   # - {RubyLsp::Requests::DocumentHighlight}
@@ -21,6 +22,7 @@ module RubyLsp
     autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
     autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
     autoload :Formatting, "ruby_lsp/requests/formatting"
+    autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
     autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"

data/lib/ruby_lsp/server.rb

@@ -48,23 +48,30 @@ module RubyLsp
         }
       end
 
-      # TODO: switch back to using Interface::ServerCapabilities once the gem is updated for spec 3.17
+      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
+        Interface::DocumentOnTypeFormattingOptions.new(
+          first_trigger_character: "{",
+          more_trigger_character: ["\n", "|"]
+        )
+      end
+
       Interface::InitializeResult.new(
-        capabilities: {
-          textDocumentSync: Interface::TextDocumentSyncOptions.new(
+        capabilities: Interface::ServerCapabilities.new(
+          text_document_sync: Interface::TextDocumentSyncOptions.new(
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
             open_close: true,
           ),
-          selectionRangeProvider: enabled_features.include?("selectionRanges"),
-          documentSymbolProvider: document_symbol_provider,
-          documentLinkProvider: document_link_provider,
-          foldingRangeProvider: folding_ranges_provider,
-          semanticTokensProvider: semantic_tokens_provider,
-          documentFormattingProvider: enabled_features.include?("formatting"),
-          documentHighlightProvider: enabled_features.include?("documentHighlights"),
-          codeActionProvider: enabled_features.include?("codeActions"),
-          diagnosticProvider: diagnostics_provider,
-        }.reject { |_, v| !v }
+          selection_range_provider: enabled_features.include?("selectionRanges"),
+          document_symbol_provider: document_symbol_provider,
+          document_link_provider: document_link_provider,
+          folding_range_provider: folding_ranges_provider,
+          semantic_tokens_provider: semantic_tokens_provider,
+          document_formatting_provider: enabled_features.include?("formatting"),
+          document_highlight_provider: enabled_features.include?("documentHighlights"),
+          code_action_provider: enabled_features.include?("codeActions"),
+          document_on_type_formatting_provider: on_type_formatting_provider,
+          diagnostic_provider: diagnostics_provider,
+        )
       )
     end
 
@@ -91,26 +98,26 @@ module RubyLsp
       Handler::VOID
     end
 
-    on("textDocument/documentSymbol") do |request|
+    on("textDocument/documentSymbol", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :document_symbol) do |document|
         Requests::DocumentSymbol.new(document).run
       end
     end
 
-    on("textDocument/documentLink") do |request|
+    on("textDocument/documentLink", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
       store.cache_fetch(uri, :document_link) do |document|
         RubyLsp::Requests::DocumentLink.new(uri, document).run
       end
     end
 
-    on("textDocument/foldingRange") do |request|
+    on("textDocument/foldingRange", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :folding_ranges) do |document|
         Requests::FoldingRanges.new(document).run
       end
     end
 
-    on("textDocument/selectionRange") do |request|
+    on("textDocument/selectionRange", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
       positions = request.dig(:params, :positions)
 
@@ -132,7 +139,7 @@ module RubyLsp
       end
     end
 
-    on("textDocument/semanticTokens/full") do |request|
+    on("textDocument/semanticTokens/full", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :semantic_highlighting) do |document|
         T.cast(
           Requests::SemanticHighlighting.new(
@@ -144,13 +151,23 @@ module RubyLsp
       end
     end
 
-    on("textDocument/formatting") do |request|
+    on("textDocument/formatting", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
 
       Requests::Formatting.new(uri, store.get(uri)).run
+    end.on_error do |error|
+      show_message(Constant::MessageType::ERROR, "Formatting error: #{error.message}")
+    end
+
+    on("textDocument/onTypeFormatting", parallel: true) do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      position = request.dig(:params, :position)
+      character = request.dig(:params, :ch)
+
+      Requests::OnTypeFormatting.new(store.get(uri), position, character).run
     end
 
-    on("textDocument/documentHighlight") do |request|
+    on("textDocument/documentHighlight", parallel: true) do |request|
       document = store.get(request.dig(:params, :textDocument, :uri))
 
       if document.parsed?
@@ -158,7 +175,7 @@ module RubyLsp
       end
     end
 
-    on("textDocument/codeAction") do |request|
+    on("textDocument/codeAction", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
       range = request.dig(:params, :range)
       start_line = range.dig(:start, :line)
@@ -169,6 +186,11 @@ module RubyLsp
       end
     end
 
+    on("$/cancelRequest") do |request|
+      cancel_request(request[:params][:id])
+      Handler::VOID
+    end
+
     on("textDocument/diagnostic") do |request|
       uri = request.dig(:params, :textDocument, :uri)
       response = store.cache_fetch(uri, :diagnostics) do |document|
@@ -176,9 +198,10 @@ module RubyLsp
       end
 
       { kind: "full", items: response.map(&:to_lsp_diagnostic) } if response
-    rescue RuboCop::ValidationError => e
-      show_message(Constant::MessageType::ERROR, "Error in RuboCop configuration file: #{e.message}")
-      nil
+    end.on_error do |error|
+      if error.is_a?(RuboCop::ValidationError)
+        show_message(Constant::MessageType::ERROR, "Error in RuboCop configuration file: #{error.message}")
+      end
     end
 
     on("shutdown") { shutdown }

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-18 00:00:00.000000000 Z
+date: 2022-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.17.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.4'
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -69,6 +69,7 @@ files:
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/handler.rb
 - lib/ruby_lsp/internal.rb
+- lib/ruby_lsp/queue.rb
 - lib/ruby_lsp/requests.rb
 - lib/ruby_lsp/requests/base_request.rb
 - lib/ruby_lsp/requests/code_actions.rb
@@ -78,12 +79,14 @@ files:
 - lib/ruby_lsp/requests/document_symbol.rb
 - lib/ruby_lsp/requests/folding_ranges.rb
 - lib/ruby_lsp/requests/formatting.rb
+- lib/ruby_lsp/requests/on_type_formatting.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
+- lib/ruby_lsp/requests/support/rubocop_runner.rb
 - lib/ruby_lsp/requests/support/selection_range.rb
 - lib/ruby_lsp/requests/support/semantic_token_encoder.rb
 - lib/ruby_lsp/requests/support/source_uri.rb