rubocop-performance 1.7.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34605a937c1a3e040428bee06e322220659c105b6e835423d9e0e73869fd83ee
-  data.tar.gz: e3fa0103bd2518cec45334bc162e144963eef9e3d09ab9fd6bd7b2d35b654e84
+  metadata.gz: 00b98a3d2af1bcfd781dfab24e4a8deb118d29fdaedeca8b2d404ff03eab3529
+  data.tar.gz: cc5508a731d9c932d2c141892aefbe15f635d18bdd95ae6ad5b4998c931fcaf2
 SHA512:
-  metadata.gz: 5fe72ab5a0370aa8e0cc434080a27a38d8979084c53c50cd18e8cbc0896572ddc9d011130d56283f9d588268253ec0e2e44fc32b81483e1458689c60c17e835b
-  data.tar.gz: a60d627b0d1ded2fb6103a78fb4414fc1e1f1ff13ab9f4e82c399289c9a40c3c6e0385ee2509074175bd724755f768dd4625bb9791af993032a1f840a0533ef6
+  metadata.gz: 806f21556b5e791a6a00866714c4feec42726b20d4c82db7c4cd89ec576624eaac3007f4a68fca4fd633fbc3ed7a41801fdb0dfc64f767ee241582a4185bbb8b
+  data.tar.gz: 1e922a3d51a62df60cdb26f99960fec91e1fa558ceea751bcce7ec529f7d4db6e1644d0dfd24848cb75e384e08fd6a3f2afaaa8f531a1118a09d35d6fa1b0e21

data/config/default.yml

@@ -49,6 +49,13 @@ Performance/ChainArrayAllocation:
   Enabled: false
   VersionAdded: '0.59'
 
+Performance/CollectionLiteralInLoop:
+  Description: 'Extract Array and Hash literals outside of loops into local variables or constants.'
+  Enabled: true
+  VersionAdded: '1.8'
+  # Min number of elements to consider an offense
+  MinSize: 1
+
 Performance/CompareWithBlock:
   Description: 'Use `sort_by(&:foo)` instead of `sort { |a, b| a.foo <=> b.foo }`.'
   Enabled: true
@@ -56,16 +63,14 @@ Performance/CompareWithBlock:
 
 Performance/Count:
   Description: >-
-                  Use `count` instead of `select...size`, `reject...size`,
-                  `select...count`, `reject...count`, `select...length`,
-                  and `reject...length`.
+                  Use `count` instead of `{select,find_all,filter,reject}...{size,count,length}`.
   # This cop has known compatibility issues with `ActiveRecord` and other
   # frameworks. ActiveRecord's `count` ignores the block that is passed to it.
   # For more information, see the documentation in the cop itself.
   SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.31'
-  VersionChanged: '1.5'
+  VersionChanged: '1.8'
 
 Performance/DeletePrefix:
   Description: 'Use `delete_prefix` instead of `gsub`.'
@@ -81,8 +86,8 @@ Performance/DeleteSuffix:
 
 Performance/Detect:
   Description: >-
-                  Use `detect` instead of `select.first`, `find_all.first`,
-                  `select.last`, and `find_all.last`.
+                  Use `detect` instead of `select.first`, `find_all.first`, `filter.first`,
+                  `select.last`, `find_all.last`, and `filter.last`.
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
   # This cop has known compatibility issues with `ActiveRecord` and other
   # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
@@ -91,7 +96,7 @@ Performance/Detect:
   SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.30'
-  VersionChanged: '1.5'
+  VersionChanged: '1.8'
 
 Performance/DoubleStartEndWith:
   Description: >-
@@ -261,6 +266,12 @@ Performance/StringReplacement:
   Enabled: true
   VersionAdded: '0.33'
 
+Performance/Sum:
+  Description: 'Use `sum` instead of a custom array summation.'
+  Reference: 'https://blog.bigbinary.com/2016/11/02/ruby-2-4-introduces-enumerable-sum.html'
+  Enabled: 'pending'
+  VersionAdded: '1.8'
+
 Performance/TimesMap:
   Description: 'Checks for .times.map calls.'
   AutoCorrect: false

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

@@ -13,8 +13,9 @@ module RuboCop
       #   # good
       #   A <= B
       #
-      class AncestorsInclude < Cop
+      class AncestorsInclude < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `<=` instead of `ancestors.include?`.'
 
@@ -23,23 +24,23 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless ancestors_include_candidate?(node)
+          return unless (subclass, superclass = ancestors_include_candidate?(node))
+          return if subclass && !subclass.const_type?
 
-          location_of_ancestors = node.children[0].loc.selector.begin_pos
-          end_location = node.loc.selector.end_pos
-          range = range_between(location_of_ancestors, end_location)
+          add_offense(range(node)) do |corrector|
+            subclass_source = subclass ? subclass.source : 'self'
 
-          add_offense(node, location: range)
+            corrector.replace(node, "#{subclass_source} <= #{superclass.source}")
+          end
         end
 
-        def autocorrect(node)
-          ancestors_include_candidate?(node) do |subclass, superclass|
-            lambda do |corrector|
-              subclass_source = subclass ? subclass.source : 'self'
+        private
 
-              corrector.replace(node, "#{subclass_source} <= #{superclass.source}")
-            end
-          end
+        def range(node)
+          location_of_ancestors = node.children[0].loc.selector.begin_pos
+          end_location = node.loc.selector.end_pos
+
+          range_between(location_of_ancestors, end_location)
         end
       end
     end

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

@@ -16,7 +16,9 @@ module RuboCop
       #   BigDecimal('1', 2)
       #   BigDecimal('1.2', 3, exception: true)
       #
-      class BigDecimalWithNumericArgument < Cop
+      class BigDecimalWithNumericArgument < Base
+        extend AutoCorrector
+
         MSG = 'Convert numeric argument to string before passing to `BigDecimal`.'
 
         def_node_matcher :big_decimal_with_numeric_argument?, <<~PATTERN
@@ -24,18 +26,11 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          big_decimal_with_numeric_argument?(node) do |numeric|
-            next if numeric.float_type? && specifies_precision?(node)
-
-            add_offense(node, location: numeric.source_range)
-          end
-        end
+          return unless (numeric = big_decimal_with_numeric_argument?(node))
+          return if numeric.float_type? && specifies_precision?(node)
 
-        def autocorrect(node)
-          big_decimal_with_numeric_argument?(node) do |numeric|
-            lambda do |corrector|
-              corrector.wrap(numeric, "'", "'")
-            end
+          add_offense(numeric.source_range) do |corrector|
+            corrector.wrap(numeric, "'", "'")
           end
         end
 

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

@@ -19,8 +19,9 @@ module RuboCop
       #   # good
       #   umethod.bind_call(obj, foo, bar)
       #
-      class BindCall < Cop
+      class BindCall < Base
         include RangeHelp
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.7
@@ -37,28 +38,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          bind_with_call_method?(node) do |receiver, bind_arg, call_args_node|
-            range = correction_range(receiver, node)
-
-            call_args = build_call_args(call_args_node)
-
-            message = message(bind_arg.source, call_args)
-
-            add_offense(node, location: range, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          receiver, bind_arg, call_args_node = bind_with_call_method?(node)
+          return unless (receiver, bind_arg, call_args_node = bind_with_call_method?(node))
 
           range = correction_range(receiver, node)
-
           call_args = build_call_args(call_args_node)
-          call_args = ", #{call_args}" unless call_args.empty?
+          message = message(bind_arg.source, call_args)
+
+          add_offense(range, message: message) do |corrector|
+            call_args = ", #{call_args}" unless call_args.empty?
 
-          replacement_method = "bind_call(#{bind_arg.source}#{call_args})"
+            replacement_method = "bind_call(#{bind_arg.source}#{call_args})"
 
-          lambda do |corrector|
             corrector.replace(range, replacement_method)
           end
         end

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

@@ -18,7 +18,7 @@ module RuboCop
       #   caller(1..1).first
       #   caller_locations(2..2).first
       #   caller_locations(1..1).first
-      class Caller < Cop
+      class Caller < Base
         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`' \
@@ -41,7 +41,8 @@ module RuboCop
         def on_send(node)
           return unless caller_with_scope_method?(node)
 
-          add_offense(node)
+          message = message(node)
+          add_offense(node, message: message)
         end
 
         private

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,7 +19,9 @@ 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`.'
         CASE_METHODS = %i[downcase upcase].freeze
 
@@ -48,21 +50,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 +78,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
@@ -61,15 +61,9 @@ module RuboCop
 
         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)
-            )
+            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