rubocop-performance 1.5.2 → 1.8.0

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)

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

@@ -12,13 +12,14 @@ module RuboCop
       #
       #   # good
       #   [].reverse_each
-      class ReverseEach < Cop
+      class ReverseEach < Base
         include RangeHelp
+        extend AutoCorrector
 
         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
 
@@ -29,12 +30,16 @@ module RuboCop
 
             range = range_between(location_of_reverse, end_location)
 
-            add_offense(node, location: range)
+            add_offense(range) do |corrector|
+              corrector.replace(replacement_range(node), UNDERSCORE)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
+        private
+
+        def replacement_range(node)
+          range_between(node.loc.dot.begin_pos, node.loc.selector.begin_pos)
         end
       end
     end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `reverse.first(n)` and `reverse.first`
+      # can be replaced by `last(n).reverse` and `last`.
+      #
+      # @example
+      #
+      #   # bad
+      #   array.reverse.first(5)
+      #   array.reverse.first
+      #
+      #   # good
+      #   array.last(5).reverse
+      #   array.last
+      #
+      class ReverseFirst < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        def_node_matcher :reverse_first_candidate?, <<~PATTERN
+          (send $(send _ :reverse) :first (int _)?)
+        PATTERN
+
+        def on_send(node)
+          reverse_first_candidate?(node) do |receiver|
+            range = correction_range(receiver, node)
+            message = build_message(node)
+
+            add_offense(range, message: message) do |corrector|
+              replacement = build_good_method(node)
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def correction_range(receiver, node)
+          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def build_message(node)
+          good_method = build_good_method(node)
+          bad_method = build_bad_method(node)
+          format(MSG, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_good_method(node)
+          if node.arguments?
+            "last(#{node.arguments.first.source}).reverse"
+          else
+            'last'
+          end
+        end
+
+        def build_bad_method(node)
+          if node.arguments?
+            "reverse.first(#{node.arguments.first.source})"
+          else
+            'reverse.first'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,67 +9,65 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2, 3].count
+      #   (1..3).to_a.count
+      #   Array[*1..3].count
+      #   Array(1..3).count
       #
       #   # bad
       #   {a: 1, b: 2, c: 3}.count
+      #   [[:foo, :bar], [1, 2]].to_h.count
+      #   Hash[*('a'..'z')].count
+      #   Hash(key: :value).count
       #
       #   # good
       #   [1, 2, 3].size
+      #   (1..3).to_a.size
+      #   Array[*1..3].size
+      #   Array(1..3).size
       #
       #   # good
       #   {a: 1, b: 2, c: 3}.size
+      #   [[:foo, :bar], [1, 2]].to_h.size
+      #   Hash[*('a'..'z')].size
+      #   Hash(key: :value).size
       #
       #   # good
       #   [1, 2, 3].count { |e| e > 2 }
       # TODO: Add advanced detection of variables that could
       # have been assigned to an array or a hash.
-      class Size < Cop
-        MSG = 'Use `size` instead of `count`.'
-
-        def on_send(node)
-          return unless eligible_node?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'size') }
-        end
-
-        private
-
-        def eligible_node?(node)
-          return false unless node.method?(:count) && !node.arguments?
-
-          eligible_receiver?(node.receiver) && !allowed_parent?(node.parent)
-        end
+      class Size < Base
+        extend AutoCorrector
 
-        def eligible_receiver?(node)
-          return false unless node
-
-          array?(node) || hash?(node)
-        end
-
-        def allowed_parent?(node)
-          node&.block_type?
-        end
-
-        def array?(node)
-          return true if node.array_type?
-          return false unless node.send_type?
-
-          _, constant = *node.receiver
-
-          constant == :Array || node.method?(:to_a)
-        end
+        MSG = 'Use `size` instead of `count`.'
 
-        def hash?(node)
-          return true if node.hash_type?
-          return false unless node.send_type?
+        def_node_matcher :array?, <<~PATTERN
+          {
+            [!nil? array_type?]
+            (send _ :to_a)
+            (send (const nil? :Array) :[] _)
+            (send nil? :Array _)
+          }
+        PATTERN
+
+        def_node_matcher :hash?, <<~PATTERN
+          {
+            [!nil? hash_type?]
+            (send _ :to_h)
+            (send (const nil? :Hash) :[] _)
+            (send nil? :Hash _)
+          }
+        PATTERN
+
+        def_node_matcher :count?, <<~PATTERN
+          (send {#array? #hash?} :count)
+        PATTERN
 
-          _, constant = *node.receiver
+        def on_send(node)
+          return if node.parent&.block_type? || !count?(node)
 
-          constant == :Hash || node.method?(:to_h)
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'size')
+          end
         end
       end
     end