rubocop-performance 1.6.1 → 1.9.0

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

@@ -9,67 +9,66 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2, 3].count
+      #   (1..3).to_a.count
+      #   Array[*1..3].count
+      #   Array(1..3).count
       #
       #   # bad
       #   {a: 1, b: 2, c: 3}.count
+      #   [[:foo, :bar], [1, 2]].to_h.count
+      #   Hash[*('a'..'z')].count
+      #   Hash(key: :value).count
       #
       #   # good
       #   [1, 2, 3].size
+      #   (1..3).to_a.size
+      #   Array[*1..3].size
+      #   Array(1..3).size
       #
       #   # good
       #   {a: 1, b: 2, c: 3}.size
+      #   [[:foo, :bar], [1, 2]].to_h.size
+      #   Hash[*('a'..'z')].size
+      #   Hash(key: :value).size
       #
       #   # good
       #   [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
+          {
+            [!nil? array_type?]
+            (send _ :to_a)
+            (send (const nil? :Array) :[] _)
+            (send nil? :Array _)
+          }
+        PATTERN
+
+        def_node_matcher :hash?, <<~PATTERN
+          {
+            [!nil? hash_type?]
+            (send _ :to_h)
+            (send (const nil? :Hash) :[] _)
+            (send nil? :Hash _)
+          }
+        PATTERN
+
+        def_node_matcher :count?, <<~PATTERN
+          (send {#array? #hash?} :count)
+        PATTERN
 
         def on_send(node)
-          return unless eligible_node?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'size') }
-        end
-
-        private
-
-        def eligible_node?(node)
-          return false unless node.method?(:count) && !node.arguments?
-
-          eligible_receiver?(node.receiver) && !allowed_parent?(node.parent)
-        end
-
-        def eligible_receiver?(node)
-          return false unless node
-
-          array?(node) || hash?(node)
-        end
-
-        def allowed_parent?(node)
-          node&.block_type?
-        end
-
-        def array?(node)
-          return true if node.array_type?
-          return false unless node.send_type?
-
-          _, constant = *node.receiver
-
-          constant == :Array || node.method?(:to_a)
-        end
-
-        def hash?(node)
-          return true if node.hash_type?
-          return false unless node.send_type?
-
-          _, constant = *node.receiver
+          return if node.parent&.block_type? || !count?(node)
 
-          constant == :Hash || node.method?(:to_h)
+          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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort { |a, b| b <=> a }`
+      # can be replaced by a faster `sort.reverse`.
+      #
+      # @example
+      #   # bad
+      #   array.sort { |a, b| b <=> a }
+      #
+      #   # good
+      #   array.sort.reverse
+      #
+      class SortReverse < Base
+        include SortBlock
+        extend AutoCorrector
+
+        MSG = 'Use `sort.reverse` instead of `%<bad_method>s`.'
+
+        def on_block(node)
+          sort_with_block?(node) do |send, var_a, var_b, body|
+            replaceable_body?(body, var_b, var_a) do
+              range = sort_range(send, node)
+
+              add_offense(range, message: message(var_a, var_b)) do |corrector|
+                replacement = 'sort.reverse'
+
+                corrector.replace(range, replacement)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(var_a, var_b)
+          bad_method = "sort { |#{var_a}, #{var_b}| #{var_b} <=> #{var_a} }"
+          format(MSG, bad_method: bad_method)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')`
+      # can be replaced by `squeeze('a')` and `squeeze!('a')`.
+      #
+      # The `squeeze('a')` method is faster than `gsub(/a+/, 'a')`.
+      #
+      # @example
+      #
+      #   # bad
+      #   str.gsub(/a+/, 'a')
+      #   str.gsub!(/a+/, 'a')
+      #
+      #   # good
+      #   str.squeeze('a')
+      #   str.squeeze!('a')
+      #
+      class Squeeze < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
+
+        PREFERRED_METHODS = {
+          gsub: :squeeze,
+          gsub!: :squeeze!
+        }.freeze
+
+        def_node_matcher :squeeze_candidate?, <<~PATTERN
+          (send
+            $!nil? ${:gsub :gsub!}
+            (regexp
+              (str $#repeating_literal?)
+              (regopt))
+            (str $_))
+        PATTERN
+
+        def on_send(node)
+          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.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
+        end
+
+        private
+
+        def repeating_literal?(regex_str)
+          regex_str.match?(/\A(?:#{Util::LITERAL_REGEX})\+\z/o)
+        end
+      end
+    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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies unnecessary use of a regex where
+      # `String#include?` would suffice.
+      #
+      # This cop's offenses are not safe to auto-correct if a receiver is nil.
+      #
+      # @example
+      #   # bad
+      #   'abc'.match?(/ab/)
+      #   /ab/.match?('abc')
+      #   'abc' =~ /ab/
+      #   /ab/ =~ 'abc'
+      #   'abc'.match(/ab/)
+      #   /ab/.match('abc')
+      #
+      #   # good
+      #   'abc'.include?('ab')
+      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)))
+           (send (regexp (str $#literal?) (regopt)) {:match :match?} $str)
+           (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)}
+        PATTERN
+
+        def on_send(node)
+          return unless (receiver, regex_str = redundant_regex?(node))
+
+          add_offense(node) do |corrector|
+            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
+            regex_str = interpret_string_escapes(regex_str)
+
+            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/o)
+        end
+      end
+    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

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # 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(:+)                        # 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].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 { |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 ?)
+            (args (arg $_acc) (arg $_elem))
+            $send)
+        PATTERN
+
+        def_node_matcher :acc_plus_elem?, <<~PATTERN
+          (send (lvar %1) :+ (lvar %2))
+        PATTERN
+        alias elem_plus_acc? acc_plus_elem?
+
+        def on_send(node)
+          return if empty_array_literal?(node)
+
+          handle_sum_candidate(node)
+          handle_sum_map_candidate(node)
+        end
+
+        def on_block(node)
+          sum_with_block_candidate?(node) do |send, init, var_acc, var_elem, body|
+            if acc_plus_elem?(body, var_acc, var_elem) || elem_plus_acc?(body, var_elem, var_acc)
+              range = sum_block_range(send, node)
+              message = build_block_message(send, init, var_acc, var_elem, body)
+
+              add_offense(range, message: message) do |corrector|
+                autocorrect(corrector, init, range)
+              end
+            end
+          end
+        end
+
+        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? && 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)
+          corrector.replace(map_range, ".#{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(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
+
+        def build_block_message(send, init, var_acc, var_elem, body)
+          good_method = build_good_method(init)
+          bad_method = build_block_bad_method(send.method_name, init, var_acc, var_elem, body)
+          format(MSG, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_good_method(init, block_pass = nil)
+          good_method = 'sum'
+
+          args = []
+          unless init.empty?
+            init = init.first
+            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, operation)
+          bad_method = "#{method}("
+          unless init.empty?
+            init = init.first
+            bad_method += "#{init.source}, "
+          end
+          bad_method += if operation.block_pass_type?
+                          '&:+)'
+                        else
+                          ':+)'
+                        end
+          bad_method
+        end
+
+        def build_block_bad_method(method, init, var_acc, var_elem, body)
+          bad_method = method.to_s
+
+          unless init.empty?
+            init = init.first
+            bad_method += "(#{init.source})"
+          end
+          bad_method += " { |#{var_acc}, #{var_elem}| #{body.source} }"
+          bad_method
+        end
+
+        def method_call_with_args_range(node)
+          node.receiver.source_range.end.join(node.source_range.end)
+        end
+      end
+    end
+  end
+end