rubocop-performance 1.7.1 → 1.8.0

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

@@ -36,7 +36,9 @@ module RuboCop
       #   { a: 1, b: 2 }.has_value?('garbage')
       #   h = { a: 1, b: 2 }; h.value?(nil)
       #
-      class InefficientHashSearch < Cop
+      class InefficientHashSearch < Base
+        extend AutoCorrector
+
         def_node_matcher :inefficient_include?, <<~PATTERN
           (send (send $_ {:keys :values}) :include? _)
         PATTERN
@@ -45,19 +47,16 @@ module RuboCop
           inefficient_include?(node) do |receiver|
             return if receiver.nil?
 
-            add_offense(node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda 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)})"
-            )
+            message = message(node)
+            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)})"
+              )
+            end
           end
         end
 

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

@@ -24,8 +24,9 @@ module RuboCop
       #   file.each_line.find { |l| l.start_with?('#') }
       #   file.each_line { |l| puts l }
       #
-      class IoReadlines < Cop
+      class IoReadlines < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
         ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).freeze
@@ -39,34 +40,16 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          readlines_on_class?(node) do |enumerable_call, readlines_call|
-            offense(node, enumerable_call, readlines_call)
-          end
+          return unless (captured_values = readlines_on_class?(node) || readlines_on_instance?(node))
 
-          readlines_on_instance?(node) do |enumerable_call, readlines_call, _|
-            offense(node, enumerable_call, readlines_call)
-          end
-        end
+          enumerable_call, readlines_call, receiver = *captured_values
+
+          range = offense_range(enumerable_call, readlines_call)
+          good_method = build_good_method(enumerable_call)
+          bad_method = build_bad_method(enumerable_call)
 
-        def autocorrect(node)
-          readlines_on_instance?(node) do |enumerable_call, readlines_call, receiver|
-            # We cannot safely correct `.readlines` method called on IO/File classes
-            # due to its signature and we are not sure with implicit receiver
-            # if it is called in the context of some instance or mentioned class.
-            return if receiver.nil?
-
-            lambda do |corrector|
-              range = correction_range(enumerable_call, readlines_call)
-
-              if readlines_call.arguments?
-                call_args = build_call_args(readlines_call.arguments)
-                replacement = "each_line(#{call_args})"
-              else
-                replacement = 'each_line'
-              end
-
-              corrector.replace(range, replacement)
-            end
+          add_offense(range, message: format(MSG, good: good_method, bad: bad_method)) do |corrector|
+            autocorrect(corrector, enumerable_call, readlines_call, receiver)
           end
         end
 
@@ -76,16 +59,22 @@ module RuboCop
           ENUMERABLE_METHODS.include?(node.to_sym)
         end
 
-        def offense(node, enumerable_call, readlines_call)
-          range = offense_range(enumerable_call, readlines_call)
-          good_method = build_good_method(enumerable_call)
-          bad_method = build_bad_method(enumerable_call)
+        def autocorrect(corrector, enumerable_call, readlines_call, receiver)
+          # We cannot safely correct `.readlines` method called on IO/File classes
+          # due to its signature and we are not sure with implicit receiver
+          # if it is called in the context of some instance or mentioned class.
+          return if receiver.nil?
+
+          range = correction_range(enumerable_call, readlines_call)
+
+          if readlines_call.arguments?
+            call_args = build_call_args(readlines_call.arguments)
+            replacement = "each_line(#{call_args})"
+          else
+            replacement = 'each_line'
+          end
 
-          add_offense(
-            node,
-            location: range,
-            message: format(MSG, good: good_method, bad: bad_method)
-          )
+          corrector.replace(range, replacement)
         end
 
         def offense_range(enumerable_call, readlines_call)

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

@@ -27,7 +27,7 @@ module RuboCop
       #     end
       #   end
       #
-      class OpenStruct < Cop
+      class OpenStruct < Base
         MSG = 'Consider using `Struct` over `OpenStruct` ' \
               'to optimize the performance.'
 
@@ -37,7 +37,7 @@ module RuboCop
 
         def on_send(node)
           open_struct(node) do
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector)
           end
         end
       end

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

@@ -24,7 +24,9 @@ module RuboCop
       #   # the desired result:
       #
       #   ('a'..'z').cover?('yellow') # => true
-      class RangeInclude < Cop
+      class RangeInclude < Base
+        extend AutoCorrector
+
         MSG = 'Use `Range#cover?` instead of `Range#%<bad_method>s`.'
 
         # TODO: If we traced out assignments of variables to their uses, we
@@ -39,12 +41,11 @@ module RuboCop
         def on_send(node)
           range_include(node) do |bad_method|
             message = format(MSG, bad_method: bad_method)
-            add_offense(node, location: :selector, message: message)
-          end
-        end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'cover?') }
+            add_offense(node.loc.selector, message: message) do |corrector|
+              corrector.replace(node.loc.selector, 'cover?')
+            end
+          end
         end
       end
     end

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

@@ -22,7 +22,9 @@ module RuboCop
       #   def another
       #     yield 1, 2, 3
       #   end
-      class RedundantBlockCall < Cop
+      class RedundantBlockCall < Base
+        extend AutoCorrector
+
         MSG = 'Use `yield` instead of `%<argname>s.call`.'
         YIELD = 'yield'
         OPEN_PAREN = '('
@@ -47,13 +49,17 @@ module RuboCop
             next unless body
 
             calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, message: format(MSG, argname: argname))
+              add_offense(blockcall, message: format(MSG, argname: argname)) do |corrector|
+                autocorrect(corrector, blockcall)
+              end
             end
           end
         end
 
+        private
+
         # offenses are registered on the `block.call` nodes
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           _receiver, _method, *args = *node
           new_source = String.new(YIELD)
           unless args.empty?
@@ -67,10 +73,9 @@ module RuboCop
           end
 
           new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
 
-        private
+          corrector.replace(node.source_range, new_source)
+        end
 
         def calls_to_report(argname, body)
           return [] if blockarg_assigned?(body, argname)

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

@@ -17,7 +17,9 @@ module RuboCop
       #   # good
       #   method(str =~ /regex/)
       #   return value unless regex =~ 'str'
-      class RedundantMatch < Cop
+      class RedundantMatch < Base
+        extend AutoCorrector
+
         MSG = 'Use `=~` in places where the `MatchData` returned by ' \
               '`#match` will not be used.'
 
@@ -37,18 +39,21 @@ module RuboCop
                         (!node.value_used? || only_truthiness_matters?(node)) &&
                         !(node.parent && node.parent.block_type?)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        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
+          new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
 
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+          corrector.replace(node.source_range, new_source)
         end
       end
     end

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

@@ -24,7 +24,9 @@ module RuboCop
       #   # good
       #   hash[:a] = 1
       #   hash[:b] = 2
-      class RedundantMerge < Cop
+      class RedundantMerge < Base
+        extend AutoCorrector
+
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -44,18 +46,17 @@ module RuboCop
 
         def on_send(node)
           each_redundant_merge(node) do |redundant_merge_node|
-            add_offense(redundant_merge_node)
-          end
-        end
-
-        def autocorrect(node)
-          redundant_merge_candidate(node) do |receiver, pairs|
-            new_source = to_assignments(receiver, pairs).join("\n")
-
-            if node.parent && pairs.size > 1
-              correct_multiple_elements(node, node.parent, new_source)
-            else
-              correct_single_element(node, new_source)
+            message = message(node)
+            add_offense(redundant_merge_node, message: message) do |corrector|
+              redundant_merge_candidate(node) do |receiver, pairs|
+                new_source = to_assignments(receiver, pairs).join("\n")
+
+                if node.parent && pairs.size > 1
+                  correct_multiple_elements(corrector, node, node.parent, new_source)
+                else
+                  correct_single_element(corrector, node, new_source)
+                end
+              end
             end
           end
         end
@@ -98,7 +99,7 @@ module RuboCop
             !EachWithObjectInspector.new(node, receiver).value_used?
         end
 
-        def correct_multiple_elements(node, parent, new_source)
+        def correct_multiple_elements(corrector, node, parent, new_source)
           if modifier_flow_control?(parent)
             new_source = rewrite_with_modifier(node, parent, new_source)
             node = parent
@@ -107,11 +108,11 @@ module RuboCop
             new_source.gsub!(/\n/, padding)
           end
 
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+          corrector.replace(node.source_range, new_source)
         end
 
-        def correct_single_element(node, new_source)
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        def correct_single_element(corrector, node, new_source)
+          corrector.replace(node.source_range, new_source)
         end
 
         def to_assignments(receiver, pairs)

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,8 +39,9 @@ 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
@@ -50,21 +51,16 @@ module RuboCop
         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))
 
-        def autocorrect(node)
-          redundant_chars_call?(node) do |receiver, method, args|
+          range = offense_range(receiver, node)
+          message = build_message(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
 

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