rubocop-performance 1.7.1 → 1.8.0

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

@@ -23,8 +23,9 @@ module RuboCop
       #   array.max_by(&:foo)
       #   array.min_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
-      class CompareWithBlock < Cop
+      class CompareWithBlock < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
@@ -51,27 +52,15 @@ module RuboCop
 
               range = compare_range(send, node)
 
-              add_offense(
-                node,
-                location: range,
-                message: message(send, method, var_a, var_b, args_a)
-              )
-            end
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            send, var_a, var_b, body = compare?(node)
-            method, arg, = replaceable_body?(body, var_a, var_b)
-            replacement =
-              if method == :[]
-                "#{send.method_name}_by { |a| a[#{arg.first.source}] }"
-              else
-                "#{send.method_name}_by(&:#{method})"
+              add_offense(range, message: message(send, method, var_a, var_b, args_a)) do |corrector|
+                replacement = if method == :[]
+                                "#{send.method_name}_by { |a| a[#{args_a.first.source}] }"
+                              else
+                                "#{send.method_name}_by(&:#{method})"
+                              end
+                corrector.replace(range, replacement)
               end
-            corrector.replace(compare_range(send, node),
-                              replacement)
+            end
           end
         end
 

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Performance
       # This cop is used to identify usages of `count` on an `Enumerable` that
-      # follow calls to `select` or `reject`. Querying logic can instead be
+      # follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
       # passed to the `count` call.
       #
       # @example
@@ -37,15 +37,16 @@ module RuboCop
       #   becomes:
       #
       #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
-      class Count < Cop
+      class Count < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'
 
         def_node_matcher :count_candidate?, <<~PATTERN
           {
-            (send (block $(send _ ${:select :reject}) ...) ${:count :length :size})
-            (send $(send _ ${:select :reject} (:block_pass _)) ${:count :length :size})
+            (send (block $(send _ ${:select :filter :find_all :reject}) ...) ${:count :length :size})
+            (send $(send _ ${:select :filter :find_all :reject} (:block_pass _)) ${:count :length :size})
           }
         PATTERN
 
@@ -57,29 +58,25 @@ module RuboCop
               selector_node.loc.selector.begin_pos
             end
 
-            add_offense(node,
-                        location: range,
-                        message: format(MSG, selector: selector,
-                                             counter: counter))
+            add_offense(range, message: format(MSG, selector: selector, counter: counter)) do |corrector|
+              autocorrect(corrector, node, selector_node, selector)
+            end
           end
         end
 
-        def autocorrect(node)
-          selector_node, selector, _counter = count_candidate?(node)
+        private
+
+        def autocorrect(corrector, node, selector_node, selector)
           selector_loc = selector_node.loc.selector
 
           return if selector == :reject
 
           range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
 
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(selector_loc, 'count')
-          end
+          corrector.remove(range)
+          corrector.replace(selector_loc, 'count')
         end
 
-        private
-
         def eligible_node?(node)
           !(node.parent && node.parent.block_type?)
         end

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

@@ -43,9 +43,10 @@ module RuboCop
       #   str.sub(/^prefix/, '')
       #   str.sub!(/^prefix/, '')
       #
-      class DeletePrefix < Cop
-        extend TargetRubyVersion
+      class DeletePrefix < Base
         include RegexpMetacharacter
+        extend AutoCorrector
+        extend TargetRubyVersion
 
         minimum_target_ruby_version 2.5
 
@@ -63,31 +64,21 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          delete_prefix_candidate?(node) do |_, bad_method, _, replace_string|
-            return unless replace_string.blank?
-
-            good_method = PREFERRED_METHODS[bad_method]
+          return unless (receiver, bad_method, regexp_str, replace_string = delete_prefix_candidate?(node))
+          return unless replace_string.blank?
 
-            message = format(MSG, current: bad_method, prefer: good_method)
+          good_method = PREFERRED_METHODS[bad_method]
 
-            add_offense(node, location: :selector, message: message)
-          end
-        end
+          message = format(MSG, current: bad_method, prefer: good_method)
 
-        def autocorrect(node)
-          delete_prefix_candidate?(node) do |receiver, bad_method, regexp_str, _|
-            lambda do |corrector|
-              good_method = PREFERRED_METHODS[bad_method]
-              regexp_str = drop_start_metacharacter(regexp_str)
-              regexp_str = interpret_string_escapes(regexp_str)
-              string_literal = to_string_literal(regexp_str)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            regexp_str = drop_start_metacharacter(regexp_str)
+            regexp_str = interpret_string_escapes(regexp_str)
+            string_literal = to_string_literal(regexp_str)
 
-              new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
 
-              # TODO: `source_range` is no longer required when RuboCop 0.81 or lower support will be dropped.
-              # https://github.com/rubocop-hq/rubocop/commit/82eb350d2cba16
-              corrector.replace(node.source_range, new_code)
-            end
+            corrector.replace(node, new_code)
           end
         end
       end

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

@@ -43,9 +43,10 @@ module RuboCop
       #   str.sub(/suffix$/, '')
       #   str.sub!(/suffix$/, '')
       #
-      class DeleteSuffix < Cop
-        extend TargetRubyVersion
+      class DeleteSuffix < Base
         include RegexpMetacharacter
+        extend AutoCorrector
+        extend TargetRubyVersion
 
         minimum_target_ruby_version 2.5
 
@@ -63,31 +64,21 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          delete_suffix_candidate?(node) do |_, bad_method, _, replace_string|
-            return unless replace_string.blank?
-
-            good_method = PREFERRED_METHODS[bad_method]
+          return unless (receiver, bad_method, regexp_str, replace_string = delete_suffix_candidate?(node))
+          return unless replace_string.blank?
 
-            message = format(MSG, current: bad_method, prefer: good_method)
+          good_method = PREFERRED_METHODS[bad_method]
 
-            add_offense(node, location: :selector, message: message)
-          end
-        end
+          message = format(MSG, current: bad_method, prefer: good_method)
 
-        def autocorrect(node)
-          delete_suffix_candidate?(node) do |receiver, bad_method, regexp_str, _|
-            lambda do |corrector|
-              good_method = PREFERRED_METHODS[bad_method]
-              regexp_str = drop_end_metacharacter(regexp_str)
-              regexp_str = interpret_string_escapes(regexp_str)
-              string_literal = to_string_literal(regexp_str)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            regexp_str = drop_end_metacharacter(regexp_str)
+            regexp_str = interpret_string_escapes(regexp_str)
+            string_literal = to_string_literal(regexp_str)
 
-              new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
 
-              # TODO: `source_range` is no longer required when RuboCop 0.81 or lower support will be dropped.
-              # https://github.com/rubocop-hq/rubocop/commit/82eb350d2cba16
-              corrector.replace(node.source_range, new_code)
-            end
+            corrector.replace(node, new_code)
           end
         end
       end

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Performance
       # This cop is used to identify usages of
-      # `select.first`, `select.last`, `find_all.first`, and `find_all.last`
+      # `select.first`, `select.last`, `find_all.first`, `find_all.last`, `filter.first`, and `filter.last`
       # and change them to use `detect` instead.
       #
       # @example
@@ -13,6 +13,8 @@ module RuboCop
       #   [].select { |item| true }.last
       #   [].find_all { |item| true }.first
       #   [].find_all { |item| true }.last
+      #   [].filter { |item| true }.first
+      #   [].filter { |item| true }.last
       #
       #   # good
       #   [].detect { |item| true }
@@ -22,7 +24,9 @@ module RuboCop
       # `ActiveRecord` does not implement a `detect` method and `find` has its
       # own meaning. Correcting ActiveRecord methods with this cop should be
       # considered unsafe.
-      class Detect < Cop
+      class Detect < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of ' \
               '`%<first_method>s.%<second_method>s`.'
         REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
@@ -30,8 +34,8 @@ module RuboCop
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ {:select :find_all}) ...) ${:first :last} $...)
-            (send $(send _ {:select :find_all} ...) ${:first :last} $...)
+            (send $(block (send _ {:select :find_all :filter}) ...) ${:first :last} $...)
+            (send $(send _ {:select :find_all :filter} ...) ${:first :last} $...)
           }
         PATTERN
 
@@ -47,25 +51,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          receiver, first_method = *node
-
-          replacement = if first_method == :last
-                          "reverse.#{preferred_method}"
-                        else
-                          preferred_method
-                        end
-
-          first_range = receiver.source_range.end.join(node.loc.selector)
-
-          receiver, _args, _body = *receiver if receiver.block_type?
-
-          lambda do |corrector|
-            corrector.remove(first_range)
-            corrector.replace(receiver.loc.selector, replacement)
-          end
-        end
-
         private
 
         def accept_first_call?(receiver, body)
@@ -86,12 +71,30 @@ module RuboCop
                                               first_method: first_method,
                                               second_method: second_method)
 
-          add_offense(node, location: range, message: formatted_message)
+          add_offense(range, message: formatted_message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          receiver, first_method = *node
+
+          replacement = if first_method == :last
+                          "reverse.#{preferred_method}"
+                        else
+                          preferred_method
+                        end
+
+          first_range = receiver.source_range.end.join(node.loc.selector)
+
+          receiver, _args, _body = *receiver if receiver.block_type?
+
+          corrector.remove(first_range)
+          corrector.replace(receiver.loc.selector, replacement)
         end
 
         def preferred_method
-          config.for_cop('Style/CollectionMethods') \
-            ['PreferredMethods']['detect'] || 'detect'
+          config.for_cop('Style/CollectionMethods')['PreferredMethods']['detect'] || 'detect'
         end
 
         def lazy?(node)

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

@@ -17,39 +17,34 @@ module RuboCop
       #   str.start_with?("a", Some::CONST)
       #   str.start_with?("a", "b", "c")
       #   str.end_with?(var1, var2)
-      class DoubleStartEndWith < Cop
+      class DoubleStartEndWith < Base
+        extend AutoCorrector
+
         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)
+          receiver, method, first_call_args, second_call_args = process_source(node)
 
           return unless receiver && second_call_args.all?(&:pure?)
 
           combined_args = combine_args(first_call_args, second_call_args)
 
-          add_offense_for_double_call(node, receiver, method, combined_args)
+          add_offense(node, message: message(node, receiver, method, combined_args)) do |corrector|
+            autocorrect(corrector, first_call_args, second_call_args, combined_args)
+          end
         end
 
-        def autocorrect(node)
-          _receiver, _method,
-          first_call_args, second_call_args = process_source(node)
+        private
 
-          combined_args = combine_args(first_call_args, second_call_args)
+        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
           range = first_argument.join(last_argument)
 
-          lambda do |corrector|
-            corrector.replace(range, combined_args)
-          end
+          corrector.replace(range, combined_args)
         end
 
-        private
-
         def process_source(node)
           if check_for_active_support_aliases?
             check_with_active_support_aliases(node)
@@ -58,17 +53,14 @@ module RuboCop
           end
         end
 
-        def combine_args(first_call_args, second_call_args)
-          (first_call_args + second_call_args).map(&:source).join(', ')
+        def message(node, receiver, method, combined_args)
+          format(
+            MSG, receiver: receiver.source, method: method, combined_args: combined_args, original_code: node.source
+          )
         end
 
-        def add_offense_for_double_call(node, receiver, method, combined_args)
-          msg = format(MSG, receiver: receiver.source,
-                            method: method,
-                            combined_args: combined_args,
-                            original_code: node.source)
-
-          add_offense(node, message: msg)
+        def combine_args(first_call_args, second_call_args)
+          (first_call_args + second_call_args).map(&:source).join(', ')
         end
 
         def check_for_active_support_aliases?

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

@@ -41,8 +41,9 @@ module RuboCop
       #   'abc'.match(/bc$/)
       #   /bc$/.match('abc')
       #
-      class EndWith < Cop
+      class EndWith < Base
         include RegexpMetacharacter
+        extend AutoCorrector
 
         MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
               'the end of the string.'
@@ -54,25 +55,19 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless redundant_regex?(node)
+          return unless (receiver, regex_str = redundant_regex?(node))
 
-          add_offense(node)
-        end
-        alias on_match_with_lvasgn on_send
-
-        def autocorrect(node)
-          redundant_regex?(node) do |receiver, regex_str|
+          add_offense(node) do |corrector|
             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)
 
-            lambda do |corrector|
-              new_source = receiver.source + '.end_with?(' +
-                           to_string_literal(regex_str) + ')'
-              corrector.replace(node.source_range, new_source)
-            end
+            new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
+
+            corrector.replace(node.source_range, new_source)
           end
         end
+        alias on_match_with_lvasgn on_send
       end
     end
   end

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

@@ -45,7 +45,7 @@ module RuboCop
       #   waldo = { a: corge, b: grault }
       #   waldo.size
       #
-      class FixedSize < Cop
+      class FixedSize < Base
         MSG = 'Do not compute the size of statically sized objects.'
 
         def_node_matcher :counter, <<~MATCHER

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

@@ -14,8 +14,9 @@ module RuboCop
       #   [1, 2, 3, 4].flat_map { |e| [e, e] }
       #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
       #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
-      class FlatMap < Cop
+      class FlatMap < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
@@ -44,25 +45,11 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
-          flatten_level, = *params.first
-
-          return unless flatten_level
-
-          range = range_between(node.loc.dot.begin_pos,
-                                node.source_range.end_pos)
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(map_node.loc.selector, 'flat_map')
-          end
-        end
-
         private
 
         def offense_for_levels(node, map_node, first_method, flatten)
           message = MSG + FLATTEN_MULTIPLE_LEVELS
+
           register_offense(node, map_node, first_method, flatten, message)
         end
 
@@ -71,13 +58,24 @@ 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)
+          range = range_between(map_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          message = format(message, method: first_method, flatten: flatten)
+
+          add_offense(range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
+          flatten_level, = *params.first
+
+          return unless flatten_level
+
+          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
 
-          add_offense(node,
-                      location: range,
-                      message: format(message, method: first_method,
-                                               flatten: flatten))
+          corrector.remove(range)
+          corrector.replace(map_node.loc.selector, 'flat_map')
         end
       end
     end