rubocop-performance 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00b98a3d2af1bcfd781dfab24e4a8deb118d29fdaedeca8b2d404ff03eab3529
-  data.tar.gz: cc5508a731d9c932d2c141892aefbe15f635d18bdd95ae6ad5b4998c931fcaf2
+  metadata.gz: f1f4841e8542a1f77f21d30ffe7c26019b9f2fb7308a985780506f1920146045
+  data.tar.gz: ed95379cd20af662ce6ce9ce4e64721ca156a6d7b62e511774df9d6abe3c9bae
 SHA512:
-  metadata.gz: 806f21556b5e791a6a00866714c4feec42726b20d4c82db7c4cd89ec576624eaac3007f4a68fca4fd633fbc3ed7a41801fdb0dfc64f767ee241582a4185bbb8b
-  data.tar.gz: 1e922a3d51a62df60cdb26f99960fec91e1fa558ceea751bcce7ec529f7d4db6e1644d0dfd24848cb75e384e08fd6a3f2afaaa8f531a1118a09d35d6fa1b0e21
+  metadata.gz: 10a1e89448abd75234807bbdd9be67b10e4b9a837d2d2d711adeb0a0d105b921d722dfcac0c46e30f55f278afc2960f888407959543097d81df4f1aa3667fac6
+  data.tar.gz: 668784bfe08775a1e8917806ef9f34d7dcb3f7581a9080ea14a44a54b43cf7e6516db4f5c4e015718824c32a8b045f43b429c8e1d3864960f41ead8684fbb5f5

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

@@ -115,7 +115,7 @@ module RuboCop
 
         def node_within_enumerable_loop?(node, ancestor)
           enumerable_loop?(ancestor) do |receiver|
-            receiver != node && !receiver.descendants.include?(node)
+            receiver != node && !receiver&.descendants&.include?(node)
           end
         end
 

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of
-      # `select.first`, `select.last`, `find_all.first`, `find_all.last`, `filter.first`, and `filter.last`
+      # This cop is used to identify usages of `first`, `last`, `[0]` or `[-1]`
+      # chained to `select`, `find_all`, or `find_all`
       # and change them to use `detect` instead.
       #
       # @example
@@ -15,6 +15,8 @@ module RuboCop
       #   [].find_all { |item| true }.last
       #   [].filter { |item| true }.first
       #   [].filter { |item| true }.last
+      #   [].filter { |item| true }[0]
+      #   [].filter { |item| true }[-1]
       #
       #   # good
       #   [].detect { |item| true }
@@ -27,27 +29,40 @@ module RuboCop
       class Detect < Base
         extend AutoCorrector
 
+        CANDIDATE_METHODS = Set[:select, :find_all, :filter].freeze
+
         MSG = 'Use `%<prefer>s` instead of ' \
               '`%<first_method>s.%<second_method>s`.'
         REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
                       '`%<first_method>s.%<second_method>s`.'
+        INDEX_MSG = 'Use `%<prefer>s` instead of ' \
+              '`%<first_method>s[%<index>i]`.'
+        INDEX_REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
+              '`%<first_method>s[%<index>i]`.'
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ {:select :find_all :filter}) ...) ${:first :last} $...)
-            (send $(send _ {:select :find_all :filter} ...) ${:first :last} $...)
+            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
+            (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
+            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
+            (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
           }
         PATTERN
 
         def on_send(node)
           detect_candidate?(node) do |receiver, second_method, args|
+            if second_method == :[]
+              index = args
+              args = {}
+            end
+
             return unless args.empty?
             return unless receiver
 
             receiver, _args, body = *receiver if receiver.block_type?
             return if accept_first_call?(receiver, body)
 
-            register_offense(node, receiver, second_method)
+            register_offense(node, receiver, second_method, index)
           end
         end
 
@@ -62,28 +77,31 @@ module RuboCop
           lazy?(caller)
         end
 
-        def register_offense(node, receiver, second_method)
+        def register_offense(node, receiver, second_method, index)
           _caller, first_method, _args = *receiver
           range = receiver.loc.selector.join(node.loc.selector)
 
-          message = second_method == :last ? REVERSE_MSG : MSG
+          message = message_for_method(second_method, index)
           formatted_message = format(message, prefer: preferred_method,
                                               first_method: first_method,
-                                              second_method: second_method)
+                                              second_method: second_method,
+                                              index: index)
 
           add_offense(range, message: formatted_message) do |corrector|
-            autocorrect(corrector, node)
+            autocorrect(corrector, node, replacement(second_method, index))
           end
         end
 
-        def autocorrect(corrector, node)
-          receiver, first_method = *node
+        def replacement(method, index)
+          if method == :last || method == :[] && index == -1
+            "reverse.#{preferred_method}"
+          else
+            preferred_method
+          end
+        end
 
-          replacement = if first_method == :last
-                          "reverse.#{preferred_method}"
-                        else
-                          preferred_method
-                        end
+        def autocorrect(corrector, node, replacement)
+          receiver, _first_method = *node
 
           first_range = receiver.source_range.end.join(node.loc.selector)
 
@@ -93,6 +111,17 @@ module RuboCop
           corrector.replace(receiver.loc.selector, replacement)
         end
 
+        def message_for_method(method, index)
+          case method
+          when :[]
+            index == -1 ? INDEX_REVERSE_MSG : INDEX_MSG
+          when :last
+            REVERSE_MSG
+          else
+            MSG
+          end
+        end
+
         def preferred_method
           config.for_cop('Style/CollectionMethods')['PreferredMethods']['detect'] || 'detect'
         end

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

@@ -10,6 +10,7 @@ module RuboCop
       #   # bad
       #   [1, 2, 3].inject(:+)
       #   [1, 2, 3].reduce(10, :+)
+      #   [1, 2, 3].inject(&:+)
       #   [1, 2, 3].reduce { |acc, elem| acc + elem }
       #
       #   # good
@@ -24,7 +25,7 @@ module RuboCop
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
 
         def_node_matcher :sum_candidate?, <<~PATTERN
-          (send _ ${:inject :reduce} $_init ? (sym :+))
+          (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
         PATTERN
 
         def_node_matcher :sum_with_block_candidate?, <<~PATTERN
@@ -40,9 +41,9 @@ module RuboCop
         alias elem_plus_acc? acc_plus_elem?
 
         def on_send(node)
-          sum_candidate?(node) do |method, init|
+          sum_candidate?(node) do |method, init, operation|
             range = sum_method_range(node)
-            message = build_method_message(method, init)
+            message = build_method_message(method, init, operation)
 
             add_offense(range, message: message) do |corrector|
               autocorrect(corrector, init, range)
@@ -81,9 +82,9 @@ module RuboCop
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end
 
-        def build_method_message(method, init)
+        def build_method_message(method, init, operation)
           good_method = build_good_method(init)
-          bad_method = build_method_bad_method(init, method)
+          bad_method = build_method_bad_method(init, method, operation)
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
@@ -98,18 +99,22 @@ module RuboCop
 
           unless init.empty?
             init = init.first
-            good_method += "(#{init.source})" if init.source.to_i != 0
+            good_method += "(#{init.source})" unless init.int_type? && init.value.zero?
           end
           good_method
         end
 
-        def build_method_bad_method(init, method)
+        def build_method_bad_method(init, method, operation)
           bad_method = "#{method}("
           unless init.empty?
             init = init.first
             bad_method += "#{init.source}, "
           end
-          bad_method += ':+)'
+          bad_method += if operation.block_pass_type?
+                          '&:+)'
+                        else
+                          ':+)'
+                        end
           bad_method
         end
 

data/lib/rubocop/performance/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Performance
     module Version
-      STRING = '1.8.0'
+      STRING = '1.8.1'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-04 00:00:00.000000000 Z
+date: 2020-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -26,6 +26,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.87.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement