rubocop-performance 1.7.0 → 1.9.1

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where custom code finding the sum of elements
+      # in some Enumerable object can be replaced by `Enumerable#sum` method.
+      #
+      # This cop can change auto-correction scope depending on the value of
+      # `SafeAutoCorrect`.
+      # Its auto-correction is marked as safe by default (`SafeAutoCorrect: true`)
+      # to prevent `TypeError` in auto-correced code when initial value is not
+      # specified as shown below:
+      #
+      # [source,ruby]
+      # ----
+      # ['a', 'b'].sum # => (String can't be coerced into Integer)
+      # ----
+      #
+      # Therefore if initial value is not specified, unsafe auto-corrected will not occur.
+      #
+      # If you always want to enable auto-correction, you can set `SafeAutoCorrect: false`.
+      #
+      # [source,yaml]
+      # ----
+      # Performance/Sum:
+      #   SafeAutoCorrect: false
+      # ----
+      #
+      # Please note that the auto-correction command line option will be changed from
+      # `rubocop -a` to `rubocop -A`, which includes unsafe auto-correction.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].inject(:+)                        # These bad cases with no initial value are unsafe and
+      #   [1, 2, 3].inject(&:+)                       # will not be auto-correced by default. If you want to
+      #   [1, 2, 3].reduce { |acc, elem| acc + elem } # auto-corrected, you can set `SafeAutoCorrect: false`.
+      #   [1, 2, 3].reduce(10, :+)
+      #   [1, 2, 3].map { |elem| elem ** 2 }.sum
+      #   [1, 2, 3].collect(&:count).sum(10)
+      #
+      #   # good
+      #   [1, 2, 3].sum
+      #   [1, 2, 3].sum(10)
+      #   [1, 2, 3].sum { |elem| elem ** 2 }
+      #   [1, 2, 3].sum(10, &:count)
+      #
+      class Sum < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        MSG_IF_NO_INIT_VALUE =
+          'Use `%<good_method>s` instead of `%<bad_method>s`, unless calling `%<bad_method>s` on an empty array.'
+        RESTRICT_ON_SEND = %i[inject reduce sum].freeze
+
+        def_node_matcher :sum_candidate?, <<~PATTERN
+          (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
+        PATTERN
+
+        def_node_matcher :sum_map_candidate?, <<~PATTERN
+          (send
+            {
+              (block $(send _ {:map :collect}) ...)
+              $(send _ {:map :collect} (block_pass _))
+            }
+          :sum $_init ?)
+        PATTERN
+
+        def_node_matcher :sum_with_block_candidate?, <<~PATTERN
+          (block
+            $(send _ {:inject :reduce} $_init ?)
+            (args (arg $_acc) (arg $_elem))
+            $send)
+        PATTERN
+
+        def_node_matcher :acc_plus_elem?, <<~PATTERN
+          (send (lvar %1) :+ (lvar %2))
+        PATTERN
+        alias elem_plus_acc? acc_plus_elem?
+
+        def on_send(node)
+          return if empty_array_literal?(node)
+
+          handle_sum_candidate(node)
+          handle_sum_map_candidate(node)
+        end
+
+        def on_block(node)
+          sum_with_block_candidate?(node) do |send, init, var_acc, var_elem, body|
+            if acc_plus_elem?(body, var_acc, var_elem) || elem_plus_acc?(body, var_elem, var_acc)
+              range = sum_block_range(send, node)
+              message = build_block_message(send, init, var_acc, var_elem, body)
+
+              add_offense(range, message: message) do |corrector|
+                autocorrect(corrector, init, range)
+              end
+            end
+          end
+        end
+
+        private
+
+        def handle_sum_candidate(node)
+          sum_candidate?(node) do |method, init, operation|
+            range = sum_method_range(node)
+            message = build_method_message(node, method, init, operation)
+
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, init, range)
+            end
+          end
+        end
+
+        def handle_sum_map_candidate(node)
+          sum_map_candidate?(node) do |map, init|
+            next if node.block_literal? || node.block_argument?
+
+            message = build_sum_map_message(map.method_name, init)
+
+            add_offense(sum_map_range(map, node), message: message) do |corrector|
+              autocorrect_sum_map(corrector, node, map, init)
+            end
+          end
+        end
+
+        def empty_array_literal?(node)
+          receiver = node.children.first
+          array_literal?(node) && receiver && receiver.children.empty?
+        end
+
+        def array_literal?(node)
+          receiver = node.children.first
+          receiver&.literal? && receiver&.array_type?
+        end
+
+        def autocorrect(corrector, init, range)
+          return if init.empty? && safe_autocorrect?
+
+          replacement = build_good_method(init)
+
+          corrector.replace(range, replacement)
+        end
+
+        def autocorrect_sum_map(corrector, sum, map, init)
+          sum_range = method_call_with_args_range(sum)
+          map_range = method_call_with_args_range(map)
+
+          block_pass = map.last_argument if map.last_argument&.block_pass_type?
+          replacement = build_good_method(init, block_pass)
+
+          corrector.remove(sum_range)
+          corrector.replace(map_range, ".#{replacement}")
+        end
+
+        def sum_method_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def sum_map_range(map, sum)
+          range_between(map.loc.selector.begin_pos, sum.source_range.end.end_pos)
+        end
+
+        def sum_block_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def build_method_message(node, method, init, operation)
+          good_method = build_good_method(init)
+          bad_method = build_method_bad_method(init, method, operation)
+          msg = if init.empty? && !array_literal?(node)
+                  MSG_IF_NO_INIT_VALUE
+                else
+                  MSG
+                end
+          format(msg, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_sum_map_message(method, init)
+          sum_method = build_good_method(init)
+          good_method = "#{sum_method} { ... }"
+          bad_method = "#{method} { ... }.#{sum_method}"
+          format(MSG, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_block_message(send, init, var_acc, var_elem, body)
+          good_method = build_good_method(init)
+          bad_method = build_block_bad_method(send.method_name, init, var_acc, var_elem, body)
+          format(MSG, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_good_method(init, block_pass = nil)
+          good_method = 'sum'
+
+          args = []
+          unless init.empty?
+            init = init.first
+            args << init.source unless init.int_type? && init.value.zero?
+          end
+          args << block_pass.source if block_pass
+          good_method += "(#{args.join(', ')})" unless args.empty?
+          good_method
+        end
+
+        def build_method_bad_method(init, method, operation)
+          bad_method = "#{method}("
+          unless init.empty?
+            init = init.first
+            bad_method += "#{init.source}, "
+          end
+          bad_method += if operation.block_pass_type?
+                          '&:+)'
+                        else
+                          ':+)'
+                        end
+          bad_method
+        end
+
+        def build_block_bad_method(method, init, var_acc, var_elem, body)
+          bad_method = method.to_s
+
+          unless init.empty?
+            init = init.first
+            bad_method += "(#{init.source})"
+          end
+          bad_method += " { |#{var_acc}, #{var_elem}| #{body.source} }"
+          bad_method
+        end
+
+        def method_call_with_args_range(node)
+          node.receiver.source_range.end.join(node.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -17,10 +17,13 @@ module RuboCop
       #   Array.new(9) do |i|
       #     i.to_s
       #   end
-      class TimesMap < Cop
+      class TimesMap < Base
+        extend AutoCorrector
+
         MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
                   'instead of `.times.%<map_or_collect>s`'
         MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'
+        RESTRICT_ON_SEND = %i[map collect].freeze
 
         def on_send(node)
           check(node)
@@ -30,35 +33,26 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          map_or_collect, count = times_map_call(node)
-
-          replacement =
-            "Array.new(#{count.source}" \
-            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
-
-          lambda do |corrector|
-            corrector.replace(map_or_collect.loc.expression, replacement)
-          end
-        end
-
         private
 
         def check(node)
           times_map_call(node) do |map_or_collect, count|
-            add_offense(node, message: message(map_or_collect, count))
+            add_offense(node, message: message(map_or_collect, count)) do |corrector|
+              replacement = "Array.new(#{count.source}" \
+                            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
+
+              corrector.replace(map_or_collect.loc.expression, replacement)
+            end
           end
         end
 
         def message(map_or_collect, count)
           template = if count.literal?
-                       MESSAGE + '.'
+                       "#{MESSAGE}."
                      else
                        "#{MESSAGE} #{MESSAGE_ONLY_IF}."
                      end
-          format(template,
-                 count: count.source,
-                 map_or_collect: map_or_collect.method_name)
+          format(template, count: count.source, map_or_collect: map_or_collect.method_name)
         end
 
         def_node_matcher :times_map_call, <<~PATTERN

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

@@ -10,6 +10,7 @@ module RuboCop
       # NOTE: `String.new` (without operator) is not exactly the same as `+''`.
       # These differ in encoding. `String.new.encoding` is always `ASCII-8BIT`.
       # However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
+      # Therefore, auto-correction is unsafe.
       # So, if you expect `ASCII-8BIT` encoding, disable this cop.
       #
       # @example
@@ -23,8 +24,11 @@ module RuboCop
       #   # good
       #   +'something'
       #   +''
-      class UnfreezeString < Cop
+      class UnfreezeString < Base
+        extend AutoCorrector
+
         MSG = 'Use unary plus to get an unfrozen string literal.'
+        RESTRICT_ON_SEND = %i[dup new].freeze
 
         def_node_matcher :dup_string?, <<~PATTERN
           (send {str dstr} :dup)
@@ -38,7 +42,21 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if dup_string?(node) || string_new?(node)
+          return unless dup_string?(node) || string_new?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "+#{string_value(node)}")
+          end
+        end
+
+        private
+
+        def string_value(node)
+          if node.receiver.source == 'String' && node.method?(:new)
+            node.arguments.empty? ? "''" : node.first_argument.source
+          else
+            node.receiver.source
+          end
         end
       end
     end

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

@@ -13,9 +13,12 @@ module RuboCop
       #   # good
       #   URI::DEFAULT_PARSER
       #
-      class UriDefaultParser < Cop
+      class UriDefaultParser < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of ' \
               '`%<double_colon>sURI::Parser.new`.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :uri_parser_new?, <<~PATTERN
           (send
@@ -28,17 +31,9 @@ module RuboCop
             double_colon = captured_value ? '::' : ''
             message = format(MSG, double_colon: double_colon)
 
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            double_colon = uri_parser_new?(node) ? '::' : ''
-
-            corrector.replace(
-              node.loc.expression, "#{double_colon}URI::DEFAULT_PARSER"
-            )
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node.loc.expression, "#{double_colon}URI::DEFAULT_PARSER")
+            end
           end
         end
       end

data/lib/rubocop/cop/performance_cops.rb

@@ -4,12 +4,16 @@ require_relative 'mixin/regexp_metacharacter'
 require_relative 'mixin/sort_block'
 
 require_relative 'performance/ancestors_include'
+require_relative 'performance/array_semi_infinite_range_slice'
 require_relative 'performance/big_decimal_with_numeric_argument'
 require_relative 'performance/bind_call'
+require_relative 'performance/block_given_with_explicit_block'
 require_relative 'performance/caller'
 require_relative 'performance/case_when_splat'
 require_relative 'performance/casecmp'
+require_relative 'performance/collection_literal_in_loop'
 require_relative 'performance/compare_with_block'
+require_relative 'performance/constant_regexp'
 require_relative 'performance/count'
 require_relative 'performance/delete_prefix'
 require_relative 'performance/delete_suffix'
@@ -19,6 +23,7 @@ require_relative 'performance/end_with'
 require_relative 'performance/fixed_size'
 require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
+require_relative 'performance/method_object_as_block'
 require_relative 'performance/open_struct'
 require_relative 'performance/range_include'
 require_relative 'performance/io_readlines'
@@ -36,6 +41,7 @@ require_relative 'performance/squeeze'
 require_relative 'performance/start_with'
 require_relative 'performance/string_include'
 require_relative 'performance/string_replacement'
+require_relative 'performance/sum'
 require_relative 'performance/times_map'
 require_relative 'performance/unfreeze_string'
 require_relative 'performance/uri_default_parser'

data/lib/rubocop/performance/version.rb

@@ -2,8 +2,13 @@
 
 module RuboCop
   module Performance
+    # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.7.0'
+      STRING = '1.9.1'
+
+      def self.document_version
+        STRING.match('\d+\.\d+').to_s
+      end
     end
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.9.1
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-07 00:00:00.000000000 Z
+date: 2020-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -18,28 +18,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.82.0
+        version: 0.90.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.82.0
+        version: 0.90.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rubocop-ast
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 0.4.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
 description: |
   A collection of RuboCop cops to check for performance optimizations
   in Ruby code.
@@ -57,13 +63,17 @@ files:
 - lib/rubocop/cop/mixin/regexp_metacharacter.rb
 - lib/rubocop/cop/mixin/sort_block.rb
 - lib/rubocop/cop/performance/ancestors_include.rb
+- lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb
 - lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb
 - lib/rubocop/cop/performance/bind_call.rb
+- lib/rubocop/cop/performance/block_given_with_explicit_block.rb
 - lib/rubocop/cop/performance/caller.rb
 - lib/rubocop/cop/performance/case_when_splat.rb
 - lib/rubocop/cop/performance/casecmp.rb
 - lib/rubocop/cop/performance/chain_array_allocation.rb
+- lib/rubocop/cop/performance/collection_literal_in_loop.rb
 - lib/rubocop/cop/performance/compare_with_block.rb
+- lib/rubocop/cop/performance/constant_regexp.rb
 - lib/rubocop/cop/performance/count.rb
 - lib/rubocop/cop/performance/delete_prefix.rb
 - lib/rubocop/cop/performance/delete_suffix.rb
@@ -74,6 +84,7 @@ files:
 - lib/rubocop/cop/performance/flat_map.rb
 - lib/rubocop/cop/performance/inefficient_hash_search.rb
 - lib/rubocop/cop/performance/io_readlines.rb
+- lib/rubocop/cop/performance/method_object_as_block.rb
 - lib/rubocop/cop/performance/open_struct.rb
 - lib/rubocop/cop/performance/range_include.rb
 - lib/rubocop/cop/performance/redundant_block_call.rb
@@ -90,6 +101,7 @@ files:
 - lib/rubocop/cop/performance/start_with.rb
 - lib/rubocop/cop/performance/string_include.rb
 - lib/rubocop/cop/performance/string_replacement.rb
+- lib/rubocop/cop/performance/sum.rb
 - lib/rubocop/cop/performance/times_map.rb
 - lib/rubocop/cop/performance/unfreeze_string.rb
 - lib/rubocop/cop/performance/uri_default_parser.rb
@@ -104,9 +116,9 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
   changelog_uri: https://github.com/rubocop-hq/rubocop-performance/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop-hq/rubocop-performance/
-  documentation_uri: https://docs.rubocop.org/rubocop-performance/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.9/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop-performance/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -121,8 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.0.rc.2
+signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.
 test_files: []