rubocop-performance 1.17.1 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec17923dd3d4e2f5428145e038da7e2f3f71da16fcd474b3a64f052ddf252215
-  data.tar.gz: fff0473253906265a38c16a534049edb9673911a6947d3e30226b87bc20160e9
+  metadata.gz: 06f3e8346dc7f9be72a1f18c62a25dc02aeac41debcfe3c58df68e2a6904df43
+  data.tar.gz: f01facdb92a3056d05990e2ed2b6b1920de0501edf53a08e95e08620651c8557
 SHA512:
-  metadata.gz: e259f4d06ff1fadaf0fb923d5324fbda387a693b146cfcbac2bd5c80b84a2086cfd4b692623e120f63bc912854ac49b360835e86d05510d2e9d01880c6c67d49
-  data.tar.gz: 4c8fc04f79ee8da81cb4ba3934ef66a080c8ab9186f5a228101ae2ed7a4212a0c616157801553582b9c9c1073a60cdb63621d1de233c9c34c1f2389d60aaf212
+  metadata.gz: 07eb541698b6ccf2985ef62392bd78703bf6607e2877ef3865ab1762d62910c4c346fbb7e9bc48af7b7d98b0e1ad22e8c79ea2425555fbe75c2a5e614837eaa7
+  data.tar.gz: 60fc9f900906cca518d0da62170f71ae6e5f5ffd44f4c1cbe75af83f9a1fef252b6bab95d3af4f49f328d4a856cd17c7f47621ee62575ab282eacfd26dc09841

data/config/default.yml

@@ -193,6 +193,12 @@ Performance/MapCompact:
   SafeAutoCorrect: false
   VersionAdded: '1.11'
 
+Performance/MapMethodChain:
+  Description: 'Checks if the `map` method is used in a chain.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '1.19'
+
 Performance/MethodObjectAsBlock:
   Description: 'Use block explicitly instead of block-passing a method object.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code'

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

@@ -39,7 +39,7 @@ module RuboCop
         RESTRICT_ON_SEND = SLICE_METHODS
 
         def_node_matcher :endless_range_slice?, <<~PATTERN
-          (send $_ $%SLICE_METHODS $#endless_range?)
+          (call $_ $%SLICE_METHODS $#endless_range?)
         PATTERN
 
         def_node_matcher :endless_range?, <<~PATTERN
@@ -59,6 +59,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -5,35 +5,42 @@ module RuboCop
     module Performance
       # Identifies places where `sort { |a, b| a.foo <=> b.foo }`
       # can be replaced by `sort_by(&:foo)`.
-      # This cop also checks `max` and `min` methods.
+      # This cop also checks `sort!`, `min`, `max` and `minmax` methods.
       #
       # @example
       #   # bad
-      #   array.sort { |a, b| a.foo <=> b.foo }
-      #   array.max { |a, b| a.foo <=> b.foo }
-      #   array.min { |a, b| a.foo <=> b.foo }
-      #   array.sort { |a, b| a[:foo] <=> b[:foo] }
+      #   array.sort   { |a, b| a.foo <=> b.foo }
+      #   array.sort!  { |a, b| a.foo <=> b.foo }
+      #   array.max    { |a, b| a.foo <=> b.foo }
+      #   array.min    { |a, b| a.foo <=> b.foo }
+      #   array.minmax { |a, b| a.foo <=> b.foo }
+      #   array.sort   { |a, b| a[:foo] <=> b[:foo] }
       #
       #   # good
       #   array.sort_by(&:foo)
+      #   array.sort_by!(&:foo)
       #   array.sort_by { |v| v.foo }
       #   array.sort_by do |var|
       #     var.foo
       #   end
       #   array.max_by(&:foo)
       #   array.min_by(&:foo)
+      #   array.minmax_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
       class CompareWithBlock < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
+        MSG = 'Use `%<replacement_method>s%<instead>s` instead of ' \
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
               '<=> %<str_b>s }`.'
 
+        REPLACEMENT = { sort: :sort_by, sort!: :sort_by!, min: :min_by, max: :max_by, minmax: :minmax_by }.freeze
+        private_constant :REPLACEMENT
+
         def_node_matcher :compare?, <<~PATTERN
           (block
-            $(send _ {:sort :min :max})
+            $(send _ {:sort :sort! :min :max :minmax})
             (args (arg $_a) (arg $_b))
             $send)
         PATTERN
@@ -54,9 +61,9 @@ module RuboCop
 
               add_offense(range, message: message(send, method, var_a, var_b, args_a)) do |corrector|
                 replacement = if method == :[]
-                                "#{send.method_name}_by { |a| a[#{args_a.first.source}] }"
+                                "#{REPLACEMENT[send.method_name]} { |a| a[#{args_a.first.source}] }"
                               else
-                                "#{send.method_name}_by(&:#{method})"
+                                "#{REPLACEMENT[send.method_name]}(&:#{method})"
                               end
                 corrector.replace(range, replacement)
               end
@@ -82,7 +89,8 @@ module RuboCop
 
         # rubocop:disable Metrics/MethodLength
         def message(send, method, var_a, var_b, args)
-          compare_method = send.method_name
+          compare_method     = send.method_name
+          replacement_method = REPLACEMENT[compare_method]
           if method == :[]
             key = args.first
             instead = " { |a| a[#{key.source}] }"
@@ -94,6 +102,7 @@ module RuboCop
             str_b = "#{var_b}.#{method}"
           end
           format(MSG, compare_method: compare_method,
+                      replacement_method: replacement_method,
                       instead: instead,
                       var_a: var_a,
                       var_b: var_b,

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

@@ -38,6 +38,10 @@ module RuboCop
 
         MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
 
+        def self.autocorrect_incompatible_with
+          [RegexpMatch]
+        end
+
         def on_regexp(node)
           return if within_allowed_assignment?(node) || !include_interpolated_const?(node) || node.single_interpolation?
 

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

@@ -64,9 +64,10 @@ module RuboCop
         }.freeze
 
         def_node_matcher :delete_prefix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
+          (call $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_prefix_candidate?(node))
           return unless replace_string.empty?
@@ -80,11 +81,13 @@ module RuboCop
             regexp_str = interpret_string_escapes(regexp_str)
             string_literal = to_string_literal(regexp_str)
 
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
             corrector.replace(node, new_code)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
       end
     end
   end

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

@@ -64,9 +64,10 @@ module RuboCop
         }.freeze
 
         def_node_matcher :delete_suffix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
+          (call $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_suffix_candidate?(node))
           return unless replace_string.empty?
@@ -80,11 +81,13 @@ module RuboCop
             regexp_str = interpret_string_escapes(regexp_str)
             string_literal = to_string_literal(regexp_str)
 
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
             corrector.replace(node, new_code)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
       end
     end
   end

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

@@ -40,9 +40,9 @@ module RuboCop
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
+            (send $(block (call _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
             (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
-            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
+            (send $(call _ %CANDIDATE_METHODS ...) ${:first :last} $...)
             (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
           }
         PATTERN
@@ -63,6 +63,7 @@ module RuboCop
             register_offense(node, receiver, second_method, index)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -54,7 +54,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
+          {(call $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :match?} $_)
            (match-with-lvasgn (regexp (str $#literal_at_end?) (regopt)) $_)}
         PATTERN
@@ -66,12 +66,14 @@ module RuboCop
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = drop_end_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
+            new_source = "#{receiver.source}#{dot}end_with?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node, new_source)
           end
         end
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
       end
     end

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

@@ -78,13 +78,13 @@ module RuboCop
         end
 
         def contains_splat?(node)
-          return unless node.array_type?
+          return false unless node.array_type?
 
           node.each_child_node(:splat).any?
         end
 
         def contains_double_splat?(node)
-          return unless node.hash_type?
+          return false unless node.hash_type?
 
           node.each_child_node(:kwsplat).any?
         end

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

@@ -45,7 +45,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[include?].freeze
 
         def_node_matcher :inefficient_include?, <<~PATTERN
-          (send (send $_ {:keys :values}) :include? _)
+          (send (call $_ {:keys :values}) :include? _)
         PATTERN
 
         def on_send(node)
@@ -56,21 +56,23 @@ module RuboCop
             add_offense(node, message: message) do |corrector|
               # Replace `keys.include?` or `values.include?` with the appropriate
               # `key?`/`value?` method.
-              corrector.replace(
-                node,
-                "#{autocorrect_hash_expression(node)}.#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
-              )
+              corrector.replace(node, replacement(node))
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def message(node)
-          "Use `##{autocorrect_method(node)}` instead of `##{current_method(node)}.include?`."
+          "Use `##{correct_method(node)}` instead of `##{current_method(node)}.include?`."
         end
 
-        def autocorrect_method(node)
+        def replacement(node)
+          "#{correct_hash_expression(node)}#{correct_dot(node)}#{correct_method(node)}(#{correct_argument(node)})"
+        end
+
+        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?'
@@ -86,13 +88,17 @@ module RuboCop
           preferred_config && preferred_config['EnforcedStyle'] == 'long' && preferred_config['Enabled']
         end
 
-        def autocorrect_argument(node)
+        def correct_argument(node)
           node.arguments.first.source
         end
 
-        def autocorrect_hash_expression(node)
+        def correct_hash_expression(node)
           node.receiver.receiver.source
         end
+
+        def correct_dot(node)
+          node.receiver.loc.dot.source
+        end
       end
     end
   end

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

@@ -40,12 +40,12 @@ module RuboCop
         def_node_matcher :map_compact, <<~PATTERN
           {
             (send
-              $(send _ {:map :collect}
+              $(call _ {:map :collect}
                 (block_pass
                   (sym _))) _)
             (send
               (block
-                $(send _ {:map :collect})
+                $(call _ {:map :collect})
                   (args ...) _) _)
           }
         PATTERN
@@ -61,6 +61,7 @@ module RuboCop
             remove_compact_method(corrector, map_node, node, node.parent)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # Checks if the map method is used in a chain.
+      #
+      # Autocorrection is not supported because an appropriate block variable name cannot be determined automatically.
+      #
+      # @safety
+      #   This cop is unsafe because false positives occur if the number of times the first method is executed
+      #   affects the return value of subsequent methods.
+      #
+      # [source,ruby]
+      # ----
+      # class X
+      #   def initialize
+      #     @@num = 0
+      #   end
+      #
+      #   def foo
+      #     @@num += 1
+      #     self
+      #   end
+      #
+      #   def bar
+      #     @@num * 2
+      #   end
+      # end
+      #
+      # [X.new, X.new].map(&:foo).map(&:bar) # => [4, 4]
+      # [X.new, X.new].map { |x| x.foo.bar } # => [2, 4]
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   array.map(&:foo).map(&:bar)
+      #
+      #   # good
+      #   array.map { |item| item.foo.bar }
+      #
+      class MapMethodChain < Base
+        include IgnoredNode
+
+        MSG = 'Use `%<method_name>s { |x| x.%<map_args>s }` instead of `%<method_name>s` method chain.'
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def_node_matcher :block_pass_with_symbol_arg?, <<~PATTERN
+          (:block_pass (:sym $_))
+        PATTERN
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+          return unless (map_arg = block_pass_with_symbol_arg?(node.first_argument))
+
+          map_args = [map_arg]
+
+          return unless (begin_of_chained_map_method = find_begin_of_chained_map_method(node, map_args))
+
+          range = begin_of_chained_map_method.loc.selector.begin.join(node.source_range.end)
+          message = format(MSG, method_name: begin_of_chained_map_method.method_name, map_args: map_args.join('.'))
+
+          add_offense(range, message: message)
+
+          ignore_node(node)
+        end
+
+        private
+
+        def find_begin_of_chained_map_method(node, map_args)
+          return unless (chained_map_method = node.receiver)
+          return if !chained_map_method.call_type? || !RESTRICT_ON_SEND.include?(chained_map_method.method_name)
+          return unless (map_arg = block_pass_with_symbol_arg?(chained_map_method.first_argument))
+
+          map_args.unshift(map_arg)
+
+          receiver = chained_map_method.receiver
+
+          return chained_map_method unless receiver.call_type? && block_pass_with_symbol_arg?(receiver.first_argument)
+
+          find_begin_of_chained_map_method(chained_map_method, map_args)
+        end
+      end
+    end
+  end
+end

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

@@ -97,7 +97,7 @@ module RuboCop
           elsif IS_A_METHODS.include?(block_body.method_name)
             block_argument.source == block_body.first_argument.source
           else
-            false
+            block_body.receiver.source == block_body.first_argument.receiver&.source
           end
         end
 

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

@@ -109,7 +109,7 @@ module RuboCop
             node = parent
           else
             padding = "\n#{leading_spaces(node)}"
-            new_source.gsub!(/\n/, padding)
+            new_source.gsub!("\n", padding)
           end
 
           corrector.replace(node, new_source)
@@ -132,7 +132,7 @@ module RuboCop
         def rewrite_with_modifier(node, parent, new_source)
           indent = ' ' * configured_indentation_width
           padding = "\n#{indent + leading_spaces(node)}"
-          new_source.gsub!(/\n/, padding)
+          new_source.gsub!("\n", padding)
 
           format(WITH_MODIFIER_CORRECTION, keyword: parent.loc.keyword.source,
                                            condition: parent.condition.source,

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

@@ -21,7 +21,7 @@ module RuboCop
         STR_SPECIAL_CHARS = %w[\n \" \' \\\\ \t \b \f \r].freeze
 
         def_node_matcher :split_call_with_regexp?, <<~PATTERN
-          {(send !nil? :split $regexp)}
+          {(call !nil? :split $regexp)}
         PATTERN
 
         def on_send(node)
@@ -35,6 +35,7 @@ module RuboCop
             corrector.replace(regexp_node, "\"#{new_argument}\"")
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -131,6 +131,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [ConstantRegexp]
+        end
+
         def on_if(node)
           check_condition(node.condition)
         end

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

@@ -27,7 +27,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[each].freeze
 
         def_node_matcher :reverse_each?, <<~MATCHER
-          (send (send _ :reverse) :each)
+          (send (call _ :reverse) :each)
         MATCHER
 
         def on_send(node)
@@ -41,6 +41,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -24,7 +24,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[first].freeze
 
         def_node_matcher :reverse_first_candidate?, <<~PATTERN
-          (send $(send _ :reverse) :first (int _)?)
+          (send $(call _ :reverse) :first (int _)?)
         PATTERN
 
         def on_send(node)
@@ -39,6 +39,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -38,6 +38,7 @@ module RuboCop
           range = offense_range(node, map_method)
           add_offense(range, message: format(MSG, method_name: node.method_name))
         end
+        alias on_csend on_send
 
         private
 

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

@@ -27,7 +27,7 @@ module RuboCop
         PREFERRED_METHODS = { gsub: :squeeze, gsub!: :squeeze! }.freeze
 
         def_node_matcher :squeeze_candidate?, <<~PATTERN
-          (send
+          (call
             $!nil? ${:gsub :gsub!}
             (regexp
               (str $#repeating_literal?)
@@ -35,6 +35,7 @@ module RuboCop
             (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           squeeze_candidate?(node) do |receiver, bad_method, regexp_str, replace_str|
             regexp_str = regexp_str[0..-2] # delete '+' from the end
@@ -46,12 +47,14 @@ module RuboCop
 
             add_offense(node.loc.selector, message: message) do |corrector|
               string_literal = to_string_literal(replace_str)
-              new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+              new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
               corrector.replace(node, new_code)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
 
         private
 

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

@@ -54,7 +54,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))
+          {(call $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :match?} $_)
            (match-with-lvasgn (regexp (str $#literal_at_start?) (regopt)) $_)}
         PATTERN
@@ -66,12 +66,14 @@ module RuboCop
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = drop_start_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{receiver.source}.start_with?(#{to_string_literal(regex_str)})"
+            new_source = "#{receiver.source}#{dot}start_with?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node, new_source)
           end
         end
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
       end
     end

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

@@ -26,11 +26,12 @@ module RuboCop
         RESTRICT_ON_SEND = %i[match =~ !~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :!~ :match?} (regexp (str $#literal?) (regopt)))
+          {(call $!nil? {:match :=~ :!~ :match?} (regexp (str $#literal?) (regopt)))
            (send (regexp (str $#literal?) (regopt)) {:match :match?} $_)
            (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)}
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, regex_str = redundant_regex?(node))
 
@@ -40,12 +41,15 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = interpret_string_escapes(regex_str)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{'!' if negation}#{receiver.source}.include?(#{to_string_literal(regex_str)})"
+            new_source = "#{'!' if negation}#{receiver.source}#{dot}include?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node, new_source)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
 
         private

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

@@ -29,7 +29,7 @@ module RuboCop
         BANG = '!'
 
         def_node_matcher :string_replacement?, <<~PATTERN
-          (send _ {:gsub :gsub!}
+          (call _ {:gsub :gsub!}
                     ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
                     $str)
         PATTERN
@@ -42,6 +42,7 @@ module RuboCop
             offense(node, first_param, second_param)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -25,7 +25,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless uri_parser_new?(node) do |captured_value|
+          uri_parser_new?(node) do |captured_value|
             double_colon = captured_value ? '::' : ''
             message = format(MSG, double_colon: double_colon)
 

data/lib/rubocop/cop/performance_cops.rb

@@ -25,6 +25,7 @@ require_relative 'performance/fixed_size'
 require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
 require_relative 'performance/map_compact'
+require_relative 'performance/map_method_chain'
 require_relative 'performance/method_object_as_block'
 require_relative 'performance/open_struct'
 require_relative 'performance/range_include'

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.17.1'
+      STRING = '1.19.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.17.1
+  version: 1.19.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-09 00:00:00.000000000 Z
+date: 2023-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -87,6 +87,7 @@ files:
 - lib/rubocop/cop/performance/inefficient_hash_search.rb
 - lib/rubocop/cop/performance/io_readlines.rb
 - lib/rubocop/cop/performance/map_compact.rb
+- lib/rubocop/cop/performance/map_method_chain.rb
 - lib/rubocop/cop/performance/method_object_as_block.rb
 - lib/rubocop/cop/performance/open_struct.rb
 - lib/rubocop/cop/performance/range_include.rb
@@ -123,7 +124,7 @@ 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.17/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.19/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -134,14 +135,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.5.0.dev
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.