rubocop-performance 1.5.1 → 1.7.1

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

@@ -31,7 +31,7 @@ module RuboCop
         MSG = 'Consider using `Struct` over `OpenStruct` ' \
               'to optimize the performance.'
 
-        def_node_matcher :open_struct, <<-PATTERN
+        def_node_matcher :open_struct, <<~PATTERN
           (send (const {nil? cbase} :OpenStruct) :new ...)
         PATTERN
 

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

@@ -3,18 +3,19 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies uses of `Range#include?`, which iterates over each
+      # This cop identifies uses of `Range#include?` and `Range#member?`, which iterates over each
       # item in a `Range` to see if a specified item is there. In contrast,
       # `Range#cover?` simply compares the target item with the beginning and
       # 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?` and
+      # This cop is `Safe: false` by default because `Range#include?` (or `Range#member?`) and
       # `Range#cover?` are not equivalent behaviour.
       #
       # @example
       #   # bad
       #   ('a'..'z').include?('b') # => true
+      #   ('a'..'z').member?('b')  # => true
       #
       #   # good
       #   ('a'..'z').cover?('b') # => true
@@ -24,21 +25,22 @@ module RuboCop
       #
       #   ('a'..'z').cover?('yellow') # => true
       class RangeInclude < Cop
-        MSG = 'Use `Range#cover?` instead of `Range#include?`.'
+        MSG = 'Use `Range#cover?` instead of `Range#%<bad_method>s`.'
 
         # TODO: If we traced out assignments of variables to their uses, we
         # might pick up on a few more instances of this issue
         # Right now, we only detect direct calls on a Range literal
         # (We don't even catch it if the Range is in double parens)
 
-        def_node_matcher :range_include, <<-PATTERN
-          (send {irange erange (begin {irange erange})} :include? ...)
+        def_node_matcher :range_include, <<~PATTERN
+          (send {irange erange (begin {irange erange})} ${:include? :member?} ...)
         PATTERN
 
         def on_send(node)
-          return unless range_include(node)
-
-          add_offense(node, location: :selector)
+          range_include(node) do |bad_method|
+            message = format(MSG, bad_method: bad_method)
+            add_offense(node, location: :selector, message: message)
+          end
         end
 
         def autocorrect(node)

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

@@ -29,16 +29,16 @@ module RuboCop
         CLOSE_PAREN = ')'
         SPACE = ' '
 
-        def_node_matcher :blockarg_def, <<-PATTERN
+        def_node_matcher :blockarg_def, <<~PATTERN
           {(def  _   (args ... (blockarg $_)) $_)
            (defs _ _ (args ... (blockarg $_)) $_)}
         PATTERN
 
-        def_node_search :blockarg_calls, <<-PATTERN
+        def_node_search :blockarg_calls, <<~PATTERN
           (send (lvar %1) :call ...)
         PATTERN
 
-        def_node_search :blockarg_assigned?, <<-PATTERN
+        def_node_search :blockarg_assigned?, <<~PATTERN
           (lvasgn %1 ...)
         PATTERN
 

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

@@ -23,12 +23,12 @@ module RuboCop
 
         # 'match' is a fairly generic name, so we don't flag it unless we see
         # a string or regexp literal on one side or the other
-        def_node_matcher :match_call?, <<-PATTERN
+        def_node_matcher :match_call?, <<~PATTERN
           {(send {str regexp} :match _)
            (send !nil? :match {str regexp})}
         PATTERN
 
-        def_node_matcher :only_truthiness_matters?, <<-PATTERN
+        def_node_matcher :only_truthiness_matters?, <<~PATTERN
           ^({if while until case while_post until_post} equal?(%0) ...)
         PATTERN
 

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

@@ -5,11 +5,25 @@ module RuboCop
     module Performance
       # This cop 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`.
       #
       # @example
+      #   # bad
       #   hash.merge!(a: 1)
       #   hash.merge!({'key' => 'value'})
+      #
+      #   # good
+      #   hash[:a] = 1
+      #   hash['key'] = 'value'
+      #
+      # @example MaxKeyValuePairs: 2 (default)
+      #   # bad
       #   hash.merge!(a: 1, b: 2)
+      #
+      #   # good
+      #   hash[:a] = 1
+      #   hash[:b] = 2
       class RedundantMerge < Cop
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
@@ -20,11 +34,11 @@ module RuboCop
           %<leading_space>send
         RUBY
 
-        def_node_matcher :redundant_merge_candidate, <<-PATTERN
+        def_node_matcher :redundant_merge_candidate, <<~PATTERN
           (send $!nil? :merge! [(hash $...) !kwsplat_type?])
         PATTERN
 
-        def_node_matcher :modifier_flow_control?, <<-PATTERN
+        def_node_matcher :modifier_flow_control?, <<~PATTERN
           [{if while until} modifier_form?]
         PATTERN
 
@@ -65,7 +79,8 @@ module RuboCop
         end
 
         def non_redundant_merge?(node, receiver, pairs)
-          non_redundant_pairs?(receiver, pairs) ||
+          pairs.empty? ||
+            non_redundant_pairs?(receiver, pairs) ||
             kwsplat_used?(pairs) ||
             non_redundant_value_used?(receiver, node)
         end
@@ -167,13 +182,11 @@ module RuboCop
           end
 
           def unwind(receiver)
-            while receiver.respond_to?(:send_type?) && receiver.send_type?
-              receiver, = *receiver
-            end
+            receiver, = *receiver while receiver.respond_to?(:send_type?) && receiver.send_type?
             receiver
           end
 
-          def_node_matcher :each_with_object_node, <<-PATTERN
+          def_node_matcher :each_with_object_node, <<~PATTERN
             (block (send _ :each_with_object _) (args _ $_) ...)
           PATTERN
         end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort { |a, b| a <=> b }`
+      # can be replaced with `sort`.
+      #
+      # @example
+      #   # bad
+      #   array.sort { |a, b| a <=> b }
+      #
+      #   # good
+      #   array.sort
+      #
+      class RedundantSortBlock < Cop
+        include SortBlock
+
+        MSG = 'Use `sort` instead of `%<bad_method>s`.'
+
+        def on_block(node)
+          sort_with_block?(node) do |send, var_a, var_b, body|
+            replaceable_body?(body, var_a, var_b) do
+              range = sort_range(send, node)
+
+              add_offense(
+                node,
+                location: range,
+                message: message(var_a, var_b)
+              )
+            end
+          end
+        end
+
+        def autocorrect(node)
+          sort_with_block?(node) do |send, _var_a, _var_b, _body|
+            lambda do |corrector|
+              range = sort_range(send, node)
+              corrector.replace(range, 'sort')
+            end
+          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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for redundant `String#chars`.
+      #
+      # @example
+      #   # bad
+      #   str.chars[0..2]
+      #   str.chars.slice(0..2)
+      #
+      #   # good
+      #   str[0..2].chars
+      #
+      #   # bad
+      #   str.chars.first
+      #   str.chars.first(2)
+      #   str.chars.last
+      #   str.chars.last(2)
+      #
+      #   # good
+      #   str[0]
+      #   str[0...2].chars
+      #   str[-1]
+      #   str[-2..-1].chars
+      #
+      #   # bad
+      #   str.chars.take(2)
+      #   str.chars.drop(2)
+      #   str.chars.length
+      #   str.chars.size
+      #   str.chars.empty?
+      #
+      #   # good
+      #   str[0...2].chars
+      #   str[2..-1].chars
+      #   str.length
+      #   str.size
+      #   str.empty?
+      #
+      class RedundantStringChars < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        REPLACEABLE_METHODS = %i[[] slice first last take drop length size empty?].freeze
+
+        def_node_matcher :redundant_chars_call?, <<~PATTERN
+          (send $(send _ :chars) $#replaceable_method? $...)
+        PATTERN
+
+        def on_send(node)
+          redundant_chars_call?(node) do |receiver, method, args|
+            range = offense_range(receiver, node)
+            message = build_message(method, args)
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          redundant_chars_call?(node) do |receiver, method, args|
+            range = correction_range(receiver, node)
+            replacement = build_good_method(method, args)
+
+            lambda do |corrector|
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def replaceable_method?(method_name)
+          REPLACEABLE_METHODS.include?(method_name)
+        end
+
+        def offense_range(receiver, node)
+          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def correction_range(receiver, node)
+          range_between(receiver.loc.dot.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def build_message(method, args)
+          good_method = build_good_method(method, args)
+          bad_method = build_bad_method(method, args)
+          format(MSG, good_method: good_method, bad_method: bad_method)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def build_good_method(method, args)
+          case method
+          when :[], :slice
+            "[#{build_call_args(args)}].chars"
+          when :first
+            if args.any?
+              "[0...#{args.first.source}].chars"
+            else
+              '[0]'
+            end
+          when :last
+            if args.any?
+              "[-#{args.first.source}..-1].chars"
+            else
+              '[-1]'
+            end
+          when :take
+            "[0...#{args.first.source}].chars"
+          when :drop
+            "[#{args.first.source}..-1].chars"
+          else
+            ".#{method}"
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def build_bad_method(method, args)
+          case method
+          when :[]
+            "chars[#{build_call_args(args)}]"
+          else
+            if args.any?
+              "chars.#{method}(#{build_call_args(args)})"
+            else
+              "chars.#{method}"
+            end
+          end
+        end
+
+        def build_call_args(call_args_node)
+          call_args_node.map(&:source).join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -73,32 +73,28 @@ module RuboCop
       #     end
       #   end
       class RegexpMatch < Cop
-        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
         TYPES_IMPLEMENTING_MATCH = %i[const regexp str sym].freeze
         MSG = 'Use `match?` instead of `%<current>s` when `MatchData` ' \
           'is not used.'
 
-        def_node_matcher :match_method?, <<-PATTERN
+        def_node_matcher :match_method?, <<~PATTERN
           {
             (send _recv :match {regexp str sym})
             (send {regexp str sym} :match _)
           }
         PATTERN
 
-        def_node_matcher :match_with_int_arg_method?, <<-PATTERN
+        def_node_matcher :match_with_int_arg_method?, <<~PATTERN
           (send _recv :match _ (int ...))
         PATTERN
 
-        def_node_matcher :match_operator?, <<-PATTERN
+        def_node_matcher :match_operator?, <<~PATTERN
           (send !nil? {:=~ :!~} !nil?)
         PATTERN
 
-        def_node_matcher :match_threequals?, <<-PATTERN
+        def_node_matcher :match_threequals?, <<~PATTERN
           (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil?)
         PATTERN
 
@@ -109,7 +105,7 @@ module RuboCop
           regexp.to_regexp.named_captures.empty?
         end
 
-        MATCH_NODE_PATTERN = <<-PATTERN
+        MATCH_NODE_PATTERN = <<~PATTERN
           {
             #match_method?
             #match_with_int_arg_method?
@@ -122,7 +118,7 @@ module RuboCop
         def_node_matcher :match_node?, MATCH_NODE_PATTERN
         def_node_search :search_match_nodes, MATCH_NODE_PATTERN
 
-        def_node_search :last_matches, <<-PATTERN
+        def_node_search :last_matches, <<~PATTERN
           {
             (send (const nil? :Regexp) :last_match)
             (send (const nil? :Regexp) :last_match _)
@@ -256,6 +252,13 @@ module RuboCop
         def correct_operator(corrector, recv, arg, oper = nil)
           op_range = correction_range(recv, arg)
 
+          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 == :!~
+        end
+
+        def replace_with_match_predicate_method(corrector, recv, arg, op_range)
           if TYPES_IMPLEMENTING_MATCH.include?(recv.type)
             corrector.replace(op_range, '.match?(')
           elsif TYPES_IMPLEMENTING_MATCH.include?(arg.type)
@@ -264,9 +267,6 @@ module RuboCop
           else
             corrector.replace(op_range, '&.match?(')
           end
-
-          corrector.insert_after(arg.loc.expression, ')')
-          corrector.insert_before(recv.loc.expression, '!') if oper == :!~
         end
 
         def swap_receiver_and_arg(corrector, recv, arg)

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

@@ -18,7 +18,7 @@ module RuboCop
         MSG = 'Use `reverse_each` instead of `reverse.each`.'
         UNDERSCORE = '_'
 
-        def_node_matcher :reverse_each?, <<-MATCHER
+        def_node_matcher :reverse_each?, <<~MATCHER
           (send $(send _ :reverse) :each)
         MATCHER
 
@@ -34,7 +34,8 @@ module RuboCop
         end
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
+          range = range_between(node.loc.dot.begin_pos, node.loc.selector.begin_pos)
+          ->(corrector) { corrector.replace(range, UNDERSCORE) }
         end
       end
     end