rubocop 0.45.0 → 0.46.0

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

@@ -28,18 +28,25 @@ module RuboCop
         MSG = 'Use `%s` instead of `%s.%s`.'.freeze
         REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
 
-        SELECT_METHODS = [:select, :find_all].freeze
-        DANGEROUS_METHODS = [:first, :last].freeze
+        def_node_matcher :detect_candidate?, <<-PATTERN
+          {
+            (send $(block (send _ {:select :find_all}) ...) ${:first :last} $...)
+            (send $(send _ {:select :find_all} ...) ${:first :last} $...)
+          }
+        PATTERN
 
         def on_send(node)
           return if rails_safe_mode?
-          receiver, second_method, *args = *node
-          return if accept_second_call?(receiver, second_method, args)
 
-          receiver, _args, body = *receiver if receiver.block_type?
-          return if accept_first_call?(receiver, body)
+          detect_candidate?(node) do |receiver, second_method, args|
+            return unless args.empty?
+            return unless receiver
 
-          offense(node, receiver, second_method)
+            receiver, _args, body = *receiver if receiver.block_type?
+            return if accept_first_call?(receiver, body)
+
+            offense(node, receiver, second_method)
+          end
         end
 
         def autocorrect(node)
@@ -63,18 +70,11 @@ module RuboCop
 
         private
 
-        def accept_second_call?(receiver, method, args)
-          !receiver ||
-            !DANGEROUS_METHODS.include?(method) ||
-            !args.empty?
-        end
-
         def accept_first_call?(receiver, body)
-          caller, first_method, args = *receiver
+          caller, _first_method, args = *receiver
 
           # check that we have usual block or block pass
           return true if body.nil? && (args.nil? || !args.block_pass_type?)
-          return true unless SELECT_METHODS.include?(first_method)
 
           lazy?(caller)
         end

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

@@ -19,65 +19,53 @@ module RuboCop
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'.freeze
-        FLATTEN_METHODS = [:flatten, :flatten!].freeze
-        MAP_METHODS = [:map, :collect].freeze
 
-        def on_send(node)
-          left, second_method, flatten_param = *node
-          return unless flatten_method?(second_method)
-
-          flatten_level, = *flatten_param
-          expression, = *left
-          _array, first_method = *expression
-          return unless map_method?(first_method)
+        def_node_matcher :flat_map_candidate?, <<-PATTERN
+          (send (block $(send _ ${:collect :map}) ...) ${:flatten :flatten!} $...)
+        PATTERN
 
-          if cop_config['EnabledForFlattenWithoutParams'] && flatten_level.nil?
-            offense_for_levels(node, expression, first_method, second_method)
-          elsif flatten_level == 1
-            offense_for_method(node, expression, first_method, second_method)
+        def on_send(node)
+          flat_map_candidate?(node) do |map_node, first_method, flatten, params|
+            flatten_level, = *params.first
+            if cop_config['EnabledForFlattenWithoutParams'] &&
+               flatten_level.nil?
+              offense_for_levels(node, map_node, first_method, flatten)
+            elsif flatten_level == 1
+              offense_for_method(node, map_node, first_method, flatten)
+            end
           end
         end
 
         def autocorrect(node)
-          receiver, _flatten, flatten_param = *node
-          flatten_level, = *flatten_param
+          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
+          flatten_level, = *params.first
           return if flatten_level.nil?
 
-          array, = *receiver
-
           lambda do |corrector|
             range = range_between(node.loc.dot.begin_pos,
                                   node.source_range.end_pos)
 
             corrector.remove(range)
-            corrector.replace(array.loc.selector, 'flat_map')
+            corrector.replace(map_node.loc.selector, 'flat_map')
           end
         end
 
         private
 
-        def flatten_method?(method_name)
-          FLATTEN_METHODS.include?(method_name)
-        end
-
-        def map_method?(method_name)
-          MAP_METHODS.include?(method_name)
-        end
-
-        def offense_for_levels(node, expression, first_method, second_method)
+        def offense_for_levels(node, map_node, first_method, flatten)
           message = MSG + FLATTEN_MULTIPLE_LEVELS
-          offense(node, expression, first_method, second_method, message)
+          offense(node, map_node, first_method, flatten, message)
         end
 
-        def offense_for_method(node, expression, first_method, second_method)
-          offense(node, expression, first_method, second_method, MSG)
+        def offense_for_method(node, map_node, first_method, flatten)
+          offense(node, map_node, first_method, flatten, MSG)
         end
 
-        def offense(node, expression, first_method, second_method, message)
-          range = range_between(expression.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
+        def offense(node, map_node, first_method, flatten, message)
+          range = range_between(map_node.loc.selector.begin_pos,
+                                node.loc.expression.end_pos)
 
-          add_offense(node, range, format(message, first_method, second_method))
+          add_offense(node, range, format(message, first_method, flatten))
         end
       end
     end

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

@@ -27,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, range, 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 { |val| val.to_a.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/string_replacement.rb

@@ -21,22 +21,24 @@ module RuboCop
       class StringReplacement < Cop
         MSG = 'Use `%s` instead of `%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 |method, 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, method, first_param, second_param)
+          end
         end
 
         def autocorrect(node)
@@ -44,7 +46,7 @@ module RuboCop
           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
 
@@ -72,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
@@ -97,7 +95,7 @@ module RuboCop
 
         def offense(node, method, 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
@@ -106,28 +104,14 @@ module RuboCop
           add_offense(node, range(node), message)
         end
 
-        def string?(node)
-          node && node.str_type?
-        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
 
@@ -149,15 +133,6 @@ 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)
           range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end