rubocop-performance 1.24.0 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b4cdc2536f76691be677a1e203a886fae5e170f550424bed14d579f39a87e75
-  data.tar.gz: 6ea02935a50fcdeb0b07d1a5d67c4414c71115019cb02dae4746c207f798cad6
+  metadata.gz: 65d9d36b4437bd92d054b743117d77b7fdb4f5391c012ae656b01dcd2ca2fa51
+  data.tar.gz: 8678a0f7fac0c650fa4c51a25e8c3e06b049c67b5fb369719fe7eee2c04a8820
 SHA512:
-  metadata.gz: 7bc4f69ef0a5ca779626b29d0a7c5333bf135b29d06d1be009acd4e9ffaa368873cb9977a94e9c5d5f50cb1c000d9fa243b8557badbab00756469a0b6a366662
-  data.tar.gz: 47e7f03cf61d57a3f9bd8e3cdb79f722fdaa279d300d2de5532435c1231fa06c28b1a148ab31c7b62775d1449a284fc43cee4bd36bbd16b1065145f022c8f729
+  metadata.gz: d0efc235b893328de9dfb9a58a26bb5d4838b9919a2b0a06e77f1f34ad1b53d39433793b1dd24dc04d34e79047aa0ff5e4863d407a48160da6c35fc45d91906f
+  data.tar.gz: 4aafa85fa2c326f532d16b338f55df55e67d9d52ebbd52196b53ae3520e7b30fdce7656081f716c91f6fe6ec3833915a6ac1bc0838d2c3016bfde6cb133689c0

data/README.md

@@ -84,7 +84,7 @@ You can read a lot more about RuboCop Performance in its [official docs](https:/
 
 ## Compatibility
 
-RuboCop Performance complies with the RuboCop core compatibility.
+RuboCop Performance is compatible with RuboCop core.
 
 See the [compatibility documentation](https://docs.rubocop.org/rubocop/compatibility.html) for further details.
 

data/config/default.yml

@@ -67,7 +67,6 @@ Performance/ChainArrayAllocation:
   Description: >-
                   Instead of chaining array methods that allocate new arrays, mutate an
                   existing array.
-  Reference: 'https://twitter.com/schneems/status/1034123879978029057'
   Enabled: false
   VersionAdded: '0.59'
 
@@ -187,14 +186,14 @@ Performance/InefficientHashSearch:
 
 Performance/IoReadlines:
   Description: 'Use `IO.each_line` (`IO#each_line`) instead of `IO.readlines` (`IO#readlines`).'
-  Reference: 'https://docs.gitlab.com/ee/development/performance.html#reading-from-files-and-other-data-sources'
+  Reference: 'https://docs.gitlab.com/development/performance/#reading-from-files-and-other-data-sources'
   Enabled: false
   VersionAdded: '1.7'
 
 Performance/MapCompact:
   Description: 'Use `filter_map` instead of `collection.map(&:do_something).compact`.'
   Enabled: pending
-  SafeAutoCorrect: false
+  Safe: false
   VersionAdded: '1.11'
 
 Performance/MapMethodChain:
@@ -356,7 +355,7 @@ 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'
+  Reference: 'https://www.bigbinary.com/blog/ruby-2-4-introduces-enumerable-sum'
   Enabled: 'pending'
   VersionAdded: '1.8'
   VersionChanged: '1.13'

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

@@ -36,7 +36,7 @@ module RuboCop
         def_node_matcher :reassigns_block_arg?, '`(lvasgn %1 ...)'
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return unless def_node
 
           block_arg = def_node.arguments.find(&:blockarg_type?)
@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def self.autocorrect_incompatible_with
-          [Lint::UnusedMethodArgument]
+          [Lint::UnusedMethodArgument, Naming::BlockForwarding]
         end
       end
     end

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

@@ -12,6 +12,14 @@ module RuboCop
       # You can set the minimum number of elements to consider
       # an offense with `MinSize`.
       #
+      # NOTE: Since Ruby 3.4, certain simple arguments to `Array#include?` are
+      # optimized directly in Ruby. This avoids allocations without changing the
+      # code, as such no offense will be registered in those cases. Currently that
+      # includes: strings, `self`, local variables, instance variables, and method
+      # calls without arguments. Additionally, any number of methods can be chained:
+      # `[1, 2, 3].include?(@foo)` and `[1, 2, 3].include?(@foo.bar.baz)` both avoid
+      # the array allocation.
+      #
       # @example
       #   # bad
       #   users.select do |user|
@@ -55,6 +63,8 @@ module RuboCop
 
         ARRAY_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_ARRAY_METHODS).to_set.freeze
 
+        ARRAY_INCLUDE_OPTIMIZED_TYPES = %i[str self lvar ivar send].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?
@@ -80,8 +90,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          receiver, method, = *node.children
-          return unless check_literal?(receiver, method) && parent_is_loop?(receiver)
+          receiver, method, *arguments = *node.children
+          return unless check_literal?(receiver, method, arguments) && parent_is_loop?(receiver)
 
           message = format(MSG, literal_class: literal_class(receiver))
           add_offense(receiver, message: message)
@@ -89,12 +99,33 @@ module RuboCop
 
         private
 
-        def check_literal?(node, method)
+        def check_literal?(node, method, arguments)
           !node.nil? &&
             nonmutable_method_of_array_or_hash?(node, method) &&
             node.children.size >= min_size &&
-            node.recursive_basic_literal?
+            node.recursive_basic_literal? &&
+            !optimized_array_include?(node, method, arguments)
+        end
+
+        # Since Ruby 3.4, simple arguments to Array#include? are optimized.
+        # See https://github.com/ruby/ruby/pull/12123 for more details.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def optimized_array_include?(node, method, arguments)
+          return false unless target_ruby_version >= 3.4 && node.array_type? && method == :include?
+          # Disallow include?(1, 2)
+          return false if arguments.count != 1
+
+          arg = arguments.first
+          # Allow `include?(foo.bar.baz.bat)`
+          while arg.send_type?
+            return false if arg.arguments.any? # Disallow include?(foo(bar))
+            break unless arg.receiver
+
+            arg = arg.receiver
+          end
+          ARRAY_INCLUDE_OPTIMIZED_TYPES.include?(arg.type)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def nonmutable_method_of_array_or_hash?(node, method)
           (node.array_type? && ARRAY_METHODS.include?(method)) ||

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

@@ -81,13 +81,15 @@ module RuboCop
 
           range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
 
-          corrector.remove(range)
+          corrector.remove(range_with_surrounding_space(range, side: :left))
           corrector.replace(selector_loc, 'count')
           negate_reject(corrector, node) if selector == :reject
         end
 
         def eligible_node?(node)
-          !(node.parent && node.parent.block_type?)
+          return false if node.parent&.block_type?
+
+          node.receiver.call_type? || node.receiver.body
         end
 
         def source_starting_at(node)

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Performance
-      # Checks for double `#start_with?` or `#end_with?` calls
-      # separated by `||`. In some cases such calls can be replaced
-      # with an single `#start_with?`/`#end_with?` call.
+      # Checks for consecutive `#start_with?` or `#end_with?` calls.
+      # These methods accept multiple arguments, so in some cases like when
+      # they are separated by `||`, they can be combined into a single method call.
       #
       # `IncludeActiveSupportAliases` configuration option is used to check for
       # `starts_with?` and `ends_with?`. These methods are defined by Active Support.
@@ -14,11 +14,13 @@ module RuboCop
       #   # bad
       #   str.start_with?("a") || str.start_with?(Some::CONST)
       #   str.start_with?("a", "b") || str.start_with?("c")
+      #   !str.start_with?(foo) && !str.start_with?(bar)
       #   str.end_with?(var1) || str.end_with?(var2)
       #
       #   # good
       #   str.start_with?("a", Some::CONST)
       #   str.start_with?("a", "b", "c")
+      #   !str.start_with?(foo, bar)
       #   str.end_with?(var1, var2)
       #
       # @example IncludeActiveSupportAliases: false (default)
@@ -43,20 +45,33 @@ module RuboCop
 
         MSG = 'Use `%<replacement>s` instead of `%<original_code>s`.'
 
+        METHODS = %i[start_with? end_with?].to_set
+        METHODS_WITH_ACTIVE_SUPPORT = %i[start_with? starts_with? end_with? ends_with?].to_set
+
         def on_or(node)
-          receiver, method, first_call_args, second_call_args = process_source(node)
+          two_start_end_with_calls(node, methods_to_check: methods) do |*matched|
+            check(node, *matched)
+          end
+        end
+
+        def on_and(node)
+          two_start_end_with_calls_negated(node, methods_to_check: methods) do |*matched|
+            check(node, *matched)
+          end
+        end
 
+        private
+
+        def check(node, receiver, method, first_call_args, second_call_args)
           return unless receiver && second_call_args.all?(&:pure?)
 
           combined_args = combine_args(first_call_args, second_call_args)
 
-          add_offense(node, message: message(node, receiver, first_call_args, method, combined_args)) do |corrector|
+          add_offense(node, message: message(node, receiver, method, combined_args)) do |corrector|
             autocorrect(corrector, first_call_args, second_call_args, combined_args)
           end
         end
 
-        private
-
         def autocorrect(corrector, first_call_args, second_call_args, combined_args)
           first_argument = first_call_args.first.source_range
           last_argument = second_call_args.last.source_range
@@ -65,17 +80,20 @@ module RuboCop
           corrector.replace(range, combined_args)
         end
 
-        def process_source(node)
+        def methods
           if check_for_active_support_aliases?
-            check_with_active_support_aliases(node)
+            METHODS_WITH_ACTIVE_SUPPORT
           else
-            two_start_end_with_calls(node)
+            METHODS
           end
         end
 
-        def message(node, receiver, first_call_args, method, combined_args)
-          dot = first_call_args.first.parent.send_type? ? '.' : '&.'
-          replacement = "#{receiver.source}#{dot}#{method}(#{combined_args})"
+        def message(node, receiver, method, combined_args)
+          parent = receiver.parent
+          grandparent = parent.parent
+          dot = parent.send_type? ? '.' : '&.'
+          bang = grandparent.send_type? && grandparent.prefix_bang? ? '!' : ''
+          replacement = "#{bang}#{receiver.source}#{dot}#{method}(#{combined_args})"
           format(MSG, replacement: replacement, original_code: node.source)
         end
 
@@ -89,16 +107,14 @@ module RuboCop
 
         def_node_matcher :two_start_end_with_calls, <<~PATTERN
           (or
-            (call $_recv [{:start_with? :end_with?} $_method] $...)
+            (call $_recv [%methods_to_check $_method] $...)
             (call _recv _method $...))
         PATTERN
 
-        def_node_matcher :check_with_active_support_aliases, <<~PATTERN
-          (or
-            (call $_recv
-                    [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
-                  $...)
-            (call _recv _method $...))
+        def_node_matcher :two_start_end_with_calls_negated, <<~PATTERN
+          (and
+            (send (call $_recv [%methods_to_check $_method] $...) :!)
+            (send (call _recv _method $...) :!))
         PATTERN
       end
     end

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

@@ -75,7 +75,7 @@ module RuboCop
         end
 
         def allowed_parent?(node)
-          node&.type?(:casgn, :block)
+          node&.type?(:casgn, :any_block)
         end
 
         def contains_splat?(node)

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

@@ -74,8 +74,8 @@ module RuboCop
 
         def correct_method(node)
           case current_method(node)
-          when :keys then use_long_method ? 'has_key?' : 'key?'
-          when :values then use_long_method ? 'has_value?' : 'value?'
+          when :keys then use_long_method? ? 'has_key?' : 'key?'
+          when :values then use_long_method? ? 'has_value?' : 'value?'
           end
         end
 
@@ -83,9 +83,8 @@ module RuboCop
           node.receiver.method_name
         end
 
-        def use_long_method
-          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config && preferred_config['EnforcedStyle'] == 'long' && preferred_config['Enabled']
+        def use_long_method?
+          config.for_enabled_cop('Style/PreferredHashMethods')['EnforcedStyle'] == 'long'
         end
 
         def correct_argument(node)

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

@@ -8,9 +8,9 @@ module RuboCop
       # This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.
       #
       # @safety
-      #   This cop's autocorrection is unsafe because `map { ... }.compact` might yield
+      #   This cop is unsafe because `map { ... }.compact` might yield
       #   different results than `filter_map`. As illustrated in the example, `filter_map`
-      #   also filters out falsy values, while `compact` only gets rid of `nil`.
+      #   also filters out falsey values, while `compact` only gets rid of `nil`.
       #
       # [source,ruby]
       # ----

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

@@ -239,7 +239,7 @@ module RuboCop
 
         def scope_root(node)
           node.each_ancestor.find do |ancestor|
-            ancestor.type?(:def, :defs, :class, :module)
+            ancestor.type?(:any_def, :class, :module)
           end
         end
 

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

@@ -16,19 +16,19 @@ module RuboCop
       #   send('do_something')
       #   attr_accessor 'do_something'
       #   instance_variable_get('@ivar')
-      #   respond_to?("string_#{interpolation}")
       #
       #   # good
       #   send(:do_something)
       #   attr_accessor :do_something
       #   instance_variable_get(:@ivar)
-      #   respond_to?(:"string_#{interpolation}")
       #
       #   # good - these methods don't support namespaced symbols
       #   const_get("#{module_path}::Base")
       #   const_source_location("#{module_path}::Base")
       #   const_defined?("#{module_path}::Base")
       #
+      #   # good - using a symbol when string interpolation is involved causes a performance regression.
+      #   respond_to?("string_#{interpolation}")
       #
       class StringIdentifierArgument < Base
         extend AutoCorrector
@@ -40,8 +40,6 @@ module RuboCop
           protected public public_constant module_function
         ].freeze
 
-        INTERPOLATION_IGNORE_METHODS = %i[const_get const_source_location const_defined?].freeze
-
         TWO_ARGUMENTS_METHOD = :alias_method
         MULTIPLE_ARGUMENTS_METHODS = %i[
           attr_accessor attr_reader attr_writer private private_constant
@@ -59,7 +57,7 @@ module RuboCop
           deprecate_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__
-        ] + COMMAND_METHODS + INTERPOLATION_IGNORE_METHODS).freeze
+        ] + COMMAND_METHODS).freeze
 
         def on_send(node)
           return if COMMAND_METHODS.include?(node.method_name) && node.receiver
@@ -83,13 +81,7 @@ module RuboCop
                         [node.first_argument]
                       end
 
-          arguments.compact.filter { |argument| string_argument_compatible?(argument, node) }
-        end
-
-        def string_argument_compatible?(argument, node)
-          return true if argument.str_type?
-
-          argument.dstr_type? && INTERPOLATION_IGNORE_METHODS.none? { |method| node.method?(method) }
+          arguments.compact.filter(&:str_type?)
         end
 
         def register_offense(argument, argument_value)

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

@@ -52,6 +52,7 @@ module RuboCop
           check(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -28,6 +28,7 @@ module RuboCop
           {
             (block (call !nil? RESTRICT_ON_SEND) (args (arg _)) (array (lvar _)))
             (numblock (call !nil? RESTRICT_ON_SEND) 1 (array (lvar _)))
+            (itblock (call !nil? RESTRICT_ON_SEND) :it (array (lvar _)))
           }
         PATTERN
 

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.24.0'
+      STRING = '1.26.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/lib/rubocop-performance.rb

@@ -7,10 +7,16 @@ require_relative 'rubocop/performance/version'
 require_relative 'rubocop/performance/plugin'
 require_relative 'rubocop/cop/performance_cops'
 
-RuboCop::Cop::Lint::UnusedMethodArgument.singleton_class.prepend(
-  Module.new do
-    def autocorrect_incompatible_with
-      super.push(RuboCop::Cop::Performance::BlockGivenWithExplicitBlock)
-    end
+autocorrect_incompatible_with_block_given_with_explicit_block = Module.new do
+  def autocorrect_incompatible_with
+    super.push(RuboCop::Cop::Performance::BlockGivenWithExplicitBlock)
   end
+end
+
+RuboCop::Cop::Lint::UnusedMethodArgument.singleton_class.prepend(
+  autocorrect_incompatible_with_block_given_with_explicit_block
+)
+
+RuboCop::Cop::Naming::BlockForwarding.singleton_class.prepend(
+  autocorrect_incompatible_with_block_given_with_explicit_block
 )

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.24.0
+  version: 1.26.0
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -32,7 +31,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: 1.75.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -42,7 +41,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: 1.75.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -52,7 +51,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.38.0
+        version: 1.44.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -62,7 +61,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.38.0
+        version: 1.44.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -146,11 +145,10 @@ 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.24/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.26/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
   rubygems_mfa_required: 'true'
   default_lint_roller_plugin: RuboCop::Performance::Plugin
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -165,8 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.
 test_files: []