rubocop 0.66.0 → 1.25.1

data/lib/rubocop/rspec/expect_offense.rb

@@ -14,7 +14,7 @@ module RuboCop
     #
     # @example Usage
     #
-    #     expect_offense(<<-RUBY.strip_indent)
+    #     expect_offense(<<~RUBY)
     #       a do
     #         b
     #       end.c
@@ -23,7 +23,7 @@ module RuboCop
     #
     # @example Equivalent assertion without `expect_offense`
     #
-    #     inspect_source(<<-RUBY.strip_indent)
+    #     inspect_source(<<~RUBY)
     #       a do
     #         b
     #       end.c
@@ -43,12 +43,12 @@ module RuboCop
     #
     # @example `expect_offense` and `expect_correction`
     #
-    #   expect_offense(<<-RUBY.strip_indent)
+    #   expect_offense(<<~RUBY)
     #     x % 2 == 0
     #     ^^^^^^^^^^ Replace with `Integer#even?`.
     #   RUBY
     #
-    #   expect_correction(<<-RUBY.strip_indent)
+    #   expect_correction(<<~RUBY)
     #     x.even?
     #   RUBY
     #
@@ -63,7 +63,7 @@ module RuboCop
     #
     # @example `expect_offense` and `expect_no_corrections`
     #
-    #   expect_offense(<<-RUBY.strip_indent)
+    #   expect_offense(<<~RUBY)
     #     a do
     #       b
     #     end.c
@@ -71,73 +71,147 @@ module RuboCop
     #   RUBY
     #
     #   expect_no_corrections
+    #
+    # If your code has variables of different lengths, you can use `%{foo}`,
+    # `^{foo}`, and `_{foo}` to format your template; you can also abbreviate
+    # offense messages with `[...]`:
+    #
+    #   %w[raise fail].each do |keyword|
+    #     expect_offense(<<~RUBY, keyword: keyword)
+    #       %{keyword}(RuntimeError, msg)
+    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument [...]
+    #     RUBY
+    #
+    #   %w[has_one has_many].each do |type|
+    #     expect_offense(<<~RUBY, type: type)
+    #       class Book
+    #         %{type} :chapter, foreign_key: 'book_id'
+    #         _{type}           ^^^^^^^^^^^^^^^^^^^^^^ Specifying the default [...]
+    #       end
+    #     RUBY
+    #   end
+    #
+    # If you need to specify an offense on a blank line, use the empty `^{}` marker:
+    #
+    # @example `^{}` empty line offense
+    #
+    #   expect_offense(<<~RUBY)
+    #
+    #     ^{} Missing frozen string literal comment.
+    #     puts 1
+    #   RUBY
     module ExpectOffense
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def expect_offense(source, file = nil)
-        RuboCop::Formatter::DisabledConfigFormatter
-          .config_to_allow_offenses = {}
-        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-        cop.instance_variable_get(:@options)[:auto_correct] = true
+      def format_offense(source, **replacements)
+        replacements.each do |keyword, value|
+          value = value.to_s
+          source = source.gsub("%{#{keyword}}", value)
+                         .gsub("^{#{keyword}}", '^' * value.size)
+                         .gsub("_{#{keyword}}", ' ' * value.size)
+        end
+        source
+      end
 
-        expected_annotations = AnnotatedSource.parse(source)
+      def expect_offense(source, file = nil, severity: nil, chomp: false, **replacements)
+        expected_annotations = parse_annotations(source, **replacements)
+        source = expected_annotations.plain_source
+        source = source.chomp if chomp
 
-        if expected_annotations.plain_source == source
-          raise 'Use `expect_no_offenses` to assert that no offenses are found'
-        end
+        @processed_source = parse_processed_source(source, file)
+        @offenses = _investigate(cop, @processed_source)
+        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
 
-        @processed_source = parse_source(expected_annotations.plain_source,
-                                         file)
+        @offenses
+      end
 
-        unless @processed_source.valid_syntax?
-          raise 'Error parsing example code'
+      # 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)
+          @processed_source = parse_processed_source(expected_annotations.plain_source)
+          _investigate(cop, @processed_source)
         end
 
-        _investigate(cop, @processed_source)
-        actual_annotations =
-          expected_annotations.with_offense_annotations(cop.offenses)
+        raise '`expect_correction` must follow `expect_offense`' unless @processed_source
 
-        expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+        source = @processed_source.raw_source
+
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrected_source = @last_corrector.rewrite
 
-      def expect_correction(correction)
-        unless @processed_source
-          raise '`expect_correction` must follow `expect_offense`'
+          break corrected_source unless loop
+          break corrected_source if @last_corrector.empty?
+          break corrected_source if corrected_source == @processed_source.buffer.source
+
+          if iteration > RuboCop::Runner::MAX_ITERATIONS
+            raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
+          end
+
+          # Prepare for next loop
+          @processed_source = parse_source(corrected_source, @processed_source.path)
+          _investigate(cop, @processed_source)
         end
 
-        corrector =
-          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-        new_source = corrector.rewrite
+        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, Metrics/CyclomaticComplexity
 
       def expect_no_corrections
-        unless @processed_source
-          raise '`expect_no_corrections` must follow `expect_offense`'
-        end
+        raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
 
-        return if cop.corrections.empty?
+        return if @last_corrector.empty?
 
         # In order to print a nice diff, e.g. what source got corrected to,
         # we need to run the actual corrections
 
-        corrector =
-          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-        new_source = corrector.rewrite
+        new_source = @last_corrector.rewrite
 
         expect(new_source).to eq(@processed_source.buffer.source)
       end
 
       def expect_no_offenses(source, file = nil)
-        inspect_source(source, file)
+        offenses = inspect_source(source, file)
+
+        expected_annotations = AnnotatedSource.parse(source)
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
+        expect(actual_annotations.to_s).to eq(source)
+      end
+
+      def parse_annotations(source, raise_error: true, **replacements)
+        set_formatter_options
+
+        source = format_offense(source, **replacements)
+        annotations = AnnotatedSource.parse(source)
+        return annotations unless raise_error && annotations.plain_source == source
+
+        raise 'Use `expect_no_offenses` to assert that no offenses are found'
+      end
+
+      def parse_processed_source(source, file = nil)
+        processed_source = parse_source(source, file)
+        return processed_source if processed_source.valid_syntax?
+
+        raise 'Error parsing example code: ' \
+              "#{processed_source.diagnostics.map(&:render).join("\n")}"
+      end
 
-        expect(cop.offenses).to be_empty
+      def set_formatter_options
+        RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+        cop.instance_variable_get(:@options)[:auto_correct] = true
       end
 
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*\^+ /.freeze
+        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze
+        ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers
         #
@@ -150,12 +224,13 @@ module RuboCop
           annotations = []
 
           annotated_source.each_line do |source_line|
-            if source_line =~ ANNOTATION_PATTERN
+            if ANNOTATION_PATTERN.match?(source_line)
               annotations << [source.size, source_line]
             else
               source << source_line
             end
           end
+          annotations.each { |a| a[0] = 1 } if source.empty?
 
           new(source, annotations)
         end
@@ -171,6 +246,25 @@ module RuboCop
           @annotations = annotations.sort.freeze
         end
 
+        def ==(other)
+          other.is_a?(self.class) && other.lines == lines && match_annotations?(other)
+        end
+
+        # Dirty hack: expectations with [...] are rewritten when they match
+        # This way the diff is clean.
+        def match_annotations?(other)
+          annotations.zip(other.annotations) do |(_actual_line, actual_annotation),
+                                                 (_expected_line, expected_annotation)|
+            if expected_annotation&.end_with?(ABBREV) &&
+               actual_annotation.start_with?(expected_annotation[0...-ABBREV.length])
+
+              expected_annotation.replace(actual_annotation)
+            end
+          end
+
+          annotations == other.annotations
+        end
+
         # Construct annotated source string (like what we parse)
         #
         # Reconstruct a deterministic annotated source string. This is
@@ -203,6 +297,7 @@ module RuboCop
 
           reconstructed.join
         end
+        alias inspect to_s
 
         # Return the plain source code without annotations
         #
@@ -221,6 +316,7 @@ module RuboCop
             offenses.map do |offense|
               indent     = ' ' * offense.column
               carets     = '^' * offense.column_length
+              carets     = '^{}' if offense.column_length.zero?
 
               [offense.line, "#{indent}#{carets} #{offense.message}\n"]
             end
@@ -228,7 +324,7 @@ module RuboCop
           self.class.new(lines, offense_annotations)
         end
 
-        private
+        protected
 
         attr_reader :lines, :annotations
       end

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

@@ -1,33 +1,36 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require 'fileutils'
 
 RSpec.shared_context 'isolated environment', :isolated_environment do
   around do |example|
     Dir.mktmpdir do |tmpdir|
       original_home = ENV['HOME']
+      original_xdg_config_home = ENV['XDG_CONFIG_HOME']
 
       # 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)
 
+      virtual_home = File.expand_path(File.join(tmpdir, 'home'))
+      Dir.mkdir(virtual_home)
+      ENV['HOME'] = virtual_home
+      ENV.delete('XDG_CONFIG_HOME')
+
+      base_dir = example.metadata[:project_inside_home] ? virtual_home : tmpdir
+      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 = tmpdir
+      RuboCop::FileFinder.root_level = working_dir
 
       begin
-        virtual_home = File.expand_path(File.join(tmpdir, 'home'))
-        Dir.mkdir(virtual_home)
-        ENV['HOME'] = virtual_home
+        FileUtils.mkdir_p(working_dir)
 
-        working_dir = File.join(tmpdir, 'work')
-        Dir.mkdir(working_dir)
-
-        RuboCop::PathUtil.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
 
         RuboCop::FileFinder.root_level = nil
       end
@@ -35,40 +38,82 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
   end
 end
 
-# `cop_config` must be declared with #let.
-RSpec.shared_context 'config', :config do
-  let(:config) do
-    # Module#<
-    unless described_class < RuboCop::Cop::Cop
-      raise '`config` must be used in `describe SomeCopClass do .. end`'
-    end
+RSpec.shared_context 'maintain registry', :restore_registry do
+  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)
+    stub_const(name, klass)
+    klass
+  end
+end
 
-    hash = { 'AllCops' => { 'TargetRubyVersion' => ruby_version } }
-    hash['Rails'] = { 'Enabled' => true } if enabled_rails
-    hash['AllCops']['TargetRailsVersion'] = rails_version if rails_version
-    if respond_to?(:cop_config)
-      cop_name = described_class.cop_name
-      hash[cop_name] = RuboCop::ConfigLoader
-                       .default_configuration[cop_name]
-                       .merge(cop_config)
+# This context assumes nothing and defines `cop`, among others.
+RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
+  ### Meant to be overridden at will
+
+  let(:cop_class) do
+    unless described_class.is_a?(Class) && described_class < RuboCop::Cop::Base
+      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`, ' \
+            'or RuboCop::Cop::Cop for legacy)'
     end
+    described_class
+  end
+
+  let(:cop_config) { {} }
+
+  let(:other_cops) { {} }
+
+  let(:cop_options) { {} }
+
+  ### Utilities
+
+  def source_range(range, buffer: source_buffer)
+    Parser::Source::Range.new(buffer, range.begin,
+                              range.exclude_end? ? range.end : range.end + 1)
+  end
+
+  ### Useful intermediary steps (less likely to be overridden)
+
+  let(:processed_source) { parse_source(source, 'test') }
+
+  let(:source_buffer) { processed_source.buffer }
 
-    hash = other_cops.merge hash if respond_to?(:other_cops)
+  let(:all_cops_config) do
+    rails = { 'TargetRubyVersion' => ruby_version }
+    rails['TargetRailsVersion'] = rails_version if rails_version
+    rails
+  end
+
+  let(:cur_cop_config) do
+    RuboCop::ConfigLoader
+      .default_configuration.for_cop(cop_class)
+      .merge({
+               'Enabled' => true, # in case it is 'pending'
+               'AutoCorrect' => true # in case defaults set it to false
+             })
+      .merge(cop_config)
+  end
+
+  let(:config) do
+    hash = { 'AllCops' => all_cops_config, cop_class.cop_name => cur_cop_config }.merge!(other_cops)
 
     RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
   end
-end
 
-RSpec.shared_context 'ruby 2.2', :ruby22 do
-  let(:ruby_version) { 2.2 }
+  let(:cop) { cop_class.new(config, cop_options) }
 end
 
-RSpec.shared_context 'ruby 2.3', :ruby23 do
-  let(:ruby_version) { 2.3 }
-end
+RSpec.shared_context 'mock console output' do
+  before do
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+  end
 
-RSpec.shared_context 'ruby 2.4', :ruby24 do
-  let(:ruby_version) { 2.4 }
+  after do
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
 end
 
 RSpec.shared_context 'ruby 2.5', :ruby25 do
@@ -79,18 +124,14 @@ RSpec.shared_context 'ruby 2.6', :ruby26 do
   let(:ruby_version) { 2.6 }
 end
 
-RSpec.shared_context 'with Rails', :enabled_rails do
-  let(:enabled_rails) { true }
-end
-
-RSpec.shared_context 'with Rails 3', :rails3 do
-  let(:rails_version) { 3.0 }
+RSpec.shared_context 'ruby 2.7', :ruby27 do
+  let(:ruby_version) { 2.7 }
 end
 
-RSpec.shared_context 'with Rails 4', :rails4 do
-  let(:rails_version) { 4.0 }
+RSpec.shared_context 'ruby 3.0', :ruby30 do
+  let(:ruby_version) { 3.0 }
 end
 
-RSpec.shared_context 'with Rails 5', :rails5 do
-  let(:rails_version) { 5.0 }
+RSpec.shared_context 'ruby 3.1', :ruby31 do
+  let(:ruby_version) { 3.1 }
 end

data/lib/rubocop/rspec/support.rb

@@ -5,8 +5,8 @@
 require_relative 'cop_helper'
 require_relative 'host_environment_simulation_helper'
 require_relative 'shared_contexts'
-require_relative 'shared_examples'
 require_relative 'expect_offense'
+require_relative 'parallel_formatter'
 
 RSpec.configure do |config|
   config.include CopHelper