rubocop 1.54.1 → 1.64.1

data/lib/rubocop/directive_comment.rb

@@ -6,9 +6,11 @@ module RuboCop
   # cops it contains.
   class DirectiveComment
     # @api private
-    REDUNDANT_DIRECTIVE_COP_DEPARTMENT = 'Lint'
+    LINT_DEPARTMENT = 'Lint'
     # @api private
-    REDUNDANT_DIRECTIVE_COP = "#{REDUNDANT_DIRECTIVE_COP_DEPARTMENT}/RedundantCopDisableDirective"
+    LINT_REDUNDANT_DIRECTIVE_COP = "#{LINT_DEPARTMENT}/RedundantCopDisableDirective"
+    # @api private
+    LINT_SYNTAX_COP = "#{LINT_DEPARTMENT}/Syntax"
     # @api private
     COP_NAME_PATTERN = '([A-Z]\w+/)*(?:[A-Z]\w+)'
     # @api private
@@ -118,9 +120,10 @@ module RuboCop
     end
 
     def parsed_cop_names
-      splitted_cops_string.map do |name|
+      cops = splitted_cops_string.map do |name|
         department?(name) ? cop_names_for_department(name) : name
       end.flatten
+      cops - [LINT_SYNTAX_COP]
     end
 
     def department?(name)
@@ -128,17 +131,16 @@ module RuboCop
     end
 
     def all_cop_names
-      exclude_redundant_directive_cop(cop_registry.names)
+      exclude_lint_department_cops(cop_registry.names)
     end
 
     def cop_names_for_department(department)
       names = cop_registry.names_for_department(department)
-      has_redundant_directive_cop = department == REDUNDANT_DIRECTIVE_COP_DEPARTMENT
-      has_redundant_directive_cop ? exclude_redundant_directive_cop(names) : names
+      department == LINT_DEPARTMENT ? exclude_lint_department_cops(names) : names
     end
 
-    def exclude_redundant_directive_cop(cops)
-      cops - [REDUNDANT_DIRECTIVE_COP]
+    def exclude_lint_department_cops(cops)
+      cops - [LINT_REDUNDANT_DIRECTIVE_COP, LINT_SYNTAX_COP]
     end
   end
 end

data/lib/rubocop/ext/regexp_node.rb

@@ -54,10 +54,7 @@ module RuboCop
         return enum_for(__method__, named: named) unless block_given?
 
         parsed_tree&.traverse do |event, exp, _index|
-          yield(exp) if event == :enter &&
-                        named == exp.respond_to?(:name) &&
-                        exp.respond_to?(:capturing?) &&
-                        exp.capturing?
+          yield(exp) if named_capturing?(exp, event, named)
         end
 
         self
@@ -65,6 +62,14 @@ module RuboCop
 
       private
 
+      def named_capturing?(exp, event, named)
+        event == :enter &&
+          named == exp.respond_to?(:name) &&
+          !exp.text.start_with?('(?<=') &&
+          exp.respond_to?(:capturing?) &&
+          exp.capturing?
+      end
+
       def with_interpolations_blanked
         # Ignore the trailing regopt node
         children[0...-1].map do |child|

data/lib/rubocop/file_finder.rb

@@ -6,12 +6,8 @@ module RuboCop
   # Common methods for finding files.
   # @api private
   module FileFinder
-    def self.root_level=(level)
-      @root_level = level
-    end
-
-    def self.root_level?(path, stop_dir)
-      (@root_level || stop_dir) == path.to_s
+    class << self
+      attr_accessor :root_level
     end
 
     def find_file_upwards(filename, start_dir, stop_dir = nil)
@@ -34,7 +30,8 @@ module RuboCop
         file = dir + filename
         yield(file.to_s) if file.exist?
 
-        break if FileFinder.root_level?(dir, stop_dir)
+        dir = dir.to_s
+        break if dir == stop_dir || dir == FileFinder.root_level
       end
     end
   end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -24,14 +24,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 valid_line?(offense)

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -30,7 +30,8 @@ module RuboCop
         @files_with_offenses ||= {}
       end
 
-      def file_started(_file, _file_info)
+      def file_started(_file, options)
+        @config_for_pwd = options[:config_store].for_pwd
         @exclude_limit_option = @options[:exclude_limit]
         @exclude_limit = Integer(@exclude_limit_option ||
           RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS)
@@ -115,16 +116,24 @@ module RuboCop
       def set_max(cfg, cop_name)
         return unless cfg[:exclude_limit]
 
-        # In case auto_gen_only_exclude is set, only modify the maximum if the
-        # files are not excluded one by one.
-        if !@options[:auto_gen_only_exclude] || @files_with_offenses[cop_name].size > @exclude_limit
-          cfg.merge!(cfg[:exclude_limit])
-        end
+        cfg.merge!(cfg[:exclude_limit]) if should_set_max?(cop_name)
 
         # Remove already used exclude_limit.
         cfg.reject! { |key| key == :exclude_limit }
       end
 
+      def should_set_max?(cop_name)
+        max_set_in_user_config =
+          @config_for_pwd.for_cop(cop_name)['Max'] != default_config(cop_name)['Max']
+
+        max_allowed = !max_set_in_user_config && !no_exclude_limit?
+        return false unless max_allowed
+
+        # In case auto_gen_only_exclude is set, only modify the maximum if the files are not
+        # excluded one by one.
+        !@options[:auto_gen_only_exclude] || @files_with_offenses[cop_name].size > @exclude_limit
+      end
+
       def output_cop_comments(output_buffer, cfg, cop_name, offense_count)
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 
@@ -192,8 +201,8 @@ module RuboCop
         # 'Enabled' option will be put into file only if exclude
         # limit is exceeded.
         rejected_keys = ['Enabled']
-        rejected_keys << 'EnforcedStyle' unless auto_gen_enforced_style?
-        cfg.reject { |key| rejected_keys.include?(key) }
+        rejected_keys << /\AEnforcedStyle\w*/ unless auto_gen_enforced_style?
+        cfg.reject { |key| include_or_match?(rejected_keys, key) }
       end
 
       def output_offending_files(output_buffer, cfg, cop_name)
@@ -262,6 +271,12 @@ module RuboCop
       def no_exclude_limit?
         @options[:no_exclude_limit] == false
       end
+
+      # Returns true if the given arr include the given elm or if any of the
+      # given arr is a regexp that matches the given elm.
+      def include_or_match?(arr, elm)
+        arr.include?(elm) || arr.any? { |x| x.is_a?(Regexp) && x.match?(elm) }
+      end
     end
   end
 end

data/lib/rubocop/formatter/formatter_set.rb

@@ -27,6 +27,7 @@ module RuboCop
         '[t]ap'         => 'TapFormatter',
         '[w]orst'       => 'WorstOffendersFormatter'
       }.freeze
+      BUILTIN_FORMATTER_NAMES = BUILTIN_FORMATTERS_FOR_KEYS.keys.map { |key| key.delete('[]') }
 
       FORMATTER_APIS = %i[started finished].freeze
 
@@ -88,7 +89,12 @@ module RuboCop
           /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
         end
 
-        raise %(No formatter for "#{specified_key}") if matching_keys.empty?
+        if matching_keys.empty?
+          similar_name = NameSimilarity.find_similar_name(specified_key, BUILTIN_FORMATTER_NAMES)
+          suggestion = %( Did you mean? "#{similar_name}") if similar_name
+
+          raise Rainbow(%(Formatter "#{specified_key}" not found.#{suggestion})).red
+        end
 
         raise %(Cannot determine formatter for "#{specified_key}") if matching_keys.size > 1
 

data/lib/rubocop/formatter/html_formatter.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'cgi'
 require 'erb'
-require 'ostruct'
 
 module RuboCop
   module Formatter
@@ -11,6 +9,7 @@ module RuboCop
     class HTMLFormatter < BaseFormatter
       ELLIPSES = '<span class="extra-code">...</span>'
       TEMPLATE_PATH = File.expand_path('../../../assets/output.html.erb', __dir__)
+      CSS_PATH = File.expand_path('../../../assets/output.css.erb', __dir__)
 
       Color = Struct.new(:red, :green, :blue, :alpha) do
         def to_s
@@ -52,8 +51,8 @@ module RuboCop
         context = ERBContext.new(files, summary)
 
         template = File.read(TEMPLATE_PATH, encoding: Encoding::UTF_8)
-        erb = ERB.new(template, trim_mode: '-')
-        html = erb.result(context.binding)
+        erb = ERB.new(template)
+        html = erb.result(context.binding).lines.map { (_1 =~ /^\s*$/).nil? ? _1 : "\n" }.join
 
         output.write html
       end
@@ -63,14 +62,6 @@ module RuboCop
         include PathUtil
         include TextUtil
 
-        SEVERITY_COLORS = {
-          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
-          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
-          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
-          error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
-          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
-        }.freeze
-
         LOGO_IMAGE_PATH = File.expand_path('../../../assets/logo.png', __dir__)
 
         attr_reader :files, :summary
@@ -88,7 +79,7 @@ module RuboCop
         # rubocop:enable Lint/UselessMethodDefinition
 
         def decorated_message(offense)
-          offense.message.gsub(/`(.+?)`/) { "<code>#{Regexp.last_match(1)}</code>" }
+          offense.message.gsub(/`(.+?)`/) { "<code>#{escape(Regexp.last_match(1))}</code>" }
         end
 
         def highlighted_source_line(offense)
@@ -124,9 +115,39 @@ module RuboCop
 
         def base64_encoded_logo_image
           image = File.read(LOGO_IMAGE_PATH, binmode: true)
-          Base64.encode64(image)
+
+          # `Base64.encode64` compatible:
+          # https://github.com/ruby/base64/blob/v0.1.1/lib/base64.rb#L27-L40
+          [image].pack('m')
+        end
+
+        def render_css
+          context = CSSContext.new
+          template = File.read(CSS_PATH, encoding: Encoding::UTF_8)
+          erb = ERB.new(template, trim_mode: '-')
+          erb.result(context.binding).lines.map do |line|
+            line == "\n" ? line : "      #{line}"
+          end.join
         end
       end
+
+      # This class provides helper methods used in the ERB CSS template.
+      class CSSContext
+        SEVERITY_COLORS = {
+          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
+          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
+          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
+          error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
+          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
+        }.freeze
+
+        # Make Kernel#binding public.
+        # rubocop:disable Lint/UselessMethodDefinition
+        def binding
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+      end
     end
   end
 end

data/lib/rubocop/formatter/json_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'pathname'
 
 module RuboCop
   module Formatter

data/lib/rubocop/formatter/junit_formatter.rb

@@ -63,7 +63,7 @@ module RuboCop
 
       def classname_attribute_value(file)
         @classname_attribute_value_cache ||= Hash.new do |hash, key|
-          hash[key] = key.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
+          hash[key] = key.delete_suffix('.rb').gsub("#{Dir.pwd}/", '').tr('/', '.')
         end
         @classname_attribute_value_cache[file]
       end

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -61,8 +61,7 @@ module RuboCop
 
         column_width = total_count.to_s.length + 2
         per_cop_counts.each do |cop_name, count|
-          output.puts "#{count.to_s.ljust(column_width)}#{cop_name}" \
-                      "#{@style_guide_links[cop_name]}\n"
+          output.puts "#{count.to_s.ljust(column_width)}#{cop_information(cop_name)}"
         end
         output.puts '--'
         output.puts "#{total_count}  Total in #{offending_files_count} files"
@@ -78,6 +77,17 @@ module RuboCop
       def total_offense_count(offense_counts)
         offense_counts.values.sum
       end
+
+      def cop_information(cop_name)
+        cop = RuboCop::Cop::Registry.global.find_by_cop_name(cop_name).new
+
+        if cop.correctable?
+          safety = cop.safe_autocorrect? ? 'Safe' : 'Unsafe'
+          correctable = Rainbow(" [#{safety} Correctable]").yellow
+        end
+
+        "#{cop_name}#{correctable}#{@style_guide_links[cop_name]}"
+      end
     end
   end
 end

data/lib/rubocop/formatter/tap_formatter.rb

@@ -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.rb

@@ -14,7 +14,7 @@ module RuboCop
     require_relative 'formatter/emacs_style_formatter'
     require_relative 'formatter/file_list_formatter'
     require_relative 'formatter/fuubar_style_formatter'
-    require_relative 'formatter/git_hub_actions_formatter'
+    require_relative 'formatter/github_actions_formatter'
     require_relative 'formatter/html_formatter'
     require_relative 'formatter/json_formatter'
     require_relative 'formatter/junit_formatter'

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

@@ -10,7 +10,7 @@
 # https://github.com/standardrb/standard/blob/main/LICENSE.txt
 #
 module RuboCop
-  module Lsp
+  module LSP
     # Log for Language Server Protocol of RuboCop.
     # @api private
     class Logger

data/lib/rubocop/lsp/routes.rb

@@ -12,12 +12,12 @@ require_relative 'severity'
 # https://github.com/standardrb/standard/blob/main/LICENSE.txt
 #
 module RuboCop
-  module Lsp
+  module LSP
     # Routes for Language Server Protocol of RuboCop.
     # @api private
     class Routes
       def self.handle(name, &block)
-        define_method("handle_#{name}", &block)
+        define_method(:"handle_#{name}", &block)
       end
 
       private_class_method :handle
@@ -36,14 +36,15 @@ module RuboCop
       end
 
       handle 'initialize' do |request|
-        @server.configure(safe_autocorrect: safe_autocorrect?(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,
-              diagnostic_provider: true,
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
                 change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
                 open_close: true
@@ -55,8 +56,9 @@ module RuboCop
 
       handle 'initialized' do |_request|
         version = RuboCop::Version::STRING
+        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
 
-        Logger.log("RuboCop #{version} language server initialized, PID #{Process.pid}")
+        Logger.log("RuboCop #{version} language server#{yjit} initialized, PID #{Process.pid}")
       end
 
       handle 'shutdown' do |request|
@@ -67,12 +69,6 @@ module RuboCop
         end
       end
 
-      handle 'textDocument/diagnostic' do |request|
-        doc = request[:params][:textDocument]
-        result = diagnostic(doc[:uri], doc[:text])
-        @server.write(result)
-      end
-
       handle 'textDocument/didChange' do |request|
         params = request[:params]
         result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
@@ -110,23 +106,35 @@ module RuboCop
       end
 
       handle 'workspace/executeCommand' do |request|
-        if request[:params][:command] == 'rubocop.formatAutocorrects'
-          uri = request[:params][:arguments][0][:uri]
-          @server.write(
-            id: request[:id],
-            method: 'workspace/applyEdit',
-            params: {
-              label: 'Format with RuboCop autocorrects',
-              edit: {
-                changes: {
-                  uri => format_file(uri)
-                }
-              }
-            }
-          )
+        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, request[:params][:command])
+          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|
@@ -164,20 +172,24 @@ module RuboCop
 
       private
 
-      def safe_autocorrect?(request)
+      def extract_initialization_options_from(request)
         safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
 
-        safe_autocorrect.nil? || safe_autocorrect == true
+        {
+          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)
+      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)
+        new_text = @server.format(remove_file_protocol_from(file_uri), text, command: command)
 
         return [] if new_text == text
 
@@ -223,7 +235,7 @@ module RuboCop
       def to_range(location)
         {
           start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
-          end: { character: location[:last_column] - 1, line: location[:last_line] - 1 }
+          end: { character: location[:last_column], line: location[:last_line] - 1 }
         }
       end
     end