rubocop-performance 1.8.0 → 1.10.0

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

@@ -29,38 +29,40 @@ module RuboCop
         #   [1,2].first    # => 1
         #   [1,2].first(1) # => [1]
         #
-        RETURN_NEW_ARRAY_WHEN_ARGS = ':first :last :pop :sample :shift '
+        RETURN_NEW_ARRAY_WHEN_ARGS = %i[first last pop sample shift].to_set.freeze
 
         # These methods return a new array only when called without a block.
-        RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = ':zip :product '
+        RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = %i[zip product].to_set.freeze
 
         # These methods ALWAYS return a new array
         # after they're called it's safe to mutate the the resulting array
-        ALWAYS_RETURNS_NEW_ARRAY = ':* :+ :- :collect :compact :drop '\
-                                   ':drop_while :flatten :map :reject ' \
-                                   ':reverse :rotate :select :shuffle :sort ' \
-                                   ':take :take_while :transpose :uniq ' \
-                                   ':values_at :| '
+        ALWAYS_RETURNS_NEW_ARRAY = %i[* + - collect compact drop
+                                      drop_while flatten map reject
+                                      reverse rotate select shuffle sort
+                                      take take_while transpose uniq
+                                      values_at |].to_set.freeze
 
         # These methods have a mutation alternative. For example :collect
         # can be called as :collect!
-        HAS_MUTATION_ALTERNATIVE = ':collect :compact :flatten :map :reject '\
-                                   ':reverse :rotate :select :shuffle :sort '\
-                                   ':uniq '
-        MSG = 'Use unchained `%<method>s!` and `%<second_method>s!` '\
+        HAS_MUTATION_ALTERNATIVE = %i[collect compact flatten map reject
+                                      reverse rotate select shuffle sort uniq].to_set.freeze
+
+        RETURNS_NEW_ARRAY = (ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK).freeze
+
+        MSG = 'Use unchained `%<method>s` and `%<second_method>s!` '\
               '(followed by `return array` if required) instead of chaining '\
               '`%<method>s...%<second_method>s`.'
 
-        def_node_matcher :flat_map_candidate?, <<~PATTERN
-          {
-            (send (send _ ${#{RETURN_NEW_ARRAY_WHEN_ARGS}} {int lvar ivar cvar gvar}) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
-            (send (block (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY} }) ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
-            (send (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK}} ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
-          }
+        def_node_matcher :chain_array_allocation?, <<~PATTERN
+          (send {
+            (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar})
+            (block (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
+            (send _ $%RETURNS_NEW_ARRAY ...)
+          } $%HAS_MUTATION_ALTERNATIVE ...)
         PATTERN
 
         def on_send(node)
-          flat_map_candidate?(node) do |fm, sm, _|
+          chain_array_allocation?(node) do |fm, sm|
             range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
 
             add_offense(range, message: format(MSG, method: fm, second_method: sm))

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

@@ -115,7 +115,7 @@ module RuboCop
 
         def node_within_enumerable_loop?(node, ancestor)
           enumerable_loop?(ancestor) do |receiver|
-            receiver != node && !receiver.descendants.include?(node)
+            receiver != node && !receiver&.descendants&.include?(node)
           end
         end
 

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop finds regular expressions with dynamic components that are all constants.
+      #
+      # Ruby allocates a new Regexp object every time it executes a code containing such
+      # a regular expression. It is more efficient to extract it into a constant,
+      # memoize it, or add an `/o` option to perform `#{}` interpolation only once and
+      # reuse that Regexp object.
+      #
+      # @example
+      #
+      #   # bad
+      #   def tokens(pattern)
+      #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/) }
+      #   end
+      #
+      #   # good
+      #   ALL_SEPARATORS = /\A#{SEPARATORS}\Z/
+      #   def tokens(pattern)
+      #     pattern.scan(TOKEN).reject { |token| token.match?(ALL_SEPARATORS) }
+      #   end
+      #
+      #   # good
+      #   def tokens(pattern)
+      #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/o) }
+      #   end
+      #
+      #   # good
+      #   def separators
+      #     @separators ||= /\A#{SEPARATORS}\Z/
+      #   end
+      #
+      class ConstantRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
+
+        def on_regexp(node)
+          return if within_allowed_assignment?(node) ||
+                    !include_interpolated_const?(node) ||
+                    node.single_interpolation?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(node, 'o')
+          end
+        end
+
+        private
+
+        def within_allowed_assignment?(node)
+          node.each_ancestor(:casgn, :or_asgn).any?
+        end
+
+        def_node_matcher :regexp_escape?, <<~PATTERN
+          (send
+            (const nil? :Regexp) :escape const_type?)
+        PATTERN
+
+        def include_interpolated_const?(node)
+          return false unless node.interpolation?
+
+          node.each_child_node(:begin).all? do |begin_node|
+            inner_node = begin_node.children.first
+            inner_node && (inner_node.const_type? || regexp_escape?(inner_node))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -42,6 +42,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'
+        RESTRICT_ON_SEND = %i[count length size].freeze
 
         def_node_matcher :count_candidate?, <<~PATTERN
           {

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

@@ -51,6 +51,7 @@ module RuboCop
         minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :delete_prefix,

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

@@ -51,6 +51,7 @@ module RuboCop
         minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :delete_suffix,

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of
-      # `select.first`, `select.last`, `find_all.first`, `find_all.last`, `filter.first`, and `filter.last`
-      # and change them to use `detect` instead.
+      # This cop is used to identify usages of `first`, `last`, `[0]` or `[-1]`
+      # chained to `select`, `find_all` or `filter` and change them to use
+      # `detect` instead.
       #
       # @example
       #   # bad
@@ -15,6 +15,8 @@ module RuboCop
       #   [].find_all { |item| true }.last
       #   [].filter { |item| true }.first
       #   [].filter { |item| true }.last
+      #   [].filter { |item| true }[0]
+      #   [].filter { |item| true }[-1]
       #
       #   # good
       #   [].detect { |item| true }
@@ -27,27 +29,41 @@ module RuboCop
       class Detect < Base
         extend AutoCorrector
 
+        CANDIDATE_METHODS = Set[:select, :find_all, :filter].freeze
+
         MSG = 'Use `%<prefer>s` instead of ' \
               '`%<first_method>s.%<second_method>s`.'
         REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
                       '`%<first_method>s.%<second_method>s`.'
+        INDEX_MSG = 'Use `%<prefer>s` instead of ' \
+              '`%<first_method>s[%<index>i]`.'
+        INDEX_REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
+              '`%<first_method>s[%<index>i]`.'
+        RESTRICT_ON_SEND = %i[first last []].freeze
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ {:select :find_all :filter}) ...) ${:first :last} $...)
-            (send $(send _ {:select :find_all :filter} ...) ${:first :last} $...)
+            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
+            (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
+            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
+            (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
           }
         PATTERN
 
         def on_send(node)
           detect_candidate?(node) do |receiver, second_method, args|
+            if second_method == :[]
+              index = args
+              args = {}
+            end
+
             return unless args.empty?
             return unless receiver
 
             receiver, _args, body = *receiver if receiver.block_type?
             return if accept_first_call?(receiver, body)
 
-            register_offense(node, receiver, second_method)
+            register_offense(node, receiver, second_method, index)
           end
         end
 
@@ -62,28 +78,31 @@ module RuboCop
           lazy?(caller)
         end
 
-        def register_offense(node, receiver, second_method)
+        def register_offense(node, receiver, second_method, index)
           _caller, first_method, _args = *receiver
           range = receiver.loc.selector.join(node.loc.selector)
 
-          message = second_method == :last ? REVERSE_MSG : MSG
+          message = message_for_method(second_method, index)
           formatted_message = format(message, prefer: preferred_method,
                                               first_method: first_method,
-                                              second_method: second_method)
+                                              second_method: second_method,
+                                              index: index)
 
           add_offense(range, message: formatted_message) do |corrector|
-            autocorrect(corrector, node)
+            autocorrect(corrector, node, replacement(second_method, index))
           end
         end
 
-        def autocorrect(corrector, node)
-          receiver, first_method = *node
+        def replacement(method, index)
+          if method == :last || method == :[] && index == -1
+            "reverse.#{preferred_method}"
+          else
+            preferred_method
+          end
+        end
 
-          replacement = if first_method == :last
-                          "reverse.#{preferred_method}"
-                        else
-                          preferred_method
-                        end
+        def autocorrect(corrector, node, replacement)
+          receiver, _first_method = *node
 
           first_range = receiver.source_range.end.join(node.loc.selector)
 
@@ -93,6 +112,17 @@ module RuboCop
           corrector.replace(receiver.loc.selector, replacement)
         end
 
+        def message_for_method(method, index)
+          case method
+          when :[]
+            index == -1 ? INDEX_REVERSE_MSG : INDEX_MSG
+          when :last
+            REVERSE_MSG
+          else
+            MSG
+          end
+        end
+
         def preferred_method
           config.for_cop('Style/CollectionMethods')['PreferredMethods']['detect'] || 'detect'
         end

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

@@ -47,6 +47,7 @@ module RuboCop
 
         MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
               'the end of the string.'
+        RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
           {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))

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

@@ -47,6 +47,7 @@ module RuboCop
       #
       class FixedSize < Base
         MSG = 'Do not compute the size of statically sized objects.'
+        RESTRICT_ON_SEND = %i[count length size].freeze
 
         def_node_matcher :counter, <<~MATCHER
           (send ${array hash str sym} {:count :length :size} $...)

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

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'
+        RESTRICT_ON_SEND = %i[flatten flatten!].freeze
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'

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

@@ -39,6 +39,8 @@ module RuboCop
       class InefficientHashSearch < Base
         extend AutoCorrector
 
+        RESTRICT_ON_SEND = %i[include?].freeze
+
         def_node_matcher :inefficient_include?, <<~PATTERN
           (send (send $_ {:keys :values}) :include? _)
         PATTERN

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

@@ -29,14 +29,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).freeze
+        RESTRICT_ON_SEND = (Enumerable.instance_methods + [:each]).freeze
 
         def_node_matcher :readlines_on_class?, <<~PATTERN
-          $(send $(send (const nil? {:IO :File}) :readlines ...) #enumerable_method?)
+          $(send $(send (const nil? {:IO :File}) :readlines ...) _)
         PATTERN
 
         def_node_matcher :readlines_on_instance?, <<~PATTERN
-          $(send $(send ${nil? !const_type?} :readlines ...) #enumerable_method? ...)
+          $(send $(send ${nil? !const_type?} :readlines ...) _ ...)
         PATTERN
 
         def on_send(node)
@@ -55,10 +55,6 @@ module RuboCop
 
         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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where methods are converted to blocks, with the
+      # use of `&method`, and passed as arguments to method calls.
+      # It is faster to replace those with explicit blocks, calling those methods inside.
+      #
+      # @example
+      #   # bad
+      #   array.map(&method(:do_something))
+      #   [1, 2, 3].each(&out.method(:puts))
+      #
+      #   # good
+      #   array.map { |x| do_something(x) }
+      #   [1, 2, 3].each { |x| out.puts(x) }
+      #
+      class MethodObjectAsBlock < Base
+        MSG = 'Use block explicitly instead of block-passing a method object.'
+
+        def_node_matcher :method_object_as_argument?, <<~PATTERN
+          (^send (send _ :method sym))
+        PATTERN
+
+        def on_block_pass(node)
+          add_offense(node) if method_object_as_argument?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -30,6 +30,7 @@ module RuboCop
       class OpenStruct < Base
         MSG = 'Consider using `Struct` over `OpenStruct` ' \
               'to optimize the performance.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :open_struct, <<~PATTERN
           (send (const {nil? cbase} :OpenStruct) :new ...)

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

@@ -28,6 +28,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `Range#cover?` instead of `Range#%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[include? member?].freeze
 
         # TODO: If we traced out assignments of variables to their uses, we
         # might pick up on a few more instances of this issue

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

@@ -80,11 +80,11 @@ module RuboCop
         def calls_to_report(argname, body)
           return [] if blockarg_assigned?(body, argname)
 
-          calls = to_enum(:blockarg_calls, body, argname)
+          blockarg_calls(body, argname).map do |call|
+            return [] if args_include_block_pass?(call)
 
-          return [] if calls.any? { |call| args_include_block_pass?(call) }
-
-          calls
+            call
+          end
         end
 
         def args_include_block_pass?(blockcall)

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
+      # and `Enumerable#none?` are compared with `===` or similar methods in block.
+      #
+      # By default, `Object#===` behaves the same as `Object#==`, but this
+      # behavior is appropriately overridden in subclass. For example,
+      # `Range#===` returns `true` when argument is within the range.
+      # Therefore, It is marked as unsafe by default because `===` and `==`
+      # do not always behave the same.
+      #
+      # @example
+      #   # bad
+      #   items.all? { |item| pattern === item }
+      #   items.all? { |item| item == other }
+      #   items.all? { |item| item.is_a?(Klass) }
+      #   items.all? { |item| item.kind_of?(Klass) }
+      #
+      #   # good
+      #   items.all?(pattern)
+      #
+      class RedundantEqualityComparisonBlock < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.5
+
+        MSG = 'Use `%<prefer>s` instead of block.'
+
+        TARGET_METHODS = %i[all? any? one? none?].freeze
+        COMPARISON_METHODS = %i[== === is_a? kind_of?].freeze
+
+        def on_block(node)
+          return unless TARGET_METHODS.include?(node.method_name)
+
+          block_argument = node.arguments.first
+          block_body = node.body
+          return unless use_equality_comparison_block?(block_body)
+          return unless (new_argument = new_argument(block_argument, block_body))
+
+          range = offense_range(node)
+          prefer = "#{node.method_name}(#{new_argument})"
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(range, prefer)
+          end
+        end
+
+        private
+
+        def use_equality_comparison_block?(block_body)
+          block_body.send_type? && COMPARISON_METHODS.include?(block_body.method_name)
+        end
+
+        def new_argument(block_argument, block_body)
+          if block_argument.source == block_body.receiver.source
+            block_body.first_argument.source
+          elsif block_argument.source == block_body.first_argument.source
+            block_body.receiver.source
+          end
+        end
+
+        def offense_range(node)
+          node.send_node.loc.selector.join(node.source_range.end)
+        end
+      end
+    end
+  end
+end