rubocop-performance 1.5.2 → 1.8.1

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

@@ -17,18 +17,20 @@ module RuboCop
       #   # good
       #   method(str =~ /regex/)
       #   return value unless regex =~ 'str'
-      class RedundantMatch < Cop
+      class RedundantMatch < Base
+        extend AutoCorrector
+
         MSG = 'Use `=~` in places where the `MatchData` returned by ' \
               '`#match` will not be used.'
 
         # '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
 
@@ -37,18 +39,21 @@ module RuboCop
                         (!node.value_used? || only_truthiness_matters?(node)) &&
                         !(node.parent && node.parent.block_type?)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           # Regexp#match can take a second argument, but this cop doesn't
           # register an offense in that case
           return unless node.first_argument.regexp_type?
 
-          new_source =
-            node.receiver.source + ' =~ ' + node.first_argument.source
+          new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
 
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+          corrector.replace(node.source_range, new_source)
         end
       end
     end

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

@@ -5,12 +5,28 @@ 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)
-      class RedundantMerge < Cop
+      #
+      #   # good
+      #   hash[:a] = 1
+      #   hash[:b] = 2
+      class RedundantMerge < Base
+        extend AutoCorrector
+
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -20,28 +36,27 @@ 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
 
         def on_send(node)
           each_redundant_merge(node) do |redundant_merge_node|
-            add_offense(redundant_merge_node)
-          end
-        end
-
-        def autocorrect(node)
-          redundant_merge_candidate(node) do |receiver, pairs|
-            new_source = to_assignments(receiver, pairs).join("\n")
-
-            if node.parent && pairs.size > 1
-              correct_multiple_elements(node, node.parent, new_source)
-            else
-              correct_single_element(node, new_source)
+            message = message(node)
+            add_offense(redundant_merge_node, message: message) do |corrector|
+              redundant_merge_candidate(node) do |receiver, pairs|
+                new_source = to_assignments(receiver, pairs).join("\n")
+
+                if node.parent && pairs.size > 1
+                  correct_multiple_elements(corrector, node, node.parent, new_source)
+                else
+                  correct_single_element(corrector, node, new_source)
+                end
+              end
             end
           end
         end
@@ -84,7 +99,7 @@ module RuboCop
             !EachWithObjectInspector.new(node, receiver).value_used?
         end
 
-        def correct_multiple_elements(node, parent, new_source)
+        def correct_multiple_elements(corrector, node, parent, new_source)
           if modifier_flow_control?(parent)
             new_source = rewrite_with_modifier(node, parent, new_source)
             node = parent
@@ -93,11 +108,11 @@ module RuboCop
             new_source.gsub!(/\n/, padding)
           end
 
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+          corrector.replace(node.source_range, new_source)
         end
 
-        def correct_single_element(node, new_source)
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        def correct_single_element(corrector, node, new_source)
+          corrector.replace(node.source_range, new_source)
         end
 
         def to_assignments(receiver, pairs)
@@ -168,13 +183,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,43 @@
+# 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 < Base
+        include SortBlock
+        extend AutoCorrector
+
+        MSG = 'Use `sort` instead of `%<bad_method>s`.'
+
+        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)
+
+            add_offense(range, message: message(var_a, var_b)) do |corrector|
+              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,133 @@
+# 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 < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        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)
+          return unless (receiver, method, args = redundant_chars_call?(node))
+
+          range = offense_range(receiver, node)
+          message = build_message(method, args)
+
+          add_offense(range, message: message) do |corrector|
+            range = correction_range(receiver, node)
+            replacement = build_good_method(method, args)
+
+            corrector.replace(range, replacement)
+          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

@@ -72,10 +72,8 @@ module RuboCop
       #       do_something($~)
       #     end
       #   end
-      class RegexpMatch < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
+      class RegexpMatch < Base
+        extend AutoCorrector
 
         # Constants are included in this list because it is unlikely that
         # someone will store `nil` as a constant and then use it for comparison
@@ -83,22 +81,22 @@ module RuboCop
         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 +107,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 +120,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 _)
@@ -145,27 +143,28 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if match_method?(node) || match_with_int_arg_method?(node)
-              corrector.replace(node.loc.selector, 'match?')
-            elsif match_operator?(node) || match_threequals?(node)
-              recv, oper, arg = *node
-              correct_operator(corrector, recv, arg, oper)
-            elsif match_with_lvasgn?(node)
-              recv, arg = *node
-              correct_operator(corrector, recv, arg)
-            end
-          end
-        end
-
         private
 
         def check_condition(cond)
           match_node?(cond) do
             return if last_match_used?(cond)
 
-            add_offense(cond)
+            message = message(cond)
+            add_offense(cond, message: message) do |corrector|
+              autocorrect(corrector, cond)
+            end
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if match_method?(node) || match_with_int_arg_method?(node)
+            corrector.replace(node.loc.selector, 'match?')
+          elsif match_operator?(node) || match_threequals?(node)
+            recv, oper, arg = *node
+            correct_operator(corrector, recv, arg, oper)
+          elsif match_with_lvasgn?(node)
+            recv, arg = *node
+            correct_operator(corrector, recv, arg)
           end
         end
 
@@ -235,10 +234,7 @@ module RuboCop
 
         def scope_root(node)
           node.each_ancestor.find do |ancestor|
-            ancestor.def_type? ||
-              ancestor.defs_type? ||
-              ancestor.class_type? ||
-              ancestor.module_type?
+            ancestor.def_type? || ancestor.defs_type? || ancestor.class_type? || ancestor.module_type?
           end
         end
 
@@ -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)