rubocop-performance 1.5.2 → 1.8.0

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

@@ -45,10 +45,10 @@ 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
+        def_node_matcher :counter, <<~MATCHER
           (send ${array hash str sym} {:count :length :size} $...)
         MATCHER
 

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

@@ -14,15 +14,16 @@ 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 ' \
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'
 
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
+        def_node_matcher :flat_map_candidate?, <<~PATTERN
           (send
             {
               (block $(send _ ${:collect :map}) ...)
@@ -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

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

@@ -36,8 +36,10 @@ module RuboCop
       #   { a: 1, b: 2 }.has_value?('garbage')
       #   h = { a: 1, b: 2 }; h.value?(nil)
       #
-      class InefficientHashSearch < Cop
-        def_node_matcher :inefficient_include?, <<-PATTERN
+      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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where inefficient `readlines` method
+      # can be replaced by `each_line` to avoid fully loading file content into memory.
+      #
+      # @example
+      #
+      #   # bad
+      #   File.readlines('testfile').each { |l| puts l }
+      #   IO.readlines('testfile', chomp: true).each { |l| puts l }
+      #
+      #   conn.readlines(10).map { |l| l.size }
+      #   file.readlines.find { |l| l.start_with?('#') }
+      #   file.readlines.each { |l| puts l }
+      #
+      #   # good
+      #   File.open('testfile', 'r').each_line { |l| puts l }
+      #   IO.open('testfile').each_line(chomp: true) { |l| puts l }
+      #
+      #   conn.each_line(10).map { |l| l.size }
+      #   file.each_line.find { |l| l.start_with?('#') }
+      #   file.each_line { |l| puts l }
+      #
+      class IoReadlines < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).freeze
+
+        def_node_matcher :readlines_on_class?, <<~PATTERN
+          $(send $(send (const nil? {:IO :File}) :readlines ...) #enumerable_method?)
+        PATTERN
+
+        def_node_matcher :readlines_on_instance?, <<~PATTERN
+          $(send $(send ${nil? !const_type?} :readlines ...) #enumerable_method? ...)
+        PATTERN
+
+        def on_send(node)
+          return unless (captured_values = readlines_on_class?(node) || readlines_on_instance?(node))
+
+          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)
+
+          add_offense(range, message: format(MSG, good: good_method, bad: bad_method)) do |corrector|
+            autocorrect(corrector, enumerable_call, readlines_call, receiver)
+          end
+        end
+
+        private
+
+        def enumerable_method?(node)
+          ENUMERABLE_METHODS.include?(node.to_sym)
+        end
+
+        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
+
+          corrector.replace(range, replacement)
+        end
+
+        def offense_range(enumerable_call, readlines_call)
+          readlines_pos = readlines_call.loc.selector.begin_pos
+          enumerable_pos = enumerable_call.loc.selector.end_pos
+          range_between(readlines_pos, enumerable_pos)
+        end
+
+        def build_good_method(enumerable_call)
+          if enumerable_call.method?(:each)
+            'each_line'
+          else
+            "each_line.#{enumerable_call.method_name}"
+          end
+        end
+
+        def build_bad_method(enumerable_call)
+          "readlines.#{enumerable_call.method_name}"
+        end
+
+        def correction_range(enumerable_call, readlines_call)
+          begin_pos = readlines_call.loc.selector.begin_pos
+
+          end_pos = if enumerable_call.method?(:each)
+                      enumerable_call.loc.expression.end_pos
+                    else
+                      enumerable_call.loc.dot.begin_pos
+                    end
+
+          range_between(begin_pos, end_pos)
+        end
+
+        def build_call_args(call_args_node)
+          call_args_node.map(&:source).join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -27,17 +27,17 @@ module RuboCop
       #     end
       #   end
       #
-      class OpenStruct < Cop
+      class OpenStruct < Base
         MSG = 'Consider using `Struct` over `OpenStruct` ' \
               'to optimize the performance.'
 
-        def_node_matcher :open_struct, <<-PATTERN
+        def_node_matcher :open_struct, <<~PATTERN
           (send (const {nil? cbase} :OpenStruct) :new ...)
         PATTERN
 
         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

@@ -3,18 +3,19 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies uses of `Range#include?`, which iterates over each
+      # This cop 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
       # is wanted.
       #
-      # This cop is `Safe: false` by default because `Range#include?` and
+      # This cop is `Safe: false` by default because `Range#include?` (or `Range#member?`) and
       # `Range#cover?` are not equivalent behaviour.
       #
       # @example
       #   # bad
       #   ('a'..'z').include?('b') # => true
+      #   ('a'..'z').member?('b')  # => true
       #
       #   # good
       #   ('a'..'z').cover?('b') # => true
@@ -23,26 +24,28 @@ module RuboCop
       #   # the desired result:
       #
       #   ('a'..'z').cover?('yellow') # => true
-      class RangeInclude < Cop
-        MSG = 'Use `Range#cover?` instead of `Range#include?`.'
+      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
         # might pick up on a few more instances of this issue
         # Right now, we only detect direct calls on a Range literal
         # (We don't even catch it if the Range is in double parens)
 
-        def_node_matcher :range_include, <<-PATTERN
-          (send {irange erange (begin {irange erange})} :include? ...)
+        def_node_matcher :range_include, <<~PATTERN
+          (send {irange erange (begin {irange erange})} ${:include? :member?} ...)
         PATTERN
 
         def on_send(node)
-          return unless range_include(node)
-
-          add_offense(node, location: :selector)
-        end
+          range_include(node) do |bad_method|
+            message = format(MSG, bad_method: bad_method)
 
-        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,23 +22,25 @@ 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 = '('
         CLOSE_PAREN = ')'
         SPACE = ' '
 
-        def_node_matcher :blockarg_def, <<-PATTERN
+        def_node_matcher :blockarg_def, <<~PATTERN
           {(def  _   (args ... (blockarg $_)) $_)
            (defs _ _ (args ... (blockarg $_)) $_)}
         PATTERN
 
-        def_node_search :blockarg_calls, <<-PATTERN
+        def_node_search :blockarg_calls, <<~PATTERN
           (send (lvar %1) :call ...)
         PATTERN
 
-        def_node_search :blockarg_assigned?, <<-PATTERN
+        def_node_search :blockarg_assigned?, <<~PATTERN
           (lvasgn %1 ...)
         PATTERN
 
@@ -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,18 +17,20 @@ 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.'
 
         # 'match' is a fairly generic name, so we don't flag it unless we see
         # a string or regexp literal on one side or the other
-        def_node_matcher :match_call?, <<-PATTERN
+        def_node_matcher :match_call?, <<~PATTERN
           {(send {str regexp} :match _)
            (send !nil? :match {str regexp})}
         PATTERN
 
-        def_node_matcher :only_truthiness_matters?, <<-PATTERN
+        def_node_matcher :only_truthiness_matters?, <<~PATTERN
           ^({if while until case while_post until_post} equal?(%0) ...)
         PATTERN
 
@@ -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

@@ -5,12 +5,28 @@ module RuboCop
     module Performance
       # This cop identifies places where `Hash#merge!` can be replaced by
       # `Hash#[]=`.
+      # You can set the maximum number of key-value pairs to consider
+      # an offense with `MaxKeyValuePairs`.
       #
       # @example
+      #   # bad
       #   hash.merge!(a: 1)
       #   hash.merge!({'key' => 'value'})
+      #
+      #   # good
+      #   hash[:a] = 1
+      #   hash['key'] = 'value'
+      #
+      # @example MaxKeyValuePairs: 2 (default)
+      #   # bad
       #   hash.merge!(a: 1, b: 2)
-      class RedundantMerge < Cop
+      #
+      #   # good
+      #   hash[:a] = 1
+      #   hash[:b] = 2
+      class RedundantMerge < Base
+        extend AutoCorrector
+
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -20,28 +36,27 @@ module RuboCop
           %<leading_space>send
         RUBY
 
-        def_node_matcher :redundant_merge_candidate, <<-PATTERN
+        def_node_matcher :redundant_merge_candidate, <<~PATTERN
           (send $!nil? :merge! [(hash $...) !kwsplat_type?])
         PATTERN
 
-        def_node_matcher :modifier_flow_control?, <<-PATTERN
+        def_node_matcher :modifier_flow_control?, <<~PATTERN
           [{if while until} modifier_form?]
         PATTERN
 
         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
@@ -84,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
@@ -93,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)
@@ -168,13 +183,11 @@ module RuboCop
           end
 
           def unwind(receiver)
-            while receiver.respond_to?(:send_type?) && receiver.send_type?
-              receiver, = *receiver
-            end
+            receiver, = *receiver while receiver.respond_to?(:send_type?) && receiver.send_type?
             receiver
           end
 
-          def_node_matcher :each_with_object_node, <<-PATTERN
+          def_node_matcher :each_with_object_node, <<~PATTERN
             (block (send _ :each_with_object _) (args _ $_) ...)
           PATTERN
         end