rubocop-performance 1.5.2 → 1.8.1

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

@@ -18,17 +18,17 @@ module RuboCop
       #   'abc'.gsub(/a+/, 'd')
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
-      class StringReplacement < Cop
+      class StringReplacement < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
         DELETE = 'delete'
         TR = 'tr'
         BANG = '!'
-        SINGLE_QUOTE = "'"
 
-        def_node_matcher :string_replacement?, <<-PATTERN
+        def_node_matcher :string_replacement?, <<~PATTERN
           (send _ {:gsub :gsub!}
                     ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
                     $str)
@@ -43,37 +43,37 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          _string, _method, first_param, second_param = *node
+        private
+
+        def offense(node, first_param, second_param)
           first_source, = first_source(first_param)
+          first_source = interpret_string_escapes(first_source) unless first_param.str_type?
           second_source, = *second_param
+          message = message(node, first_source, second_source)
 
-          unless first_param.str_type?
-            first_source = interpret_string_escapes(first_source)
+          add_offense(range(node), message: message) do |corrector|
+            autocorrect(corrector, node)
           end
+        end
 
-          replacement_method =
-            replacement_method(node, first_source, second_source)
+        def autocorrect(corrector, node)
+          _string, _method, first_param, second_param = *node
+          first_source, = first_source(first_param)
+          second_source, = *second_param
 
-          replace_method(node, first_source, second_source, first_param,
-                         replacement_method)
-        end
+          first_source = interpret_string_escapes(first_source) unless first_param.str_type?
 
-        def replace_method(node, first, second, first_param, replacement)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement)
-            unless first_param.str_type?
-              corrector.replace(first_param.source_range,
-                                to_string_literal(first))
-            end
-
-            if second.empty? && first.length == 1
-              remove_second_param(corrector, node, first_param)
-            end
-          end
+          replace_method(corrector, node, first_source, second_source, first_param)
         end
 
-        private
+        def replace_method(corrector, node, first_source, second_source, first_param)
+          replacement_method = replacement_method(node, first_source, second_source)
+
+          corrector.replace(node.loc.selector, replacement_method)
+          corrector.replace(first_param.source_range, to_string_literal(first_source)) unless first_param.str_type?
+
+          remove_second_param(corrector, node, first_param) if second_source.empty? && first_source.length == 1
+        end
 
         def accept_second_param?(second_param)
           second_source, = *second_param
@@ -97,17 +97,6 @@ module RuboCop
           first_source.length != 1
         end
 
-        def offense(node, first_param, second_param)
-          first_source, = first_source(first_param)
-          unless first_param.str_type?
-            first_source = interpret_string_escapes(first_source)
-          end
-          second_source, = *second_param
-          message = message(node, first_source, second_source)
-
-          add_offense(node, location: range(node), message: message)
-        end
-
         def first_source(first_param)
           case first_param.type
           when :regexp

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

@@ -0,0 +1,134 @@
+# 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.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].inject(:+)
+      #   [1, 2, 3].reduce(10, :+)
+      #   [1, 2, 3].inject(&:+)
+      #   [1, 2, 3].reduce { |acc, elem| acc + elem }
+      #
+      #   # good
+      #   [1, 2, 3].sum
+      #   [1, 2, 3].sum(10)
+      #   [1, 2, 3].sum
+      #
+      class Sum < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        def_node_matcher :sum_candidate?, <<~PATTERN
+          (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
+        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)
+          sum_candidate?(node) do |method, init, operation|
+            range = sum_method_range(node)
+            message = build_method_message(method, init, operation)
+
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, init, range)
+            end
+          end
+        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 autocorrect(corrector, init, range)
+          return if init.empty?
+
+          replacement = build_good_method(init)
+
+          corrector.replace(range, replacement)
+        end
+
+        def sum_method_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.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(method, init, operation)
+          good_method = build_good_method(init)
+          bad_method = build_method_bad_method(init, method, operation)
+          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)
+          good_method = 'sum'
+
+          unless init.empty?
+            init = init.first
+            good_method += "(#{init.source})" unless init.int_type? && init.value.zero?
+          end
+          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
+      end
+    end
+  end
+end

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

@@ -17,7 +17,9 @@ 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'
@@ -30,38 +32,29 @@ 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
+        def_node_matcher :times_map_call, <<~PATTERN
           {(block $(send (send $!nil? :times) {:map :collect}) ...)
            $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
         PATTERN

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

@@ -7,7 +7,7 @@ module RuboCop
       # literal instead of `String#dup` and `String.new`.
       # Unary plus operator is faster than `String#dup`.
       #
-      # Note: `String.new` (without operator) is not exactly the same as `+''`.
+      # 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`).
       # So, if you expect `ASCII-8BIT` encoding, disable this cop.
@@ -23,18 +23,14 @@ module RuboCop
       #   # good
       #   +'something'
       #   +''
-      class UnfreezeString < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.3
-
+      class UnfreezeString < Base
         MSG = 'Use unary plus to get an unfrozen string literal.'
 
-        def_node_matcher :dup_string?, <<-PATTERN
+        def_node_matcher :dup_string?, <<~PATTERN
           (send {str dstr} :dup)
         PATTERN
 
-        def_node_matcher :string_new?, <<-PATTERN
+        def_node_matcher :string_new?, <<~PATTERN
           {
             (send (const nil? :String) :new {str dstr})
             (send (const nil? :String) :new)

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

@@ -13,11 +13,13 @@ 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`.'
 
-        def_node_matcher :uri_parser_new?, <<-PATTERN
+        def_node_matcher :uri_parser_new?, <<~PATTERN
           (send
             (const
               (const ${nil? cbase} :URI) :Parser) :new)
@@ -28,17 +30,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

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'mixin/regexp_metacharacter'
+require_relative 'mixin/sort_block'
+
+require_relative 'performance/ancestors_include'
+require_relative 'performance/big_decimal_with_numeric_argument'
+require_relative 'performance/bind_call'
 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/count'
+require_relative 'performance/delete_prefix'
+require_relative 'performance/delete_suffix'
 require_relative 'performance/detect'
 require_relative 'performance/double_start_end_with'
 require_relative 'performance/end_with'
@@ -13,14 +22,22 @@ require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
 require_relative 'performance/open_struct'
 require_relative 'performance/range_include'
+require_relative 'performance/io_readlines'
 require_relative 'performance/redundant_block_call'
 require_relative 'performance/redundant_match'
 require_relative 'performance/redundant_merge'
+require_relative 'performance/redundant_sort_block'
+require_relative 'performance/redundant_string_chars'
 require_relative 'performance/regexp_match'
 require_relative 'performance/reverse_each'
+require_relative 'performance/reverse_first'
 require_relative 'performance/size'
+require_relative 'performance/sort_reverse'
+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/inject.rb

@@ -8,7 +8,7 @@ module RuboCop
       def self.defaults!
         path = CONFIG_DEFAULT.to_s
         hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
         puts "configuration from #{path}" if ConfigLoader.debug?
         config = ConfigLoader.merge_with_default(config, path)
         ConfigLoader.instance_variable_set(:@default_configuration, config)

data/lib/rubocop/performance/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Performance
     module Version
-      STRING = '1.5.2'
+      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.5.2
+  version: 1.8.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-25 00:00:00.000000000 Z
+date: 2020-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -18,14 +18,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.71.0
+        version: 0.87.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.71.0
+        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
@@ -40,9 +54,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |2
-      A collection of RuboCop cops to check for performance optimizations
-      in Ruby code.
+description: |
+  A collection of RuboCop cops to check for performance optimizations
+  in Ruby code.
 email: rubocop@googlegroups.com
 executables: []
 extensions: []
@@ -54,28 +68,44 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-performance.rb
+- 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/big_decimal_with_numeric_argument.rb
+- lib/rubocop/cop/performance/bind_call.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/count.rb
+- lib/rubocop/cop/performance/delete_prefix.rb
+- lib/rubocop/cop/performance/delete_suffix.rb
 - lib/rubocop/cop/performance/detect.rb
 - lib/rubocop/cop/performance/double_start_end_with.rb
 - lib/rubocop/cop/performance/end_with.rb
 - lib/rubocop/cop/performance/fixed_size.rb
 - 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/open_struct.rb
 - lib/rubocop/cop/performance/range_include.rb
 - lib/rubocop/cop/performance/redundant_block_call.rb
 - lib/rubocop/cop/performance/redundant_match.rb
 - lib/rubocop/cop/performance/redundant_merge.rb
+- lib/rubocop/cop/performance/redundant_sort_block.rb
+- lib/rubocop/cop/performance/redundant_string_chars.rb
 - lib/rubocop/cop/performance/regexp_match.rb
 - lib/rubocop/cop/performance/reverse_each.rb
+- lib/rubocop/cop/performance/reverse_first.rb
 - lib/rubocop/cop/performance/size.rb
+- lib/rubocop/cop/performance/sort_reverse.rb
+- lib/rubocop/cop/performance/squeeze.rb
 - 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
@@ -87,10 +117,10 @@ homepage: https://github.com/rubocop-hq/rubocop-performance
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://docs.rubocop.org/projects/performance
+  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/projects/performance
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop-performance/issues
 post_install_message: 
 rdoc_options: []
@@ -100,14 +130,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.