rubocop 1.24.1 → 1.64.1

data/lib/rubocop/formatter/tap_formatter.rb

@@ -29,7 +29,7 @@ module RuboCop
       def report_line(location)
         source_line = location.source_line
 
-        if location.first_line == location.last_line
+        if location.single_line?
           output.puts("# #{source_line}")
         else
           output.puts("# #{source_line} #{yellow(ELLIPSES)}")
@@ -53,14 +53,10 @@ module RuboCop
           message: message(offense)
         )
 
-        begin
-          return unless valid_line?(offense)
+        return unless valid_line?(offense)
 
-          report_line(offense.location)
-          report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
-          # range is not on a valid line; perhaps the source file is empty
-        end
+        report_line(offense.location)
+        report_highlighted_area(offense.highlighted_area)
       end
 
       def annotate_message(msg)

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -12,7 +12,7 @@ module RuboCop
     # 26  this/file/is/really/bad.rb
     # 3   just/ok.rb
     # --
-    # 29  Total
+    # 29  Total in 2 files
     class WorstOffendersFormatter < BaseFormatter
       attr_reader :offense_counts
 
@@ -36,15 +36,17 @@ module RuboCop
       def report_summary(offense_counts)
         per_file_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
+        file_count = per_file_counts.size
 
         output.puts
 
+        column_width = total_count.to_s.length + 2
         per_file_counts.each do |file_name, count|
-          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}" \
-                      "#{file_name}\n"
+          output.puts "#{count.to_s.ljust(column_width)}#{file_name}\n"
         end
+
         output.puts '--'
-        output.puts "#{total_count}  Total"
+        output.puts "#{total_count}  Total in #{file_count} files"
 
         output.puts
       end

data/lib/rubocop/formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The bootstrap module for formatter.
+  module Formatter
+    require_relative 'formatter/text_util'
+
+    require_relative 'formatter/base_formatter'
+    require_relative 'formatter/simple_text_formatter'
+
+    # relies on simple text
+    require_relative 'formatter/clang_style_formatter'
+    require_relative 'formatter/disabled_config_formatter'
+    require_relative 'formatter/emacs_style_formatter'
+    require_relative 'formatter/file_list_formatter'
+    require_relative 'formatter/fuubar_style_formatter'
+    require_relative 'formatter/github_actions_formatter'
+    require_relative 'formatter/html_formatter'
+    require_relative 'formatter/json_formatter'
+    require_relative 'formatter/junit_formatter'
+    require_relative 'formatter/markdown_formatter'
+    require_relative 'formatter/offense_count_formatter'
+    require_relative 'formatter/pacman_formatter'
+    require_relative 'formatter/progress_formatter'
+    require_relative 'formatter/quiet_formatter'
+    require_relative 'formatter/tap_formatter'
+    require_relative 'formatter/worst_offenders_formatter'
+
+    # relies on progress formatter
+    require_relative 'formatter/auto_gen_config_formatter'
+
+    require_relative 'formatter/formatter_set'
+  end
+end

data/lib/rubocop/lockfile.rb

@@ -1,18 +1,39 @@
 # frozen_string_literal: true
 
+begin
+  # We might not be running with `bundle exec`, so we need to pull in Bundler ourselves,
+  # in order to use `Bundler::LockfileParser`.
+  require 'bundler'
+rescue LoadError
+  nil
+end
+
 module RuboCop
   # Encapsulation of a lockfile for use when checking for gems.
   # Does not actually resolve gems, just parses the lockfile.
   # @api private
   class Lockfile
-    # Gems that the bundle depends on
+    # @param [String, Pathname, nil] lockfile_path
+    def initialize(lockfile_path = nil)
+      lockfile_path ||= begin
+        ::Bundler.default_lockfile if bundler_lock_parser_defined?
+      rescue ::Bundler::GemfileNotFound
+        nil # We might not be a folder with a Gemfile, but that's okay.
+      end
+
+      @lockfile_path = lockfile_path
+    end
+
+    # Gems that the bundle directly depends on.
+    # @return [Array<Bundler::Dependency>, nil]
     def dependencies
       return [] unless parser
 
       parser.dependencies.values
     end
 
-    # All activated gems, including transitive dependencies
+    # All activated gems, including transitive dependencies.
+    # @return [Array<Bundler::Dependency>, nil]
     def gems
       return [] unless parser
 
@@ -21,20 +42,48 @@ module RuboCop
       parser.dependencies.values.concat(parser.specs.flat_map(&:dependencies))
     end
 
+    # Returns the locked versions of gems from this lockfile.
+    # @param [Boolean] include_transitive_dependencies: When false, only direct dependencies
+    #   are returned, i.e. those listed explicitly in the `Gemfile`.
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def gem_versions(include_transitive_dependencies: true)
+      return {} unless parser
+
+      all_gem_versions = parser.specs.to_h { |spec| [spec.name, spec.version] }
+
+      if include_transitive_dependencies
+        all_gem_versions
+      else
+        direct_dep_names = parser.dependencies.keys
+        all_gem_versions.slice(*direct_dep_names)
+      end
+    end
+
+    # Whether this lockfile includes the named gem, directly or indirectly.
+    # @param [String] name
+    # @return [Boolean]
     def includes_gem?(name)
       gems.any? { |gem| gem.name == name }
     end
 
     private
 
+    # @return [Bundler::LockfileParser, nil]
     def parser
-      return unless defined?(Bundler) && Bundler.default_lockfile
       return @parser if defined?(@parser)
 
-      lockfile = Bundler.read_file(Bundler.default_lockfile)
-      @parser = lockfile ? Bundler::LockfileParser.new(lockfile) : nil
-    rescue Bundler::BundlerError
-      nil
+      @parser = if @lockfile_path && File.exist?(@lockfile_path) && bundler_lock_parser_defined?
+                  begin
+                    lockfile = ::Bundler.read_file(@lockfile_path)
+                    ::Bundler::LockfileParser.new(lockfile) if lockfile
+                  rescue ::Bundler::BundlerError
+                    nil
+                  end
+                end
+    end
+
+    def bundler_lock_parser_defined?
+      Object.const_defined?(:Bundler) && Bundler.const_defined?(:LockfileParser)
     end
   end
 end

data/lib/rubocop/lsp/logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Log for Language Server Protocol of RuboCop.
+    # @api private
+    class Logger
+      def self.log(message)
+        warn("[server] #{message}")
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/routes.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Routes for Language Server Protocol of RuboCop.
+    # @api private
+    class Routes
+      def self.handle(name, &block)
+        define_method(:"handle_#{name}", &block)
+      end
+
+      private_class_method :handle
+
+      def initialize(server)
+        @server = server
+
+        @text_cache = {}
+      end
+
+      def for(name)
+        name = "handle_#{name}"
+        return unless respond_to?(name)
+
+        method(name)
+      end
+
+      handle 'initialize' do |request|
+        initialization_options = extract_initialization_options_from(request)
+
+        @server.configure(initialization_options)
+
+        @server.write(
+          id: request[:id],
+          result: LanguageServer::Protocol::Interface::InitializeResult.new(
+            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
+              document_formatting_provider: true,
+              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+                open_close: true
+              )
+            )
+          )
+        )
+      end
+
+      handle 'initialized' do |_request|
+        version = RuboCop::Version::STRING
+        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
+
+        Logger.log("RuboCop #{version} language server#{yjit} initialized, PID #{Process.pid}")
+      end
+
+      handle 'shutdown' do |request|
+        Logger.log('Client asked to shutdown RuboCop language server.')
+        @server.stop do
+          @server.write(id: request[:id], result: nil)
+          Logger.log('Exiting...')
+        end
+      end
+
+      handle 'textDocument/didChange' do |request|
+        params = request[:params]
+        result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didOpen' do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didClose' do |request|
+        @text_cache.delete(request.dig(:params, :textDocument, :uri))
+      end
+
+      handle 'textDocument/formatting' do |request|
+        uri = request[:params][:textDocument][:uri]
+        @server.write(id: request[:id], result: format_file(uri))
+      end
+
+      handle 'workspace/didChangeConfiguration' do |_request|
+        Logger.log('Ignoring workspace/didChangeConfiguration')
+      end
+
+      handle 'workspace/didChangeWatchedFiles' do |request|
+        changed = request[:params][:changes].any? do |change|
+          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+        end
+
+        if changed
+          Logger.log('Configuration file changed; restart required')
+          @server.stop
+        end
+      end
+
+      handle 'workspace/executeCommand' do |request|
+        case (command = request[:params][:command])
+        when 'rubocop.formatAutocorrects'
+          label = 'Format with RuboCop autocorrects'
+        when 'rubocop.formatAutocorrectsAll'
+          label = 'Format all with RuboCop autocorrects'
+        else
+          handle_unsupported_method(request, command)
+          return
+        end
+
+        uri = request[:params][:arguments][0][:uri]
+        formatted = nil
+
+        # The `workspace/executeCommand` is an LSP method triggered by intentional user actions,
+        # so the user's intention for autocorrection is respected.
+        LSP.disable { formatted = format_file(uri, command: command) }
+
+        @server.write(
+          id: request[:id],
+          method: 'workspace/applyEdit',
+          params: {
+            label: label,
+            edit: {
+              changes: {
+                uri => formatted
+              }
+            }
+          }
+        )
+      end
+
+      handle 'textDocument/willSave' do |_request|
+        # Nothing to do
+      end
+
+      handle 'textDocument/didSave' do |_request|
+        # Nothing to do
+      end
+
+      handle '$/cancelRequest' do |_request|
+        # Can't cancel anything because single-threaded
+      end
+
+      handle '$/setTrace' do |_request|
+        # No-op, we log everything
+      end
+
+      def handle_unsupported_method(request, method = request[:method])
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Unsupported Method: #{method}"
+          )
+        )
+        Logger.log("Unsupported Method: #{method}")
+      end
+
+      def handle_method_missing(request)
+        return unless request.key?(:id)
+
+        @server.write(id: request[:id], result: nil)
+      end
+
+      private
+
+      def extract_initialization_options_from(request)
+        safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
+
+        {
+          safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
+          lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+        }
+      end
+
+      def format_file(file_uri, command: nil)
+        unless (text = @text_cache[file_uri])
+          Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
+
+          return []
+        end
+
+        new_text = @server.format(remove_file_protocol_from(file_uri), text, command: command)
+
+        return [] if new_text == text
+
+        [
+          newText: new_text,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: text.count("\n") + 1, character: 0 }
+          }
+        ]
+      end
+
+      def diagnostic(file_uri, text)
+        @text_cache[file_uri] = text
+        offenses = @server.offenses(remove_file_protocol_from(file_uri), text)
+        diagnostics = offenses.map { |offense| to_diagnostic(offense) }
+
+        {
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: file_uri,
+            diagnostics: diagnostics
+          }
+        }
+      end
+
+      def remove_file_protocol_from(uri)
+        uri.delete_prefix('file://')
+      end
+
+      def to_diagnostic(offense)
+        code = offense[:cop_name]
+        message = offense[:message]
+        loc = offense[:location]
+        rubocop_severity = offense[:severity]
+        severity = Severity.find_by(rubocop_severity)
+
+        {
+          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
+        }
+      end
+
+      def to_range(location)
+        {
+          start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
+          end: { character: location[:last_column], line: location[:last_line] - 1 }
+        }
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/runtime.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Runtime for Language Server Protocol of RuboCop.
+    # @api private
+    class Runtime
+      attr_writer :safe_autocorrect, :lint_mode, :layout_mode
+
+      def initialize(config_store)
+        @config_store = config_store
+        @logged_paths = []
+        @safe_autocorrect = true
+        @lint_mode = false
+        @layout_mode = false
+      end
+
+      # This abuses the `--stdin` option of rubocop and reads the formatted text
+      # from the `options[:stdin]` that rubocop mutates. This depends on
+      # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup
+      # or reassign that options object. Risky business!
+      #
+      # Reassigning `options[:stdin]` is done here:
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131
+      # Printing `options[:stdin]`
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95
+      # Setting `parallel: true` would break this here:
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72
+      def format(path, text, command:)
+        safe_autocorrect = if command
+                             command == 'rubocop.formatAutocorrects'
+                           else
+                             @safe_autocorrect
+                           end
+
+        formatting_options = {
+          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: safe_autocorrect
+        }
+        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
+
+        redirect_stdout { run_rubocop(formatting_options, path) }
+
+        formatting_options[:stdin]
+      end
+
+      def offenses(path, text)
+        diagnostic_options = {
+          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
+        }
+        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
+
+        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
+        results = JSON.parse(json, symbolize_names: true)
+
+        if results[:files].empty?
+          unless @logged_paths.include?(path)
+            Logger.log "Ignoring file, per configuration: #{path}"
+            @logged_paths << path
+          end
+          return []
+        end
+
+        results.dig(:files, 0, :offenses)
+      end
+
+      private
+
+      def config_only_options
+        only_options = []
+        only_options << 'Lint' if @lint_mode
+        only_options << 'Layout' if @layout_mode
+        only_options
+      end
+
+      def redirect_stdout(&block)
+        stdout = StringIO.new
+
+        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
+
+        stdout.string
+      end
+
+      def run_rubocop(options, path)
+        runner = RuboCop::Runner.new(options, @config_store)
+
+        runner.run([path])
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/server.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+require_relative '../lsp'
+require_relative 'logger'
+require_relative 'routes'
+require_relative 'runtime'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Language Server Protocol of RuboCop.
+    # @api private
+    class Server
+      def initialize(config_store)
+        $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
+
+        RuboCop::LSP.enable
+
+        @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
+        @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
+        @runtime = RuboCop::LSP::Runtime.new(config_store)
+        @routes = Routes.new(self)
+      end
+
+      def start
+        @reader.read do |request|
+          if !request.key?(:method)
+            @routes.handle_method_missing(request)
+          elsif (route = @routes.for(request[:method]))
+            route.call(request)
+          else
+            @routes.handle_unsupported_method(request)
+          end
+        rescue StandardError => e
+          Logger.log("Error #{e.class} #{e.message[0..100]}")
+          Logger.log(e.backtrace.inspect)
+        end
+      end
+
+      def write(response)
+        @writer.write(response)
+      end
+
+      def format(path, text, command:)
+        @runtime.format(path, text, command: command)
+      end
+
+      def offenses(path, text)
+        @runtime.offenses(path, text)
+      end
+
+      def configure(options)
+        @runtime.safe_autocorrect = options[:safe_autocorrect]
+        @runtime.lint_mode = options[:lint_mode]
+        @runtime.layout_mode = options[:layout_mode]
+      end
+
+      def stop(&block)
+        at_exit(&block) if block
+        exit
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/severity.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Severity for Language Server Protocol of RuboCop.
+    # @api private
+    class Severity
+      SEVERITIES = {
+        fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+        error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+        warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
+        convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+        refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT,
+        info: LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT
+      }.freeze
+
+      def self.find_by(rubocop_severity)
+        if (severity = SEVERITIES[rubocop_severity.to_sym])
+          return severity
+        end
+
+        Logger.log("Unknown severity: #{rubocop_severity}")
+        LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT
+      end
+    end
+  end
+end

data/lib/rubocop/lsp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The RuboCop's built-in LSP module.
+  module LSP
+    module_function
+
+    # Returns true when LSP is enabled, false when disabled.
+    #
+    # @return [Boolean]
+    def enabled?
+      @enabled ||= false
+    end
+
+    # Enable LSP.
+    #
+    # @return [void]
+    def enable
+      @enabled = true
+    end
+
+    # Disable LSP.
+    #
+    # @return [void]
+    def disable(&block)
+      if block
+        original = @enabled
+        @enabled = false
+        yield
+        @enabled = original
+      else
+        @enabled = false
+      end
+    end
+  end
+end