rubocop-performance 1.7.1 → 1.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34605a937c1a3e040428bee06e322220659c105b6e835423d9e0e73869fd83ee
-  data.tar.gz: e3fa0103bd2518cec45334bc162e144963eef9e3d09ab9fd6bd7b2d35b654e84
+  metadata.gz: 30b8495304f86e7ef0e9a7f11e12a30ab7986fb4b12cb1921870f31a1b37a42f
+  data.tar.gz: 1863b8766efff5dd99b2e4f2dbb4e16191f223d12dbfd51826a837f1f75eef08
 SHA512:
-  metadata.gz: 5fe72ab5a0370aa8e0cc434080a27a38d8979084c53c50cd18e8cbc0896572ddc9d011130d56283f9d588268253ec0e2e44fc32b81483e1458689c60c17e835b
-  data.tar.gz: a60d627b0d1ded2fb6103a78fb4414fc1e1f1ff13ab9f4e82c399289c9a40c3c6e0385ee2509074175bd724755f768dd4625bb9791af993032a1f840a0533ef6
+  metadata.gz: a6071b0e37b9a9683f1992b88b36e0911004e0ec8fc4b41f78ba569ce396d96840acb0eff937d519d132917dec1b0a5af9fe4d1563d743e293ee78239a59b13f
+  data.tar.gz: 74c457f9d7f7ef240a2fa483100ff1120fc4edba7bb64e999f78a85e106621cba4ddef1a2dae7f375f9541d021a0fa08f054edf83ebd1646423d214b4677e212

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

@@ -7,6 +7,15 @@ Performance/AncestorsInclude:
   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'
@@ -17,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: >-
@@ -49,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`.'
@@ -81,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`
@@ -91,7 +116,7 @@ Performance/Detect:
   SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.30'
-  VersionChanged: '1.5'
+  VersionChanged: '1.8'
 
 Performance/DoubleStartEndWith:
   Description: >-
@@ -149,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
@@ -261,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
@@ -272,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,33 +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|
-              subclass_source = subclass ? subclass.source : 'self'
+        private
 
-              corrector.replace(node, "#{subclass_source} <= #{superclass.source}")
-            end
-          end
+        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

@@ -16,26 +16,22 @@ module RuboCop
       #   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|
-            next if numeric.float_type? && specifies_precision?(node)
-
-            add_offense(node, location: numeric.source_range)
-          end
-        end
+          return unless (numeric = big_decimal_with_numeric_argument?(node))
+          return if numeric.float_type? && specifies_precision?(node)
 
-        def autocorrect(node)
-          big_decimal_with_numeric_argument?(node) do |numeric|
-            lambda do |corrector|
-              corrector.wrap(numeric, "'", "'")
-            end
+          add_offense(numeric.source_range) do |corrector|
+            corrector.wrap(numeric, "'", "'")
           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