Make RuboCop runner composable and capture any stdout message from it

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,31 @@ 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
+          @runner.run(filename, document.source)
+
+          diagnostics(uri)
         end
 
         private
 
-        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)) }
+        sig { params(uri: String).returns(T::Array[Support::RuboCopDiagnostic]) }
+        def diagnostics(uri)
+          @runner.offenses.map do |offense|
+            Support::RuboCopDiagnostic.new(offense, uri)
+          end
         end
       end
     end

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,25 @@ 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
-          )
+          @runner = T.let(RuboCopRunner.new(
+            "-a", # --auto-correct
+          ), 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

lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rubocop"
+rescue LoadError
+  return
+end
+
+require "cgi"
+require "singleton"
+
+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([
+          "--force-exclusion",
+        ].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
+          super(rubocop_options, ::RuboCop::ConfigStore.new)
+        end
+
+        sig { params(path: String, contents: String).void }
+        def run(path, contents)
+          @errors = []
+          @warnings = []
+          @offenses = []
+          @options[:stdin] = contents
+          capture_output { super([path]) }
+          display_handled_errors
+        end
+
+        sig { returns(String) }
+        def formatted_source
+          @options[:stdin]
+        end
+
+        private
+
+        sig { void }
+        def display_handled_errors
+          return if errors.empty?
+
+          $stderr.puts "[RuboCop] Encountered and handled errors:"
+          errors.uniq.each do |error|
+            $stderr.puts "[RuboCop]   - #{error}"
+          end
+        end
+
+        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
+        def file_finished(_file, offenses)
+          @offenses = offenses
+        end
+
+        sig { params(block: T.proc.void).void }
+        def capture_output(&block)
+          original_verbosity = $VERBOSE
+          orig_stdout = $stdout
+          orig_stderr = $stderr
+
+          $VERBOSE = nil
+          $stderr = StringIO.new
+          $stdout = StringIO.new
+
+          block.call
+        ensure
+          $stdout = orig_stdout
+          $stderr = orig_stderr
+          $VERBOSE = original_verbosity
+        end
+      end
+    end
+  end
+end