rubocop-performance 1.7.0 → 1.9.1

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

@@ -18,11 +18,11 @@ module RuboCop
       #   caller(1..1).first
       #   caller_locations(2..2).first
       #   caller_locations(1..1).first
-      class Caller < Cop
-        MSG_BRACE = 'Use `%<method>s(%<n>d..%<n>d).first`' \
-                    ' instead of `%<method>s[%<m>d]`.'
-        MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
-                    ' instead of `%<method>s.first`.'
+      class Caller < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred_method>s` instead of `%<current_method>s`.'
+        RESTRICT_ON_SEND = %i[first []].freeze
 
         def_node_matcher :slow_caller?, <<~PATTERN
           {
@@ -41,25 +41,24 @@ module RuboCop
         def on_send(node)
           return unless caller_with_scope_method?(node)
 
-          add_offense(node)
-        end
-
-        private
-
-        def message(node)
           method_name = node.receiver.method_name
           caller_arg = node.receiver.first_argument
           n = caller_arg ? int_value(caller_arg) : 1
-
           if node.method?(:[])
             m = int_value(node.first_argument)
             n += m
-            format(MSG_BRACE, n: n, m: m, method: method_name)
-          else
-            format(MSG_FIRST, n: n, method: method_name)
+          end
+
+          preferred_method = "#{method_name}(#{n}..#{n}).first"
+
+          message = format(MSG, preferred_method: preferred_method, current_method: node.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
           end
         end
 
+        private
+
         def int_value(node)
           node.children[0]
         end

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

@@ -53,9 +53,10 @@ module RuboCop
       #   when 5
       #     baz
       #   end
-      class CaseWhenSplat < Cop
+      class CaseWhenSplat < Base
         include Alignment
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Reordering `when` conditions with a splat to the end ' \
           'of the `when` branches can improve performance.'
@@ -66,24 +67,30 @@ module RuboCop
           when_conditions = case_node.when_branches.flat_map(&:conditions)
 
           splat_offenses(when_conditions).reverse_each do |condition|
-            range = condition.parent.loc.keyword.join(condition.source_range)
+            next if ignored_node?(condition.parent)
+
+            ignore_node(condition.parent)
             variable, = *condition
             message = variable.array_type? ? ARRAY_MSG : MSG
-            add_offense(condition.parent, location: range, message: message)
+            add_offense(range(condition), message: message) do |corrector|
+              autocorrect(corrector, condition.parent)
+            end
           end
         end
 
-        def autocorrect(when_node)
-          lambda do |corrector|
-            if needs_reorder?(when_node)
-              reorder_condition(corrector, when_node)
-            else
-              inline_fix_branch(corrector, when_node)
-            end
+        private
+
+        def autocorrect(corrector, when_node)
+          if needs_reorder?(when_node)
+            reorder_condition(corrector, when_node)
+          else
+            inline_fix_branch(corrector, when_node)
           end
         end
 
-        private
+        def range(node)
+          node.parent.loc.keyword.join(node.source_range)
+        end
 
         def replacement(conditions)
           reordered = conditions.partition(&:splat_type?).reverse

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

@@ -19,8 +19,11 @@ module RuboCop
       #   # good
       #   str.casecmp('ABC').zero?
       #   'abc'.casecmp(str).zero?
-      class Casecmp < Cop
+      class Casecmp < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND = %i[== eql? !=].freeze
         CASE_METHODS = %i[downcase upcase].freeze
 
         def_node_matcher :downcase_eq, <<~PATTERN
@@ -48,21 +51,13 @@ module RuboCop
           return unless downcase_eq(node) || eq_downcase(node)
           return unless (parts = take_method_apart(node))
 
-          _, _, arg, variable = parts
+          _receiver, method, arg, variable = parts
           good_method = build_good_method(arg, variable)
 
-          add_offense(
-            node,
-            message: format(MSG, good: good_method, bad: node.source)
-          )
-        end
-
-        def autocorrect(node)
-          return unless (parts = take_method_apart(node))
-
-          receiver, method, arg, variable = parts
-
-          correction(node, receiver, method, arg, variable)
+          message = format(MSG, good: good_method, bad: node.source)
+          add_offense(node, message: message) do |corrector|
+            correction(corrector, node, method, arg, variable)
+          end
         end
 
         private
@@ -84,14 +79,12 @@ module RuboCop
           [receiver, method, arg, variable]
         end
 
-        def correction(node, _receiver, method, arg, variable)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.expression, '!') if method == :!=
+        def correction(corrector, node, method, arg, variable)
+          corrector.insert_before(node.loc.expression, '!') if method == :!=
 
-            replacement = build_good_method(arg, variable)
+          replacement = build_good_method(arg, variable)
 
-            corrector.replace(node.loc.expression, replacement)
-          end
+          corrector.replace(node.loc.expression, replacement)
         end
 
         def build_good_method(arg, variable)

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

@@ -20,7 +20,7 @@ module RuboCop
       #   array.flatten!
       #   array.map! { |x| x.downcase }
       #   array
-      class ChainArrayAllocation < Cop
+      class ChainArrayAllocation < Base
         include RangeHelp
 
         # These methods return a new array but only sometimes. They must be
@@ -29,47 +29,43 @@ 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, _|
-            range = range_between(
-              node.loc.dot.begin_pos,
-              node.source_range.end_pos
-            )
-            add_offense(
-              node,
-              location: range,
-              message: format(MSG, method: fm, second_method: 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))
           end
         end
       end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where Array and Hash literals are used
+      # within loops. It is better to extract them into a local variable or constant
+      # to avoid unnecessary allocations on each iteration.
+      #
+      # You can set the minimum number of elements to consider
+      # an offense with `MinSize`.
+      #
+      # @example
+      #   # bad
+      #   users.select do |user|
+      #     %i[superadmin admin].include?(user.role)
+      #   end
+      #
+      #   # good
+      #   admin_roles = %i[superadmin admin]
+      #   users.select do |user|
+      #     admin_roles.include?(user.role)
+      #   end
+      #
+      #   # good
+      #   ADMIN_ROLES = %i[superadmin admin]
+      #   ...
+      #   users.select do |user|
+      #     ADMIN_ROLES.include?(user.role)
+      #   end
+      #
+      class CollectionLiteralInLoop < Base
+        MSG = 'Avoid immutable %<literal_class>s literals in loops. '\
+          'It is better to extract it into a local variable or a constant.'
+
+        POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
+        LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
+
+        ENUMERABLE_METHOD_NAMES = (Enumerable.instance_methods + [:each]).to_set.freeze
+        NONMUTATING_ARRAY_METHODS = %i[& * + - <=> == [] all? any? assoc at
+                                       bsearch bsearch_index collect combination
+                                       compact count cycle deconstruct difference dig
+                                       drop drop_while each each_index empty? eql?
+                                       fetch filter find_index first flatten hash
+                                       include? index inspect intersection join
+                                       last length map max min minmax none? one? pack
+                                       permutation product rassoc reject
+                                       repeated_combination repeated_permutation reverse
+                                       reverse_each rindex rotate sample select shuffle
+                                       size slice sort sum take take_while
+                                       to_a to_ary to_h to_s transpose union uniq
+                                       values_at zip |].freeze
+
+        ARRAY_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_ARRAY_METHODS).to_set.freeze
+
+        NONMUTATING_HASH_METHODS = %i[< <= == > >= [] any? assoc compact dig
+                                      each each_key each_pair each_value empty?
+                                      eql? fetch fetch_values filter flatten has_key?
+                                      has_value? hash include? inspect invert key key?
+                                      keys? length member? merge rassoc rehash reject
+                                      select size slice to_a to_h to_hash to_proc to_s
+                                      transform_keys transform_values value? values values_at].freeze
+
+        HASH_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_HASH_METHODS).to_set.freeze
+
+        def_node_matcher :kernel_loop?, <<~PATTERN
+          (block
+            (send {nil? (const nil? :Kernel)} :loop)
+            ...)
+        PATTERN
+
+        def_node_matcher :enumerable_loop?, <<~PATTERN
+          (block
+            (send $_ #enumerable_method? ...)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          receiver, method, = *node.children
+          return unless check_literal?(receiver, method) && parent_is_loop?(receiver)
+
+          message = format(MSG, literal_class: literal_class(receiver))
+          add_offense(receiver, message: message)
+        end
+
+        private
+
+        def check_literal?(node, method)
+          !node.nil? &&
+            nonmutable_method_of_array_or_hash?(node, method) &&
+            node.children.size >= min_size &&
+            node.recursive_basic_literal?
+        end
+
+        def nonmutable_method_of_array_or_hash?(node, method)
+          (node.array_type? && ARRAY_METHODS.include?(method)) ||
+            (node.hash_type? && HASH_METHODS.include?(method))
+        end
+
+        def parent_is_loop?(node)
+          node.each_ancestor.any? { |ancestor| loop?(ancestor, node) }
+        end
+
+        def loop?(ancestor, node)
+          keyword_loop?(ancestor.type) ||
+            kernel_loop?(ancestor) ||
+            node_within_enumerable_loop?(node, ancestor)
+        end
+
+        def keyword_loop?(type)
+          LOOP_TYPES.include?(type)
+        end
+
+        def node_within_enumerable_loop?(node, ancestor)
+          enumerable_loop?(ancestor) do |receiver|
+            receiver != node && !receiver&.descendants&.include?(node)
+          end
+        end
+
+        def literal_class(node)
+          if node.array_type?
+            'Array'
+          elsif node.hash_type?
+            'Hash'
+          end
+        end
+
+        def enumerable_method?(method_name)
+          ENUMERABLE_METHOD_NAMES.include?(method_name)
+        end
+
+        def min_size
+          Integer(cop_config['MinSize'] || 1)
+        end
+      end
+    end
+  end
+end

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

@@ -23,8 +23,9 @@ module RuboCop
       #   array.max_by(&:foo)
       #   array.min_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
-      class CompareWithBlock < Cop
+      class CompareWithBlock < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
@@ -51,27 +52,15 @@ module RuboCop
 
               range = compare_range(send, node)
 
-              add_offense(
-                node,
-                location: range,
-                message: message(send, method, var_a, var_b, args_a)
-              )
-            end
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            send, var_a, var_b, body = compare?(node)
-            method, arg, = replaceable_body?(body, var_a, var_b)
-            replacement =
-              if method == :[]
-                "#{send.method_name}_by { |a| a[#{arg.first.source}] }"
-              else
-                "#{send.method_name}_by(&:#{method})"
+              add_offense(range, message: message(send, method, var_a, var_b, args_a)) do |corrector|
+                replacement = if method == :[]
+                                "#{send.method_name}_by { |a| a[#{args_a.first.source}] }"
+                              else
+                                "#{send.method_name}_by(&:#{method})"
+                              end
+                corrector.replace(range, replacement)
               end
-            corrector.replace(compare_range(send, node),
-                              replacement)
+            end
           end
         end
 

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

@@ -0,0 +1,68 @@
+# 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
+      # 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
+      #
+      class ConstantRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Extract this regexp into a constant or append an `/o` option to its options.'
+
+        def on_regexp(node)
+          return if within_const_assignment?(node) ||
+                    !include_interpolated_const?(node) ||
+                    node.single_interpolation?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(node, 'o')
+          end
+        end
+
+        private
+
+        def within_const_assignment?(node)
+          node.each_ancestor(:casgn).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