rubocop-performance 1.11.5 → 1.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fffd38c1ed7da6f4ff4f67b3f1d7d08bc60e8871dc22d4ac266de6facc04fcf
-  data.tar.gz: e0de1a9ec946e37b2654390d4b46a0b9f0e1afbc37fec464c6fd78001ad5e509
+  metadata.gz: ee80f72f854adad1ef3a54295f5b732578373d11d19eae5b7ea0386bd2fa0f25
+  data.tar.gz: da36ad6040d986c56430965521ee1e597d3bc0919fa9c77ec1e34e5ca2cf43d6
 SHA512:
-  metadata.gz: 4225a879e2e0421438be5d17bb38d982901709c809ed7ccda3a0095affaf77a707c5fb5657ee61b123546860f1e9f0bcf783ed706b8b17fba9114588a16b4653
-  data.tar.gz: 3af998bbda7046ae5a55f06bb1ecc941dff48901d94a791fd81963cc1d76adf39524600c7ff4633c3dc06f925a2d8ea7f57716f51de2079e971c10b6194e40bb
+  metadata.gz: 255bba802b4023ec8be39476cc06c7614a4f7cbce11260a608f4c5c479f6e3d9b41ad6a286f8d42cb805ae65995d3bb29f46a746080dde0fa121f3a269cfaeb9
+  data.tar.gz: 24bffb35ce7441354bb42920d3ec49a07fa005edd4847bdd81066d22beda71dbb186e5e82205c6ad181372be1963e431751466560345068d995400f237297fb8

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-21 Bozhidar Batsov
+Copyright (c) 2012-22 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/config/default.yml

@@ -17,7 +17,7 @@ Performance/ArraySemiInfiniteRangeSlice:
   VersionAdded: '1.9'
 
 Performance/BigDecimalWithNumericArgument:
-  Description: 'Convert numeric argument to string before passing to BigDecimal.'
+  Description: 'Convert numeric literal to string and pass it to `BigDecimal`.'
   Enabled: 'pending'
   VersionAdded: '1.7'
 
@@ -43,10 +43,9 @@ Performance/CaseWhenSplat:
                  Reordering `when` conditions with a splat to the end
                  of the `when` branches can improve performance.
   Enabled: false
-  AutoCorrect: false
   SafeAutoCorrect: false
   VersionAdded: '0.34'
-  VersionChanged: '0.59'
+  VersionChanged: '1.13'
 
 Performance/Casecmp:
   Description: >-
@@ -76,6 +75,12 @@ Performance/CompareWithBlock:
   Enabled: true
   VersionAdded: '0.46'
 
+Performance/ConcurrentMonotonicTime:
+  Description: 'Use `Process.clock_gettime(Process::CLOCK_MONOTONIC)` instead of `Concurrent.monotonic_time`.'
+  Reference: 'https://github.com/rails/rails/pull/43502'
+  Enabled: pending
+  VersionAdded: '1.12'
+
 Performance/ConstantRegexp:
   Description: 'Finds regular expressions with dynamic components that are all constants.'
   Enabled: pending
@@ -131,7 +136,7 @@ Performance/DoubleStartEndWith:
   VersionAdded: '0.36'
   VersionChanged: '0.48'
   # Used to check for `starts_with?` and `ends_with?`.
-  # These methods are defined by `ActiveSupport`.
+  # These methods are defined by Active Support.
   IncludeActiveSupportAliases: false
 
 Performance/EndWith:
@@ -306,12 +311,17 @@ Performance/StartWith:
   VersionAdded: '0.36'
   VersionChanged: '1.10'
 
+Performance/StringIdentifierArgument:
+  Description: 'Use symbol identifier argument instead of string identifier argument.'
+  Enabled: pending
+  VersionAdded: '1.13'
+
 Performance/StringInclude:
   Description: 'Use `String#include?` instead of a regex match with literal-only pattern.'
   Enabled: 'pending'
-  AutoCorrect: false
   SafeAutoCorrect: false
   VersionAdded: '1.7'
+  VersionChanged: '1.12'
 
 Performance/StringReplacement:
   Description: >-
@@ -324,17 +334,20 @@ Performance/StringReplacement:
 
 Performance/Sum:
   Description: 'Use `sum` instead of a custom array summation.'
+  SafeAutoCorrect: false
   Reference: 'https://blog.bigbinary.com/2016/11/02/ruby-2-4-introduces-enumerable-sum.html'
   Enabled: 'pending'
   VersionAdded: '1.8'
+  VersionChanged: '1.13'
+  OnlySumOrWithInitialValue: false
 
 Performance/TimesMap:
   Description: 'Checks for .times.map calls.'
-  AutoCorrect: false
   Enabled: true
+  # See https://github.com/rubocop/rubocop/issues/4658
+  SafeAutoCorrect: false
   VersionAdded: '0.36'
-  VersionChanged: '0.50'
-  SafeAutoCorrect: false # see https://github.com/rubocop/rubocop/issues/4658
+  VersionChanged: '1.13'
 
 Performance/UnfreezeString:
   Description: 'Use unary plus to get an unfrozen string literal.'

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop is used to identify usages of `ancestors.include?` and
       # change them to use `<=` instead.
       #
+      # @safety
+      #   This cop is unsafe because it can't tell whether the receiver is a class or an object.
+      #   e.g. the false positive was for `Nokogiri::XML::Node#ancestors`.
+      #
       # @example
       #   # bad
       #   A.ancestors.include?(B)

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

@@ -7,7 +7,9 @@ module RuboCop
       # can be replaced by `Array#take` and `Array#drop`.
       # This cop was created due to a mistake in microbenchmark and hence is disabled by default.
       # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
-      # This cop is also unsafe for string slices because strings do not have `#take` and `#drop` methods.
+      #
+      # @safety
+      #   This cop is unsafe for string slices because strings do not have `#take` and `#drop` methods.
       #
       # @example
       #   # bad

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

@@ -10,36 +10,47 @@ module RuboCop
       # @example
       #   # bad
       #   BigDecimal(1, 2)
+      #   4.to_d(6)
       #   BigDecimal(1.2, 3, exception: true)
+      #   4.5.to_d(6, exception: true)
       #
       #   # good
       #   BigDecimal('1', 2)
+      #   BigDecimal('4', 6)
       #   BigDecimal('1.2', 3, exception: true)
+      #   BigDecimal('4.5', 6, exception: true)
       #
       class BigDecimalWithNumericArgument < Base
         extend AutoCorrector
 
-        MSG = 'Convert numeric argument to string before passing to `BigDecimal`.'
-        RESTRICT_ON_SEND = %i[BigDecimal].freeze
+        MSG = 'Convert numeric literal to string and pass it to `BigDecimal`.'
+        RESTRICT_ON_SEND = %i[BigDecimal to_d].freeze
 
         def_node_matcher :big_decimal_with_numeric_argument?, <<~PATTERN
           (send nil? :BigDecimal $numeric_type? ...)
         PATTERN
 
+        def_node_matcher :to_d?, <<~PATTERN
+          (send [!nil? $numeric_type?] :to_d ...)
+        PATTERN
+
         def on_send(node)
-          return unless (numeric = big_decimal_with_numeric_argument?(node))
-          return if numeric.float_type? && specifies_precision?(node)
+          if (numeric = big_decimal_with_numeric_argument?(node))
+            add_offense(numeric.source_range) do |corrector|
+              corrector.wrap(numeric, "'", "'")
+            end
+          elsif (numeric_to_d = to_d?(node))
+            add_offense(numeric_to_d.source_range) do |corrector|
+              big_decimal_args = node
+                                 .arguments
+                                 .map(&:source)
+                                 .unshift("'#{numeric_to_d.source}'")
+                                 .join(', ')
 
-          add_offense(numeric.source_range) do |corrector|
-            corrector.wrap(numeric, "'", "'")
+              corrector.replace(node, "BigDecimal(#{big_decimal_args})")
+            end
           end
         end
-
-        private
-
-        def specifies_precision?(node)
-          node.arguments.size > 1 && !node.arguments[1].hash_type?
-        end
       end
     end
   end

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

@@ -38,8 +38,9 @@ module RuboCop
 
           block_arg = def_node.arguments.find(&:blockarg_type?)
           return unless block_arg
+          return unless (block_arg_name = block_arg.loc.name)
 
-          block_arg_name = block_arg.loc.name.source.to_sym
+          block_arg_name = block_arg_name.source.to_sym
           return if reassigns_block_arg?(def_node, block_arg_name)
 
           add_offense(node) do |corrector|

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

@@ -17,11 +17,13 @@ module RuboCop
       # this defining a higher level when condition to override a condition
       # that is inside of the splat expansion.
       #
-      # This is not a guaranteed performance improvement. If the data being
-      # processed by the `case` condition is normalized in a manner that favors
-      # hitting a condition in the splat expansion, it is possible that
-      # moving the splat condition to the end will use more memory,
-      # and run slightly slower.
+      # @safety
+      #   This cop is not unsafe auto-correction because it is not a guaranteed
+      #   performance improvement. If the data being processed by the `case` condition is
+      #   normalized in a manner that favors hitting a condition in the splat expansion,
+      #   it is possible that moving the splat condition to the end will use more memory,
+      #   and run slightly slower.
+      #   See for more details: https://github.com/rubocop/rubocop/pull/6163
       #
       # @example
       #   # bad

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

@@ -5,8 +5,10 @@ module RuboCop
     module Performance
       # This cop identifies places where a case-insensitive string comparison
       # can better be implemented using `casecmp`.
-      # This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
-      # differently when using Non-ASCII characters.
+      #
+      # @safety
+      #   This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
+      #   differently when using Non-ASCII characters.
       #
       # @example
       #   # bad

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `Concurrent.monotonic_time`
+      # can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`.
+      #
+      # @example
+      #
+      #   # bad
+      #   Concurrent.monotonic_time
+      #
+      #   # good
+      #   Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      #
+      class ConcurrentMonotonicTime < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[monotonic_time].freeze
+
+        def_node_matcher :concurrent_monotonic_time?, <<~PATTERN
+          (send
+            (const {nil? cbase} :Concurrent) :monotonic_time ...)
+        PATTERN
+
+        def on_send(node)
+          return unless concurrent_monotonic_time?(node)
+
+          optional_unit_parameter = ", #{node.first_argument.source}" if node.first_argument
+          prefer = "Process.clock_gettime(Process::CLOCK_MONOTONIC#{optional_unit_parameter})"
+          message = format(MSG, prefer: prefer, current: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,28 @@ module RuboCop
       # follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
       # passed to the `count` call.
       #
+      # @safety
+      #   This cop is unsafe because it has known compatibility issues with `ActiveRecord` and other
+      #   frameworks. ActiveRecord's `count` ignores the block that is passed to it.
+      #   `ActiveRecord` will ignore the block that is passed to `count`.
+      #   Other methods, such as `select`, will convert the association to an
+      #   array and then run the block on the array. A simple work around to
+      #   make `count` work with a block is to call `to_a.count {...}`.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   `Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
+      #   ----
+      #
+      #   becomes:
+      #
+      #   [source,ruby]
+      #   ----
+      #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
+      #   ----
+      #
       # @example
       #   # bad
       #   [1, 2, 3].select { |e| e > 2 }.size
@@ -24,19 +46,6 @@ module RuboCop
       #   [1, 2, 3].count { |e| e < 2 && e.even? }
       #   Model.select('field AS field_one').count
       #   Model.select(:value).count
-      #
-      # `ActiveRecord` compatibility:
-      # `ActiveRecord` will ignore the block that is passed to `count`.
-      # Other methods, such as `select`, will convert the association to an
-      # array and then run the block on the array. A simple work around to
-      # make `count` work with a block is to call `to_a.count {...}`.
-      #
-      # Example:
-      #   `Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
-      #
-      #   becomes:
-      #
-      #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
       class Count < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -7,7 +7,6 @@ module RuboCop
       #
       # This cop identifies places where `gsub(/\Aprefix/, '')` and `sub(/\Aprefix/, '')`
       # can be replaced by `delete_prefix('prefix')`.
-      # It is marked as unsafe by default because `Pathname` has `sub` but not `delete_prefix`.
       #
       # This cop has `SafeMultiline` configuration option that `true` by default because
       # `^prefix` is unsafe as it will behave incompatible with `delete_prefix`
@@ -15,6 +14,9 @@ module RuboCop
       #
       # The `delete_prefix('prefix')` method is faster than `gsub(/\Aprefix/, '')`.
       #
+      # @safety
+      #   This cop is unsafe because `Pathname` has `sub` but not `delete_prefix`.
+      #
       # @example
       #
       #   # bad
@@ -47,9 +49,6 @@ module RuboCop
       class DeletePrefix < Base
         include RegexpMetacharacter
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze

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

@@ -7,7 +7,6 @@ module RuboCop
       #
       # This cop identifies places where `gsub(/suffix\z/, '')` and `sub(/suffix\z/, '')`
       # can be replaced by `delete_suffix('suffix')`.
-      # It is marked as unsafe by default because `Pathname` has `sub` but not `delete_suffix`.
       #
       # This cop has `SafeMultiline` configuration option that `true` by default because
       # `suffix$` is unsafe as it will behave incompatible with `delete_suffix?`
@@ -15,6 +14,9 @@ module RuboCop
       #
       # The `delete_suffix('suffix')` method is faster than `gsub(/suffix\z/, '')`.
       #
+      # @safety
+      #   This cop is unsafe because `Pathname` has `sub` but not `delete_suffix`.
+      #
       # @example
       #
       #   # bad
@@ -47,9 +49,6 @@ module RuboCop
       class DeleteSuffix < Base
         include RegexpMetacharacter
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze

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

@@ -7,6 +7,11 @@ module RuboCop
       # chained to `select`, `find_all` or `filter` and change them to use
       # `detect` instead.
       #
+      # @safety
+      #   This cop is unsafe because is has known compatibility issues with `ActiveRecord` and other
+      #   frameworks. `ActiveRecord` does not implement a `detect` method and `find` has its own
+      #   meaning. Correcting `ActiveRecord` methods with this cop should be considered unsafe.
+      #
       # @example
       #   # bad
       #   [].select { |item| true }.first
@@ -22,10 +27,6 @@ module RuboCop
       #   [].detect { |item| true }
       #   [].reverse.detect { |item| true }
       #
-      # `ActiveRecord` compatibility:
-      # `ActiveRecord` does not implement a `detect` method and `find` has its
-      # own meaning. Correcting ActiveRecord methods with this cop should be
-      # considered unsafe.
       class Detect < Base
         extend AutoCorrector
 
@@ -90,7 +91,7 @@ module RuboCop
         end
 
         def replacement(method, index)
-          if method == :last || method == :[] && index == -1
+          if method == :last || (method == :[] && index == -1)
             "reverse.#{preferred_method}"
           else
             preferred_method

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

@@ -7,6 +7,9 @@ module RuboCop
       # separated by `||`. In some cases such calls can be replaced
       # with an single `#start_with?`/`#end_with?` call.
       #
+      # `IncludeActiveSupportAliases` configuration option is used to check for
+      # `starts_with?` and `ends_with?`. These methods are defined by Active Support.
+      #
       # @example
       #   # bad
       #   str.start_with?("a") || str.start_with?(Some::CONST)
@@ -17,6 +20,24 @@ module RuboCop
       #   str.start_with?("a", Some::CONST)
       #   str.start_with?("a", "b", "c")
       #   str.end_with?(var1, var2)
+      #
+      # @example IncludeActiveSupportAliases: false (default)
+      #   # good
+      #   str.starts_with?("a", "b") || str.starts_with?("c")
+      #   str.ends_with?(var1) || str.ends_with?(var2)
+      #
+      #   str.starts_with?("a", "b", "c")
+      #   str.ends_with?(var1, var2)
+      #
+      # @example IncludeActiveSupportAliases: true
+      #   # bad
+      #   str.starts_with?("a", "b") || str.starts_with?("c")
+      #   str.ends_with?(var1) || str.ends_with?(var2)
+      #
+      #   # good
+      #   str.starts_with?("a", "b", "c")
+      #   str.ends_with?(var1, var2)
+      #
       class DoubleStartEndWith < Base
         extend AutoCorrector
 

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

@@ -9,6 +9,11 @@ module RuboCop
       # `end$` is unsafe as it will behave incompatible with `end_with?`
       # for receiver is multiline string.
       #
+      # @safety
+      #   This will change to a new method call which isn't guaranteed to be on the
+      #   object. Switching these methods has to be done with knowledge of the types
+      #   of the variables which rubocop doesn't have.
+      #
       # @example
       #   # bad
       #   'abc'.match?(/bc\Z/)

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

@@ -15,6 +15,9 @@ module RuboCop
       # both perform an O(n) search through all of the values, calling `values`
       # allocates a new array while using `value?` does not.
       #
+      # @safety
+      #   This cop is unsafe because it can't tell whether the receiver is a hash object.
+      #
       # @example
       #   # bad
       #   { a: 1, b: 2 }.keys.include?(:a)

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

@@ -6,8 +6,10 @@ module RuboCop
       # In Ruby 2.7, `Enumerable#filter_map` has been added.
       #
       # This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.
-      # It is marked as unsafe auto-correction by default because `map { ... }.compact`
-      # that is not compatible with `filter_map`.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `map { ... }.compact` that is not
+      #   compatible with `filter_map`.
       #
       # [source,ruby]
       # ----
@@ -56,19 +58,19 @@ module RuboCop
 
           add_offense(range) do |corrector|
             corrector.replace(map_node.loc.selector, 'filter_map')
-            remove_compact_method(corrector, node)
+            remove_compact_method(corrector, node, node.parent)
           end
         end
 
         private
 
-        def remove_compact_method(corrector, compact_node)
-          chained_method = compact_node.parent
+        def remove_compact_method(corrector, compact_node, chained_method)
           compact_method_range = compact_node.loc.selector
 
           if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && chained_method.dot? &&
+             !map_method_and_compact_method_on_same_line?(compact_node) &&
              !invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
-            compact_method_range = range_by_whole_lines(compact_method_range, include_final_newline: true)
+            compact_method_range = compact_method_with_final_newline_range(compact_method_range)
           else
             corrector.remove(compact_node.loc.dot)
           end
@@ -76,9 +78,21 @@ module RuboCop
           corrector.remove(compact_method_range)
         end
 
+        def map_method_and_compact_method_on_same_line?(compact_node)
+          return false unless compact_node.children.first.respond_to?(:send_node)
+
+          map_node = compact_node.children.first.send_node
+
+          compact_node.loc.selector.line == map_node.loc.selector.line
+        end
+
         def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
           compact_node.loc.selector.line == chained_method.loc.selector.line
         end
+
+        def compact_method_with_final_newline_range(compact_method_range)
+          range_by_whole_lines(compact_method_range, include_final_newline: true)
+        end
       end
     end
   end

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

@@ -11,6 +11,10 @@ module RuboCop
       # especially in case of single-threaded
       # applications with multiple `OpenStruct` instantiations.
       #
+      # @safety
+      #   This cop is unsafe because `OpenStruct.new` and `Struct.new`
+      #   are not equivalent.
+      #
       # @example
       #   # bad
       #   class MyClass

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

@@ -9,8 +9,9 @@ module RuboCop
       # end points of the `Range`. In a great majority of cases, this is what
       # is wanted.
       #
-      # This cop is `Safe: false` by default because `Range#include?` (or `Range#member?`) and
-      # `Range#cover?` are not equivalent behaviour.
+      # @safety
+      #   This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
+      #   are not equivalent behaviour.
       #
       # @example
       #   # bad

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

@@ -55,6 +55,7 @@ module RuboCop
             end
           end
         end
+        alias on_defs on_def
 
         private
 

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

@@ -9,8 +9,9 @@ module RuboCop
       # 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.
+      #
+      # @safety
+      #   This cop is unsafe because `===` and `==` do not always behave the same.
       #
       # @example
       #   # bad
@@ -24,9 +25,6 @@ module RuboCop
       #
       class RedundantEqualityComparisonBlock < Base
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of block.'
 

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

@@ -8,8 +8,9 @@ module RuboCop
       # You can set the maximum number of key-value pairs to consider
       # an offense with `MaxKeyValuePairs`.
       #
-      # This cop is marked as unsafe because RuboCop cannot determine if the
-      # receiver of `merge!` is actually a hash or not.
+      # @safety
+      #   This cop is unsafe because RuboCop cannot determine if the
+      #   receiver of `merge!` is actually a hash or not.
       #
       # @example
       #   # bad
@@ -91,7 +92,7 @@ module RuboCop
         end
 
         def non_redundant_pairs?(receiver, pairs)
-          pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
+          (pairs.size > 1 && !receiver.pure?) || pairs.size > max_key_value_pairs
         end
 
         def kwsplat_used?(pairs)

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

@@ -82,14 +82,10 @@ module RuboCop
 
         def build_good_method(method, args)
           case method
-          when :[], :slice
+          when :slice
             "[#{build_call_args(args)}].chars"
-          when :first
-            if args.any?
-              "[0...#{args.first.source}].chars"
-            else
-              '[0]'
-            end
+          when :[], :first
+            build_good_method_for_brackets_or_first_method(method, args)
           when :take
             "[0...#{args.first.source}].chars"
           else
@@ -97,6 +93,18 @@ module RuboCop
           end
         end
 
+        def build_good_method_for_brackets_or_first_method(method, args)
+          first_arg = args.first
+
+          if first_arg&.range_type?
+            "[#{build_call_args(args)}].chars"
+          elsif method == :first && args.any?
+            "[0...#{args.first.source}].chars"
+          else
+            first_arg ? "[#{first_arg.source}]" : '[0]'
+          end
+        end
+
         def build_bad_method(method, args)
           case method
           when :[]

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

@@ -9,6 +9,11 @@ module RuboCop
       # `^start` is unsafe as it will behave incompatible with `start_with?`
       # for receiver is multiline string.
       #
+      # @safety
+      #   This will change to a new method call which isn't guaranteed to be on the
+      #   object. Switching these methods has to be done with knowledge of the types
+      #   of the variables which rubocop doesn't have.
+      #
       # @example
       #   # bad
       #   'abc'.match?(/\Aab/)

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where string identifier argument can be replaced
+      # by symbol identifier argument.
+      # It prevents the redundancy of the internal string-to-symbol conversion.
+      #
+      # This cop targets methods that take identifier (e.g. method name) argument
+      # and the following examples are parts of it.
+      #
+      # @example
+      #
+      #   # bad
+      #   send('do_something')
+      #   attr_accessor 'do_something'
+      #   instance_variable_get('@ivar')
+      #
+      #   # good
+      #   send(:do_something)
+      #   attr_accessor :do_something
+      #   instance_variable_get(:@ivar)
+      #
+      class StringIdentifierArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<symbol_arg>s` instead of `%<string_arg>s`.'
+
+        # NOTE: `attr` method is not included in this list as it can cause false positives in Nokogiri API.
+        # And `attr` may not be used because `Style/Attr` registers an offense.
+        # https://github.com/rubocop/rubocop-performance/issues/278
+        RESTRICT_ON_SEND = %i[
+          alias_method attr_accessor attr_reader attr_writer autoload autoload?
+          class_variable_defined? const_defined? const_get const_set const_source_location
+          define_method instance_method method_defined? private_class_method? private_method_defined?
+          protected_method_defined? public_class_method public_instance_method public_method_defined?
+          remove_class_variable remove_method undef_method class_variable_get class_variable_set
+          deprecate_constant module_function private private_constant protected public public_constant
+          remove_const ruby2_keywords
+          define_singleton_method instance_variable_defined instance_variable_get instance_variable_set
+          method public_method public_send remove_instance_variable respond_to? send singleton_method
+          __send__
+        ].freeze
+
+        def on_send(node)
+          return unless (first_argument = node.first_argument)
+          return unless first_argument.str_type?
+          return if first_argument.value.include?(' ')
+
+          replacement = first_argument.value.to_sym.inspect
+
+          message = format(MSG, symbol_arg: replacement, string_arg: first_argument.source)
+
+          add_offense(first_argument, message: message) do |corrector|
+            corrector.replace(first_argument, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,8 @@ module RuboCop
       # 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.
+      # @safety
+      #   This cop's offenses are not safe to auto-correct if a receiver is nil.
       #
       # @example
       #   # bad

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

@@ -6,35 +6,46 @@ 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:
+      # @safety
+      #   Auto-corrections are unproblematic wherever an initial value is provided explicitly:
       #
-      # [source,ruby]
-      # ----
-      # ['a', 'b'].sum # => (String can't be coerced into Integer)
-      # ----
+      #   [source,ruby]
+      #   ----
+      #   [1, 2, 3].reduce(4, :+) # => 10
+      #   [1, 2, 3].sum(4) # => 10
       #
-      # Therefore if initial value is not specified, unsafe auto-corrected will not occur.
+      #   [].reduce(4, :+) # => 4
+      #   [].sum(4) # => 4
+      #   ----
       #
-      # If you always want to enable auto-correction, you can set `SafeAutoCorrect: false`.
+      #   This also holds true for non-numeric types which implement a `:+` method:
       #
-      # [source,yaml]
-      # ----
-      # Performance/Sum:
-      #   SafeAutoCorrect: false
-      # ----
+      #   [source,ruby]
+      #   ----
+      #   ['l', 'o'].reduce('Hel', :+) # => "Hello"
+      #   ['l', 'o'].sum('Hel') # => "Hello"
+      #   ----
       #
-      # Please note that the auto-correction command line option will be changed from
-      # `rubocop -a` to `rubocop -A`, which includes unsafe auto-correction.
+      #   When no initial value is provided though, `Enumerable#reduce` will pick the first enumerated value
+      #   as initial value and successively add all following values to it, whereas
+      #   `Enumerable#sum` will set an initial value of `0` (`Integer`) which can lead to a `TypeError`:
       #
-      # @example
+      #   [source,ruby]
+      #   ----
+      #   [].reduce(:+) # => nil
+      #   [1, 2, 3].reduce(:+) # => 6
+      #   ['H', 'e', 'l', 'l', 'o'].reduce(:+) # => "Hello"
+      #
+      #   [].sum # => 0
+      #   [1, 2, 3].sum # => 6
+      #   ['H', 'e', 'l', 'l', 'o'].sum # => in `+': String can't be coerced into Integer (TypeError)
+      #   ----
+      #
+      # @example OnlySumOrWithInitialValue: false (default)
       #   # 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].inject(:+)                        # Auto-corrections for cases without initial value are unsafe
+      #   [1, 2, 3].inject(&:+)                       # and will only be performed when using the `-A` option.
+      #   [1, 2, 3].reduce { |acc, elem| acc + elem } # They can be prohibited completely using `SafeAutoCorrect: true`.
       #   [1, 2, 3].reduce(10, :+)
       #   [1, 2, 3].map { |elem| elem ** 2 }.sum
       #   [1, 2, 3].collect(&:count).sum(10)
@@ -45,6 +56,17 @@ module RuboCop
       #   [1, 2, 3].sum { |elem| elem ** 2 }
       #   [1, 2, 3].sum(10, &:count)
       #
+      # @example OnlySumOrWithInitialValue: true
+      #   # bad
+      #   [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(10)
+      #   [1, 2, 3].sum { |elem| elem ** 2 }
+      #   [1, 2, 3].sum(10, &:count)
+      #
       class Sum < Base
         include RangeHelp
         extend AutoCorrector
@@ -103,6 +125,8 @@ module RuboCop
 
         def handle_sum_candidate(node)
           sum_candidate?(node) do |method, init, operation|
+            next if cop_config['OnlySumOrWithInitialValue'] && init.empty?
+
             range = sum_method_range(node)
             message = build_method_message(node, method, init, operation)
 
@@ -156,7 +180,7 @@ module RuboCop
         end
 
         def sum_method_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.end.end_pos)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
 
         def sum_map_range(map, sum)

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

@@ -7,6 +7,18 @@ module RuboCop
       # In most cases such calls can be replaced
       # with an explicit array creation.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `Integer#times` does nothing if receiver is 0
+      #   or less. However, `Array.new` raises an error if argument is less than 0.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   -1.times{}    # does nothing
+      #   Array.new(-1) # ArgumentError: negative array size
+      #   ----
+      #
       # @example
       #   # bad
       #   9.times.map do |i|

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

@@ -7,11 +7,11 @@ module RuboCop
       # literal instead of `String#dup` and `String.new`.
       # Unary plus operator is faster than `String#dup`.
       #
-      # 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.
+      # @safety
+      #   This cop's autocorrection is unsafe because `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`).
+      #   if you expect `ASCII-8BIT` encoding, disable this cop.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/performance_cops.rb

@@ -13,6 +13,7 @@ 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/concurrent_monotonic_time'
 require_relative 'performance/constant_regexp'
 require_relative 'performance/count'
 require_relative 'performance/delete_prefix'
@@ -43,6 +44,7 @@ require_relative 'performance/size'
 require_relative 'performance/sort_reverse'
 require_relative 'performance/squeeze'
 require_relative 'performance/start_with'
+require_relative 'performance/string_identifier_argument'
 require_relative 'performance/string_include'
 require_relative 'performance/string_replacement'
 require_relative 'performance/sum'

data/lib/rubocop/performance/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Performance
     # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.11.5'
+      STRING = '1.13.2'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.11.5
+  version: 1.13.2
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-18 00:00:00.000000000 Z
+date: 2022-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -74,6 +74,7 @@ files:
 - lib/rubocop/cop/performance/chain_array_allocation.rb
 - lib/rubocop/cop/performance/collection_literal_in_loop.rb
 - lib/rubocop/cop/performance/compare_with_block.rb
+- lib/rubocop/cop/performance/concurrent_monotonic_time.rb
 - lib/rubocop/cop/performance/constant_regexp.rb
 - lib/rubocop/cop/performance/count.rb
 - lib/rubocop/cop/performance/delete_prefix.rb
@@ -104,6 +105,7 @@ files:
 - lib/rubocop/cop/performance/sort_reverse.rb
 - lib/rubocop/cop/performance/squeeze.rb
 - lib/rubocop/cop/performance/start_with.rb
+- lib/rubocop/cop/performance/string_identifier_argument.rb
 - lib/rubocop/cop/performance/string_include.rb
 - lib/rubocop/cop/performance/string_replacement.rb
 - lib/rubocop/cop/performance/sum.rb
@@ -121,8 +123,9 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
   changelog_uri: https://github.com/rubocop/rubocop-performance/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-performance/
-  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.11/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.13/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -138,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.12
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.