rubocop-performance 1.5.1 → 1.7.1

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)

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,17 +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 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})

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

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.5, `String#delete_suffix` has been added.
+      #
+      # This cop identifies places where `gsub(/suffix\z/, '')` and `sub(/suffix\z/, '')`
+      # can be replaced by `delete_suffix('suffix')`.
+      #
+      # This cop has `SafeMultiline` configuration option that `true` by default because
+      # `suffix$` is unsafe as it will behave incompatible with `delete_suffix?`
+      # for receiver is multiline string.
+      #
+      # The `delete_suffix('suffix')` method is faster than `gsub(/suffix\z/, '')`.
+      #
+      # @example
+      #
+      #   # bad
+      #   str.gsub(/suffix\z/, '')
+      #   str.gsub!(/suffix\z/, '')
+      #
+      #   str.sub(/suffix\z/, '')
+      #   str.sub!(/suffix\z/, '')
+      #
+      #   # good
+      #   str.delete_suffix('suffix')
+      #   str.delete_suffix!('suffix')
+      #
+      # @example SafeMultiline: true (default)
+      #
+      #   # good
+      #   str.gsub(/suffix$/, '')
+      #   str.gsub!(/suffix$/, '')
+      #   str.sub(/suffix$/, '')
+      #   str.sub!(/suffix$/, '')
+      #
+      # @example SafeMultiline: false
+      #
+      #   # bad
+      #   str.gsub(/suffix$/, '')
+      #   str.gsub!(/suffix$/, '')
+      #   str.sub(/suffix$/, '')
+      #   str.sub!(/suffix$/, '')
+      #
+      class DeleteSuffix < Cop
+        extend TargetRubyVersion
+        include RegexpMetacharacter
+
+        minimum_target_ruby_version 2.5
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        PREFERRED_METHODS = {
+          gsub: :delete_suffix,
+          gsub!: :delete_suffix!,
+          sub: :delete_suffix,
+          sub!: :delete_suffix!
+        }.freeze
+
+        def_node_matcher :delete_suffix_candidate?, <<~PATTERN
+          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
+        PATTERN
+
+        def on_send(node)
+          delete_suffix_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_suffix_candidate?(node) do |receiver, bad_method, regexp_str, _|
+            lambda do |corrector|
+              good_method = PREFERRED_METHODS[bad_method]
+              regexp_str = drop_end_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

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

@@ -28,7 +28,7 @@ module RuboCop
         REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
                       '`%<first_method>s.%<second_method>s`.'
 
-        def_node_matcher :detect_candidate?, <<-PATTERN
+        def_node_matcher :detect_candidate?, <<~PATTERN
           {
             (send $(block (send _ {:select :find_all}) ...) ${:first :last} $...)
             (send $(send _ {:select :find_all} ...) ${:first :last} $...)

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

@@ -75,13 +75,13 @@ module RuboCop
           cop_config['IncludeActiveSupportAliases']
         end
 
-        def_node_matcher :two_start_end_with_calls, <<-PATTERN
+        def_node_matcher :two_start_end_with_calls, <<~PATTERN
           (or
             (send $_recv [{:start_with? :end_with?} $_method] $...)
             (send _recv _method $...))
         PATTERN
 
-        def_node_matcher :check_with_active_support_aliases, <<-PATTERN
+        def_node_matcher :check_with_active_support_aliases, <<~PATTERN
           (or
             (send $_recv
                     [{:start_with? :starts_with? :end_with? :ends_with?} $_method]

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

@@ -3,8 +3,11 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies unnecessary use of a regex where `String#end_with?`
-      # would suffice.
+      # This cop identifies unnecessary use of a regex where `String#end_with?` would suffice.
+      #
+      # This cop has `SafeMultiline` configuration option that `true` by default because
+      # `end$` is unsafe as it will behave incompatible with `end_with?`
+      # for receiver is multiline string.
       #
       # @example
       #   # bad
@@ -17,24 +20,39 @@ module RuboCop
       #
       #   # good
       #   'abc'.end_with?('bc')
+      #
+      # @example SafeMultiline: true (default)
+      #
+      #   # good
+      #   'abc'.match?(/bc$/)
+      #   /bc$/.match?('abc')
+      #   'abc' =~ /bc$/
+      #   /bc$/ =~ 'abc'
+      #   'abc'.match(/bc$/)
+      #   /bc$/.match('abc')
+      #
+      # @example SafeMultiline: false
+      #
+      #   # bad
+      #   'abc'.match?(/bc$/)
+      #   /bc$/.match?('abc')
+      #   'abc' =~ /bc$/
+      #   /bc$/ =~ 'abc'
+      #   'abc'.match(/bc$/)
+      #   /bc$/.match('abc')
+      #
       class EndWith < Cop
+        include RegexpMetacharacter
+
         MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
               'the end of the string.'
-        SINGLE_QUOTE = "'"
 
-        def_node_matcher :redundant_regex?, <<-PATTERN
+        def_node_matcher :redundant_regex?, <<~PATTERN
           {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :match?} $_)
            (match-with-lvasgn (regexp (str $#literal_at_end?) (regopt)) $_)}
         PATTERN
 
-        def literal_at_end?(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?
-          regex_str =~ /\A(?:#{LITERAL_REGEX})+\\z\z/
-        end
-
         def on_send(node)
           return unless redundant_regex?(node)
 
@@ -45,7 +63,7 @@ module RuboCop
         def autocorrect(node)
           redundant_regex?(node) do |receiver, regex_str|
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
-            regex_str = regex_str[0..-3] # drop \Z anchor
+            regex_str = drop_end_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
 
             lambda do |corrector|

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

@@ -48,7 +48,7 @@ module RuboCop
       class FixedSize < Cop
         MSG = 'Do not compute the size of statically sized objects.'
 
-        def_node_matcher :counter, <<-MATCHER
+        def_node_matcher :counter, <<~MATCHER
           (send ${array hash str sym} {:count :length :size} $...)
         MATCHER
 

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

@@ -22,7 +22,7 @@ module RuboCop
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'
 
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
+        def_node_matcher :flat_map_candidate?, <<~PATTERN
           (send
             {
               (block $(send _ ${:collect :map}) ...)

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

@@ -37,7 +37,7 @@ module RuboCop
       #   h = { a: 1, b: 2 }; h.value?(nil)
       #
       class InefficientHashSearch < Cop
-        def_node_matcher :inefficient_include?, <<-PATTERN
+        def_node_matcher :inefficient_include?, <<~PATTERN
           (send (send $_ {:keys :values}) :include? _)
         PATTERN
 

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where inefficient `readlines` method
+      # can be replaced by `each_line` to avoid fully loading file content into memory.
+      #
+      # @example
+      #
+      #   # bad
+      #   File.readlines('testfile').each { |l| puts l }
+      #   IO.readlines('testfile', chomp: true).each { |l| puts l }
+      #
+      #   conn.readlines(10).map { |l| l.size }
+      #   file.readlines.find { |l| l.start_with?('#') }
+      #   file.readlines.each { |l| puts l }
+      #
+      #   # good
+      #   File.open('testfile', 'r').each_line { |l| puts l }
+      #   IO.open('testfile').each_line(chomp: true) { |l| puts l }
+      #
+      #   conn.each_line(10).map { |l| l.size }
+      #   file.each_line.find { |l| l.start_with?('#') }
+      #   file.each_line { |l| puts l }
+      #
+      class IoReadlines < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).freeze
+
+        def_node_matcher :readlines_on_class?, <<~PATTERN
+          $(send $(send (const nil? {:IO :File}) :readlines ...) #enumerable_method?)
+        PATTERN
+
+        def_node_matcher :readlines_on_instance?, <<~PATTERN
+          $(send $(send ${nil? !const_type?} :readlines ...) #enumerable_method? ...)
+        PATTERN
+
+        def on_send(node)
+          readlines_on_class?(node) do |enumerable_call, readlines_call|
+            offense(node, enumerable_call, readlines_call)
+          end
+
+          readlines_on_instance?(node) do |enumerable_call, readlines_call, _|
+            offense(node, enumerable_call, readlines_call)
+          end
+        end
+
+        def autocorrect(node)
+          readlines_on_instance?(node) do |enumerable_call, readlines_call, receiver|
+            # We cannot safely correct `.readlines` method called on IO/File classes
+            # due to its signature and we are not sure with implicit receiver
+            # if it is called in the context of some instance or mentioned class.
+            return if receiver.nil?
+
+            lambda do |corrector|
+              range = correction_range(enumerable_call, readlines_call)
+
+              if readlines_call.arguments?
+                call_args = build_call_args(readlines_call.arguments)
+                replacement = "each_line(#{call_args})"
+              else
+                replacement = 'each_line'
+              end
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def enumerable_method?(node)
+          ENUMERABLE_METHODS.include?(node.to_sym)
+        end
+
+        def offense(node, enumerable_call, readlines_call)
+          range = offense_range(enumerable_call, readlines_call)
+          good_method = build_good_method(enumerable_call)
+          bad_method = build_bad_method(enumerable_call)
+
+          add_offense(
+            node,
+            location: range,
+            message: format(MSG, good: good_method, bad: bad_method)
+          )
+        end
+
+        def offense_range(enumerable_call, readlines_call)
+          readlines_pos = readlines_call.loc.selector.begin_pos
+          enumerable_pos = enumerable_call.loc.selector.end_pos
+          range_between(readlines_pos, enumerable_pos)
+        end
+
+        def build_good_method(enumerable_call)
+          if enumerable_call.method?(:each)
+            'each_line'
+          else
+            "each_line.#{enumerable_call.method_name}"
+          end
+        end
+
+        def build_bad_method(enumerable_call)
+          "readlines.#{enumerable_call.method_name}"
+        end
+
+        def correction_range(enumerable_call, readlines_call)
+          begin_pos = readlines_call.loc.selector.begin_pos
+
+          end_pos = if enumerable_call.method?(:each)
+                      enumerable_call.loc.expression.end_pos
+                    else
+                      enumerable_call.loc.dot.begin_pos
+                    end
+
+          range_between(begin_pos, end_pos)
+        end
+
+        def build_call_args(call_args_node)
+          call_args_node.map(&:source).join(', ')
+        end
+      end
+    end
+  end
+end