rubocop-performance 1.7.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5be372d62d20424e05201d4b78bb06bf19fc707d845d6b799599ba72958f72b7
-  data.tar.gz: 87c59d78e37de238add70195fa26c95d31b23eb3065695f443a1694d3acf9145
+  metadata.gz: c90f0ddd451c37a5c2187423524462aaa583fc0a7d4fb0342077eb792f03bfcc
+  data.tar.gz: 7606efa668ec94c24a35b93df1062a5a6f39e8c787e013d2707f69448841b7e9
 SHA512:
-  metadata.gz: d6caf119ca1a8b11d829ed555f3a0653a1087d3a3ee3be078460c9ecfb5a5fb236a7abf2c058f57647d4f74dffccc66aebcf4d330f5a6a5bd5deaa12a8fea480
-  data.tar.gz: d8a6e634d4453300d24e5869bffa690457d07048b1e2978cc00dbc930c40e2dc80789a6faa95823e63414e5c579f8784cbe4f743607e2fd9598cf478aa1801ed
+  metadata.gz: a2a0094a2edfa59ee9a517cbf5d71ae1fa0fc67042bf0c35b129872a1b6cb6f892c182a0777da2a4e34f1a4c4b4292c30d19a34083b65844802e75b021f75322
+  data.tar.gz: e24dab2beb33688d61cf110a748d5295921c185324df366c0e02478ff44c34acb0857d8b603ca308021c7eaaf6e13d9ecbaeda1f80572b180d499c1b4e5fec5d

data/README.md

@@ -76,6 +76,14 @@ Performance/Size:
 
 You can read a lot more about RuboCop Performance in its [official docs](https://docs.rubocop.org/rubocop-performance/).
 
+## Compatibility
+
+RuboCop Performance complies with the RuboCop core compatibility.
+
+See the [compatibility documentation](https://docs.rubocop.org/rubocop/compatibility.html) for further details.
+
+**Note:** Performance cops are all MRI focused and are highly dependent of the version of MRI you're using.
+
 ## Contributing
 
 Checkout the [contribution guidelines](CONTRIBUTING.md).

data/config/default.yml

@@ -4,8 +4,18 @@ Performance/AncestorsInclude:
   Description: 'Use `A <= B` instead of `A.ancestors.include?(B)`.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code'
   Enabled: 'pending'
+  Safe: false
   VersionAdded: '1.7'
 
+Performance/ArraySemiInfiniteRangeSlice:
+  Description: 'Identifies places where slicing arrays with semi-infinite ranges can be replaced by `Array#take` and `Array#drop`.'
+  # This cop was created due to a mistake in microbenchmark.
+  # Refer https://github.com/rubocop-hq/rubocop-performance/pull/175#issuecomment-731892717
+  Enabled: false
+  # Unsafe for string slices because strings do not have `#take` and `#drop` methods.
+  Safe: false
+  VersionAdded: '1.9'
+
 Performance/BigDecimalWithNumericArgument:
   Description: 'Convert numeric argument to string before passing to BigDecimal.'
   Enabled: 'pending'
@@ -16,11 +26,17 @@ Performance/BindCall:
   Enabled: true
   VersionAdded: '1.6'
 
+Performance/BlockGivenWithExplicitBlock:
+  Description: 'Check block argument explicitly instead of using `block_given?`.'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/Caller:
   Description: >-
              Use `caller(n..n)` instead of `caller`.
   Enabled: true
   VersionAdded: '0.49'
+  VersionChanged: '1.9'
 
 Performance/CaseWhenSplat:
   Description: >-
@@ -48,23 +64,33 @@ Performance/ChainArrayAllocation:
   Enabled: false
   VersionAdded: '0.59'
 
+Performance/CollectionLiteralInLoop:
+  Description: 'Extract Array and Hash literals outside of loops into local variables or constants.'
+  Enabled: 'pending'
+  VersionAdded: '1.8'
+  # Min number of elements to consider an offense
+  MinSize: 1
+
 Performance/CompareWithBlock:
   Description: 'Use `sort_by(&:foo)` instead of `sort { |a, b| a.foo <=> b.foo }`.'
   Enabled: true
   VersionAdded: '0.46'
 
+Performance/ConstantRegexp:
+  Description: 'Finds regular expressions with dynamic components that are all constants.'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/Count:
   Description: >-
-                  Use `count` instead of `select...size`, `reject...size`,
-                  `select...count`, `reject...count`, `select...length`,
-                  and `reject...length`.
+                  Use `count` instead of `{select,find_all,filter,reject}...{size,count,length}`.
   # This cop has known compatibility issues with `ActiveRecord` and other
   # frameworks. ActiveRecord's `count` ignores the block that is passed to it.
   # For more information, see the documentation in the cop itself.
   SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.31'
-  VersionChanged: '1.5'
+  VersionChanged: '1.8'
 
 Performance/DeletePrefix:
   Description: 'Use `delete_prefix` instead of `gsub`.'
@@ -80,8 +106,8 @@ Performance/DeleteSuffix:
 
 Performance/Detect:
   Description: >-
-                  Use `detect` instead of `select.first`, `find_all.first`,
-                  `select.last`, and `find_all.last`.
+                  Use `detect` instead of `select.first`, `find_all.first`, `filter.first`,
+                  `select.last`, `find_all.last`, and `filter.last`.
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
   # This cop has known compatibility issues with `ActiveRecord` and other
   # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
@@ -90,7 +116,7 @@ Performance/Detect:
   SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.30'
-  VersionChanged: '1.5'
+  VersionChanged: '1.8'
 
 Performance/DoubleStartEndWith:
   Description: >-
@@ -148,6 +174,12 @@ Performance/IoReadlines:
   Enabled: false
   VersionAdded: '1.7'
 
+Performance/MethodObjectAsBlock:
+  Description: 'Use block explicitly instead of block-passing a method object.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/OpenStruct:
   Description: 'Use `Struct` instead of `OpenStruct`.'
   Enabled: false
@@ -247,6 +279,8 @@ Performance/StartWith:
 Performance/StringInclude:
   Description: 'Use `String#include?` instead of a regex match with literal-only pattern.'
   Enabled: 'pending'
+  AutoCorrect: false
+  SafeAutoCorrect: false
   VersionAdded: '1.7'
 
 Performance/StringReplacement:
@@ -258,6 +292,12 @@ Performance/StringReplacement:
   Enabled: true
   VersionAdded: '0.33'
 
+Performance/Sum:
+  Description: 'Use `sum` instead of a custom array summation.'
+  Reference: 'https://blog.bigbinary.com/2016/11/02/ruby-2-4-introduces-enumerable-sum.html'
+  Enabled: 'pending'
+  VersionAdded: '1.8'
+
 Performance/TimesMap:
   Description: 'Checks for .times.map calls.'
   AutoCorrect: false
@@ -269,7 +309,9 @@ Performance/TimesMap:
 Performance/UnfreezeString:
   Description: 'Use unary plus to get an unfrozen string literal.'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '0.50'
+  VersionChanged: '1.9'
 
 Performance/UriDefaultParser:
   Description: 'Use `URI::DEFAULT_PARSER` instead of `URI::Parser.new`.'

data/lib/rubocop/cop/mixin/regexp_metacharacter.rb

@@ -25,7 +25,7 @@ module RuboCop
         # (tricky: \s, \d, and so on are metacharacters, but other characters
         #  escaped with a slash are just literals. LITERAL_REGEX takes all
         #  that into account.)
-        /\A\\A(?:#{Util::LITERAL_REGEX})+\z/.match?(regex_str)
+        /\A\\A(?:#{Util::LITERAL_REGEX})+\z/o.match?(regex_str)
       end
 
       def literal_at_start_with_caret?(regex_str)
@@ -35,21 +35,21 @@ module RuboCop
         # (tricky: \s, \d, and so on are metacharacters, but other characters
         #  escaped with a slash are just literals. LITERAL_REGEX takes all
         #  that into account.)
-        /\A\^(?:#{Util::LITERAL_REGEX})+\z/.match?(regex_str)
+        /\A\^(?:#{Util::LITERAL_REGEX})+\z/o.match?(regex_str)
       end
 
       def literal_at_end_with_backslash_z?(regex_str)
         # is this regexp 'literal' in the sense of only matching literal
         # chars, rather than using metachars like . and * and so on?
         # also, is it anchored at the end of the string?
-        /\A(?:#{Util::LITERAL_REGEX})+\\z\z/.match?(regex_str)
+        /\A(?:#{Util::LITERAL_REGEX})+\\z\z/o.match?(regex_str)
       end
 
       def literal_at_end_with_dollar?(regex_str)
         # is this regexp 'literal' in the sense of only matching literal
         # chars, rather than using metachars like . and * and so on?
         # also, is it anchored at the end of the string?
-        /\A(?:#{Util::LITERAL_REGEX})+\$\z/.match?(regex_str)
+        /\A(?:#{Util::LITERAL_REGEX})+\$\z/o.match?(regex_str)
       end
 
       def drop_start_metacharacter(regexp_string)

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

@@ -13,31 +13,35 @@ module RuboCop
       #   # good
       #   A <= B
       #
-      class AncestorsInclude < Cop
+      class AncestorsInclude < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `<=` instead of `ancestors.include?`.'
+        RESTRICT_ON_SEND = %i[include?].freeze
 
         def_node_matcher :ancestors_include_candidate?, <<~PATTERN
           (send (send $_subclass :ancestors) :include? $_superclass)
         PATTERN
 
         def on_send(node)
-          return unless ancestors_include_candidate?(node)
+          return unless (subclass, superclass = ancestors_include_candidate?(node))
+          return if subclass && !subclass.const_type?
 
-          location_of_ancestors = node.children[0].loc.selector.begin_pos
-          end_location = node.loc.selector.end_pos
-          range = range_between(location_of_ancestors, end_location)
+          add_offense(range(node)) do |corrector|
+            subclass_source = subclass ? subclass.source : 'self'
 
-          add_offense(node, location: range)
+            corrector.replace(node, "#{subclass_source} <= #{superclass.source}")
+          end
         end
 
-        def autocorrect(node)
-          ancestors_include_candidate?(node) do |subclass, superclass|
-            lambda do |corrector|
-              corrector.replace(node, "#{subclass.source} <= #{superclass.source}")
-            end
-          end
+        private
+
+        def range(node)
+          location_of_ancestors = node.children[0].loc.selector.begin_pos
+          end_location = node.loc.selector.end_pos
+
+          range_between(location_of_ancestors, end_location)
         end
       end
     end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where slicing arrays with semi-infinite ranges
+      # can be replaced by `Array#take` and `Array#drop`.
+      # This cop was created due to a mistake in microbenchmark and hence is disabled by default.
+      # Refer https://github.com/rubocop-hq/rubocop-performance/pull/175#issuecomment-731892717
+      # This cop is also unsafe for string slices because strings do not have `#take` and `#drop` methods.
+      #
+      # @example
+      #   # bad
+      #   # array[..2]
+      #   # array[...2]
+      #   # array[2..]
+      #   # array[2...]
+      #   # array.slice(..2)
+      #
+      #   # good
+      #   array.take(3)
+      #   array.take(2)
+      #   array.drop(2)
+      #   array.drop(2)
+      #   array.take(3)
+      #
+      class ArraySemiInfiniteRangeSlice < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s` with semi-infinite range.'
+
+        SLICE_METHODS = Set[:[], :slice].freeze
+        RESTRICT_ON_SEND = SLICE_METHODS
+
+        def_node_matcher :endless_range_slice?, <<~PATTERN
+          (send $_ $%SLICE_METHODS $#endless_range?)
+        PATTERN
+
+        def_node_matcher :endless_range?, <<~PATTERN
+          {
+            ({irange erange} nil? (int positive?))
+            ({irange erange} (int positive?) nil?)
+          }
+        PATTERN
+
+        def on_send(node)
+          endless_range_slice?(node) do |receiver, method_name, range_node|
+            prefer = range_node.begin ? :drop : :take
+            message = format(MSG, prefer: prefer, current: method_name)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, correction(receiver, range_node))
+            end
+          end
+        end
+
+        private
+
+        def correction(receiver, range_node)
+          method_call = if range_node.begin
+                          "drop(#{range_node.begin.value})"
+                        elsif range_node.irange_type?
+                          "take(#{range_node.end.value + 1})"
+                        else
+                          "take(#{range_node.end.value})"
+                        end
+
+          "#{receiver.source}.#{method_call}"
+        end
+      end
+    end
+  end
+end

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

@@ -8,34 +8,37 @@ module RuboCop
       # than from Numeric for BigDecimal.
       #
       # @example
-      #
       #   # bad
-      # BigDecimal(1, 2)
-      # BigDecimal(1.2, 3, exception: true)
+      #   BigDecimal(1, 2)
+      #   BigDecimal(1.2, 3, exception: true)
       #
       #   # good
-      # BigDecimal('1', 2)
-      # BigDecimal('1.2', 3, exception: true)
+      #   BigDecimal('1', 2)
+      #   BigDecimal('1.2', 3, exception: true)
       #
-      class BigDecimalWithNumericArgument < Cop
+      class BigDecimalWithNumericArgument < Base
+        extend AutoCorrector
+
         MSG = 'Convert numeric argument to string before passing to `BigDecimal`.'
+        RESTRICT_ON_SEND = %i[BigDecimal].freeze
 
         def_node_matcher :big_decimal_with_numeric_argument?, <<~PATTERN
           (send nil? :BigDecimal $numeric_type? ...)
         PATTERN
 
         def on_send(node)
-          big_decimal_with_numeric_argument?(node) do |numeric|
-            add_offense(node, location: numeric.source_range)
+          return unless (numeric = big_decimal_with_numeric_argument?(node))
+          return if numeric.float_type? && specifies_precision?(node)
+
+          add_offense(numeric.source_range) do |corrector|
+            corrector.wrap(numeric, "'", "'")
           end
         end
 
-        def autocorrect(node)
-          big_decimal_with_numeric_argument?(node) do |numeric|
-            lambda do |corrector|
-              corrector.wrap(numeric, "'", "'")
-            end
-          end
+        private
+
+        def specifies_precision?(node)
+          node.arguments.size > 1 && !node.arguments[1].hash_type?
         end
       end
     end

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

@@ -19,14 +19,16 @@ module RuboCop
       #   # good
       #   umethod.bind_call(obj, foo, bar)
       #
-      class BindCall < Cop
+      class BindCall < Base
         include RangeHelp
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.7
 
         MSG = 'Use `bind_call(%<bind_arg>s%<comma>s%<call_args>s)` ' \
               'instead of `bind(%<bind_arg>s).call(%<call_args>s)`.'
+        RESTRICT_ON_SEND = %i[call].freeze
 
         def_node_matcher :bind_with_call_method?, <<~PATTERN
           (send
@@ -37,28 +39,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          bind_with_call_method?(node) do |receiver, bind_arg, call_args_node|
-            range = correction_range(receiver, node)
-
-            call_args = build_call_args(call_args_node)
-
-            message = message(bind_arg.source, call_args)
-
-            add_offense(node, location: range, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          receiver, bind_arg, call_args_node = bind_with_call_method?(node)
+          return unless (receiver, bind_arg, call_args_node = bind_with_call_method?(node))
 
           range = correction_range(receiver, node)
-
           call_args = build_call_args(call_args_node)
-          call_args = ", #{call_args}" unless call_args.empty?
+          message = message(bind_arg.source, call_args)
+
+          add_offense(range, message: message) do |corrector|
+            call_args = ", #{call_args}" unless call_args.empty?
 
-          replacement_method = "bind_call(#{bind_arg.source}#{call_args})"
+            replacement_method = "bind_call(#{bind_arg.source}#{call_args})"
 
-          lambda do |corrector|
             corrector.replace(range, replacement_method)
           end
         end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies unnecessary use of a `block_given?` where explicit check
+      # of block argument would suffice.
+      #
+      # @example
+      #   # bad
+      #   def method(&block)
+      #     do_something if block_given?
+      #   end
+      #
+      #   # good
+      #   def method(&block)
+      #     do_something if block
+      #   end
+      #
+      #   # good - block is reassigned
+      #   def method(&block)
+      #     block ||= -> { do_something }
+      #     warn "Using default ..." unless block_given?
+      #     # ...
+      #   end
+      #
+      class BlockGivenWithExplicitBlock < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[block_given?].freeze
+        MSG = 'Check block argument explicitly instead of using `block_given?`.'
+
+        def_node_matcher :reassigns_block_arg?, '`(lvasgn %1 ...)'
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return unless def_node
+
+          block_arg = def_node.arguments.find(&:blockarg_type?)
+          return unless block_arg
+
+          block_arg_name = block_arg.loc.name.source.to_sym
+          return if reassigns_block_arg?(def_node, block_arg_name)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, block_arg_name)
+          end
+        end
+      end
+    end
+  end
+end