rubocop-performance 1.7.1 → 1.9.2

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

@@ -13,29 +13,19 @@ module RuboCop
       #   # good
       #   array.sort
       #
-      class RedundantSortBlock < Cop
+      class RedundantSortBlock < Base
         include SortBlock
+        extend AutoCorrector
 
         MSG = 'Use `sort` instead of `%<bad_method>s`.'
 
         def on_block(node)
-          sort_with_block?(node) do |send, var_a, var_b, body|
-            replaceable_body?(body, var_a, var_b) do
-              range = sort_range(send, node)
+          return unless (send, var_a, var_b, body = sort_with_block?(node))
 
-              add_offense(
-                node,
-                location: range,
-                message: message(var_a, var_b)
-              )
-            end
-          end
-        end
+          replaceable_body?(body, var_a, var_b) do
+            range = sort_range(send, node)
 
-        def autocorrect(node)
-          sort_with_block?(node) do |send, _var_a, _var_b, _body|
-            lambda do |corrector|
-              range = sort_range(send, node)
+            add_offense(range, message: message(var_a, var_b)) do |corrector|
               corrector.replace(range, 'sort')
             end
           end

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

@@ -39,41 +39,33 @@ module RuboCop
       #   str.size
       #   str.empty?
       #
-      class RedundantStringChars < Cop
+      class RedundantStringChars < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        REPLACEABLE_METHODS = %i[[] slice first last take drop length size empty?].freeze
+        RESTRICT_ON_SEND = %i[[] slice first last take drop length size empty?].freeze
 
         def_node_matcher :redundant_chars_call?, <<~PATTERN
-          (send $(send _ :chars) $#replaceable_method? $...)
+          (send $(send _ :chars) $_ $...)
         PATTERN
 
         def on_send(node)
-          redundant_chars_call?(node) do |receiver, method, args|
-            range = offense_range(receiver, node)
-            message = build_message(method, args)
-            add_offense(node, location: range, message: message)
-          end
-        end
+          return unless (receiver, method, args = redundant_chars_call?(node))
+
+          range = offense_range(receiver, node)
+          message = build_message(method, args)
 
-        def autocorrect(node)
-          redundant_chars_call?(node) do |receiver, method, args|
+          add_offense(range, message: message) do |corrector|
             range = correction_range(receiver, node)
             replacement = build_good_method(method, args)
 
-            lambda do |corrector|
-              corrector.replace(range, replacement)
-            end
+            corrector.replace(range, replacement)
           end
         end
 
         private
 
-        def replaceable_method?(method_name)
-          REPLACEABLE_METHODS.include?(method_name)
-        end
-
         def offense_range(receiver, node)
           range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
         end

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

@@ -72,7 +72,9 @@ module RuboCop
       #       do_something($~)
       #     end
       #   end
-      class RegexpMatch < Cop
+      class RegexpMatch < Base
+        extend AutoCorrector
+
         # Constants are included in this list because it is unlikely that
         # someone will store `nil` as a constant and then use it for comparison
         TYPES_IMPLEMENTING_MATCH = %i[const regexp str sym].freeze
@@ -141,27 +143,28 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if match_method?(node) || match_with_int_arg_method?(node)
-              corrector.replace(node.loc.selector, 'match?')
-            elsif match_operator?(node) || match_threequals?(node)
-              recv, oper, arg = *node
-              correct_operator(corrector, recv, arg, oper)
-            elsif match_with_lvasgn?(node)
-              recv, arg = *node
-              correct_operator(corrector, recv, arg)
-            end
-          end
-        end
-
         private
 
         def check_condition(cond)
           match_node?(cond) do
             return if last_match_used?(cond)
 
-            add_offense(cond)
+            message = message(cond)
+            add_offense(cond, message: message) do |corrector|
+              autocorrect(corrector, cond)
+            end
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if match_method?(node) || match_with_int_arg_method?(node)
+            corrector.replace(node.loc.selector, 'match?')
+          elsif match_operator?(node) || match_threequals?(node)
+            recv, oper, arg = *node
+            correct_operator(corrector, recv, arg, oper)
+          elsif match_with_lvasgn?(node)
+            recv, arg = *node
+            correct_operator(corrector, recv, arg)
           end
         end
 
@@ -231,10 +234,7 @@ module RuboCop
 
         def scope_root(node)
           node.each_ancestor.find do |ancestor|
-            ancestor.def_type? ||
-              ancestor.defs_type? ||
-              ancestor.class_type? ||
-              ancestor.module_type?
+            ancestor.def_type? || ancestor.defs_type? || ancestor.class_type? || ancestor.module_type?
           end
         end
 

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

@@ -12,30 +12,31 @@ module RuboCop
       #
       #   # good
       #   [].reverse_each
-      class ReverseEach < Cop
+      class ReverseEach < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `reverse_each` instead of `reverse.each`.'
-        UNDERSCORE = '_'
+        RESTRICT_ON_SEND = %i[each].freeze
 
         def_node_matcher :reverse_each?, <<~MATCHER
-          (send $(send _ :reverse) :each)
+          (send (send _ :reverse) :each)
         MATCHER
 
         def on_send(node)
-          reverse_each?(node) do |receiver|
-            location_of_reverse = receiver.loc.selector.begin_pos
-            end_location = node.loc.selector.end_pos
+          reverse_each?(node) do
+            range = offense_range(node)
 
-            range = range_between(location_of_reverse, end_location)
-
-            add_offense(node, location: range)
+            add_offense(range) do |corrector|
+              corrector.replace(range, 'reverse_each')
+            end
           end
         end
 
-        def autocorrect(node)
-          range = range_between(node.loc.dot.begin_pos, node.loc.selector.begin_pos)
-          ->(corrector) { corrector.replace(range, UNDERSCORE) }
+        private
+
+        def offense_range(node)
+          range_between(node.children.first.loc.selector.begin_pos, node.loc.selector.end_pos)
         end
       end
     end

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

@@ -16,10 +16,12 @@ module RuboCop
       #   array.last(5).reverse
       #   array.last
       #
-      class ReverseFirst < Cop
+      class ReverseFirst < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[first].freeze
 
         def_node_matcher :reverse_first_candidate?, <<~PATTERN
           (send $(send _ :reverse) :first (int _)?)
@@ -30,16 +32,9 @@ module RuboCop
             range = correction_range(receiver, node)
             message = build_message(node)
 
-            add_offense(node, location: range, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          reverse_first_candidate?(node) do |receiver|
-            range = correction_range(receiver, node)
-            replacement = build_good_method(node)
+            add_offense(range, message: message) do |corrector|
+              replacement = build_good_method(node)
 
-            lambda do |corrector|
               corrector.replace(range, replacement)
             end
           end

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

@@ -35,8 +35,11 @@ module RuboCop
       #   [1, 2, 3].count { |e| e > 2 }
       # TODO: Add advanced detection of variables that could
       # have been assigned to an array or a hash.
-      class Size < Cop
+      class Size < Base
+        extend AutoCorrector
+
         MSG = 'Use `size` instead of `count`.'
+        RESTRICT_ON_SEND = %i[count].freeze
 
         def_node_matcher :array?, <<~PATTERN
           {
@@ -63,11 +66,9 @@ module RuboCop
         def on_send(node)
           return if node.parent&.block_type? || !count?(node)
 
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'size') }
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'size')
+          end
         end
       end
     end

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

@@ -13,8 +13,9 @@ module RuboCop
       #   # good
       #   array.sort.reverse
       #
-      class SortReverse < Cop
+      class SortReverse < Base
         include SortBlock
+        extend AutoCorrector
 
         MSG = 'Use `sort.reverse` instead of `%<bad_method>s`.'
 
@@ -23,21 +24,11 @@ module RuboCop
             replaceable_body?(body, var_b, var_a) do
               range = sort_range(send, node)
 
-              add_offense(
-                node,
-                location: range,
-                message: message(var_a, var_b)
-              )
-            end
-          end
-        end
+              add_offense(range, message: message(var_a, var_b)) do |corrector|
+                replacement = 'sort.reverse'
 
-        def autocorrect(node)
-          sort_with_block?(node) do |send, _var_a, _var_b, _body|
-            lambda do |corrector|
-              range = sort_range(send, node)
-              replacement = 'sort.reverse'
-              corrector.replace(range, replacement)
+                corrector.replace(range, replacement)
+              end
             end
           end
         end

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

@@ -18,8 +18,11 @@ module RuboCop
       #   str.squeeze('a')
       #   str.squeeze!('a')
       #
-      class Squeeze < Cop
+      class Squeeze < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :squeeze,
@@ -36,24 +39,18 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          squeeze_candidate?(node) do |_, bad_method, regexp_str, replace_str|
+          squeeze_candidate?(node) do |receiver, bad_method, regexp_str, replace_str|
             regexp_str = regexp_str[0..-2] # delete '+' from the end
             regexp_str = interpret_string_escapes(regexp_str)
             return unless replace_str == regexp_str
 
             good_method = PREFERRED_METHODS[bad_method]
             message = format(MSG, current: bad_method, prefer: good_method)
-            add_offense(node, location: :selector, message: message)
-          end
-        end
 
-        def autocorrect(node)
-          squeeze_candidate?(node) do |receiver, bad_method, _regexp_str, replace_str|
-            lambda do |corrector|
-              good_method = PREFERRED_METHODS[bad_method]
+            add_offense(node.loc.selector, message: message) do |corrector|
               string_literal = to_string_literal(replace_str)
-
               new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+
               corrector.replace(node.source_range, new_code)
             end
           end
@@ -62,7 +59,7 @@ module RuboCop
         private
 
         def repeating_literal?(regex_str)
-          regex_str.match?(/\A(?:#{Util::LITERAL_REGEX})\+\z/)
+          regex_str.match?(/\A(?:#{Util::LITERAL_REGEX})\+\z/o)
         end
       end
     end

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

@@ -41,11 +41,13 @@ module RuboCop
       #   'abc'.match(/^ab/)
       #   /^ab/.match('abc')
       #
-      class StartWith < Cop
+      class StartWith < Base
         include RegexpMetacharacter
+        extend AutoCorrector
 
         MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
               'the beginning of the string.'
+        RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
           {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))
@@ -54,25 +56,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_start_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
 
-            lambda do |corrector|
-              new_source = receiver.source + '.start_with?(' +
-                           to_string_literal(regex_str) + ')'
-              corrector.replace(node.source_range, new_source)
-            end
+            new_source = "#{receiver.source}.start_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/string_include.rb

@@ -19,8 +19,11 @@ module RuboCop
       #
       #   # good
       #   'abc'.include?('ab')
-      class StringInclude < Cop
+      class StringInclude < Base
+        extend AutoCorrector
+
         MSG = 'Use `String#include?` instead of a regex match with literal-only pattern.'
+        RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
           {(send $!nil? {:match :=~ :match?} (regexp (str $#literal?) (regopt)))
@@ -29,29 +32,23 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless redundant_regex?(node)
-
-          add_offense(node)
-        end
-        alias on_match_with_lvasgn on_send
+          return unless (receiver, regex_str = redundant_regex?(node))
 
-        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 = interpret_string_escapes(regex_str)
 
-            lambda do |corrector|
-              new_source = receiver.source + '.include?(' +
-                           to_string_literal(regex_str) + ')'
-              corrector.replace(node.source_range, new_source)
-            end
+            new_source = "#{receiver.source}.include?(#{to_string_literal(regex_str)})"
+
+            corrector.replace(node.source_range, new_source)
           end
         end
+        alias on_match_with_lvasgn on_send
 
         private
 
         def literal?(regex_str)
-          regex_str.match?(/\A#{Util::LITERAL_REGEX}+\z/)
+          regex_str.match?(/\A#{Util::LITERAL_REGEX}+\z/o)
         end
       end
     end

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

@@ -18,10 +18,12 @@ module RuboCop
       #   'abc'.gsub(/a+/, 'd')
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
-      class StringReplacement < Cop
+      class StringReplacement < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
         DELETE = 'delete'
         TR = 'tr'
@@ -42,33 +44,37 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def offense(node, first_param, second_param)
+          first_source, = first_source(first_param)
+          first_source = interpret_string_escapes(first_source) unless first_param.str_type?
+          second_source, = *second_param
+          message = message(node, first_source, second_source)
+
+          add_offense(range(node), message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
           _string, _method, first_param, second_param = *node
           first_source, = first_source(first_param)
           second_source, = *second_param
 
           first_source = interpret_string_escapes(first_source) unless first_param.str_type?
 
-          replacement_method =
-            replacement_method(node, first_source, second_source)
-
-          replace_method(node, first_source, second_source, first_param,
-                         replacement_method)
+          replace_method(corrector, node, first_source, second_source, first_param)
         end
 
-        def replace_method(node, first, second, first_param, replacement)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement)
-            unless first_param.str_type?
-              corrector.replace(first_param.source_range,
-                                to_string_literal(first))
-            end
+        def replace_method(corrector, node, first_source, second_source, first_param)
+          replacement_method = replacement_method(node, first_source, second_source)
 
-            remove_second_param(corrector, node, first_param) if second.empty? && first.length == 1
-          end
-        end
+          corrector.replace(node.loc.selector, replacement_method)
+          corrector.replace(first_param.source_range, to_string_literal(first_source)) unless first_param.str_type?
 
-        private
+          remove_second_param(corrector, node, first_param) if second_source.empty? && first_source.length == 1
+        end
 
         def accept_second_param?(second_param)
           second_source, = *second_param
@@ -92,15 +98,6 @@ module RuboCop
           first_source.length != 1
         end
 
-        def offense(node, first_param, second_param)
-          first_source, = first_source(first_param)
-          first_source = interpret_string_escapes(first_source) unless first_param.str_type?
-          second_source, = *second_param
-          message = message(node, first_source, second_source)
-
-          add_offense(node, location: range(node), message: message)
-        end
-
         def first_source(first_param)
           case first_param.type
           when :regexp