rubocop 0.78.0 → 1.13.0

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|
@@ -13,21 +12,22 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
       # 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
-        ENV.delete('XDG_CONFIG_HOME')
-
-        working_dir = File.join(tmpdir, 'work')
-        Dir.mkdir(working_dir)
+        FileUtils.mkdir_p(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
@@ -38,27 +38,70 @@ 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
+
+# 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
 
-    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(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) { cop_class.new(config, cop_options) }
 end
 
 RSpec.shared_context 'mock console output' do
@@ -73,14 +116,6 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
-RSpec.shared_context 'ruby 2.3', :ruby23 do
-  let(:ruby_version) { 2.3 }
-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
@@ -88,3 +123,11 @@ end
 RSpec.shared_context 'ruby 2.6', :ruby26 do
   let(:ruby_version) { 2.6 }
 end
+
+RSpec.shared_context 'ruby 2.7', :ruby27 do
+  let(:ruby_version) { 2.7 }
+end
+
+RSpec.shared_context 'ruby 3.0', :ruby30 do
+  let(:ruby_version) { 3.0 }
+end

data/lib/rubocop/runner.rb

@@ -11,12 +11,20 @@ module RuboCop
     class InfiniteCorrectionLoop < RuntimeError
       attr_reader :offenses
 
-      def initialize(path, offenses)
-        super "Infinite loop detected in #{path}."
-        @offenses = offenses
+      def initialize(path, offenses_by_iteration, loop_start: -1)
+        @offenses = offenses_by_iteration.flatten.uniq
+        root_cause = offenses_by_iteration[loop_start..-1]
+                     .map { |x| x.map(&:cop_name).uniq.join(', ') }
+                     .join(' -> ')
+
+        message = 'Infinite loop detected'
+        message += " in #{path}" if path
+        message += " and caused by #{root_cause}" if root_cause
+        super message
       end
     end
 
+    # @api private
     MAX_ITERATIONS = 200
 
     attr_reader :errors, :warnings
@@ -56,12 +64,17 @@ module RuboCop
     # instances that each inspects its allotted group of files.
     def warm_cache(target_files)
       puts 'Running parallel inspection' if @options[:debug]
-      Parallel.each(target_files, &method(:file_offenses))
+      Parallel.each(target_files) { |target_file| file_offenses(target_file) }
     end
 
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
-      target_files = target_finder.find(paths)
+      mode = if @options[:only_recognized_file_types]
+               :only_recognized_file_types
+             else
+               :all_file_types
+             end
+      target_files = target_finder.find(paths, mode)
       target_files.each(&:freeze).freeze
     end
 
@@ -76,8 +89,9 @@ module RuboCop
       # 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])
+        ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root])
       end
+
       formatter_set.finished(inspected_files.freeze)
       formatter_set.close_output_files
     end
@@ -98,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)
@@ -115,9 +127,9 @@ module RuboCop
 
     def file_offenses(file)
       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)
+        source, offenses = do_inspection_loop(file)
+        offenses = add_redundant_disables(file, offenses.compact.sort, source)
+        offenses.sort.reject(&:disabled?).freeze
       end
     end
 
@@ -126,7 +138,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?
@@ -148,16 +160,29 @@ 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)
+          offenses |= new_offenses
         end
       end
+      offenses
+    end
+
+    def team_for_redundant_disables(file, offenses, source)
+      return unless check_for_redundant_disables?(source)
+
+      config = @config_store.for_file(file)
+      team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options)
+      return if team.cops.empty?
 
-      offenses.sort.reject(&:disabled?).freeze
+      team.cops.first.offenses_to_check = offenses
+      yield team
     end
 
     def check_for_redundant_disables?(source)
@@ -165,39 +190,20 @@ module RuboCop
     end
 
     def redundant_cop_disable_directive(file)
-      config = @config_store.for(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
+      config = @config_store.for_file(file)
+      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?
       @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,
-                                 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)
@@ -211,7 +217,7 @@ module RuboCop
       @cached_run ||=
         (@options[:cache] == 'true' ||
          @options[:cache] != 'false' &&
-         @config_store.for(Dir.pwd).for_all_cops['UseCache']) &&
+         @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.
@@ -230,19 +236,23 @@ module RuboCop
       cache.save(offenses)
     end
 
-    def do_inspection_loop(file, processed_source)
-      offenses = []
+    def do_inspection_loop(file)
+      processed_source = get_processed_source(file)
+      # This variable is 2d array used to track corrected offenses after each
+      # inspection iteration. This is used to output meaningful infinite loop
+      # error message.
+      offenses_by_iteration = []
 
       # When running with --auto-correct, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
-      iterate_until_no_changes(processed_source, offenses) do
+      iterate_until_no_changes(processed_source, offenses_by_iteration) do
         # The offenses that couldn't be corrected will be found again so we
         # only keep the corrected ones in order to avoid duplicate reporting.
-        offenses.select!(&:corrected?)
+        !offenses_by_iteration.empty? && offenses_by_iteration.last.select!(&:corrected?)
         new_offenses, updated_source_file = inspect_file(processed_source)
-        offenses.concat(new_offenses).uniq!
+        offenses_by_iteration.push(new_offenses)
 
         # We have to reprocess the source to pickup the changes. Since the
         # change could (theoretically) introduce parsing errors, we break the
@@ -252,10 +262,12 @@ module RuboCop
         processed_source = get_processed_source(file)
       end
 
+      # Return summary of corrected offenses after all iterations
+      offenses = offenses_by_iteration.flatten.uniq
       [processed_source, offenses]
     end
 
-    def iterate_until_no_changes(source, offenses)
+    def iterate_until_no_changes(source, offenses_by_iteration)
       # Keep track of the state of the source. If a cop modifies the source
       # and another cop undoes it producing identical source we have an
       # infinite loop.
@@ -267,10 +279,10 @@ module RuboCop
       iterations = 0
 
       loop do
-        check_for_infinite_loop(source, offenses)
+        check_for_infinite_loop(source, offenses_by_iteration)
 
         if (iterations += 1) > MAX_ITERATIONS
-          raise InfiniteCorrectionLoop.new(source.path, offenses)
+          raise InfiniteCorrectionLoop.new(source.path, offenses_by_iteration)
         end
 
         source = yield
@@ -280,29 +292,41 @@ module RuboCop
 
     # Check whether a run created source identical to a previous run, which
     # means that we definitely have an infinite loop.
-    def check_for_infinite_loop(processed_source, offenses)
+    def check_for_infinite_loop(processed_source, offenses_by_iteration)
       checksum = processed_source.checksum
 
-      if @processed_sources.include?(checksum)
-        raise InfiniteCorrectionLoop.new(processed_source.path, offenses)
+      if (loop_start_index = @processed_sources.index(checksum))
+        raise InfiniteCorrectionLoop.new(
+          processed_source.path,
+          offenses_by_iteration,
+          loop_start: loop_start_index
+        )
       end
 
       @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)
-      @mobilized_cop_classes ||= {}
-      @mobilized_cop_classes[config.object_id] ||= begin
-        cop_classes = Cop::Cop.all
+    def mobilized_cop_classes(config) # rubocop:disable Metrics/AbcSize
+      @mobilized_cop_classes ||= {}.compare_by_identity
+      @mobilized_cop_classes[config] ||= begin
+        cop_classes = Cop::Registry.all
+
+        # `@options[:only]` and `@options[:except]` are not qualified until
+        # needed so that the Registry can be fully loaded, including any
+        # cops added by `require`s.
+        qualify_option_cop_names
 
         OptionsValidator.new(@options).validate_cop_options
 
@@ -314,7 +338,17 @@ module RuboCop
 
         cop_classes.reject! { |c| c.match?(@options[:except]) }
 
-        Cop::Registry.new(cop_classes)
+        Cop::Registry.new(cop_classes, @options)
+      end
+    end
+
+    def qualify_option_cop_names
+      %i[only except].each do |option|
+        next unless @options[option]
+
+        @options[option].map! do |cop_name|
+          Cop::Registry.qualified_cop_name(cop_name, "--#{option} option")
+        end
       end
     end
 
@@ -333,9 +367,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
@@ -351,18 +383,23 @@ module RuboCop
 
     def minimum_severity_to_fail
       @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)
       end
     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
 
@@ -371,9 +408,9 @@ module RuboCop
     # otherwise dormant team that can be used for config- and option-
     # level caching in ResultCache.
     def standby_team(config)
-      @team_by_config ||= {}
-      @team_by_config[config.object_id] ||=
-        Cop::Team.new(mobilized_cop_classes(config), config, @options)
+      @team_by_config ||= {}.compare_by_identity
+      @team_by_config[config] ||=
+        Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
     end
   end
 end