rubocop 0.84.0 → 0.85.1

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

@@ -122,7 +122,9 @@ module RuboCop
 
           return unless first_offense
 
-          return unused_range(node.type, mlhs_node, right) if unused_variables_only?(first_offense, variables)
+          if unused_variables_only?(first_offense, variables)
+            return unused_range(node.type, mlhs_node, right)
+          end
 
           return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for *unless* expressions with *else* clauses.
+      # This cop looks for `unless` expressions with `else` clauses.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for *when;* uses in *case* expressions.
+      # This cop checks for `when;` uses in `case` expressions.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/team.rb

@@ -2,7 +2,13 @@
 
 module RuboCop
   module Cop
-    # FIXME
+    # A group of cops, ready to be called on duty to inspect files.
+    # Team is responsible for selecting only relevant cops to be sent on duty,
+    # as well as insuring that the needed forces are sent along with them.
+    #
+    # For performance reasons, Team will first dispatch cops & forces in two groups,
+    # first the ones needed for autocorrection (if any), then the rest
+    # (unless autocorrections happened).
     class Team
       DEFAULT_OPTIONS = {
         auto_correct: false,
@@ -11,12 +17,12 @@ module RuboCop
 
       Investigation = Struct.new(:offenses, :errors)
 
-      attr_reader :errors, :warnings, :updated_source_file
+      attr_reader :errors, :warnings, :updated_source_file, :cops
 
       alias updated_source_file? updated_source_file
 
-      def initialize(cop_classes, config, options = nil)
-        @cop_classes = cop_classes
+      def initialize(cops, config = nil, options = nil)
+        @cops = cops
         @config = config
         @options = options || DEFAULT_OPTIONS
         @errors = []
@@ -25,6 +31,31 @@ module RuboCop
         validate_config
       end
 
+      # @return [Team]
+      def self.new(cop_or_classes, config, options = {})
+        # Support v0 api:
+        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+
+        super
+      end
+
+      # @return [Team] with cops assembled from the given `cop_classes`
+      def self.mobilize(cop_classes, config, options = nil)
+        options ||= DEFAULT_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
+        only = options.fetch(:only, [])
+        safe = options.fetch(:safe, false)
+        cop_classes.enabled(config, only, safe).map do |cop_class|
+          cop_class.new(config, options)
+        end
+      end
+
       def autocorrect?
         @options[:auto_correct]
       end
@@ -44,14 +75,6 @@ module RuboCop
         offenses(processed_source)
       end
 
-      def cops
-        only = @options.fetch(:only, [])
-        safe = @options.fetch(:safe, false)
-        @cops ||= @cop_classes.enabled(@config, only, safe).map do |cop_class|
-          cop_class.new(@config, @options)
-        end
-      end
-
       def forces
         @forces ||= forces_for(cops)
       end
@@ -93,21 +116,23 @@ module RuboCop
 
       private
 
-      def offenses(processed_source)
+      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
-        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
-
-        autocorrect =
-          investigate(autocorrect_cops, processed_source) do |offenses|
-            # 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 offenses if autocorrect(processed_source.buffer,
-                                           autocorrect_cops)
-          end
+        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)
 
@@ -120,13 +145,32 @@ module RuboCop
       def investigate(cops, processed_source)
         return Investigation.new([], {}) if cops.empty?
 
-        commissioner = Commissioner.new(cops, forces_for(cops))
+        commissioner = Commissioner.new(cops, forces_for(cops), @options)
         offenses = commissioner.investigate(processed_source)
-        yield offenses if block_given?
 
         Investigation.new(offenses, commissioner.errors)
       end
 
+      def roundup_relevant_cops(filename)
+        cops.reject do |cop|
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
+        end
+      end
+
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
       def autocorrect_all_cops(buffer, cops)
         corrector = Corrector.new(buffer)
 

data/lib/rubocop/cop/util.rb

@@ -108,7 +108,7 @@ module RuboCop
       end
 
       def trim_string_interporation_escape_character(str)
-        str.gsub(/\\\#{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
+        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 
       def interpret_string_escapes(string)

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

@@ -97,6 +97,10 @@ module RuboCop
           @format_sequences ||= parse
         end
 
+        def valid?
+          !mixed_formats?
+        end
+
         def named_interpolation?
           format_sequences.any?(&:name)
         end
@@ -114,6 +118,20 @@ module RuboCop
             )
           end
         end
+
+        def mixed_formats?
+          formats = format_sequences.map do |seq|
+            if seq.name
+              :named
+            elsif seq.max_digit_dollar_num
+              :numbered
+            else
+              :unnumbered
+            end
+          end
+
+          formats.uniq.size > 1
+        end
       end
     end
   end

data/lib/rubocop/cop/variable_force/branch.rb

@@ -109,7 +109,9 @@ module RuboCop
             return false if may_jump_to_other_branch?
 
             other.each_ancestor(include_self: true) do |other_ancestor|
-              return !child_node.equal?(other_ancestor.child_node) if control_node.equal?(other_ancestor.control_node)
+              if control_node.equal?(other_ancestor.control_node)
+                return !child_node.equal?(other_ancestor.child_node)
+              end
             end
 
             if parent

data/lib/rubocop/formatter/junit_formatter.rb

@@ -35,19 +35,29 @@ module RuboCop
         #
         # In the future, it would be preferable to return only enabled cops.
         Cop::Cop.all.each do |cop|
+          target_offenses = offenses_for_cop(offenses, cop)
+
+          next unless relevant_for_output?(options, target_offenses)
+
           REXML::Element.new('testcase', @testsuite).tap do |testcase|
             testcase.attributes['classname'] = classname_attribute_value(file)
             testcase.attributes['name'] = cop.cop_name
 
-            target_offenses = offenses.select do |offense|
-              offense.cop_name == cop.cop_name
-            end
-
             add_failure_to(testcase, target_offenses, cop.cop_name)
           end
         end
       end
 
+      def relevant_for_output?(options, target_offenses)
+        !options[:display_only_failed] || target_offenses.any?
+      end
+
+      def offenses_for_cop(all_offenses, cop)
+        all_offenses.select do |offense|
+          offense.cop_name == cop.cop_name
+        end
+      end
+
       def classname_attribute_value(file)
         file.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
       end

data/lib/rubocop/magic_comment.rb

@@ -133,7 +133,7 @@ module RuboCop
     # @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
     # @see https://git.io/vMCXh Emacs handling in Ruby's parse.y
     class EmacsComment < EditorComment
-      FORMAT    = /\-\*\-(.+)\-\*\-/.freeze
+      FORMAT    = /-\*-(.+)-\*-/.freeze
       SEPARATOR = ';'
       OPERATOR  = ':'
 

data/lib/rubocop/options.rb

@@ -143,6 +143,8 @@ module RuboCop
           @options[:output_path] = path
         end
       end
+
+      option(opts, '--display-only-failed')
     end
 
     def add_severity_option(opts)
@@ -276,7 +278,9 @@ module RuboCop
                                    'be used with --only.'
       end
       raise OptionArgumentError, 'Syntax checking cannot be turned off.' if except_syntax?
-      raise OptionArgumentError, '-C/--cache argument must be true or false' unless boolean_or_empty_cache?
+      unless boolean_or_empty_cache?
+        raise OptionArgumentError, '-C/--cache argument must be true or false'
+      end
 
       if display_only_fail_level_offenses_with_autocorrect?
         raise OptionArgumentError, '--autocorrect cannot be used with ' \
@@ -284,6 +288,7 @@ module RuboCop
       end
       validate_auto_gen_config
       validate_auto_correct
+      validate_display_only_failed
       validate_parallel
 
       return if incompatible_options.size <= 1
@@ -307,13 +312,20 @@ module RuboCop
       end
     end
 
+    def validate_display_only_failed
+      return unless @options.key?(:display_only_failed)
+      return if @options[:format] == 'junit'
+
+      raise OptionArgumentError,
+            format('--display-only-failed can only be used together with --format junit.')
+    end
+
     def validate_auto_correct
       return if @options.key?(:auto_correct)
       return unless @options.key?(:disable_uncorrectable)
 
       raise OptionArgumentError,
-            format('--%<flag>s can only be used together with --auto-correct.',
-                   flag: '--disable-uncorrectable')
+            format('--disable-uncorrectable can only be used together with --auto-correct.')
     end
 
     def validate_parallel
@@ -429,6 +441,8 @@ module RuboCop
                                          'if no format is specified.'],
       fail_level:                       ['Minimum severity (A/R/C/W/E/F) for exit',
                                          'with error code.'],
+      display_only_failed:              ['Only output offense messages. Omit passing',
+                                         'cops. Only valid for --format junit.'],
       display_only_fail_level_offenses:
                                         ['Only output offense messages at',
                                          'the specified --fail-level or above'],

data/lib/rubocop/result_cache.rb

@@ -33,7 +33,7 @@ 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)
@@ -60,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.
@@ -72,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)
@@ -143,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

@@ -48,30 +48,9 @@ module CopHelper
     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
-      raise RuboCop::Runner::InfiniteCorrectionLoop.new(file, []) if cnt > RuboCop::Runner::MAX_ITERATIONS
-    end
-  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)
+    team.inspect_file(processed_source)
   end
 end
 

data/lib/rubocop/rspec/expect_offense.rb

@@ -71,9 +71,27 @@ module RuboCop
     #   RUBY
     #
     #   expect_no_corrections
+    #
+    # If your code has variables of different lengths, you can use `%{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
     module ExpectOffense
+      def format_offense(source, **replacements)
+        replacements.each do |keyword, value|
+          source = source.gsub("%{#{keyword}}", value)
+                         .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, **replacements)
+        source = format_offense(source, **replacements)
         RuboCop::Formatter::DisabledConfigFormatter
           .config_to_allow_offenses = {}
         RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
@@ -96,17 +114,38 @@ module RuboCop
 
         expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      def expect_correction(correction)
+      def expect_correction(correction, loop: true)
         raise '`expect_correction` must follow `expect_offense`' unless @processed_source
 
-        corrector =
-          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-        new_source = corrector.rewrite
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrector =
+            RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
+          corrected_source = corrector.rewrite
+
+          break corrected_source unless loop
+          break corrected_source if cop.corrections.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
+          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)
+        end
 
         expect(new_source).to eq(correction)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source