rubocop-performance 1.8.1 → 1.10.1

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,28 +6,67 @@ 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].inject(&:+)
-      #   [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 :+) (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
           (block
             $(send _ {:inject :reduce} $_init ?)
@@ -41,14 +80,10 @@ module RuboCop
         alias elem_plus_acc? acc_plus_elem?
 
         def on_send(node)
-          sum_candidate?(node) do |method, init, operation|
-            range = sum_method_range(node)
-            message = build_method_message(method, init, operation)
+          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)
@@ -66,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, operation)
+        def build_method_message(node, method, init, operation)
           good_method = build_good_method(init)
           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
 
@@ -94,13 +191,16 @@ 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})" unless init.int_type? && init.value.zero?
+            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
 
@@ -128,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)

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

@@ -10,6 +10,7 @@ module RuboCop
       # NOTE: `String.new` (without operator) is not exactly the same as `+''`.
       # These differ in encoding. `String.new.encoding` is always `ASCII-8BIT`.
       # However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
+      # Therefore, auto-correction is unsafe.
       # So, if you expect `ASCII-8BIT` encoding, disable this cop.
       #
       # @example
@@ -24,7 +25,10 @@ module RuboCop
       #   +'something'
       #   +''
       class UnfreezeString < Base
+        extend AutoCorrector
+
         MSG = 'Use unary plus to get an unfrozen string literal.'
+        RESTRICT_ON_SEND = %i[dup new].freeze
 
         def_node_matcher :dup_string?, <<~PATTERN
           (send {str dstr} :dup)
@@ -38,7 +42,21 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if dup_string?(node) || string_new?(node)
+          return unless dup_string?(node) || string_new?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "+#{string_value(node)}")
+          end
+        end
+
+        private
+
+        def string_value(node)
+          if node.receiver.source == 'String' && node.method?(:new)
+            node.arguments.empty? ? "''" : node.first_argument.source
+          else
+            node.receiver.source
+          end
         end
       end
     end

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

@@ -18,6 +18,7 @@ module RuboCop
 
         MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of ' \
               '`%<double_colon>sURI::Parser.new`.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :uri_parser_new?, <<~PATTERN
           (send

data/lib/rubocop/cop/performance_cops.rb

@@ -4,13 +4,16 @@ require_relative 'mixin/regexp_metacharacter'
 require_relative 'mixin/sort_block'
 
 require_relative 'performance/ancestors_include'
+require_relative 'performance/array_semi_infinite_range_slice'
 require_relative 'performance/big_decimal_with_numeric_argument'
 require_relative 'performance/bind_call'
+require_relative 'performance/block_given_with_explicit_block'
 require_relative 'performance/caller'
 require_relative 'performance/case_when_splat'
 require_relative 'performance/casecmp'
 require_relative 'performance/collection_literal_in_loop'
 require_relative 'performance/compare_with_block'
+require_relative 'performance/constant_regexp'
 require_relative 'performance/count'
 require_relative 'performance/delete_prefix'
 require_relative 'performance/delete_suffix'
@@ -20,13 +23,16 @@ require_relative 'performance/end_with'
 require_relative 'performance/fixed_size'
 require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
+require_relative 'performance/method_object_as_block'
 require_relative 'performance/open_struct'
 require_relative 'performance/range_include'
 require_relative 'performance/io_readlines'
 require_relative 'performance/redundant_block_call'
+require_relative 'performance/redundant_equality_comparison_block'
 require_relative 'performance/redundant_match'
 require_relative 'performance/redundant_merge'
 require_relative 'performance/redundant_sort_block'
+require_relative 'performance/redundant_split_regexp_argument'
 require_relative 'performance/redundant_string_chars'
 require_relative 'performance/regexp_match'
 require_relative 'performance/reverse_each'

data/lib/rubocop/performance/version.rb

@@ -2,8 +2,13 @@
 
 module RuboCop
   module Performance
+    # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.8.1'
+      STRING = '1.10.1'
+
+      def self.document_version
+        STRING.match('\d+\.\d+').to_s
+      end
     end
   end
 end