rubocop 1.9.1 → 1.22.3

data/lib/rubocop/rspec/expect_offense.rb

@@ -118,8 +118,7 @@ module RuboCop
 
         @processed_source = parse_processed_source(source, file)
         @offenses = _investigate(cop, @processed_source)
-        actual_annotations =
-          expected_annotations.with_offense_annotations(@offenses)
+        actual_annotations = expected_annotations.with_offense_annotations(@offenses)
 
         expect(actual_annotations).to eq(expected_annotations), ''
         expect(@offenses.map(&:severity).uniq).to eq([severity]) if severity
@@ -127,7 +126,7 @@ module RuboCop
         @offenses
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
       def expect_correction(correction, loop: true, source: nil)
         if source
           expected_annotations = parse_annotations(source, raise_error: false)
@@ -137,6 +136,8 @@ module RuboCop
 
         raise '`expect_correction` must follow `expect_offense`' unless @processed_source
 
+        source = @processed_source.raw_source
+
         iteration = 0
         new_source = loop do
           iteration += 1
@@ -152,14 +153,15 @@ module RuboCop
           end
 
           # Prepare for next loop
-          @processed_source = parse_source(corrected_source,
-                                           @processed_source.path)
+          @processed_source = parse_source(corrected_source, @processed_source.path)
           _investigate(cop, @processed_source)
         end
 
+        raise 'Use `expect_no_corrections` if the code will not change' if new_source == source
+
         expect(new_source).to eq(correction)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
@@ -178,8 +180,7 @@ module RuboCop
         offenses = inspect_source(source, file)
 
         expected_annotations = AnnotatedSource.parse(source)
-        actual_annotations =
-          expected_annotations.with_offense_annotations(offenses)
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
         expect(actual_annotations.to_s).to eq(source)
       end
 
@@ -198,7 +199,7 @@ module RuboCop
         return processed_source if processed_source.valid_syntax?
 
         raise 'Error parsing example code: ' \
-          "#{processed_source.diagnostics.map(&:render).join("\n")}"
+              "#{processed_source.diagnostics.map(&:render).join("\n")}"
       end
 
       def set_formatter_options
@@ -246,9 +247,7 @@ module RuboCop
         end
 
         def ==(other)
-          other.is_a?(self.class) &&
-            other.lines == lines &&
-            match_annotations?(other)
+          other.is_a?(self.class) && other.lines == lines && match_annotations?(other)
         end
 
         # Dirty hack: expectations with [...] are rewritten when they match

data/lib/rubocop/rspec/parallel_formatter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+RSpec::Support.require_rspec_core 'formatters/base_text_formatter'
+RSpec::Support.require_rspec_core 'formatters/console_codes'
+
+module RuboCop
+  module RSpec
+    # RSpec formatter for use with running `rake spec` in parallel. This formatter
+    # removes much of the noise from RSpec so that only the important information
+    # will be surfaced by test-queue.
+    # It also adds metadata to the output in order to more easily find the text
+    # needed for outputting after the parallel run completes.
+    class ParallelFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+      ::RSpec::Core::Formatters.register self, :dump_pending, :dump_failures, :dump_summary
+
+      # Don't show pending tests
+      def dump_pending(*); end
+
+      # The BEGIN/END comments are used by `spec_runner.rake` to determine what
+      # output goes where in the final parallelized output, and should not be
+      # removed!
+      def dump_failures(notification)
+        return if notification.failure_notifications.empty?
+
+        output.puts '# FAILURES BEGIN'
+        notification.failure_notifications.each do |failure|
+          output.puts failure.fully_formatted('*', colorizer)
+        end
+        output.puts
+        output.puts '# FAILURES END'
+      end
+
+      def dump_summary(summary)
+        output_summary(summary)
+        output_rerun_commands(summary)
+      end
+
+      private
+
+      def colorizer
+        @colorizer ||= ::RSpec::Core::Formatters::ConsoleCodes
+      end
+
+      # The BEGIN/END comments are used by `spec_runner.rake` to determine what
+      # output goes where in the final parallelized output, and should not be
+      # removed!
+      def output_summary(summary)
+        output.puts '# SUMMARY BEGIN'
+        output.puts colorize_summary(summary)
+        output.puts '# SUMMARY END'
+      end
+
+      def colorize_summary(summary)
+        totals = totals(summary)
+
+        if summary.failure_count.positive? || summary.errors_outside_of_examples_count.positive?
+          colorizer.wrap(totals, ::RSpec.configuration.failure_color)
+        else
+          colorizer.wrap(totals, ::RSpec.configuration.success_color)
+        end
+      end
+
+      # The BEGIN/END comments are used by `spec_runner.rake` to determine what
+      # output goes where in the final parallelized output, and should not be
+      # removed!
+      def output_rerun_commands(summary)
+        output.puts '# RERUN BEGIN'
+        output.puts summary.colorized_rerun_commands.lines[3..-1].join
+        output.puts '# RERUN END'
+      end
+
+      def totals(summary)
+        output = pluralize(summary.example_count, 'example')
+        output += ", #{summary.pending_count} pending" if summary.pending_count.positive?
+        output += ", #{pluralize(summary.failure_count, 'failure')}"
+
+        if summary.errors_outside_of_examples_count.positive?
+          error_count = pluralize(summary.errors_outside_of_examples_count, 'error')
+          output += ", #{error_count} occurred outside of examples"
+        end
+
+        output
+      end
+
+      def pluralize(*args)
+        ::RSpec::Core::Formatters::Helpers.pluralize(*args)
+      end
+    end
+  end
+end

data/lib/rubocop/rspec/shared_contexts.rb

@@ -27,9 +27,7 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
       begin
         FileUtils.mkdir_p(working_dir)
 
-        Dir.chdir(working_dir) do
-          example.run
-        end
+        Dir.chdir(working_dir) { example.run }
       ensure
         ENV['HOME'] = original_home
         ENV['XDG_CONFIG_HOME'] = original_xdg_config_home
@@ -41,9 +39,7 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
 end
 
 RSpec.shared_context 'maintain registry', :restore_registry do
-  around(:each) do |example|
-    RuboCop::Cop::Registry.with_temporary_global { example.run }
-  end
+  around(:each) { |example| RuboCop::Cop::Registry.with_temporary_global { example.run } }
 
   def stub_cop_class(name, inherit: RuboCop::Cop::Base, &block)
     klass = Class.new(inherit, &block)
@@ -100,15 +96,12 @@ RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
   end
 
   let(:config) do
-    hash = { 'AllCops' => all_cops_config,
-             cop_class.cop_name => cur_cop_config }.merge!(other_cops)
+    hash = { 'AllCops' => all_cops_config, cop_class.cop_name => cur_cop_config }.merge!(other_cops)
 
     RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
   end
 
-  let(:cop) do
-    cop_class.new(config, cop_options)
-  end
+  let(:cop) { cop_class.new(config, cop_options) }
 end
 
 RSpec.shared_context 'mock console output' do
@@ -123,10 +116,6 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
-RSpec.shared_context 'ruby 2.4', :ruby24 do
-  let(:ruby_version) { 2.4 }
-end
-
 RSpec.shared_context 'ruby 2.5', :ruby25 do
   let(:ruby_version) { 2.5 }
 end
@@ -142,3 +131,7 @@ end
 RSpec.shared_context 'ruby 3.0', :ruby30 do
   let(:ruby_version) { 3.0 }
 end
+
+RSpec.shared_context 'ruby 3.1', :ruby31 do
+  let(:ruby_version) { 3.1 }
+end

data/lib/rubocop/rspec/support.rb

@@ -6,6 +6,7 @@ require_relative 'cop_helper'
 require_relative 'host_environment_simulation_helper'
 require_relative 'shared_contexts'
 require_relative 'expect_offense'
+require_relative 'parallel_formatter'
 
 RSpec.configure do |config|
   config.include CopHelper

data/lib/rubocop/runner.rb

@@ -60,7 +60,7 @@ module RuboCop
 
     private
 
-    # Warms up the RuboCop cache by forking a suitable number of rubocop
+    # Warms up the RuboCop cache by forking a suitable number of RuboCop
     # instances that each inspects its allotted group of files.
     def warm_cache(target_files)
       puts 'Running parallel inspection' if @options[:debug]
@@ -112,9 +112,7 @@ module RuboCop
     end
 
     def list_files(paths)
-      paths.each do |path|
-        puts PathUtil.relative_path(path)
-      end
+      paths.each { |path| puts PathUtil.relative_path(path) }
     end
 
     def process_file(file)
@@ -193,11 +191,10 @@ module RuboCop
 
     def redundant_cop_disable_directive(file)
       config = @config_store.for_file(file)
-      if config.for_cop(Cop::Lint::RedundantCopDisableDirective)
-               .fetch('Enabled')
-        cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
-        yield cop if cop.relevant_file?(file)
-      end
+      return unless config.for_cop(Cop::Lint::RedundantCopDisableDirective).fetch('Enabled')
+
+      cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
+      yield cop if cop.relevant_file?(file)
     end
 
     def filtered_run?
@@ -206,9 +203,7 @@ module RuboCop
 
     def file_started(file)
       puts "Scanning #{file}" if @options[:debug]
-      formatter_set.file_started(file,
-                                 cli_options: @options,
-                                 config_store: @config_store)
+      formatter_set.file_started(file, cli_options: @options, config_store: @config_store)
     end
 
     def file_finished(file, offenses)
@@ -221,8 +216,7 @@ module RuboCop
     def cached_run?
       @cached_run ||=
         (@options[:cache] == 'true' ||
-         @options[:cache] != 'false' &&
-         @config_store.for_pwd.for_all_cops['UseCache']) &&
+         (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) &&
         # When running --auto-gen-config, there's some processing done in the
         # cops related to calculating the Max parameters for Metrics cops. We
         # need to do that processing and cannot use caching.
@@ -372,9 +366,7 @@ module RuboCop
       @formatter_set ||= begin
         set = Formatter::FormatterSet.new(@options)
         pairs = @options[:formatters] || [['progress']]
-        pairs.each do |formatter_key, output_path|
-          set.add_formatter(formatter_key, output_path)
-        end
+        pairs.each { |formatter_key, output_path| set.add_formatter(formatter_key, output_path) }
         set
       end
     end

data/lib/rubocop/target_finder.rb

@@ -61,9 +61,7 @@ module RuboCop
       hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = all_files.select do |file|
-        to_inspect?(file, hidden_files, base_dir_config)
-      end
+      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
 
       target_files.sort_by!(&order)
     end
@@ -96,12 +94,23 @@ module RuboCop
     end
 
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      dirs = Dir.glob(File.join(base_dir.gsub('/**/', '/\**/'), '*/'), flags)
+      base_dir = base_dir.gsub('/{}/', '/\{}/')
+      dirs = Dir.glob(File.join(base_dir.gsub('/*/', '/\*/').gsub('/**/', '/\**/'), '*/'), flags)
                 .reject do |dir|
-                  dir.end_with?('/./', '/../') || File.fnmatch?(exclude_pattern, dir, flags)
+                  next true if dir.end_with?('/./', '/../')
+                  next true if File.fnmatch?(exclude_pattern, dir, flags)
+
+                  symlink_excluded_or_infinite_loop?(base_dir, dir, exclude_pattern, flags)
                 end
-      dirs.flat_map { |dir| wanted_dir_patterns(dir, exclude_pattern, flags) }
-          .unshift(base_dir)
+      dirs.flat_map { |dir| wanted_dir_patterns(dir, exclude_pattern, flags) }.unshift(base_dir)
+    end
+
+    def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags)
+      dir_realpath = File.realpath(current_dir)
+      File.symlink?(current_dir.chomp('/')) && (
+        File.fnmatch?(exclude_pattern, "#{dir_realpath}/", flags) ||
+        File.realpath(base_dir).start_with?(dir_realpath)
+      )
     end
 
     def combined_exclude_glob_patterns(base_dir)
@@ -117,9 +126,7 @@ module RuboCop
 
     def ruby_extensions
       @ruby_extensions ||= begin
-        ext_patterns = all_cops_include.select do |pattern|
-          pattern.start_with?('**/*.')
-        end
+        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
         ext_patterns.map { |pattern| pattern.sub('**/*', '') }
       end
     end
@@ -130,16 +137,13 @@ module RuboCop
 
     def ruby_filenames
       @ruby_filenames ||= begin
-        file_patterns = all_cops_include.reject do |pattern|
-          pattern.start_with?('**/*.')
-        end
+        file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
         file_patterns.map { |pattern| pattern.sub('**/', '') }
       end
     end
 
     def all_cops_include
-      @all_cops_include ||=
-        @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
+      @all_cops_include ||= @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
     end
 
     def ruby_executable?(file)
@@ -162,8 +166,7 @@ module RuboCop
     end
 
     def ruby_file?(file)
-      stdin? || ruby_extension?(file) || ruby_filename?(file) ||
-        ruby_executable?(file)
+      stdin? || ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
     end
 
     def configured_include?(file)

data/lib/rubocop/target_ruby.rb

@@ -4,11 +4,11 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    KNOWN_RUBIES = [2.4, 2.5, 2.6, 2.7, 3.0].freeze
+    KNOWN_RUBIES = [2.5, 2.6, 2.7, 3.0, 3.1].freeze
     DEFAULT_VERSION = KNOWN_RUBIES.first
 
     OBSOLETE_RUBIES = {
-      1.9 => '0.41', 2.0 => '0.50', 2.1 => '0.57', 2.2 => '0.68', 2.3 => '0.81'
+      1.9 => '0.41', 2.0 => '0.50', 2.1 => '0.57', 2.2 => '0.68', 2.3 => '0.81', 2.4 => '1.12'
     }.freeze
     private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
 
@@ -65,15 +65,11 @@ module RuboCop
         file = version_file
         return unless file && File.file?(file)
 
-        File.read(file).match(pattern) do |md|
-          md[:version].to_f
-        end
+        File.read(file).match(pattern) { |md| md[:version].to_f }
       end
 
       def version_file
-        @version_file ||=
-          @config.find_file_upwards(filename,
-                                    @config.base_dir_for_path_parameters)
+        @version_file ||= @config.find_file_upwards(filename, @config.base_dir_for_path_parameters)
       end
     end
 
@@ -147,10 +143,12 @@ module RuboCop
 
       GEMSPEC_EXTENSION = '.gemspec'
 
+      # @!method required_ruby_version(node)
       def_node_search :required_ruby_version, <<~PATTERN
         (send _ :required_ruby_version= $_)
       PATTERN
 
+      # @!method gem_requirement?(node)
       def_node_matcher :gem_requirement?, <<~PATTERN
         (send (const(const _ :Gem):Requirement) :new $str)
       PATTERN
@@ -165,14 +163,10 @@ module RuboCop
         file = gemspec_filepath
         return unless file && File.file?(file)
 
-        version = version_from_gemspec_file(file)
-        return if version.nil?
-
-        requirement = version.children.last
-        return version_from_array(version) if version.array_type?
-        return version_from_array(requirement) if gem_requirement? version
+        right_hand_side = version_from_gemspec_file(file)
+        return if right_hand_side.nil?
 
-        version_from_str(version.str_content)
+        find_minimal_known_ruby(right_hand_side)
       end
 
       def gemspec_filename
@@ -192,15 +186,25 @@ module RuboCop
         required_ruby_version(processed_source.ast).first
       end
 
+      def version_from_right_hand_side(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
+        else
+          right_hand_side.value
+        end
+      end
+
       def version_from_array(array)
-        versions = array.children.map { |v| version_from_str(v.is_a?(String) ? v : v.str_content) }
-        versions.compact.min
+        array.children.map(&:value)
       end
 
-      def version_from_str(str)
-        str.match(/^(?:>=|<=)?\s*(?<version>\d+(?:\.\d+)*)/) do |md|
-          md[:version].to_f
-        end
+      def find_minimal_known_ruby(right_hand_side)
+        version = version_from_right_hand_side(right_hand_side)
+        requirement = Gem::Requirement.new(version)
+
+        KNOWN_RUBIES.detect { |v| requirement.satisfied_by?(Gem::Version.new("#{v}.99")) }
       end
     end
 

data/lib/rubocop/version.rb

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