rubocop-performance 1.13.3 → 1.19.0

data/lib/rubocop/cop/performance/detect.rb

@@ -3,14 +3,14 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `first`, `last`, `[0]` or `[-1]`
+      # Identifies usages of `first`, `last`, `[0]` or `[-1]`
       # chained to `select`, `find_all` or `filter` and change them to use
       # `detect` instead.
       #
       # @safety
-      #   This cop is unsafe because is has known compatibility issues with `ActiveRecord` and other
-      #   frameworks. `ActiveRecord` does not implement a `detect` method and `find` has its own
-      #   meaning. Correcting `ActiveRecord` methods with this cop should be considered unsafe.
+      #   This cop is unsafe because it assumes that the receiver is an
+      #   `Array` or equivalent, but can't reliably detect it. For example,
+      #   if the receiver is a `Hash`, it may report a false positive.
       #
       # @example
       #   # bad
@@ -40,9 +40,9 @@ module RuboCop
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
+            (send $(block (call _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
             (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
-            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
+            (send $(call _ %CANDIDATE_METHODS ...) ${:first :last} $...)
             (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
           }
         PATTERN
@@ -63,6 +63,7 @@ module RuboCop
             register_offense(node, receiver, second_method, index)
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/performance/double_start_end_with.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop checks for double `#start_with?` or `#end_with?` calls
+      # Checks for double `#start_with?` or `#end_with?` calls
       # separated by `||`. In some cases such calls can be replaced
       # with an single `#start_with?`/`#end_with?` call.
       #
@@ -41,8 +41,7 @@ module RuboCop
       class DoubleStartEndWith < Base
         extend AutoCorrector
 
-        MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` ' \
-              'instead of `%<original_code>s`.'
+        MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` instead of `%<original_code>s`.'
 
         def on_or(node)
           receiver, method, first_call_args, second_call_args = process_source(node)
@@ -59,8 +58,8 @@ module RuboCop
         private
 
         def autocorrect(corrector, first_call_args, second_call_args, combined_args)
-          first_argument = first_call_args.first.loc.expression
-          last_argument = second_call_args.last.loc.expression
+          first_argument = first_call_args.first.source_range
+          last_argument = second_call_args.last.source_range
           range = first_argument.join(last_argument)
 
           corrector.replace(range, combined_args)

data/lib/rubocop/cop/performance/end_with.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies unnecessary use of a regex where `String#end_with?` would suffice.
+      # Identifies unnecessary use of a regex where `String#end_with?` would suffice.
       #
       # This cop has `SafeMultiline` configuration option that `true` by default because
       # `end$` is unsafe as it will behave incompatible with `end_with?`
@@ -50,12 +50,11 @@ module RuboCop
         include RegexpMetacharacter
         extend AutoCorrector
 
-        MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
-              'the end of the string.'
+        MSG = 'Use `String#end_with?` instead of a regex match anchored to the end of the string.'
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
+          {(call $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :match?} $_)
            (match-with-lvasgn (regexp (str $#literal_at_end?) (regopt)) $_)}
         PATTERN
@@ -67,12 +66,14 @@ module RuboCop
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = drop_end_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
+            new_source = "#{receiver.source}#{dot}end_with?(#{to_string_literal(regex_str)})"
 
-            corrector.replace(node.source_range, new_source)
+            corrector.replace(node, new_source)
           end
         end
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
       end
     end

data/lib/rubocop/cop/performance/fixed_size.rb

@@ -78,13 +78,13 @@ module RuboCop
         end
 
         def contains_splat?(node)
-          return unless node.array_type?
+          return false unless node.array_type?
 
           node.each_child_node(:splat).any?
         end
 
         def contains_double_splat?(node)
-          return unless node.hash_type?
+          return false unless node.hash_type?
 
           node.each_child_node(:kwsplat).any?
         end

data/lib/rubocop/cop/performance/flat_map.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `map { ... }.flatten` and
+      # Identifies usages of `map { ... }.flatten` and
       # change them to use `flat_map { ... }` instead.
       #
       # @example
@@ -28,7 +28,7 @@ module RuboCop
         def_node_matcher :flat_map_candidate?, <<~PATTERN
           (send
             {
-              (block $(send _ ${:collect :map}) ...)
+              $(block (send _ ${:collect :map}) ...)
               $(send _ ${:collect :map} (block_pass _))
             }
             ${:flatten :flatten!}
@@ -60,7 +60,8 @@ module RuboCop
         end
 
         def register_offense(node, map_node, first_method, flatten, message)
-          range = range_between(map_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          map_send_node = map_node.block_type? ? map_node.send_node : map_node
+          range = range_between(map_send_node.loc.selector.begin_pos, node.source_range.end_pos)
           message = format(message, method: first_method, flatten: flatten)
 
           add_offense(range, message: message) do |corrector|
@@ -74,10 +75,11 @@ module RuboCop
 
           return unless flatten_level
 
-          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+          map_send_node = map_node.block_type? ? map_node.send_node : map_node
+          range = range_between(map_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
-          corrector.replace(map_node.loc.selector, 'flat_map')
+          corrector.replace(map_send_node.loc.selector, 'flat_map')
         end
       end
     end

data/lib/rubocop/cop/performance/inefficient_hash_search.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop checks for inefficient searching of keys and values within
+      # Checks for inefficient searching of keys and values within
       # hashes.
       #
       # `Hash#keys.include?` is less efficient than `Hash#key?` because
@@ -45,7 +45,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[include?].freeze
 
         def_node_matcher :inefficient_include?, <<~PATTERN
-          (send (send $_ {:keys :values}) :include? _)
+          (send (call $_ {:keys :values}) :include? _)
         PATTERN
 
         def on_send(node)
@@ -56,23 +56,23 @@ module RuboCop
             add_offense(node, message: message) do |corrector|
               # Replace `keys.include?` or `values.include?` with the appropriate
               # `key?`/`value?` method.
-              corrector.replace(
-                node.loc.expression,
-                "#{autocorrect_hash_expression(node)}."\
-                "#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
-              )
+              corrector.replace(node, replacement(node))
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def message(node)
-          "Use `##{autocorrect_method(node)}` instead of "\
-            "`##{current_method(node)}.include?`."
+          "Use `##{correct_method(node)}` instead of `##{current_method(node)}.include?`."
         end
 
-        def autocorrect_method(node)
+        def replacement(node)
+          "#{correct_hash_expression(node)}#{correct_dot(node)}#{correct_method(node)}(#{correct_argument(node)})"
+        end
+
+        def correct_method(node)
           case current_method(node)
           when :keys then use_long_method ? 'has_key?' : 'key?'
           when :values then use_long_method ? 'has_value?' : 'value?'
@@ -85,18 +85,20 @@ module RuboCop
 
         def use_long_method
           preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config &&
-            preferred_config['EnforcedStyle'] == 'long' &&
-            preferred_config['Enabled']
+          preferred_config && preferred_config['EnforcedStyle'] == 'long' && preferred_config['Enabled']
         end
 
-        def autocorrect_argument(node)
+        def correct_argument(node)
           node.arguments.first.source
         end
 
-        def autocorrect_hash_expression(node)
+        def correct_hash_expression(node)
           node.receiver.receiver.source
         end
+
+        def correct_dot(node)
+          node.receiver.loc.dot.source
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/io_readlines.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where inefficient `readlines` method
+      # Identifies places where inefficient `readlines` method
       # can be replaced by `each_line` to avoid fully loading file content into memory.
       #
       # @example
@@ -95,7 +95,7 @@ module RuboCop
           begin_pos = readlines_call.loc.selector.begin_pos
 
           end_pos = if enumerable_call.method?(:each)
-                      enumerable_call.loc.expression.end_pos
+                      enumerable_call.source_range.end_pos
                     else
                       enumerable_call.loc.dot.begin_pos
                     end

data/lib/rubocop/cop/performance/map_compact.rb

@@ -40,12 +40,12 @@ module RuboCop
         def_node_matcher :map_compact, <<~PATTERN
           {
             (send
-              $(send _ {:map :collect}
+              $(call _ {:map :collect}
                 (block_pass
                   (sym _))) _)
             (send
               (block
-                $(send _ {:map :collect})
+                $(call _ {:map :collect})
                   (args ...) _) _)
           }
         PATTERN
@@ -61,13 +61,14 @@ module RuboCop
             remove_compact_method(corrector, map_node, node, node.parent)
           end
         end
+        alias on_csend on_send
 
         private
 
         def remove_compact_method(corrector, map_node, compact_node, chained_method)
           compact_method_range = compact_node.loc.selector
 
-          if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && chained_method.dot? &&
+          if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && use_dot?(chained_method) &&
              !map_method_and_compact_method_on_same_line?(map_node, compact_node) &&
              !invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
             compact_method_range = compact_method_with_final_newline_range(compact_method_range)
@@ -78,12 +79,16 @@ module RuboCop
           corrector.remove(compact_method_range)
         end
 
+        def use_dot?(node)
+          node.respond_to?(:dot?) && node.dot?
+        end
+
         def map_method_and_compact_method_on_same_line?(map_node, compact_node)
           compact_node.loc.selector.line == map_node.loc.selector.line
         end
 
         def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
-          compact_node.loc.selector.line == chained_method.loc.selector.line
+          compact_node.loc.selector.line == chained_method.loc.last_line
         end
 
         def compact_method_with_final_newline_range(compact_method_range)

data/lib/rubocop/cop/performance/map_method_chain.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # Checks if the map method is used in a chain.
+      #
+      # Autocorrection is not supported because an appropriate block variable name cannot be determined automatically.
+      #
+      # @safety
+      #   This cop is unsafe because false positives occur if the number of times the first method is executed
+      #   affects the return value of subsequent methods.
+      #
+      # [source,ruby]
+      # ----
+      # class X
+      #   def initialize
+      #     @@num = 0
+      #   end
+      #
+      #   def foo
+      #     @@num += 1
+      #     self
+      #   end
+      #
+      #   def bar
+      #     @@num * 2
+      #   end
+      # end
+      #
+      # [X.new, X.new].map(&:foo).map(&:bar) # => [4, 4]
+      # [X.new, X.new].map { |x| x.foo.bar } # => [2, 4]
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   array.map(&:foo).map(&:bar)
+      #
+      #   # good
+      #   array.map { |item| item.foo.bar }
+      #
+      class MapMethodChain < Base
+        include IgnoredNode
+
+        MSG = 'Use `%<method_name>s { |x| x.%<map_args>s }` instead of `%<method_name>s` method chain.'
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def_node_matcher :block_pass_with_symbol_arg?, <<~PATTERN
+          (:block_pass (:sym $_))
+        PATTERN
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+          return unless (map_arg = block_pass_with_symbol_arg?(node.first_argument))
+
+          map_args = [map_arg]
+
+          return unless (begin_of_chained_map_method = find_begin_of_chained_map_method(node, map_args))
+
+          range = begin_of_chained_map_method.loc.selector.begin.join(node.source_range.end)
+          message = format(MSG, method_name: begin_of_chained_map_method.method_name, map_args: map_args.join('.'))
+
+          add_offense(range, message: message)
+
+          ignore_node(node)
+        end
+
+        private
+
+        def find_begin_of_chained_map_method(node, map_args)
+          return unless (chained_map_method = node.receiver)
+          return if !chained_map_method.call_type? || !RESTRICT_ON_SEND.include?(chained_map_method.method_name)
+          return unless (map_arg = block_pass_with_symbol_arg?(chained_map_method.first_argument))
+
+          map_args.unshift(map_arg)
+
+          receiver = chained_map_method.receiver
+
+          return chained_map_method unless receiver.call_type? && block_pass_with_symbol_arg?(receiver.first_argument)
+
+          find_begin_of_chained_map_method(chained_map_method, map_args)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/method_object_as_block.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where methods are converted to blocks, with the
+      # Identifies places where methods are converted to blocks, with the
       # use of `&method`, and passed as arguments to method calls.
       # It is faster to replace those with explicit blocks, calling those methods inside.
       #

data/lib/rubocop/cop/performance/open_struct.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop checks for `OpenStruct.new` calls.
+      # Checks for `OpenStruct.new` calls.
       # Instantiation of an `OpenStruct` invalidates
       # Ruby global method cache as it causes dynamic method
       # definition during program runtime.
@@ -32,8 +32,7 @@ module RuboCop
       #   end
       #
       class OpenStruct < Base
-        MSG = 'Consider using `Struct` over `OpenStruct` ' \
-              'to optimize the performance.'
+        MSG = 'Consider using `Struct` over `OpenStruct` to optimize the performance.'
         RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :open_struct, <<~PATTERN

data/lib/rubocop/cop/performance/range_include.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies uses of `Range#include?` and `Range#member?`, which iterates over each
+      # Identifies uses of `Range#include?` and `Range#member?`, which iterates over each
       # item in a `Range` to see if a specified item is there. In contrast,
       # `Range#cover?` simply compares the target item with the beginning and
       # end points of the `Range`. In a great majority of cases, this is what
@@ -11,7 +11,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
-      #   are not equivalent behaviour.
+      #   are not equivalent behavior.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/performance/redundant_block_call.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies the use of a `&block` parameter and `block.call`
+      # Identifies the use of a `&block` parameter and `block.call`
       # where `yield` would do just as well.
       #
       # @example
@@ -75,7 +75,7 @@ module RuboCop
 
           new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
 
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def calls_to_report(argname, body)

data/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb

@@ -3,13 +3,23 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
+      # Checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
       # and `Enumerable#none?` are compared with `===` or similar methods in block.
       #
       # By default, `Object#===` behaves the same as `Object#==`, but this
       # behavior is appropriately overridden in subclass. For example,
       # `Range#===` returns `true` when argument is within the range.
       #
+      # This cop has `AllowRegexpMatch` option and it is true by default because
+      # `regexp.match?('string')` often used in block changes to the opposite result:
+      #
+      # [source,ruby]
+      # ----
+      # [/pattern/].all? { |regexp| regexp.match?('pattern') } # => true
+      # [/pattern/].all? { |regexp| regexp =~ 'pattern' }      # => true
+      # [/pattern/].all?('pattern')                            # => false
+      # ----
+      #
       # @safety
       #   This cop is unsafe because `===` and `==` do not always behave the same.
       #
@@ -22,14 +32,31 @@ module RuboCop
       #
       #   # good
       #   items.all?(pattern)
+      #   items.all?(Klass)
+      #
+      # @example AllowRegexpMatch: true (default)
+      #
+      #   # good
+      #   items.all? { |item| item =~ pattern }
+      #   items.all? { |item| item.match?(pattern) }
+      #
+      # @example AllowRegexpMatch: false
+      #
+      #   # bad
+      #   items.all? { |item| item =~ pattern }
+      #   items.all? { |item| item.match?(pattern) }
       #
       class RedundantEqualityComparisonBlock < Base
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of block.'
 
         TARGET_METHODS = %i[all? any? one? none?].freeze
         COMPARISON_METHODS = %i[== === is_a? kind_of?].freeze
+        REGEXP_METHODS = %i[=~ match?].freeze
         IS_A_METHODS = %i[is_a? kind_of?].freeze
 
         def on_block(node)
@@ -57,7 +84,11 @@ module RuboCop
         end
 
         def use_equality_comparison_block?(block_body)
-          block_body.send_type? && COMPARISON_METHODS.include?(block_body.method_name)
+          return false unless block_body.send_type?
+
+          method_name = block_body.method_name
+
+          COMPARISON_METHODS.include?(method_name) || (!allow_regexp_match? && REGEXP_METHODS.include?(method_name))
         end
 
         def same_block_argument_and_is_a_argument?(block_body, block_argument)
@@ -66,7 +97,7 @@ module RuboCop
           elsif IS_A_METHODS.include?(block_body.method_name)
             block_argument.source == block_body.first_argument.source
           else
-            false
+            block_body.receiver.source == block_body.first_argument.receiver&.source
           end
         end
 
@@ -96,6 +127,10 @@ module RuboCop
         def offense_range(node)
           node.send_node.loc.selector.join(node.source_range.end)
         end
+
+        def allow_regexp_match?
+          cop_config.fetch('AllowRegexpMatch', true)
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/redundant_match.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies the use of `Regexp#match` or `String#match`, which
+      # Identifies the use of `Regexp#match` or `String#match`, which
       # returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
       # index/`nil` and is more performant.
       #
@@ -20,8 +20,7 @@ module RuboCop
       class RedundantMatch < Base
         extend AutoCorrector
 
-        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
-              '`#match` will not be used.'
+        MSG = 'Use `=~` in places where the `MatchData` returned by `#match` will not be used.'
         RESTRICT_ON_SEND = %i[match].freeze
 
         # 'match' is a fairly generic name, so we don't flag it unless we see
@@ -41,20 +40,22 @@ module RuboCop
                         !(node.parent && node.parent.block_type?)
 
           add_offense(node) do |corrector|
-            autocorrect(corrector, node)
+            autocorrect(corrector, node) if autocorrectable?(node)
           end
         end
 
         private
 
         def autocorrect(corrector, node)
-          # Regexp#match can take a second argument, but this cop doesn't
-          # register an offense in that case
-          return unless node.first_argument.regexp_type?
-
           new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
 
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
+        end
+
+        def autocorrectable?(node)
+          # Regexp#match can take a second argument, but this cop doesn't
+          # register an offense in that case
+          node.receiver.regexp_type? || node.first_argument.regexp_type?
         end
       end
     end