rubocop 0.90.0 → 0.91.0

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

@@ -49,6 +49,10 @@ module RuboCop
       #   foo && foo < bar
       #   foo < bar if foo
       #
+      #   # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      #   # do the opposite of what the author intends.
+      #   foo && foo.empty?
+      #
       #   # This could start returning `nil` as well as the return of the method
       #   foo.nil? || foo.bar
       #   !foo || foo.bar
@@ -104,6 +108,7 @@ module RuboCop
           # chain greater than 2
           return if chain_size(method_chain, method) > 1
           return if unsafe_method_used?(method_chain, method)
+          return if method_chain.method?(:empty?)
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)

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

@@ -31,9 +31,10 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[first last [] at slice].freeze
 
         def_node_matcher :sample_candidate?, <<~PATTERN
-          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
+          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)

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

@@ -16,11 +16,10 @@ module RuboCop
       class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'
-
-        def_node_matcher :sending?, '({send csend} _ :send ...)'
+        RESTRICT_ON_SEND = %i[send].freeze
 
         def on_send(node)
-          return unless sending?(node) && node.arguments?
+          return unless node.arguments?
 
           add_offense(node.loc.selector)
         end

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

@@ -112,6 +112,8 @@ module RuboCop
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'

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

@@ -27,6 +27,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
+        RESTRICT_ON_SEND = %i[dig].freeze
 
         def_node_matcher :single_argument_dig?, <<~PATTERN
           (send _ :dig $!splat)

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

@@ -19,11 +19,12 @@ module RuboCop
         minimum_target_ruby_version 2.6
 
         MSG = 'Prefer ary[n..] over ary[n..-1].'
+        RESTRICT_ON_SEND = %i[[]].freeze
 
         def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
 
         def on_send(node)
-          return unless node.method?(:[]) && node.arguments.count == 1
+          return unless node.arguments.count == 1
           return unless range_till_minus_one?(node.arguments.first)
 
           add_offense(node.first_argument) do |corrector|

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

@@ -20,6 +20,7 @@ module RuboCop
 
         MSG =
           'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        RESTRICT_ON_SEND = %i[puts].freeze
 
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for places where string concatenation
       # can be replaced with string interpolation.
       #
+      # The cop can autocorrect simple cases but will skip autocorrecting
+      # more complex cases where the resulting code would be harder to read.
+      # In those cases, it might be useful to extract statements to local
+      # variables or methods which you can then interpolate in a string.
+      #
       # @example
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
@@ -19,6 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
+        RESTRICT_ON_SEND = %i[+].freeze
 
         def_node_matcher :string_concatenation?, <<~PATTERN
           {
@@ -28,7 +34,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:+)
           return unless string_concatenation?(node)
 
           topmost_plus_node = find_topmost_plus_node(node)
@@ -37,7 +42,9 @@ module RuboCop
           collect_parts(topmost_plus_node, parts)
 
           add_offense(topmost_plus_node) do |corrector|
-            corrector.replace(topmost_plus_node, replacement(parts))
+            if parts.none? { |part| uncorrectable?(part) }
+              corrector.replace(topmost_plus_node, replacement(parts))
+            end
           end
         end
 
@@ -66,6 +73,13 @@ module RuboCop
           node.send_type? && node.method?(:+)
         end
 
+        def uncorrectable?(part)
+          part.multiline? ||
+            part.dstr_type? ||
+            (part.str_type? && part.heredoc?) ||
+            part.each_descendant(:block).any?
+        end
+
         def replacement(parts)
           interpolated_parts =
             parts.map do |part|

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

@@ -18,6 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `strip` instead of `%<methods>s`.'
+        RESTRICT_ON_SEND = %i[lstrip rstrip].freeze
 
         def_node_matcher :lstrip_rstrip, <<~PATTERN
           {(send $(send _ $:rstrip) $:lstrip)

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

@@ -22,6 +22,7 @@ module RuboCop
 
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {

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

@@ -32,7 +32,7 @@ module RuboCop
         NONZERO_MSG = 'Use `!empty?` instead of ' \
                       '`%<lhs>s %<opr>s %<rhs>s`.'
 
-        LENGTH_METHODS = %i[size length].freeze
+        RESTRICT_ON_SEND = %i[size length].freeze
 
         def on_send(node)
           check_zero_length_predicate(node)
@@ -42,8 +42,6 @@ module RuboCop
         private
 
         def check_zero_length_predicate(node)
-          return unless LENGTH_METHODS.include?(node.method_name)
-
           zero_length_predicate = zero_length_predicate(node.parent)
           return unless zero_length_predicate
 
@@ -59,8 +57,6 @@ module RuboCop
         end
 
         def check_nonzero_length_predicate(node)
-          return unless LENGTH_METHODS.include?(node.method_name)
-
           nonzero_length_predicate = nonzero_length_predicate(node.parent)
           return unless nonzero_length_predicate
 

data/lib/rubocop/core_ext/string.rb

@@ -2,7 +2,7 @@
 
 # Extensions to the core String class
 class String
-  unless method_defined? :blank?
+  unless method_defined?(:blank?) && ' '.blank?
     # Checks whether a string is blank. A string is considered blank if it
     # is either empty or contains only whitespace characters.
     #

data/lib/rubocop/ext/regexp_node.rb

@@ -21,10 +21,10 @@ module RuboCop
 
         str = content
         Ext::RegexpNode.parsed_cache[str] ||= begin
-                                                Regexp::Parser.parse(str)
-                                              rescue StandardError
-                                                nil
-                                              end
+          Regexp::Parser.parse(str)
+        rescue StandardError
+          nil
+        end
       end
 
       def each_capture(named: ANY)

data/lib/rubocop/options.rb

@@ -69,6 +69,7 @@ module RuboCop
 
         add_severity_option(opts)
         add_flags_with_optional_args(opts)
+        add_cache_options(opts)
         add_boolean_flags(opts)
         add_aliases(opts)
 
@@ -164,10 +165,16 @@ module RuboCop
       end
     end
 
+    def add_cache_options(opts)
+      option(opts, '-C', '--cache FLAG')
+      option(opts, '--cache-root DIR') do
+        @validator.validate_cache_enabled_for_cache_root
+      end
+    end
+
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def add_boolean_flags(opts)
       option(opts, '-F', '--fail-fast')
-      option(opts, '-C', '--cache FLAG')
       option(opts, '-d', '--debug')
       option(opts, '-D', '--[no-]display-cop-names')
       option(opts, '-E', '--extra-details')
@@ -392,6 +399,13 @@ module RuboCop
       # of option order.
       raise OptionParser::MissingArgument
     end
+
+    def validate_cache_enabled_for_cache_root
+      return unless @options[:cache] == 'false'
+
+      raise OptionArgumentError, '--cache-root can not be used with ' \
+                                  '--cache false'
+    end
   end
 
   # This module contains help texts for command line options.
@@ -464,6 +478,10 @@ module RuboCop
       cache:                            ["Use result caching (FLAG=true) or don't",
                                          '(FLAG=false), default determined by',
                                          'configuration parameter AllCops: UseCache.'],
+      cache_root:                       ['Set the cache root directory.',
+                                         'Takes precedence over the configuration',
+                                         'parameter AllCops: CacheRootDirectory and',
+                                         'the $RUBOCOP_CACHE_ROOT environment variable.'],
       debug:                            'Display debug info.',
       display_cop_names:                ['Display cop names in offense messages.',
                                          'Default is true.'],

data/lib/rubocop/result_cache.rb

@@ -3,6 +3,7 @@
 require 'digest/sha1'
 require 'find'
 require 'etc'
+require 'zlib'
 
 module RuboCop
   # Provides functionality for caching rubocop runs.
@@ -30,6 +31,11 @@ module RuboCop
     end
 
     class << self
+      # @api private
+      attr_accessor :rubocop_required_features
+
+      ResultCache.rubocop_required_features = []
+
       private
 
       def requires_file_removal?(file_count, config_store)
@@ -61,7 +67,8 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = config_store.for_pwd.for_all_cops['CacheRootDirectory']
+      root = ENV['RUBOCOP_CACHE_ROOT']
+      root ||= config_store.for_pwd.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.
@@ -76,7 +83,10 @@ module RuboCop
       config_store.for_pwd.for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
+    attr :path
+
     def initialize(file, team, options, config_store, cache_root = nil)
+      cache_root ||= options[:cache_root]
       cache_root ||= ResultCache.cache_root(config_store)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
@@ -159,27 +169,34 @@ module RuboCop
     end
 
     # The checksum of the rubocop program running the inspection.
-    # rubocop:disable Metrics/AbcSize
     def rubocop_checksum
       ResultCache.source_checksum ||=
         begin
-          lib_root = File.join(File.dirname(__FILE__), '..')
-          exe_root = File.join(lib_root, '..', 'exe')
-
-          # These are all the files we have `require`d plus everything in the
-          # exe directory. A change to any of them could affect the cop output
-          # so we include them in the cache hash.
-          source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
-
           digest = Digest::SHA1.new
-          source_files
+          rubocop_extra_features
             .select { |path| File.file?(path) }
             .sort!
-            .each { |path| digest << File.mtime(path).to_s }
+            .each do |path|
+              content = File.open(path, 'rb', &:read)
+              digest << Zlib.crc32(content).to_s # mtime not reliable
+            end
+          digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING
           digest.hexdigest
         end
     end
-    # rubocop:enable Metrics/AbcSize
+
+    def rubocop_extra_features
+      lib_root = File.join(File.dirname(__FILE__), '..')
+      exe_root = File.join(lib_root, '..', 'exe')
+
+      # These are all the files we have `require`d plus everything in the
+      # exe directory. A change to any of them could affect the cop output
+      # so we include them in the cache hash.
+      source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
+      source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+
+      source_files
+    end
 
     # Return a hash of the options given at invocation, minus the ones that have
     # no effect on which offenses and disabled line ranges are found, and thus

data/lib/rubocop/runner.rb

@@ -11,9 +11,12 @@ 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(' -> ')
+        super "Infinite loop detected in #{path} and caused by #{root_cause}"
       end
     end
 
@@ -81,7 +84,10 @@ 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.
-      ResultCache.cleanup(@config_store, @options[:debug]) if files.size > 1 && cached_run?
+      if files.size > 1 && cached_run?
+        ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root])
+      end
+
       formatter_set.finished(inspected_files.freeze)
       formatter_set.close_output_files
     end
@@ -233,18 +239,21 @@ module RuboCop
 
     def do_inspection_loop(file)
       processed_source = get_processed_source(file)
-      offenses = []
+      # 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
@@ -254,10 +263,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.
@@ -269,10 +280,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
@@ -282,11 +293,15 @@ 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

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.90.0'
+    STRING = '0.91.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, '\
           'rubocop-ast %<rubocop_ast_version>s, ' \