rubocop 0.86.0 → 0.87.0

data/lib/rubocop/cop/style/zero_length_predicate.rb

@@ -108,8 +108,8 @@ module RuboCop
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
-          {(send (send (send (const nil? :File) :stat _) ...) ...)
-           (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+          {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
+           (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN
       end
     end

data/lib/rubocop/cop/team.rb

@@ -10,23 +10,16 @@ module RuboCop
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
     class Team
-      DEFAULT_OPTIONS = {
-        auto_correct: false,
-        debug: false
-      }.freeze
-
-      Investigation = Struct.new(:offenses, :errors)
-
       attr_reader :errors, :warnings, :updated_source_file, :cops
 
       alias updated_source_file? updated_source_file
 
-      def initialize(cops, config = nil, options = nil)
+      def initialize(cops, config = nil, options = {})
         @cops = cops
         @config = config
-        @options = options || DEFAULT_OPTIONS
-        @errors = []
-        @warnings = []
+        @options = options
+        reset
+        @ready = true
 
         validate_config
       end
@@ -40,15 +33,14 @@ module RuboCop
       end
 
       # @return [Team] with cops assembled from the given `cop_classes`
-      def self.mobilize(cop_classes, config, options = nil)
-        options ||= DEFAULT_OPTIONS
+      def self.mobilize(cop_classes, config, options = {})
         cops = mobilize_cops(cop_classes, config, options)
         new(cops, config, options)
       end
 
       # @return [Array<Cop::Cop>]
-      def self.mobilize_cops(cop_classes, config, options = nil)
-        options ||= DEFAULT_OPTIONS
+      def self.mobilize_cops(cop_classes, config, options = {})
+        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
         only = options.fetch(:only, [])
         safe = options.fetch(:safe, false)
         cop_classes.enabled(config, only, safe).map do |cop_class|
@@ -64,93 +56,102 @@ module RuboCop
         @options[:debug]
       end
 
+      # @deprecated. Use investigate
+      # @return Array<offenses>
       def inspect_file(processed_source)
-        # If we got any syntax errors, return only the syntax offenses.
-        unless processed_source.valid_syntax?
-          return Lint::Syntax.offenses_from_processed_source(
-            processed_source, @config, @options
-          )
+        investigate(processed_source).offenses
+      end
+
+      # @return [Commissioner::InvestigationReport]
+      def investigate(processed_source)
+        be_ready
+
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run auto-correcting cops by themselves, and only
+        # run the other cops when no corrections are left
+        on_duty = roundup_relevant_cops(processed_source.file_path)
+
+        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+
+        report = investigate_partial(autocorrect_cops, processed_source)
+
+        unless autocorrect(processed_source, report)
+          # If we corrected some errors, another round of inspection will be
+          # done, and any other offenses will be caught then, so only need
+          # to check other_cops if no correction was done
+          report = report.merge(investigate_partial(other_cops, processed_source))
         end
 
-        offenses(processed_source)
+        process_errors(processed_source.path, report.errors)
+
+        report
+      ensure
+        @ready = false
       end
 
+      # @deprecated
       def forces
-        @forces ||= forces_for(cops)
+        @forces ||= self.class.forces_for(cops)
       end
 
-      def forces_for(cops)
-        Force.all.each_with_object([]) do |force_class, forces|
-          joining_cops = cops.select { |cop| cop.join_force?(force_class) }
-          next if joining_cops.empty?
+      # @return [Array<Force>] needed for the given cops
+      def self.forces_for(cops)
+        needed = Hash.new { |h, k| h[k] = [] }
+        cops.each do |cop|
+          Array(cop.class.joining_forces).each { |force| needed[force] << cop }
+        end
 
-          forces << force_class.new(joining_cops)
+        needed.map do |force_class, joining_cops|
+          force_class.new(joining_cops)
         end
       end
 
-      def autocorrect(buffer, cops)
+      def external_dependency_checksum
+        keys = cops.map(&:external_dependency_checksum).compact
+        Digest::SHA1.hexdigest(keys.join)
+      end
+
+      private
+
+      def autocorrect(processed_source, report)
         @updated_source_file = false
         return unless autocorrect?
 
-        new_source = autocorrect_all_cops(buffer, cops)
+        new_source = autocorrect_report(report)
 
-        return if new_source == buffer.source
+        return unless new_source
 
         if @options[:stdin]
           # holds source read in from stdin, when --stdin option is used
           @options[:stdin] = new_source
         else
-          filename = buffer.name
+          filename = processed_source.buffer.name
           File.open(filename, 'w') { |f| f.write(new_source) }
         end
         @updated_source_file = true
-      rescue RuboCop::ErrorWithAnalyzedFileLocation => e
-        process_errors(buffer.name, [e])
-        raise e.cause
-      end
-
-      def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
-        Digest::SHA1.hexdigest(keys.join)
       end
 
-      private
-
-      def offenses(processed_source) # rubocop:disable Metrics/AbcSize
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
-        # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source.file_path)
-
-        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
-
-        autocorrect = investigate(autocorrect_cops, processed_source)
-
-        if autocorrect(processed_source.buffer, autocorrect_cops)
-          # We corrected some errors. Another round of inspection will be
-          # done, and any other offenses will be caught then, so we don't
-          # need to continue.
-          return autocorrect.offenses
-        end
-
-        other = investigate(other_cops, processed_source)
+      def be_ready
+        return if @ready
 
-        errors = [*autocorrect.errors, *other.errors]
-        process_errors(processed_source.path, errors)
-
-        autocorrect.offenses.concat(other.offenses)
+        reset
+        @cops.map!(&:ready)
+        @ready = true
       end
 
-      def investigate(cops, processed_source)
-        return Investigation.new([], {}) if cops.empty?
-
-        commissioner = Commissioner.new(cops, forces_for(cops), @options)
-        offenses = commissioner.investigate(processed_source)
+      def reset
+        @errors = []
+        @warnings = []
+      end
 
-        Investigation.new(offenses, commissioner.errors)
+      # @return [Commissioner::InvestigationReport]
+      def investigate_partial(cops, processed_source)
+        commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
+        commissioner.investigate(processed_source)
       end
 
+      # @return [Array<cop>]
       def roundup_relevant_cops(filename)
         cops.reject do |cop|
           cop.excluded_file?(filename) ||
@@ -171,30 +172,45 @@ module RuboCop
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_all_cops(buffer, cops)
-        corrector = Corrector.new(buffer)
+      def autocorrect_report(report)
+        corrector = collate_corrections(report)
 
-        collate_corrections(corrector, cops)
+        corrector.rewrite unless corrector.empty?
+      end
 
-        if !corrector.corrections.empty?
-          corrector.rewrite
-        else
-          buffer.source
+      def collate_corrections(report)
+        corrector = Corrector.new(report.processed_source)
+
+        each_corrector(report) do |to_merge|
+          suppress_clobbering do
+            corrector.merge!(to_merge)
+          end
         end
+
+        corrector
       end
 
-      def collate_corrections(corrector, cops)
+      def each_corrector(report)
         skips = Set.new
+        report.cop_reports.each do |cop_report|
+          cop = cop_report.cop
+          corrector = cop_report.corrector
 
-        cops.each do |cop|
-          next if cop.corrections.empty?
+          next if corrector.nil? || corrector.empty?
           next if skips.include?(cop.class)
 
-          corrector.corrections.concat(cop.corrections)
+          yield corrector
+
           skips.merge(cop.class.autocorrect_incompatible_with)
         end
       end
 
+      def suppress_clobbering
+        yield
+      rescue ::Parser::ClobberingError
+        # ignore Clobbering errors
+      end
+
       def validate_config
         cops.each do |cop|
           cop.validate_config if cop.respond_to?(:validate_config)

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

@@ -41,8 +41,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos
-          attr_reader :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
 
           def initialize(match)
             @source = match[0]

data/lib/rubocop/name_similarity.rb

@@ -22,9 +22,7 @@ module RuboCop
       names.delete(target_name)
 
       spell_checker = DidYouMean::SpellChecker.new(dictionary: names)
-      similar_names = spell_checker.correct(target_name)
-
-      similar_names
+      spell_checker.correct(target_name)
     end
   end
 end

data/lib/rubocop/options.rb

@@ -163,7 +163,7 @@ module RuboCop
       end
     end
 
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def add_boolean_flags(opts)
       option(opts, '-F', '--fail-fast')
       option(opts, '-C', '--cache FLAG')
@@ -171,7 +171,16 @@ module RuboCop
       option(opts, '-D', '--[no-]display-cop-names')
       option(opts, '-E', '--extra-details')
       option(opts, '-S', '--display-style-guide')
-      option(opts, '-a', '--auto-correct')
+      option(opts, '-a', '--auto-correct') do
+        @options[:safe_auto_correct] = true
+      end
+      option(opts, '--safe-autocorrect') do
+        warn '--safe-autocorrect is deprecated; use --autocorrect'
+        @options[:safe_auto_correct] = @options[:auto_correct] = true
+      end
+      option(opts, '-A', '--auto-correct-all') do
+        @options[:auto_correct] = true
+      end
       option(opts, '--disable-pending-cops')
       option(opts, '--enable-pending-cops')
       option(opts, '--ignore-disable-comments')
@@ -184,7 +193,7 @@ module RuboCop
       option(opts, '-V', '--verbose-version')
       option(opts, '-P', '--parallel')
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def add_aliases(opts)
       option(opts, '-l', '--lint') do
@@ -196,9 +205,6 @@ module RuboCop
         @options[:only] << 'Layout'
         @options[:auto_correct] = true
       end
-      option(opts, '--safe-auto-correct') do
-        @options[:auto_correct] = true
-      end
     end
 
     def add_list_options(opts)
@@ -465,8 +471,9 @@ module RuboCop
       lint:                             'Run only lint cops.',
       safe:                             'Run only safe cops.',
       list_target_files:                'List all files RuboCop will inspect.',
-      auto_correct:                     'Auto-correct offenses.',
-      safe_auto_correct:                'Run auto-correct only when it\'s safe.',
+      auto_correct:                     'Auto-correct offenses (only when it\'s safe).',
+      safe_autocorrect:                 '(same, deprecated)',
+      auto_correct_all:                 'Auto-correct offenses (safe and unsafe)',
       fix_layout:                       'Run only layout cops, with auto-correct on.',
       color:                            'Force color output on or off.',
       version:                          'Display version.',

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/rspec/cop_helper.rb

@@ -43,14 +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
+    @last_corrector.rewrite
   end
 
   def _investigate(cop, processed_source)
     team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
-    team.inspect_file(processed_source)
+    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

@@ -100,7 +100,7 @@ module RuboCop
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def expect_offense(source, file = nil, **replacements)
+      def expect_offense(source, file = nil, severity: nil, **replacements)
         source = format_offense(source, **replacements)
         RuboCop::Formatter::DisabledConfigFormatter
           .config_to_allow_offenses = {}
@@ -118,11 +118,12 @@ module RuboCop
 
         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
 
       def expect_correction(correction, loop: true)
@@ -132,12 +133,10 @@ module RuboCop
         new_source = loop do
           iteration += 1
 
-          corrector =
-            RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-          corrected_source = corrector.rewrite
+          corrected_source = @last_corrector.rewrite
 
           break corrected_source unless loop
-          break corrected_source if cop.corrections.empty?
+          break corrected_source if @last_corrector.empty?
           break corrected_source if corrected_source == @processed_source.buffer.source
 
           if iteration > RuboCop::Runner::MAX_ITERATIONS
@@ -145,9 +144,6 @@ module RuboCop
           end
 
           # Prepare for next loop
-          cop.instance_variable_set(:@corrections, [])
-          # Cache invalidation. This is bad!
-          cop.instance_variable_set(:@token_table, nil)
           @processed_source = parse_source(corrected_source,
                                            @processed_source.path)
           _investigate(cop, @processed_source)
@@ -160,24 +156,22 @@ module RuboCop
       def expect_no_corrections
         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