rubocop-performance 1.4.1 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7ae023c81bdf2e4816ffa5bed9a98fc10bcaec5e6e37c89f51eb9fb11fa452f
-  data.tar.gz: 01bc8929e0c9ab2d80933c13c35dbcc713a04574ff51002ff2f7182e05045917
+  metadata.gz: 111d420207542c8522d9f34b5b8bf24356572b5fbcf0c11dfcb1e7f738a4c76f
+  data.tar.gz: 97632031f51e154320bc3d585da448740596436882b67277f1b5d26ddfe55fba
 SHA512:
-  metadata.gz: 05da6b08dea1f6b8f16aa077bbfaa021b9586efb6895452f6af465fa03f695740370d8eb126d467c79565c204a2d76125fd0ce6137b9e18bb3dbe47d6c9ed44d
-  data.tar.gz: b0c11d70c9677b6e7e8796523b602a7dfe8ed308dfe124b26a4935193eee4293f5147cdd198b2a277841ccea131dde686c0be965811659cb030b16e3a0841b68
+  metadata.gz: a36e6950e6fe7847303c87862df76767d32c4f68640c229ad4ceb6115d4ae2093be18a8296c2e49324c67e8eb06dd99db42f8823586f1b572e10a74693b831d1
+  data.tar.gz: 782352b1a7c420ac3c5498aeff749577e6280fb35d6e36844ae875511e9b6b44becfd9a2789d1b4c672cb71a91b8ab1cc63c89ec41abda8d1f34f1dacd26a07c

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-18 Bozhidar Batsov
+Copyright (c) 2012-20 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -16,7 +16,7 @@ gem install rubocop-performance
 or if you use bundler put this in your `Gemfile`
 
 ```ruby
-gem 'rubocop-performance'
+gem 'rubocop-performance', require: false
 ```
 
 ## Usage
@@ -72,6 +72,10 @@ Performance/Size:
     - lib/example.rb
 ```
 
+## Documentation
+
+You can read a lot more about RuboCop Performance in its [official docs](https://docs.rubocop.org/rubocop-performance/).
+
 ## Contributing
 
 Checkout the [contribution guidelines](CONTRIBUTING.md).

data/config/default.yml

@@ -1,5 +1,10 @@
 # This is the default configuration file.
 
+Performance/BindCall:
+  Description: 'Use `bind_call(obj, args, ...)` instead of `bind(obj).call(args, ...)`.'
+  Enabled: true
+  VersionAdded: '1.6'
+
 Performance/Caller:
   Description: >-
              Use `caller(n..n)` instead of `caller`.
@@ -21,6 +26,7 @@ Performance/Casecmp:
              Use `casecmp` rather than `downcase ==`, `upcase ==`, `== downcase`, or `== upcase`..
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code'
   Enabled: true
+  Safe: false
   VersionAdded: '0.36'
 
 Performance/ChainArrayAllocation:
@@ -44,11 +50,22 @@ Performance/Count:
   # 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.
-  # If you understand the known risk, you can disable `SafeMode`.
-  SafeMode: true
+  SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.31'
-  VersionChanged: '0.39'
+  VersionChanged: '1.5'
+
+Performance/DeletePrefix:
+  Description: 'Use `delete_prefix` instead of `gsub`.'
+  Enabled: true
+  SafeMultiline: true
+  VersionAdded: '1.6'
+
+Performance/DeleteSuffix:
+  Description: 'Use `delete_suffix` instead of `gsub`.'
+  Enabled: true
+  SafeMultiline: true
+  VersionAdded: '1.6'
 
 Performance/Detect:
   Description: >-
@@ -59,10 +76,10 @@ Performance/Detect:
   # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
   # has its own meaning. Correcting `ActiveRecord` methods with this cop
   # should be considered unsafe.
-  SafeMode: true
+  SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.30'
-  VersionChanged: '0.39'
+  VersionChanged: '1.5'
 
 Performance/DoubleStartEndWith:
   Description: >-
@@ -84,11 +101,12 @@ Performance/EndWith:
   SafeAutoCorrect: false
   AutoCorrect: false
   Enabled: true
+  SafeMultiline: true
   VersionAdded: '0.36'
-  VersionChanged: '0.44'
+  VersionChanged: '1.6'
 
 Performance/FixedSize:
-  Description: 'Do not compute the size of statically sized objects except in constants'
+  Description: 'Do not compute the size of statically sized objects except in constants.'
   Enabled: true
   VersionAdded: '0.35'
 
@@ -96,7 +114,7 @@ Performance/FlatMap:
   Description: >-
                   Use `Enumerable#flat_map`
                   instead of `Enumerable#map...Array#flatten(1)`
-                  or `Enumberable#collect..Array#flatten(1)`
+                  or `Enumberable#collect..Array#flatten(1)`.
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
   Enabled: true
   VersionAdded: '0.30'
@@ -107,7 +125,7 @@ Performance/FlatMap:
   # `flatten` without any parameters can flatten multiple levels.
 
 Performance/InefficientHashSearch:
-  Description: 'Use `key?` or `value?` instead of `keys.include?` or `values.include?`'
+  Description: 'Use `key?` or `value?` instead of `keys.include?` or `values.include?`.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
   Enabled: true
   VersionAdded: '0.56'
@@ -178,8 +196,9 @@ Performance/StartWith:
   SafeAutoCorrect: false
   AutoCorrect: false
   Enabled: true
+  SafeMultiline: true
   VersionAdded: '0.36'
-  VersionChanged: '0.44'
+  VersionChanged: '1.6'
 
 Performance/StringReplacement:
   Description: >-

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling regexp metacharacters.
+    module RegexpMetacharacter
+      private
+
+      def literal_at_start?(regexp)
+        return true if literal_at_start_with_backslash_a?(regexp)
+
+        !safe_multiline? && literal_at_start_with_caret?(regexp)
+      end
+
+      def literal_at_end?(regexp)
+        return true if literal_at_end_with_backslash_z?(regexp)
+
+        !safe_multiline? && literal_at_end_with_dollar?(regexp)
+      end
+
+      def literal_at_start_with_backslash_a?(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 start of the string?
+        # (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)
+      end
+
+      def literal_at_start_with_caret?(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 start of the string?
+        # (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)
+      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)
+      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)
+      end
+
+      def drop_start_metacharacter(regexp_string)
+        if regexp_string.start_with?('\\A')
+          regexp_string[2..-1] # drop `\A` anchor
+        else
+          regexp_string[1..-1] # drop `^` anchor
+        end
+      end
+
+      def drop_end_metacharacter(regexp_string)
+        if regexp_string.end_with?('\\z')
+          regexp_string.chomp('\z') # drop `\z` anchor
+        else
+          regexp_string.chop # drop `$` anchor
+        end
+      end
+
+      def safe_multiline?
+        cop_config.fetch('SafeMultiline', true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.7, `UnboundMethod#bind_call` has been added.
+      #
+      # This cop identifies places where `bind(obj).call(args, ...)`
+      # can be replaced by `bind_call(obj, args, ...)`.
+      #
+      # The `bind_call(obj, args, ...)` method is faster than
+      # `bind(obj).call(args, ...)`.
+      #
+      # @example
+      #   # bad
+      #   umethod.bind(obj).call(foo, bar)
+      #   umethod.bind(obj).(foo, bar)
+      #
+      #   # good
+      #   umethod.bind_call(obj, foo, bar)
+      #
+      class BindCall < Cop
+        include RangeHelp
+        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)`.'
+
+        def_node_matcher :bind_with_call_method?, <<~PATTERN
+          (send
+            $(send
+              (send nil? _) :bind
+              $(...)) :call
+            $...)
+        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)
+
+          range = correction_range(receiver, node)
+
+          call_args = build_call_args(call_args_node)
+          call_args = ", #{call_args}" unless call_args.empty?
+
+          replacement_method = "bind_call(#{bind_arg.source}#{call_args})"
+
+          lambda do |corrector|
+            corrector.replace(range, replacement_method)
+          end
+        end
+
+        private
+
+        def message(bind_arg, call_args)
+          comma = call_args.empty? ? '' : ', '
+
+          format(MSG, bind_arg: bind_arg, comma: comma, call_args: call_args)
+        end
+
+        def correction_range(receiver, node)
+          location_of_bind = receiver.loc.selector.begin_pos
+          location_of_call = node.loc.end.end_pos
+
+          range_between(location_of_bind, location_of_call)
+        end
+
+        def build_call_args(call_args_node)
+          call_args_node.map(&:source).join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -24,14 +24,14 @@ module RuboCop
         MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
                     ' instead of `%<method>s.first`.'
 
-        def_node_matcher :slow_caller?, <<-PATTERN
+        def_node_matcher :slow_caller?, <<~PATTERN
           {
             (send nil? {:caller :caller_locations})
             (send nil? {:caller :caller_locations} int)
           }
         PATTERN
 
-        def_node_matcher :caller_with_scope_method?, <<-PATTERN
+        def_node_matcher :caller_with_scope_method?, <<~PATTERN
           {
             (send #slow_caller? :first)
             (send #slow_caller? :[] int)
@@ -51,7 +51,7 @@ module RuboCop
           caller_arg = node.receiver.first_argument
           n = caller_arg ? int_value(caller_arg) : 1
 
-          if node.method_name == :[]
+          if node.method?(:[])
             m = int_value(node.first_argument)
             n += m
             format(MSG_BRACE, n: n, m: m, method: method_name)

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

@@ -5,6 +5,8 @@ module RuboCop
     module Performance
       # This cop identifies places where a case-insensitive string comparison
       # can better be implemented using `casecmp`.
+      # This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
+      # differently when using Non-ASCII characters.
       #
       # @example
       #   # bad
@@ -21,21 +23,21 @@ module RuboCop
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
         CASE_METHODS = %i[downcase upcase].freeze
 
-        def_node_matcher :downcase_eq, <<-PATTERN
+        def_node_matcher :downcase_eq, <<~PATTERN
           (send
             $(send _ ${:downcase :upcase})
             ${:== :eql? :!=}
             ${str (send _ {:downcase :upcase} ...) (begin str)})
         PATTERN
 
-        def_node_matcher :eq_downcase, <<-PATTERN
+        def_node_matcher :eq_downcase, <<~PATTERN
           (send
             {str (send _ {:downcase :upcase} ...) (begin str)}
             ${:== :eql? :!=}
             $(send _ ${:downcase :upcase}))
         PATTERN
 
-        def_node_matcher :downcase_downcase, <<-PATTERN
+        def_node_matcher :downcase_downcase, <<~PATTERN
           (send
             $(send _ ${:downcase :upcase})
             ${:== :eql? :!=}

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

@@ -51,7 +51,7 @@ module RuboCop
               '(followed by `return array` if required) instead of chaining '\
               '`%<method>s...%<second_method>s`.'
 
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
+        def_node_matcher :flat_map_candidate?, <<~PATTERN
           {
             (send (send _ ${#{RETURN_NEW_ARRAY_WHEN_ARGS}} {int lvar ivar cvar gvar}) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
             (send (block (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY} }) ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)

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

@@ -30,14 +30,14 @@ module RuboCop
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
               '<=> %<str_b>s }`.'
 
-        def_node_matcher :compare?, <<-PATTERN
+        def_node_matcher :compare?, <<~PATTERN
           (block
             $(send _ {:sort :min :max})
             (args (arg $_a) (arg $_b))
             $send)
         PATTERN
 
-        def_node_matcher :replaceable_body?, <<-PATTERN
+        def_node_matcher :replaceable_body?, <<~PATTERN
           (send
             (send (lvar %1) $_method $...)
             :<=>

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

@@ -32,18 +32,17 @@ module RuboCop
       # make `count` work with a block is to call `to_a.count {...}`.
       #
       # Example:
-      #   Model.where(id: [1, 2, 3].select { |m| m.method == true }.size
+      #   `Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
       #
       #   becomes:
       #
-      #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
+      #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
       class Count < Cop
-        include SafeMode
         include RangeHelp
 
         MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'
 
-        def_node_matcher :count_candidate?, <<-PATTERN
+        def_node_matcher :count_candidate?, <<~PATTERN
           {
             (send (block $(send _ ${:select :reject}) ...) ${:count :length :size})
             (send $(send _ ${:select :reject} (:block_pass _)) ${:count :length :size})
@@ -51,8 +50,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if rails_safe_mode?
-
           count_candidate?(node) do |selector_node, selector, counter|
             return unless eligible_node?(node)
 

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.5, `String#delete_prefix` has been added.
+      #
+      # This cop identifies places where `gsub(/\Aprefix/, '')` and `sub(/\Aprefix/, '')`
+      # can be replaced by `delete_prefix('prefix')`.
+      #
+      # This cop has `SafeMultiline` configuration option that `true` by default because
+      # `^prefix` is unsafe as it will behave incompatible with `delete_prefix`
+      # for receiver is multiline string.
+      #
+      # The `delete_prefix('prefix')` method is faster than `gsub(/\Aprefix/, '')`.
+      #
+      # @example
+      #
+      #   # bad
+      #   str.gsub(/\Aprefix/, '')
+      #   str.gsub!(/\Aprefix/, '')
+      #
+      #   str.sub(/\Aprefix/, '')
+      #   str.sub!(/\Aprefix/, '')
+      #
+      #   # good
+      #   str.delete_prefix('prefix')
+      #   str.delete_prefix!('prefix')
+      #
+      # @example SafeMultiline: true (default)
+      #
+      #   # good
+      #   str.gsub(/^prefix/, '')
+      #   str.gsub!(/^prefix/, '')
+      #   str.sub(/^prefix/, '')
+      #   str.sub!(/^prefix/, '')
+      #
+      # @example SafeMultiline: false
+      #
+      #   # bad
+      #   str.gsub(/^prefix/, '')
+      #   str.gsub!(/^prefix/, '')
+      #   str.sub(/^prefix/, '')
+      #   str.sub!(/^prefix/, '')
+      #
+      class DeletePrefix < Cop
+        extend TargetRubyVersion
+        include RegexpMetacharacter
+
+        minimum_target_ruby_version 2.5
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        PREFERRED_METHODS = {
+          gsub: :delete_prefix,
+          gsub!: :delete_prefix!,
+          sub: :delete_prefix,
+          sub!: :delete_prefix!
+        }.freeze
+
+        def_node_matcher :delete_prefix_candidate?, <<~PATTERN
+          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
+        PATTERN
+
+        def on_send(node)
+          delete_prefix_candidate?(node) do |_, bad_method, _, replace_string|
+            return unless replace_string.blank?
+
+            good_method = PREFERRED_METHODS[bad_method]
+
+            message = format(MSG, current: bad_method, prefer: good_method)
+
+            add_offense(node, location: :selector, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          delete_prefix_candidate?(node) do |receiver, bad_method, regexp_str, _|
+            lambda do |corrector|
+              good_method = PREFERRED_METHODS[bad_method]
+              regexp_str = drop_start_metacharacter(regexp_str)
+              regexp_str = interpret_string_escapes(regexp_str)
+              string_literal = to_string_literal(regexp_str)
+
+              new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+
+              # TODO: `source_range` is no longer required when RuboCop 0.81 or lower support will be dropped.
+              # https://github.com/rubocop-hq/rubocop/commit/82eb350d2cba16
+              corrector.replace(node.source_range, new_code)
+            end
+          end
+        end
+      end
+    end
+  end
+end