rubocop 0.83.0 → 0.87.0

data/lib/rubocop/rake_task.rb

@@ -8,14 +8,11 @@ module RuboCop
   #
   # require 'rubocop/rake_task'
   # RuboCop::RakeTask.new
-  class RakeTask < Rake::TaskLib
-    attr_accessor :name
-    attr_accessor :verbose
-    attr_accessor :fail_on_error
-    attr_accessor :patterns
-    attr_accessor :formatters
-    attr_accessor :requires
-    attr_accessor :options
+  #
+  # Use global Rake namespace here to avoid namespace issues with custom
+  # rubocop-rake tasks
+  class RakeTask < ::Rake::TaskLib
+    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
 
     def initialize(name = :rubocop, *args, &task_block)
       setup_ivars(name)
@@ -69,7 +66,7 @@ module RuboCop
         task(:auto_correct, *args) do |_, task_args|
           RakeFileUtils.verbose(verbose) do
             yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-            options = full_options.unshift('--auto-correct')
+            options = full_options.unshift('--auto-correct-all')
             options.delete('--parallel')
             run_cli(verbose, options)
           end

data/lib/rubocop/remote_config.rb

@@ -56,9 +56,7 @@ module RuboCop
     def generate_request(uri)
       request = Net::HTTP::Get.new(uri.request_uri)
 
-      if cache_path_exists?
-        request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
-      end
+      request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822 if cache_path_exists?
 
       yield request
     end

data/lib/rubocop/result_cache.rb

@@ -33,16 +33,14 @@ module RuboCop
 
       def requires_file_removal?(file_count, config_store)
         file_count > 1 &&
-          file_count > config_store.for('.').for_all_cops['MaxFilesInCache']
+          file_count > config_store.for_dir('.').for_all_cops['MaxFilesInCache']
       end
 
       def remove_oldest_files(files, dirs, cache_root, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
         remove_count = 1 + files.length / 2
-        if verbose
-          puts "Removing the #{remove_count} oldest files from #{cache_root}"
-        end
+        puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)
       rescue Errno::ENOENT
@@ -62,7 +60,7 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = config_store.for('.').for_all_cops['CacheRootDirectory']
+      root = config_store.for_dir('.').for_all_cops['CacheRootDirectory']
       root ||= if ENV.key?('XDG_CACHE_HOME')
                  # Include user ID in the path to make sure the user has write
                  # access.
@@ -74,7 +72,7 @@ module RuboCop
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
-      config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
+      config_store.for_dir('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
     def initialize(file, team, options, config_store, cache_root = nil)
@@ -145,7 +143,7 @@ module RuboCop
       digester = Digest::SHA1.new
       mode = File.stat(file).mode
       digester.update(
-        "#{file}#{mode}#{config_store.for(file).signature}"
+        "#{file}#{mode}#{config_store.for_file(file).signature}"
       )
       digester.file(file)
       digester.hexdigest

data/lib/rubocop/rspec/cop_helper.rb

@@ -43,37 +43,14 @@ module CopHelper
     processed_source = parse_source(source, file)
     _investigate(cop, processed_source)
 
-    corrector =
-      RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
-    corrector.rewrite
-  end
-
-  def autocorrect_source_with_loop(source, file = nil)
-    cnt = 0
-    loop do
-      cop.instance_variable_set(:@corrections, [])
-      new_source = autocorrect_source(source, file)
-      return new_source if new_source == source
-
-      source = new_source
-      cnt += 1
-      if cnt > RuboCop::Runner::MAX_ITERATIONS
-        raise RuboCop::Runner::InfiniteCorrectionLoop.new(file, [])
-      end
-    end
+    @last_corrector.rewrite
   end
 
   def _investigate(cop, processed_source)
-    forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
-      next unless cop.join_force?(klass)
-
-      instances << klass.new([cop])
-    end
-
-    commissioner =
-      RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
-    commissioner.investigate(processed_source)
-    commissioner
+    team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
+    report = team.investigate(processed_source)
+    @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
+    report.offenses
   end
 end
 

data/lib/rubocop/rspec/expect_offense.rb

@@ -71,9 +71,37 @@ 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:
+    #
+    #   %w[raise fail].each do |keyword|
+    #     expect_offense(<<~RUBY, keyword: keyword)
+    #       %{keyword}(RuntimeError, msg)
+    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument can be removed.
+    #     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 value is redundant.
+    #       end
+    #     RUBY
+    #   end
     module ExpectOffense
+      def format_offense(source, **replacements)
+        replacements.each do |keyword, value|
+          source = source.gsub("%{#{keyword}}", value)
+                         .gsub("^{#{keyword}}", '^' * value.size)
+                         .gsub("_{#{keyword}}", ' ' * value.size)
+        end
+        source
+      end
+
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def expect_offense(source, file = nil)
+      def expect_offense(source, file = nil, severity: nil, **replacements)
+        source = format_offense(source, **replacements)
         RuboCop::Formatter::DisabledConfigFormatter
           .config_to_allow_offenses = {}
         RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
@@ -88,53 +116,62 @@ module RuboCop
         @processed_source = parse_source(expected_annotations.plain_source,
                                          file)
 
-        unless @processed_source.valid_syntax?
-          raise 'Error parsing example code'
-        end
+        raise 'Error parsing example code' unless @processed_source.valid_syntax?
 
-        _investigate(cop, @processed_source)
+        offenses = _investigate(cop, @processed_source)
         actual_annotations =
-          expected_annotations.with_offense_annotations(cop.offenses)
+          expected_annotations.with_offense_annotations(offenses)
 
         expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
+        expect(offenses.map(&:severity).uniq).to eq([severity]) if severity
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      def expect_correction(correction)
-        unless @processed_source
-          raise '`expect_correction` must follow `expect_offense`'
-        end
+      def expect_correction(correction, loop: true)
+        raise '`expect_correction` must follow `expect_offense`' unless @processed_source
+
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrected_source = @last_corrector.rewrite
 
-        corrector =
-          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-        new_source = corrector.rewrite
+          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, [])
+          end
+
+          # Prepare for next loop
+          @processed_source = parse_source(corrected_source,
+                                           @processed_source.path)
+          _investigate(cop, @processed_source)
+        end
 
         expect(new_source).to eq(correction)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       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(cop.offenses)
+          expected_annotations.with_offense_annotations(offenses)
         expect(actual_annotations.to_s).to eq(source)
       end
 

data/lib/rubocop/rspec/shared_contexts.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require 'fileutils'
 
 RSpec.shared_context 'isolated environment', :isolated_environment do
   around do |example|
@@ -38,28 +37,67 @@ 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
+# 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(:source) { 'code = {some: :ruby}' }
 
-    hash = { 'AllCops' => { 'TargetRubyVersion' => ruby_version } }
-    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('Enabled' => true) # in case it is 'pending'
-                       .merge(cop_config)
+  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)
 
-    hash = other_cops.merge hash if respond_to?(:other_cops)
+  let(:processed_source) { parse_source(source, 'test') }
+
+  let(:source_buffer) { processed_source.buffer }
+
+  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
+
+  let(:cop) do
+    cop_class.new(config, cop_options).tap do |cop|
+      cop.send :begin_investigation, processed_source
+    end
+  end
 end
 
 RSpec.shared_context 'mock console output' do

data/lib/rubocop/runner.rb

@@ -80,9 +80,7 @@ module RuboCop
       # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization
       # mainly targets editors that integrates RuboCop. When RuboCop is run
       # by an editor, it should be inspecting only one file.
-      if files.size > 1 && cached_run?
-        ResultCache.cleanup(@config_store, @options[:debug])
-      end
+      ResultCache.cleanup(@config_store, @options[:debug]) if files.size > 1 && cached_run?
       formatter_set.finished(inspected_files.freeze)
       formatter_set.close_output_files
     end
@@ -122,7 +120,8 @@ module RuboCop
       file_offense_cache(file) do
         source = get_processed_source(file)
         source, offenses = do_inspection_loop(file, source)
-        add_redundant_disables(file, offenses.compact.sort, source)
+        offenses = add_redundant_disables(file, offenses.compact.sort, source)
+        offenses.sort.reject(&:disabled?).freeze
       end
     end
 
@@ -131,7 +130,7 @@ module RuboCop
     end
 
     def file_offense_cache(file)
-      config = @config_store.for(file)
+      config = @config_store.for_file(file)
       cache = cached_result(file, standby_team(config)) if cached_run?
 
       if cache&.valid?
@@ -153,16 +152,30 @@ module RuboCop
     end
 
     def add_redundant_disables(file, offenses, source)
-      if check_for_redundant_disables?(source)
-        redundant_cop_disable_directive(file) do |cop|
-          cop.check(offenses, source.disabled_line_ranges, source.comments)
-          offenses += cop.offenses
-          offenses += autocorrect_redundant_disables(file, source, cop,
-                                                     offenses)
+      team_for_redundant_disables(file, offenses, source) do |team|
+        new_offenses, redundant_updated = inspect_file(source, team)
+        offenses += new_offenses
+        if redundant_updated
+          # Do one extra inspection loop if any redundant disables were
+          # removed. This is done in order to find rubocop:enable directives that
+          # have now become useless.
+          _source, new_offenses = do_inspection_loop(file,
+                                                     get_processed_source(file))
+          offenses |= new_offenses
         end
       end
+      offenses
+    end
+
+    def team_for_redundant_disables(file, offenses, source)
+      return unless check_for_redundant_disables?(source)
 
-      offenses.sort.reject(&:disabled?).freeze
+      config = @config_store.for_file(file)
+      team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options)
+      return if team.cops.empty?
+
+      team.cops.first.offenses_to_check = offenses
+      yield team
     end
 
     def check_for_redundant_disables?(source)
@@ -170,7 +183,7 @@ module RuboCop
     end
 
     def redundant_cop_disable_directive(file)
-      config = @config_store.for(file)
+      config = @config_store.for_file(file)
       if config.for_cop(Cop::Lint::RedundantCopDisableDirective)
                .fetch('Enabled')
         cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
@@ -182,22 +195,6 @@ module RuboCop
       @options[:except] || @options[:only]
     end
 
-    def autocorrect_redundant_disables(file, source, cop, offenses)
-      cop.processed_source = source
-
-      team = Cop::Team.new(RuboCop::Cop::Registry.new, nil, @options)
-      team.autocorrect(source.buffer, [cop])
-
-      return [] unless team.updated_source_file?
-
-      # Do one extra inspection loop if any redundant disables were
-      # removed. This is done in order to find rubocop:enable directives that
-      # have now become useless.
-      _source, new_offenses = do_inspection_loop(file,
-                                                 get_processed_source(file))
-      new_offenses - offenses
-    end
-
     def file_started(file)
       puts "Scanning #{file}" if @options[:debug]
       formatter_set.file_started(file,
@@ -216,7 +213,7 @@ module RuboCop
       @cached_run ||=
         (@options[:cache] == 'true' ||
          @options[:cache] != 'false' &&
-         @config_store.for(Dir.pwd).for_all_cops['UseCache']) &&
+         @config_store.for_dir(Dir.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.
@@ -295,13 +292,16 @@ module RuboCop
       @processed_sources << checksum
     end
 
-    def inspect_file(processed_source)
-      config = @config_store.for(processed_source.path)
-      team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
-      offenses = team.inspect_file(processed_source)
+    def inspect_file(processed_source, team = mobilize_team(processed_source))
+      report = team.investigate(processed_source)
       @errors.concat(team.errors)
       @warnings.concat(team.warnings)
-      [offenses, team.updated_source_file?]
+      [report.offenses, team.updated_source_file?]
+    end
+
+    def mobilize_team(processed_source)
+      config = @config_store.for_file(processed_source.path)
+      Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
     end
 
     def mobilized_cop_classes(config)
@@ -362,12 +362,16 @@ module RuboCop
     end
 
     def get_processed_source(file)
-      ruby_version = @config_store.for(file).target_ruby_version
+      ruby_version = @config_store.for_file(file).target_ruby_version
 
       if @options[:stdin]
         ProcessedSource.new(@options[:stdin], ruby_version, file)
       else
-        ProcessedSource.from_file(file, ruby_version)
+        begin
+          ProcessedSource.from_file(file, ruby_version)
+        rescue Errno::ENOENT
+          raise RuboCop::Error, "No such file or directory: #{file}"
+        end
       end
     end
 
@@ -378,7 +382,7 @@ module RuboCop
     def standby_team(config)
       @team_by_config ||= {}
       @team_by_config[config.object_id] ||=
-        Cop::Team.new(mobilized_cop_classes(config), config, @options)
+        Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
     end
   end
 end