rubocop-performance 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c98065b3a22d03c0e9290990288d6b8a82a87d956bdf4165d94d3cd326ae7bf5
-  data.tar.gz: a9ee1493235e6584ad381941423c0cac234bfc36fb4a2417433e667a16bec054
+  metadata.gz: 874ce36b942ed539ead8c3329a7dd6831224459a286c2b3189605775e725fc60
+  data.tar.gz: 584a851432d98e548151baa8afc1f9a30d5dcca05f8eae0d86c68f17bf933f34
 SHA512:
-  metadata.gz: 35f36bff7bfe1b19496bfea773e7d0f7892731e57b06bb523ac192324a817f401207750abab20892ea58ec54595d1bdfd454bf250a4a00baf6ef0f4ac3f7b030
-  data.tar.gz: 84a6ebc3e13d7c24aa6f1219443ce2c6cf6cd6c6253d4f09c78056fb3906f08bcb44db5365b03231aae55170a653e504b4a3433b4ed4a4dea1ee21b23d7a1387
+  metadata.gz: 102cccbb3be2ba55702a2e7aff3c56c6325c80481d269f87921ca1d16a79fa12830c6f080f49bacdebf4b5726e4f4c42af2527c13a4abac5aae0cf4544fb018e
+  data.tar.gz: 23c8beebceef175caf7e226a136bb3eaff500b71f5e3e26cba9fee9a84e36aa7a3b315b11216844b7980a421a82fff7a5346560ef1418f58fbe5261599fe4dec

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: >-
@@ -137,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:
@@ -312,6 +311,11 @@ 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'
@@ -330,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/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/detect.rb

@@ -27,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
 

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/map_compact.rb

@@ -58,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
@@ -78,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/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/string_identifier_argument.rb

@@ -0,0 +1,59 @@
+# 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`.'
+
+        RESTRICT_ON_SEND = %i[
+          alias_method attr 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/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)
 

data/lib/rubocop/cop/performance_cops.rb

@@ -44,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.12.0'
+      STRING = '1.13.0'
 
       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.12.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-31 00:00:00.000000000 Z
+date: 2021-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -105,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
@@ -122,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.12/
+  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:
@@ -139,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.0.dev
+rubygems_version: 3.3.0
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.