rubocop-performance 1.13.3 → 1.19.0

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `Hash#merge!` can be replaced by
-      # `Hash#[]=`.
+      # Identifies places where `Hash#merge!` can be replaced by `Hash#[]=`.
       # You can set the maximum number of key-value pairs to consider
       # an offense with `MaxKeyValuePairs`.
       #
@@ -29,6 +28,7 @@ module RuboCop
       #   hash[:a] = 1
       #   hash[:b] = 2
       class RedundantMerge < Base
+        include Alignment
         extend AutoCorrector
 
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
@@ -100,8 +100,7 @@ module RuboCop
         end
 
         def non_redundant_value_used?(receiver, node)
-          node.value_used? &&
-            !EachWithObjectInspector.new(node, receiver).value_used?
+          node.value_used? && !EachWithObjectInspector.new(node, receiver).value_used?
         end
 
         def correct_multiple_elements(corrector, node, parent, new_source)
@@ -110,14 +109,14 @@ module RuboCop
             node = parent
           else
             padding = "\n#{leading_spaces(node)}"
-            new_source.gsub!(/\n/, padding)
+            new_source.gsub!("\n", padding)
           end
 
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def correct_single_element(corrector, node, new_source)
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def to_assignments(receiver, pairs)
@@ -126,16 +125,14 @@ module RuboCop
 
             key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
 
-            format(AREF_ASGN, receiver: receiver.source,
-                              key: key,
-                              value: value.source)
+            format(AREF_ASGN, receiver: receiver.source, key: key, value: value.source)
           end
         end
 
         def rewrite_with_modifier(node, parent, new_source)
-          indent = ' ' * indent_width
+          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,
@@ -148,10 +145,6 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def max_key_value_pairs
           Integer(cop_config['MaxKeyValuePairs'] || 2)
         end

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `sort { |a, b| a <=> b }`
-      # can be replaced with `sort`.
+      # Identifies places where `sort { |a, b| a <=> b }` can be replaced with `sort`.
       #
       # @example
       #   # bad
@@ -17,25 +16,33 @@ module RuboCop
         include SortBlock
         extend AutoCorrector
 
-        MSG = 'Use `sort` instead of `%<bad_method>s`.'
+        MSG = 'Use `sort` without block.'
 
         def on_block(node)
           return unless (send, var_a, var_b, body = sort_with_block?(node))
 
           replaceable_body?(body, var_a, var_b) do
-            range = sort_range(send, node)
+            register_offense(send, node)
+          end
+        end
+
+        def on_numblock(node)
+          return unless (send, arg_count, body = sort_with_numblock?(node))
+          return unless arg_count == 2
 
-            add_offense(range, message: message(var_a, var_b)) do |corrector|
-              corrector.replace(range, 'sort')
-            end
+          replaceable_body?(body, :_1, :_2) do
+            register_offense(send, node)
           end
         end
 
         private
 
-        def message(var_a, var_b)
-          bad_method = "sort { |#{var_a}, #{var_b}| #{var_a} <=> #{var_b} }"
-          format(MSG, bad_method: bad_method)
+        def register_offense(send, node)
+          range = sort_range(send, node)
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'sort')
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `split` argument can be replaced from
+      # Identifies places where `split` argument can be replaced from
       # a deterministic regexp to a string.
       #
       # @example
@@ -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/redundant_string_chars.rb

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop checks for redundant `String#chars`.
+      # Checks for redundant `String#chars`.
       #
       # @example
       #   # bad
       #   str.chars[0..2]
       #   str.chars.slice(0..2)
+      #   str.chars.last
       #
       #   # good
       #   str[0..2].chars
@@ -20,6 +21,7 @@ module RuboCop
       #   # good
       #   str[0]
       #   str[0...2].chars
+      #   str[-1]
       #
       #   # bad
       #   str.chars.take(2)
@@ -33,9 +35,8 @@ module RuboCop
       #   str.size
       #   str.empty?
       #
-      #   # For example, if the receiver is a blank string, it will be incompatible.
+      #   # For example, if the receiver is an empty string, it will be incompatible.
       #   # If a negative value is specified for the receiver, `nil` is returned.
-      #   str.chars.last    # Incompatible with `str[-1]`.
       #   str.chars.last(2) # Incompatible with `str[-2..-1].chars`.
       #   str.chars.drop(2) # Incompatible with `str[2..-1].chars`.
       #
@@ -44,7 +45,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[[] slice first take length size empty?].freeze
+        RESTRICT_ON_SEND = %i[[] slice first last take length size empty?].freeze
 
         def_node_matcher :redundant_chars_call?, <<~PATTERN
           (send $(send _ :chars) $_ $...)
@@ -52,6 +53,7 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver, method, args = redundant_chars_call?(node))
+          return if method == :last && !args.empty?
 
           range = offense_range(receiver, node)
           message = build_message(method, args)
@@ -67,11 +69,11 @@ module RuboCop
         private
 
         def offense_range(receiver, node)
-          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(receiver.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def correction_range(receiver, node)
-          range_between(receiver.loc.dot.begin_pos, node.loc.expression.end_pos)
+          range_between(receiver.loc.dot.begin_pos, node.source_range.end_pos)
         end
 
         def build_message(method, args)
@@ -86,6 +88,8 @@ module RuboCop
             "[#{build_call_args(args)}].chars"
           when :[], :first
             build_good_method_for_brackets_or_first_method(method, args)
+          when :last
+            '[-1]'
           when :take
             "[0...#{args.first.source}].chars"
           else

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

@@ -74,6 +74,9 @@ module RuboCop
       #   end
       class RegexpMatch < Base
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
 
         # Constants are included in this list because it is unlikely that
         # someone will store `nil` as a constant and then use it for comparison
@@ -121,13 +124,17 @@ module RuboCop
 
         def_node_search :last_matches, <<~PATTERN
           {
-            (send (const nil? :Regexp) :last_match)
-            (send (const nil? :Regexp) :last_match _)
+            (send (const {nil? cbase} :Regexp) :last_match)
+            (send (const {nil? cbase} :Regexp) :last_match _)
             ({back_ref nth_ref} _)
             (gvar #match_gvar?)
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [ConstantRegexp]
+        end
+
         def on_if(node)
           check_condition(node.condition)
         end
@@ -182,9 +189,9 @@ module RuboCop
 
         def range_to_search_for_last_matches(match_node, body, scope_root)
           expression = if modifier_form?(match_node)
-                         match_node.parent.if_branch.loc.expression
+                         match_node.parent.if_branch.source_range
                        else
-                         match_node.loc.expression
+                         match_node.source_range
                        end
 
           match_node_pos = expression.begin_pos
@@ -196,15 +203,15 @@ module RuboCop
         def next_match_pos(body, match_node_pos, scope_root)
           node = search_match_nodes(body).find do |match|
             begin_pos = if modifier_form?(match)
-                          match.parent.if_branch.loc.expression.begin_pos
+                          match.parent.if_branch.source_range.begin_pos
                         else
-                          match.loc.expression.begin_pos
+                          match.source_range.begin_pos
                         end
 
             begin_pos > match_node_pos && scope_root(match) == scope_root
           end
 
-          node ? node.loc.expression.begin_pos : Float::INFINITY
+          node ? node.source_range.begin_pos : Float::INFINITY
         end
 
         def modifier_form?(match_node)
@@ -213,9 +220,8 @@ module RuboCop
 
         def find_last_match(body, range, scope_root)
           last_matches(body).find do |ref|
-            ref_pos = ref.loc.expression.begin_pos
-            range.cover?(ref_pos) &&
-              scope_root(ref) == scope_root
+            ref_pos = ref.source_range.begin_pos
+            range.cover?(ref_pos) && scope_root(ref) == scope_root
           end
         end
 
@@ -238,14 +244,7 @@ module RuboCop
         end
 
         def match_gvar?(sym)
-          %i[
-            $~
-            $MATCH
-            $PREMATCH
-            $POSTMATCH
-            $LAST_PAREN_MATCH
-            $LAST_MATCH_INFO
-          ].include?(sym)
+          %i[$~ $MATCH $PREMATCH $POSTMATCH $LAST_PAREN_MATCH $LAST_MATCH_INFO].include?(sym)
         end
 
         def correct_operator(corrector, recv, arg, oper = nil)
@@ -253,8 +252,8 @@ module RuboCop
 
           replace_with_match_predicate_method(corrector, recv, arg, op_range)
 
-          corrector.insert_after(arg.loc.expression, ')') unless op_range.source.end_with?('(')
-          corrector.insert_before(recv.loc.expression, '!') if oper == :!~
+          corrector.insert_after(arg, ')') unless op_range.source.end_with?('(')
+          corrector.insert_before(recv, '!') if oper == :!~
         end
 
         def replace_with_match_predicate_method(corrector, recv, arg, op_range)
@@ -269,14 +268,14 @@ module RuboCop
         end
 
         def swap_receiver_and_arg(corrector, recv, arg)
-          corrector.replace(recv.loc.expression, arg.source)
-          corrector.replace(arg.loc.expression, recv.source)
+          corrector.replace(recv, arg.source)
+          corrector.replace(arg, recv.source)
         end
 
         def correction_range(recv, arg)
           buffer = processed_source.buffer
-          op_begin_pos = recv.loc.expression.end_pos
-          op_end_pos = arg.loc.expression.begin_pos
+          op_begin_pos = recv.source_range.end_pos
+          op_end_pos = arg.source_range.begin_pos
           Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
         end
       end

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `reverse.each` and
-      # change them to use `reverse_each` instead.
+      # Identifies usages of `reverse.each` and change them to use `reverse_each` instead.
       #
       # If the return value is used, it will not be detected because the result will be different.
       #
@@ -28,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)
@@ -42,6 +41,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `reverse.first(n)` and `reverse.first`
+      # Identifies places where `reverse.first(n)` and `reverse.first`
       # can be replaced by `last(n).reverse` and `last`.
       #
       # @example
@@ -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,11 +39,12 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def correction_range(receiver, node)
-          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(receiver.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def build_message(node)

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
 
@@ -52,7 +53,7 @@ module RuboCop
         end
 
         def offense_range(node, map_method)
-          range_between(node.loc.selector.begin_pos, map_method.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, map_method.source_range.end_pos)
         end
       end
     end

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `count` on an
-      # `Array` and `Hash` and change them to `size`.
+      # Identifies usages of `count` on an `Array` and `Hash` and change them to `size`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `sort { |a, b| b <=> a }`
+      # Identifies places where `sort { |a, b| b <=> a }`
       # can be replaced by a faster `sort.reverse`.
       #
       # @example
@@ -17,27 +17,36 @@ module RuboCop
         include SortBlock
         extend AutoCorrector
 
-        MSG = 'Use `sort.reverse` instead of `%<bad_method>s`.'
+        MSG = 'Use `sort.reverse` instead.'
 
         def on_block(node)
           sort_with_block?(node) do |send, var_a, var_b, body|
             replaceable_body?(body, var_b, var_a) do
-              range = sort_range(send, node)
+              register_offense(send, node)
+            end
+          end
+        end
 
-              add_offense(range, message: message(var_a, var_b)) do |corrector|
-                replacement = 'sort.reverse'
+        def on_numblock(node)
+          sort_with_numblock?(node) do |send, arg_count, body|
+            next unless arg_count == 2
 
-                corrector.replace(range, replacement)
-              end
+            replaceable_body?(body, :_2, :_1) do
+              register_offense(send, node)
             end
           end
         end
 
         private
 
-        def message(var_a, var_b)
-          bad_method = "sort { |#{var_a}, #{var_b}| #{var_b} <=> #{var_a} }"
-          format(MSG, bad_method: bad_method)
+        def register_offense(send, node)
+          range = sort_range(send, node)
+
+          add_offense(range) do |corrector|
+            replacement = 'sort.reverse'
+
+            corrector.replace(range, replacement)
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')`
+      # Identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')`
       # can be replaced by `squeeze('a')` and `squeeze!('a')`.
       #
       # The `squeeze('a')` method is faster than `gsub(/a+/, 'a')`.
@@ -24,13 +24,10 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub!].freeze
 
-        PREFERRED_METHODS = {
-          gsub: :squeeze,
-          gsub!: :squeeze!
-        }.freeze
+        PREFERRED_METHODS = { gsub: :squeeze, gsub!: :squeeze! }.freeze
 
         def_node_matcher :squeeze_candidate?, <<~PATTERN
-          (send
+          (call
             $!nil? ${:gsub :gsub!}
             (regexp
               (str $#repeating_literal?)
@@ -38,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
@@ -49,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.source_range, new_code)
+              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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies unnecessary use of a regex where `String#start_with?` would suffice.
+      # Identifies unnecessary use of a regex where `String#start_with?` would suffice.
       #
       # This cop has `SafeMultiline` configuration option that `true` by default because
       # `^start` is unsafe as it will behave incompatible with `start_with?`
@@ -50,12 +50,11 @@ module RuboCop
         include RegexpMetacharacter
         extend AutoCorrector
 
-        MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
-              'the beginning of the string.'
+        MSG = 'Use `String#start_with?` instead of a regex match anchored to the beginning of the string.'
         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
@@ -67,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.source_range, new_source)
+            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_identifier_argument.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where string identifier argument can be replaced
+      # Identifies places where string identifier argument can be replaced
       # by symbol identifier argument.
       # It prevents the redundancy of the internal string-to-symbol conversion.
       #
@@ -27,28 +27,33 @@ module RuboCop
 
         MSG = 'Use `%<symbol_arg>s` instead of `%<string_arg>s`.'
 
+        COMMAND_METHODS = %i[
+          alias_method attr_accessor attr_reader attr_writer autoload autoload? private private_constant
+          protected public public_constant module_function
+        ].freeze
+
         # 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?
+        RESTRICT_ON_SEND = (%i[
           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
+          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).freeze
 
         def on_send(node)
+          return if COMMAND_METHODS.include?(node.method_name) && node.receiver
           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
+          first_argument_value = first_argument.value
+          return if first_argument_value.include?(' ') || first_argument_value.include?('::')
+
+          replacement = first_argument_value.to_sym.inspect
 
           message = format(MSG, symbol_arg: replacement, string_arg: first_argument.source)