rubocop 1.53.1 → 1.57.2

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -6,27 +6,40 @@ module RuboCop
       # Helper to abstract complexity of building range pairs
       # with octal escape reconstruction (needed for regexp_parser < 2.7).
       class RegexpRanges
-        attr_reader :compound_token, :root
+        attr_reader :root
 
         def initialize(root)
           @root = root
           @compound_token = []
+          @pairs = []
+          @populated = false
+        end
+
+        def compound_token
+          populate_all unless @populated
+
+          @compound_token
         end
 
         def pairs
-          unless @pairs
-            @pairs = []
-            populate(root)
-          end
+          populate_all unless @populated
+
+          @pairs
+        end
+
+        private
+
+        def populate_all
+          populate(@root)
 
           # If either bound is a compound the first one is an escape
           # and that's all we need to work with.
           # If there are any cops that wanted to operate on the compound
           # expression we could wrap it with a facade class.
-          @pairs.map { |pair| pair.map(&:first) }
-        end
+          @pairs.map! { |pair| pair.map(&:first) }
 
-        private
+          @populated = true
+        end
 
         def populate(expr)
           expressions = expr.expressions.to_a
@@ -35,15 +48,15 @@ module RuboCop
             current = expressions.shift
 
             if escaped_octal?(current)
-              compound_token << current
-              compound_token.concat(pop_octal_digits(expressions))
+              @compound_token << current
+              @compound_token.concat(pop_octal_digits(expressions))
               # If we have all the digits we can discard.
             end
 
             next unless current.type == :set
 
             process_set(expressions, current)
-            compound_token.clear
+            @compound_token.clear
           end
         end
 
@@ -64,8 +77,8 @@ module RuboCop
 
         def compose_range(expressions, current)
           range_start, range_end = current.expressions
-          range_start = if compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
-                          compound_token.dup << range_start
+          range_start = if @compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
+                          @compound_token.dup << range_start
                         else
                           [range_start]
                         end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -102,10 +102,11 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent&.parent
-          return nil unless grandparent_node
+          return nil unless (grandparent_node = node.parent&.parent)
+          if (node = find_multiple_assignment_node(grandparent_node))
+            return node
+          end
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
 
           grandparent_node
         end
@@ -118,9 +119,17 @@ module RuboCop
         end
 
         def for_assignment_node
-          return nil unless node.parent&.for_type?
+          node.ancestors.find(&:for_type?)
+        end
 
-          node.parent
+        def find_multiple_assignment_node(grandparent_node)
+          return unless grandparent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+          return if grandparent_node.children.any?(&:splat_type?)
+
+          parent = grandparent_node.parent
+          return parent if parent.type == MULTIPLE_ASSIGNMENT_TYPE
+
+          find_multiple_assignment_node(parent)
         end
       end
     end

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/html_formatter.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'cgi'
 require 'erb'
 require 'ostruct'
@@ -124,7 +123,10 @@ 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
       end
     end

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/lsp/routes.rb

@@ -36,12 +36,19 @@ module RuboCop
       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,
-              diagnostic_provider: true,
+              diagnostic_provider: LanguageServer::Protocol::Interface::DiagnosticOptions.new(
+                inter_file_dependencies: false,
+                workspace_diagnostics: false
+              ),
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
                 change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
                 open_close: true
@@ -108,23 +115,29 @@ 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]
+        @server.write(
+          id: request[:id],
+          method: 'workspace/applyEdit',
+          params: {
+            label: label,
+            edit: {
+              changes: {
+                uri => format_file(uri, command: command)
+              }
+            }
+          }
+        )
       end
 
       handle 'textDocument/willSave' do |_request|
@@ -162,14 +175,24 @@ module RuboCop
 
       private
 
-      def format_file(file_uri)
+      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)
+        new_text = @server.format(remove_file_protocol_from(file_uri), text, command: command)
 
         return [] if new_text == text
 

data/lib/rubocop/lsp/runtime.rb

@@ -14,9 +14,14 @@ module RuboCop
     # 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
@@ -30,10 +35,17 @@ module RuboCop
       #   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)
+      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: true
+          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) }
 
@@ -44,6 +56,7 @@ module RuboCop
         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)
@@ -61,6 +74,13 @@ module RuboCop
 
       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
 

data/lib/rubocop/lsp/server.rb

@@ -36,8 +36,8 @@ module RuboCop
             @routes.handle_unsupported_method(request)
           end
         rescue StandardError => e
-          log("Error #{e.class} #{e.message[0..100]}")
-          log(e.backtrace.inspect)
+          Logger.log("Error #{e.class} #{e.message[0..100]}")
+          Logger.log(e.backtrace.inspect)
         end
       end
 
@@ -45,14 +45,20 @@ module RuboCop
         @writer.write(response)
       end
 
-      def format(path, text)
-        @runtime.format(path, text)
+      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

data/lib/rubocop/magic_comment.rb

@@ -7,7 +7,7 @@ module RuboCop
   class MagicComment
     # IRB's pattern for matching magic comment tokens.
     # @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5
-    TOKEN = /[[:alnum:]\-_]+/.freeze
+    TOKEN = '(?<token>[[:alnum:]\-_]+)'
     KEYWORDS = {
       encoding: '(?:en)?coding',
       frozen_string_literal: 'frozen[_-]string[_-]literal',
@@ -129,7 +129,7 @@ module RuboCop
     # @return [String] if pattern matched
     # @return [nil] otherwise
     def extract(pattern)
-      @comment[pattern, 1]
+      @comment[pattern, :token]
     end
 
     # Parent to Vim and Emacs magic comment handling.
@@ -157,10 +157,10 @@ module RuboCop
       # @return [String] extracted value if it is found
       # @return [nil] otherwise
       def match(keyword)
-        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*(#{TOKEN})\z/
+        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*#{TOKEN}\z/
 
         tokens.each do |token|
-          next unless (value = token[pattern, 1])
+          next unless (value = token[pattern, :token])
 
           return value.downcase
         end
@@ -188,7 +188,7 @@ module RuboCop
     # @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
     # @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y
     class EmacsComment < EditorComment
-      REGEXP    = /-\*-(.+)-\*-/.freeze
+      REGEXP    = /-\*-(?<token>.+)-\*-/.freeze
       FORMAT    = '# -*- %s -*-'
       SEPARATOR = ';'
       OPERATOR  = ':'
@@ -216,7 +216,7 @@ module RuboCop
     #
     #   comment.encoding # => 'ascii-8bit'
     class VimComment < EditorComment
-      REGEXP    = /#\s*vim:\s*(.+)/.freeze
+      REGEXP    = /#\s*vim:\s*(?<token>.+)/.freeze
       FORMAT    = '# vim: %s'
       SEPARATOR = ', '
       OPERATOR  = '='
@@ -259,9 +259,11 @@ module RuboCop
     #   comment2.frozen_string_literal # => nil
     #   comment2.encoding              # => 'utf-8'
     class SimpleComment < MagicComment
+      FSTRING_LITERAL_COMMENT = 'frozen_string_literal:\s*(true|false)'
+
       # Match `encoding` or `coding`
       def encoding
-        extract(/\A\s*\#.*\b#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
+        extract(/\A\s*\#\s*(#{FSTRING_LITERAL_COMMENT})?\s*#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
       end
 
       # Rewrite the comment without a given token type
@@ -283,15 +285,15 @@ module RuboCop
       # Case-insensitive and dashes/underscores are acceptable.
       # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138
       def extract_frozen_string_literal
-        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
       end
 
       def extract_shareable_constant_value
-        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*#{TOKEN}\s*\z/io)
       end
 
       def extract_typed
-        extract(/\A\s*#\s*#{KEYWORDS[:typed]}:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:typed]}:\s*#{TOKEN}\s*\z/io)
       end
     end
   end

data/lib/rubocop/result_cache.rb

@@ -202,6 +202,10 @@ module RuboCop
       lib_root = File.join(File.dirname(__FILE__), '..')
       exe_root = File.join(lib_root, '..', 'exe')
 
+      # Make sure to use an absolute path to prevent errors on Windows
+      # when traversing the relative paths with symlinks.
+      exe_root = File.absolute_path(exe_root)
+
       # These are all the files we have `require`d plus everything in the
       # exe directory. A change to any of them could affect the cop output
       # so we include them in the cache hash.

data/lib/rubocop/rspec/shared_contexts.rb

@@ -11,6 +11,8 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       # Make sure to expand all symlinks in the path first. Otherwise we may
       # get mismatched pathnames when loading config files later on.
       tmpdir = File.realpath(tmpdir)
+      # Make upwards search for .rubocop.yml files stop at this directory.
+      RuboCop::FileFinder.root_level = tmpdir
 
       virtual_home = File.expand_path(File.join(tmpdir, 'home'))
       Dir.mkdir(virtual_home)
@@ -21,9 +23,6 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       root = example.metadata[:root]
       working_dir = root ? File.join(base_dir, 'work', root) : File.join(base_dir, 'work')
 
-      # Make upwards search for .rubocop.yml files stop at this directory.
-      RuboCop::FileFinder.root_level = working_dir
-
       begin
         FileUtils.mkdir_p(working_dir)
 

data/lib/rubocop/runner.rb

@@ -421,10 +421,10 @@ module RuboCop
     end
 
     def considered_failure?(offense)
-      # For :autocorrect level, any offense - corrected or not - is a failure.
       return false if offense.disabled?
 
-      return true if @options[:fail_level] == :autocorrect
+      # For :autocorrect level, any correctable offense is a failure, regardless of severity
+      return true if @options[:fail_level] == :autocorrect && offense.correctable?
 
       !offense.corrected? && offense.severity >= minimum_severity_to_fail
     end
@@ -461,7 +461,9 @@ module RuboCop
       @minimum_severity_to_fail ||= begin
         # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail
         name = @options[:fail_level] || :refactor
-        RuboCop::Cop::Severity.new(name)
+
+        # autocorrect is a fake level - use the default
+        RuboCop::Cop::Severity.new(name == :autocorrect ? :refactor : name)
       end
     end
 

data/lib/rubocop/server/cache.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'pathname'
 require_relative '../cache_config'
 require_relative '../config_finder'

data/lib/rubocop/server/client_command/exec.rb

@@ -32,7 +32,7 @@ module RuboCop
 
         def ensure_server!
           if incompatible_version?
-            puts 'RuboCop version incompatibility found, RuboCop server restarting...'
+            warn 'RuboCop version incompatibility found, RuboCop server restarting...'
             ClientCommand::Stop.new.run
           elsif check_running_server
             return

data/lib/rubocop/string_interpreter.rb

@@ -32,9 +32,9 @@ module RuboCop
 
       def interpret_string_escape(escape)
         case escape[1]
-        when 'u' then interpret_unicode(escape)
-        when 'x' then interpret_hex(escape)
-        when /\d/       then interpret_octal(escape)
+        when 'u'  then interpret_unicode(escape)
+        when 'x'  then interpret_hex(escape)
+        when /\d/ then interpret_octal(escape)
         else
           escape[1] # literal escaped char, like \\
         end

data/lib/rubocop/target_finder.rb

@@ -94,8 +94,12 @@ module RuboCop
     end
 
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      base_dir = base_dir.gsub('/{}/', '/\{}/')
-      dirs = Dir.glob(File.join(base_dir.gsub('/*/', '/\*/').gsub('/**/', '/\**/'), '*/'), flags)
+      # Escape glob characters in base_dir to avoid unwanted behavior.
+      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
+        "\\#{reserved_glob_character}"
+      end
+
+      dirs = Dir.glob(File.join(base_dir, '*/'), flags)
                 .reject do |dir|
                   next true if dir.end_with?('/./', '/../')
                   next true if File.fnmatch?(exclude_pattern, dir, flags)
@@ -114,7 +118,7 @@ module RuboCop
     end
 
     def combined_exclude_glob_patterns(base_dir)
-      exclude = @config_store.for(base_dir).for_all_cops['Exclude']
+      exclude = @config_store.for(base_dir).for_all_cops['Exclude'] || []
       patterns = exclude.select { |pattern| pattern.is_a?(String) && pattern.end_with?('/**/*') }
                         .map { |pattern| pattern.sub("#{base_dir}/", '') }
       "#{base_dir}/{#{patterns.join(',')}}"

data/lib/rubocop/target_ruby.rb

@@ -155,9 +155,11 @@ module RuboCop
         (send _ :required_ruby_version= $_)
       PATTERN
 
-      # @!method gem_requirement?(node)
-      def_node_matcher :gem_requirement?, <<~PATTERN
-        (send (const(const _ :Gem):Requirement) :new $str)
+      # @!method gem_requirement_versions(node)
+      def_node_matcher :gem_requirement_versions, <<~PATTERN
+        (send (const(const _ :Gem):Requirement) :new
+          {$str+ | (send $str :freeze)+ | (array $str+) | (array (send $str :freeze)+)}
+        )
       PATTERN
 
       def name
@@ -194,10 +196,12 @@ module RuboCop
       end
 
       def version_from_right_hand_side(right_hand_side)
+        gem_requirement_versions = gem_requirement_versions(right_hand_side)
+
         if right_hand_side.array_type?
           version_from_array(right_hand_side)
-        elsif gem_requirement?(right_hand_side)
-          right_hand_side.children.last.value
+        elsif gem_requirement_versions
+          gem_requirement_versions.map(&:value)
         else
           right_hand_side.value
         end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.53.1'
+    STRING = '1.57.2'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

data/lib/rubocop.rb

@@ -162,6 +162,7 @@ require_relative 'rubocop/cop/correctors/string_literal_corrector'
 require_relative 'rubocop/cop/correctors/unused_arg_corrector'
 
 require_relative 'rubocop/cop/bundler/duplicated_gem'
+require_relative 'rubocop/cop/bundler/duplicated_group'
 require_relative 'rubocop/cop/bundler/gem_comment'
 require_relative 'rubocop/cop/bundler/gem_filename'
 require_relative 'rubocop/cop/bundler/gem_version'
@@ -579,6 +580,7 @@ require_relative 'rubocop/cop/style/redundant_regexp_constructor'
 require_relative 'rubocop/cop/style/redundant_self_assignment'
 require_relative 'rubocop/cop/style/redundant_self_assignment_branch'
 require_relative 'rubocop/cop/style/require_order'
+require_relative 'rubocop/cop/style/single_line_do_end_block'
 require_relative 'rubocop/cop/style/sole_nested_conditional'
 require_relative 'rubocop/cop/style/static_class'
 require_relative 'rubocop/cop/style/map_compact_with_conditional_block'