rubocop-performance 1.8.0 → 1.10.0

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

@@ -22,6 +22,7 @@ module RuboCop
 
         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
         # a string or regexp literal on one side or the other

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

@@ -29,6 +29,7 @@ module RuboCop
 
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[merge!].freeze
 
         WITH_MODIFIER_CORRECTION = <<~RUBY
           %<keyword>s %<condition>s

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `split` argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'a,b,c'.split(/,/)
+      #
+      #   # good
+      #   'a,b,c'.split(',')
+      class RedundantSplitRegexpArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use string as argument instead of regexp.'
+        RESTRICT_ON_SEND = %i[split].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[\n \" \' \\\\ \t \b \f \r].freeze
+
+        def_node_matcher :split_call_with_regexp?, <<~PATTERN
+          {(send !nil? :split {regexp})}
+        PATTERN
+
+        def on_send(node)
+          return unless split_call_with_regexp?(node)
+          return unless determinist_regexp?(node.first_argument)
+
+          add_offense(node.first_argument) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def determinist_regexp?(first_argument)
+          DETERMINISTIC_REGEX.match?(first_argument.source)
+        end
+
+        def autocorrect(corrector, node)
+          new_argument = replacement(node)
+
+          corrector.replace(node.first_argument, "\"#{new_argument}\"")
+        end
+
+        def replacement(node)
+          regexp_content = node.first_argument.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -44,10 +44,10 @@ module RuboCop
         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)
@@ -66,10 +66,6 @@ module RuboCop
 
         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/reverse_each.rb

@@ -17,29 +17,26 @@ module RuboCop
         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
-
-            range = range_between(location_of_reverse, end_location)
+          reverse_each?(node) do
+            range = offense_range(node)
 
             add_offense(range) do |corrector|
-              corrector.replace(replacement_range(node), UNDERSCORE)
+              corrector.replace(range, 'reverse_each')
             end
           end
         end
 
         private
 
-        def replacement_range(node)
-          range_between(node.loc.dot.begin_pos, node.loc.selector.begin_pos)
+        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

@@ -21,6 +21,7 @@ module RuboCop
         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 _)?)

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

@@ -39,6 +39,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `size` instead of `count`.'
+        RESTRICT_ON_SEND = %i[count].freeze
 
         def_node_matcher :array?, <<~PATTERN
           {

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

@@ -22,6 +22,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :squeeze,
@@ -58,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

@@ -47,6 +47,7 @@ module RuboCop
 
         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)))

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

@@ -23,6 +23,7 @@ module RuboCop
         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)))
@@ -47,7 +48,7 @@ module RuboCop
         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

@@ -23,6 +23,7 @@ module RuboCop
         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'

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

@@ -6,25 +6,65 @@ module RuboCop
       # This cop identifies places where custom code finding the sum of elements
       # in some Enumerable object can be replaced by `Enumerable#sum` method.
       #
+      # This cop can change auto-correction scope depending on the value of
+      # `SafeAutoCorrect`.
+      # Its auto-correction is marked as safe by default (`SafeAutoCorrect: true`)
+      # to prevent `TypeError` in auto-correced code when initial value is not
+      # specified as shown below:
+      #
+      # [source,ruby]
+      # ----
+      # ['a', 'b'].sum # => (String can't be coerced into Integer)
+      # ----
+      #
+      # Therefore if initial value is not specified, unsafe auto-corrected will not occur.
+      #
+      # If you always want to enable auto-correction, you can set `SafeAutoCorrect: false`.
+      #
+      # [source,yaml]
+      # ----
+      # Performance/Sum:
+      #   SafeAutoCorrect: false
+      # ----
+      #
+      # Please note that the auto-correction command line option will be changed from
+      # `rubocop -a` to `rubocop -A`, which includes unsafe auto-correction.
+      #
       # @example
       #   # bad
-      #   [1, 2, 3].inject(:+)
+      #   [1, 2, 3].inject(:+)                        # These bad cases with no initial value are unsafe and
+      #   [1, 2, 3].inject(&:+)                       # will not be auto-correced by default. If you want to
+      #   [1, 2, 3].reduce { |acc, elem| acc + elem } # auto-corrected, you can set `SafeAutoCorrect: false`.
       #   [1, 2, 3].reduce(10, :+)
-      #   [1, 2, 3].reduce { |acc, elem| acc + elem }
+      #   [1, 2, 3].map { |elem| elem ** 2 }.sum
+      #   [1, 2, 3].collect(&:count).sum(10)
       #
       #   # good
       #   [1, 2, 3].sum
       #   [1, 2, 3].sum(10)
-      #   [1, 2, 3].sum
+      #   [1, 2, 3].sum { |elem| elem ** 2 }
+      #   [1, 2, 3].sum(10, &:count)
       #
       class Sum < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        MSG_IF_NO_INIT_VALUE =
+          'Use `%<good_method>s` instead of `%<bad_method>s`, unless calling `%<bad_method>s` on an empty array.'
+        RESTRICT_ON_SEND = %i[inject reduce sum].freeze
 
         def_node_matcher :sum_candidate?, <<~PATTERN
-          (send _ ${:inject :reduce} $_init ? (sym :+))
+          (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
+        PATTERN
+
+        def_node_matcher :sum_map_candidate?, <<~PATTERN
+          (send
+            {
+              (block $(send _ {:map :collect}) ...)
+              $(send _ {:map :collect} (block_pass _))
+            }
+          :sum $_init ?)
         PATTERN
 
         def_node_matcher :sum_with_block_candidate?, <<~PATTERN
@@ -40,14 +80,10 @@ module RuboCop
         alias elem_plus_acc? acc_plus_elem?
 
         def on_send(node)
-          sum_candidate?(node) do |method, init|
-            range = sum_method_range(node)
-            message = build_method_message(method, init)
+          return if empty_array_literal?(node)
 
-            add_offense(range, message: message) do |corrector|
-              autocorrect(corrector, init, range)
-            end
-          end
+          handle_sum_candidate(node)
+          handle_sum_map_candidate(node)
         end
 
         def on_block(node)
@@ -65,25 +101,87 @@ module RuboCop
 
         private
 
+        def handle_sum_candidate(node)
+          sum_candidate?(node) do |method, init, operation|
+            range = sum_method_range(node)
+            message = build_method_message(node, method, init, operation)
+
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, init, range)
+            end
+          end
+        end
+
+        def handle_sum_map_candidate(node)
+          sum_map_candidate?(node) do |map, init|
+            next if node.block_literal? || node.block_argument?
+
+            message = build_sum_map_message(map.method_name, init)
+
+            add_offense(sum_map_range(map, node), message: message) do |corrector|
+              autocorrect_sum_map(corrector, node, map, init)
+            end
+          end
+        end
+
+        def empty_array_literal?(node)
+          receiver = node.children.first
+          array_literal?(node) && receiver && receiver.children.empty?
+        end
+
+        def array_literal?(node)
+          receiver = node.children.first
+          receiver&.literal? && receiver&.array_type?
+        end
+
         def autocorrect(corrector, init, range)
-          return if init.empty?
+          return if init.empty? && safe_autocorrect?
 
           replacement = build_good_method(init)
 
           corrector.replace(range, replacement)
         end
 
+        def autocorrect_sum_map(corrector, sum, map, init)
+          sum_range = method_call_with_args_range(sum)
+          map_range = method_call_with_args_range(map)
+
+          block_pass = map.last_argument if map.last_argument&.block_pass_type?
+          replacement = build_good_method(init, block_pass)
+
+          corrector.remove(sum_range)
+
+          dot = '.' if map.receiver
+          corrector.replace(map_range, "#{dot}#{replacement}")
+        end
+
         def sum_method_range(node)
           range_between(node.loc.selector.begin_pos, node.loc.end.end_pos)
         end
 
+        def sum_map_range(map, sum)
+          range_between(map.loc.selector.begin_pos, sum.source_range.end.end_pos)
+        end
+
         def sum_block_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end
 
-        def build_method_message(method, init)
+        def build_method_message(node, method, init, operation)
           good_method = build_good_method(init)
-          bad_method = build_method_bad_method(init, method)
+          bad_method = build_method_bad_method(init, method, operation)
+          msg = if init.empty? && !array_literal?(node)
+                  MSG_IF_NO_INIT_VALUE
+                else
+                  MSG
+                end
+          format(msg, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_sum_map_message(method, init)
+          sum_method = build_good_method(init)
+          good_method = "#{sum_method} { ... }"
+          bad_method = "#{method} { ... }.#{sum_method}"
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
@@ -93,23 +191,30 @@ module RuboCop
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
-        def build_good_method(init)
+        def build_good_method(init, block_pass = nil)
           good_method = 'sum'
 
+          args = []
           unless init.empty?
             init = init.first
-            good_method += "(#{init.source})" if init.source.to_i != 0
+            args << init.source unless init.int_type? && init.value.zero?
           end
+          args << block_pass.source if block_pass
+          good_method += "(#{args.join(', ')})" unless args.empty?
           good_method
         end
 
-        def build_method_bad_method(init, method)
+        def build_method_bad_method(init, method, operation)
           bad_method = "#{method}("
           unless init.empty?
             init = init.first
             bad_method += "#{init.source}, "
           end
-          bad_method += ':+)'
+          bad_method += if operation.block_pass_type?
+                          '&:+)'
+                        else
+                          ':+)'
+                        end
           bad_method
         end
 
@@ -123,6 +228,14 @@ module RuboCop
           bad_method += " { |#{var_acc}, #{var_elem}| #{body.source} }"
           bad_method
         end
+
+        def method_call_with_args_range(node)
+          if (receiver = node.receiver)
+            receiver.source_range.end.join(node.source_range.end)
+          else
+            node.source_range
+          end
+        end
       end
     end
   end

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

@@ -23,6 +23,7 @@ module RuboCop
         MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
                   'instead of `.times.%<map_or_collect>s`'
         MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'
+        RESTRICT_ON_SEND = %i[map collect].freeze
 
         def on_send(node)
           check(node)