rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -28,110 +27,112 @@ module RuboCop
       class Sample < Cop
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'.freeze
 
-        def on_send(node)
-          analyzer = ShuffleAnalyzer.new(node)
-          return unless analyzer.offensive?
-          add_offense(node, analyzer.source_range, analyzer.message)
-        end
-
-        def autocorrect(node)
-          ShuffleAnalyzer.new(node).autocorrect
-        end
-
-        # An internal class for representing a shuffle + method node analyzer.
-        class ShuffleAnalyzer
-          def initialize(shuffle_node)
-            @shuffle_node = shuffle_node
-            @method_node  = shuffle_node.parent
-          end
+        def_node_matcher :sample_candidate?, <<-PATTERN
+          (send $(send _ :shuffle $...) ${:first :last :[]} $...)
+        PATTERN
 
-          def autocorrect
-            ->(corrector) { corrector.replace(source_range, correct) }
-          end
+        def on_send(node)
+          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+            return unless offensive?(method, method_args)
 
-          def message
-            format(MSG, correct: correct, incorrect: source_range.source)
+            range = source_range(shuffle, node)
+            message = message(shuffle_arg, method, method_args, range)
+            add_offense(node, location: range, message: message)
           end
+        end
 
-          def offensive?
-            shuffle_node.to_a[1] == :shuffle && corrigible?
-          end
+        def autocorrect(node)
+          shuffle_node, shuffle_arg, method, method_args =
+            sample_candidate?(node)
 
-          def source_range
-            Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
-                                      shuffle_node.loc.selector.begin_pos,
-                                      method_node.source_range.end_pos)
+          lambda do |corrector|
+            corrector.replace(source_range(shuffle_node, node),
+                              correction(shuffle_arg, method, method_args))
           end
+        end
 
-          private
-
-          attr_reader :method_node, :shuffle_node
+        private
 
-          def correct
-            args = [sample_arg, shuffle_arg].compact.join(', ')
-            args.empty? ? 'sample' : "sample(#{args})"
+        def offensive?(method, method_args)
+          case method
+          when :first, :last
+            true
+          when :[]
+            sample_size(method_args) != :unknown
+          else
+            false
           end
+        end
 
-          def corrigible?
-            case method
-            when :first, :last then true
-            when :[]           then sample_size != :unknown
-            else false
-            end
+        def sample_size(method_args)
+          case method_args.size
+          when 1
+            sample_size_for_one_arg(method_args.first)
+          when 2
+            sample_size_for_two_args(*method_args)
           end
+        end
 
-          def method
-            method_node.to_a[1]
+        def sample_size_for_one_arg(arg)
+          case arg.type
+          when :erange, :irange
+            range_size(arg)
+          when :int
+            arg.to_a.first.zero? ? nil : :unknown
+          else
+            :unknown
           end
+        end
 
-          def method_arg
-            _, _, arg = *method_node
-            arg.source if arg
-          end
+        def sample_size_for_two_args(first, second)
+          return :unknown unless first.int_type? && first.to_a.first.zero?
+          second.int_type? ? second.to_a.first : :unknown
+        end
 
-          def range_size(range_node)
-            vals = *range_node
-            return :unknown unless vals.all?(&:int_type?)
-            low, high = *vals.map(&:to_a).map(&:first)
-            return :unknown unless low.zero? && high >= 0
-            case range_node.type
-            when :erange then high - low
-            when :irange then high - low + 1
-            end
+        def range_size(range_node)
+          vals = range_node.to_a
+          return :unknown unless vals.all?(&:int_type?)
+          low, high = vals.map { |val| val.children[0] }
+          return :unknown unless low.zero? && high >= 0
+
+          case range_node.type
+          when :erange
+            (low...high).size
+          when :irange
+            (low..high).size
           end
+        end
 
-          def sample_arg
-            case method
-            when :first, :last then method_arg
-            when :[]           then sample_size
-            end
-          end
+        def source_range(shuffle_node, node)
+          Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
+                                    shuffle_node.loc.selector.begin_pos,
+                                    node.source_range.end_pos)
+        end
 
-          def sample_size
-            _, _, *args = *method_node
-            case args.size
-            when 1 then sample_size_for_one_arg(args.first)
-            when 2 then sample_size_for_two_args(*args)
-            end
-          end
+        def message(shuffle_arg, method, method_args, range)
+          format(MSG,
+                 correct: correction(shuffle_arg, method, method_args),
+                 incorrect: range.source)
+        end
 
-          def sample_size_for_one_arg(arg)
-            case arg.type
-            when :erange, :irange then range_size(arg)
-            when :int             then arg.to_a.first.zero? ? nil : :unknown
-            else :unknown
-            end
-          end
+        def correction(shuffle_arg, method, method_args)
+          shuffle_arg = extract_source(shuffle_arg)
+          sample_arg = sample_arg(method, method_args)
+          args = [sample_arg, shuffle_arg].compact.join(', ')
+          args.empty? ? 'sample' : "sample(#{args})"
+        end
 
-          def sample_size_for_two_args(first, second)
-            return :unknown unless first.int_type? && first.to_a.first.zero?
-            second.int_type? ? second.to_a.first : :unknown
+        def sample_arg(method, method_args)
+          case method
+          when :first, :last
+            extract_source(method_args)
+          when :[]
+            sample_size(method_args)
           end
+        end
 
-          def shuffle_arg
-            _, _, arg = *shuffle_node
-            arg.source if arg
-          end
+        def extract_source(args)
+          args.empty? ? nil : args.first.source
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -28,15 +27,9 @@ module RuboCop
         MSG = 'Use `size` instead of `count`.'.freeze
 
         def on_send(node)
-          receiver, method, args = *node
+          return unless eligible_node?(node)
 
-          return if receiver.nil?
-          return unless method == :count
-          return unless array?(receiver) || hash?(receiver)
-          return if node.parent && node.parent.block_type?
-          return if args
-
-          add_offense(node, node.loc.selector)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -45,18 +38,32 @@ module RuboCop
 
         private
 
+        def eligible_node?(node)
+          return false unless node.method?(:count) && !node.arguments?
+
+          eligible_receiver?(node.receiver) && !allowed_parent?(node.parent)
+        end
+
+        def eligible_receiver?(node)
+          return false unless node
+
+          array?(node) || hash?(node)
+        end
+
+        def allowed_parent?(node)
+          node && node.block_type?
+        end
+
         def array?(node)
-          receiver, method = *node
-          _, constant = *receiver
+          _, constant = *node.receiver
 
-          node.array_type? || constant == :Array || method == :to_a
+          node.array_type? || constant == :Array || node.method_name == :to_a
         end
 
         def hash?(node)
-          receiver, method = *node
-          _, constant = *receiver
+          _, constant = *node.receiver
 
-          node.hash_type? || constant == :Hash || method == :to_h
+          node.hash_type? || constant == :Hash || node.method_name == :to_h
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,22 +7,21 @@ module RuboCop
       # `String#start_with?` would suffice.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc' =~ /\Aab/
       #   'abc'.match(/\Aab/)
       #
-      #   @good
-      #   'abc' =~ /ab/
-      #   'abc' =~ /\A\w*/
+      #   # good
+      #   'abc'.start_with?('ab')
       class StartWith < Cop
         MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
               'the beginning of the string.'.freeze
         SINGLE_QUOTE = "'".freeze
 
-        def_node_matcher :redundant_regex?, <<-END
-          {(send $!nil {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+        def_node_matcher :redundant_regex?, <<-PATTERN
+          {(send $!nil? {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
-        END
+        PATTERN
 
         def literal_at_start?(regex_str)
           # is this regexp 'literal' in the sense of only matching literal
@@ -36,7 +34,9 @@ module RuboCop
         end
 
         def on_send(node)
-          add_offense(node, :expression, MSG) if redundant_regex?(node)
+          return unless redundant_regex?(node)
+
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,49 +7,51 @@ module RuboCop
       # `tr` or `delete`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc'.gsub('b', 'd')
       #   'abc'.gsub('a', '')
       #   'abc'.gsub(/a/, 'd')
       #   'abc'.gsub!('a', 'd')
       #
-      #   @good
+      #   # good
       #   'abc'.gsub(/.*/, 'a')
       #   'abc'.gsub(/a+/, 'd')
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
-        REGEXP_CONSTRUCTOR_METHODS = [:new, :compile].freeze
-        GSUB_METHODS = [:gsub, :gsub!].freeze
-        DETERMINISTIC_TYPES = [:regexp, :str, :send].freeze
         DELETE = 'delete'.freeze
         TR = 'tr'.freeze
         BANG = '!'.freeze
         SINGLE_QUOTE = "'".freeze
 
-        def on_send(node)
-          _string, method, first_param, second_param = *node
+        def_node_matcher :string_replacement?, <<-PATTERN
+          (send _ {:gsub :gsub!}
+                    ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
+                    $str)
+        PATTERN
 
-          return unless GSUB_METHODS.include?(method)
-          return if accept_second_param?(second_param)
-          return if accept_first_param?(first_param)
+        def on_send(node)
+          string_replacement?(node) do |first_param, second_param|
+            return if accept_second_param?(second_param)
+            return if accept_first_param?(first_param)
 
-          offense(node, method, first_param, second_param)
+            offense(node, first_param, second_param)
+          end
         end
 
         def autocorrect(node)
-          _string, method, first_param, second_param = *node
+          _string, _method, first_param, second_param = *node
           first_source, = first_source(first_param)
           second_source, = *second_param
 
-          if regex?(first_param)
+          unless first_param.str_type?
             first_source = interpret_string_escapes(first_source)
           end
 
           replacement_method =
-            replacement_method(method, first_source, second_source)
+            replacement_method(node, first_source, second_source)
 
           replace_method(node, first_source, second_source, first_param,
                          replacement_method)
@@ -73,19 +74,15 @@ module RuboCop
         private
 
         def accept_second_param?(second_param)
-          return true unless string?(second_param)
           second_source, = *second_param
-
           second_source.length > 1
         end
 
         def accept_first_param?(first_param)
-          return true unless DETERMINISTIC_TYPES.include?(first_param.type)
-
           first_source, options = first_source(first_param)
           return true if first_source.nil?
 
-          if regex?(first_param)
+          unless first_param.str_type?
             return true if options
             return true unless first_source =~ DETERMINISTIC_REGEX
             # This must be done after checking DETERMINISTIC_REGEX
@@ -96,39 +93,25 @@ module RuboCop
           first_source.length != 1
         end
 
-        def offense(node, method, first_param, second_param)
+        def offense(node, first_param, second_param)
           first_source, = first_source(first_param)
-          if regex?(first_param)
+          unless first_param.str_type?
             first_source = interpret_string_escapes(first_source)
           end
           second_source, = *second_param
-          message = message(method, first_source, second_source)
-
-          add_offense(node, range(node), message)
-        end
+          message = message(node, first_source, second_source)
 
-        def string?(node)
-          node && node.str_type?
+          add_offense(node, location: range(node), message: message)
         end
 
         def first_source(first_param)
           case first_param.type
-          when :regexp, :send
-            return nil unless regex?(first_param)
-            source, options = extract_source(first_param)
-          when :str
-            source, = *first_param
-          end
-
-          [source, options]
-        end
-
-        def extract_source(node)
-          case node.type
           when :regexp
-            source_from_regex_literal(node)
+            source_from_regex_literal(first_param)
           when :send
-            source_from_regex_constructor(node)
+            source_from_regex_constructor(first_param)
+          when :str
+            first_param.children.first
           end
         end
 
@@ -150,41 +133,25 @@ module RuboCop
           end
         end
 
-        def regex?(node)
-          return true if node.regexp_type?
-
-          const, init, = *node
-          _, klass = *const
-
-          klass == :Regexp && REGEXP_CONSTRUCTOR_METHODS.include?(init)
-        end
-
         def range(node)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    node.source_range.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
-        def replacement_method(method, first_source, second_source)
+        def replacement_method(node, first_source, second_source)
           replacement = if second_source.empty? && first_source.length == 1
                           DELETE
                         else
                           TR
                         end
 
-          "#{replacement}#{BANG if bang_method?(method)}"
+          "#{replacement}#{BANG if node.bang_method?}"
         end
 
-        def message(method, first_source, second_source)
-          replacement_method = replacement_method(method,
-                                                  first_source,
-                                                  second_source)
-
-          format(MSG, replacement_method, method)
-        end
+        def message(node, first_source, second_source)
+          replacement_method =
+            replacement_method(node, first_source, second_source)
 
-        def bang_method?(method)
-          method.to_s.end_with?(BANG)
+          format(MSG, prefer: replacement_method, current: node.method_name)
         end
 
         def method_suffix(node)
@@ -192,10 +159,8 @@ module RuboCop
         end
 
         def remove_second_param(corrector, node, first_param)
-          end_range =
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      first_param.source_range.end_pos,
-                                      node.source_range.end_pos)
+          end_range = range_between(first_param.source_range.end_pos,
+                                    node.source_range.end_pos)
 
           corrector.replace(end_range, method_suffix(node))
         end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,18 +8,19 @@ module RuboCop
       # with an explicit array creation.
       #
       # @example
-      #
-      #   @bad
+      #   # bad
       #   9.times.map do |i|
       #     i.to_s
       #   end
       #
-      #   @good
+      #   # good
       #   Array.new(9) do |i|
       #     i.to_s
       #   end
       class TimesMap < Cop
-        MSG = 'Use `Array.new` with a block instead of `.times.%s`.'.freeze
+        MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
+                  'instead of `.times.%<map_or_collect>s`'.freeze
+        MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'.freeze
 
         def on_send(node)
           check(node)
@@ -30,32 +30,41 @@ module RuboCop
           check(node)
         end
 
-        private
+        def autocorrect(node)
+          map_or_collect, count = times_map_call(node)
 
-        def check(node)
-          times_map_call(node) do |map_or_collect|
-            add_offense(node, :expression, format(MSG, map_or_collect))
+          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
 
-        def_node_matcher :times_map_call, <<-END
-          {(block (send (send !nil :times) ${:map :collect}) ...)
-           (send (send !nil :times) ${:map :collect} (block_pass ...))}
-        END
-
-        def autocorrect(node)
-          send_node = node.send_type? ? node : node.each_descendant(:send).first
-
-          receiver, _method_name, *args = *send_node
-          count, = *receiver
-
-          replacement = "Array.new(#{count.source}" \
-                        "#{args.map { |arg| ", #{arg.source}" }.join})"
+        private
 
-          lambda do |corrector|
-            corrector.replace(send_node.loc.expression, replacement)
+        def check(node)
+          times_map_call(node) do |map_or_collect, count|
+            add_offense(node, message: message(map_or_collect, count))
           end
         end
+
+        def message(map_or_collect, count)
+          template = if count.literal?
+                       MESSAGE + '.'
+                     else
+                       "#{MESSAGE} #{MESSAGE_ONLY_IF}."
+                     end
+          format(template,
+                 count: count.source,
+                 map_or_collect: map_or_collect.method_name)
+        end
+
+        def_node_matcher :times_map_call, <<-PATTERN
+          {(block $(send (send $!nil? :times) {:map :collect}) ...)
+           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
+        PATTERN
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.3 or later, use unary plus operator to unfreeze a string
+      # 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 `+''`.
+      # 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.
+      #
+      # @example
+      #   # bad
+      #   ''.dup
+      #   "something".dup
+      #   String.new
+      #   String.new('')
+      #   String.new('something')
+      #
+      #   # good
+      #   +'something'
+      #   +''
+      class UnfreezeString < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
+
+        MSG = 'Use unary plus to get an unfrozen string literal.'.freeze
+
+        def_node_matcher :dup_string?, <<-PATTERN
+          (send {str dstr} :dup)
+        PATTERN
+
+        def_node_matcher :string_new?, <<-PATTERN
+          {
+            (send (const nil? :String) :new {str dstr})
+            (send (const nil? :String) :new)
+          }
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if dup_string?(node) || string_new?(node)
+        end
+      end
+    end
+  end
+end