rubocop 0.42.0 → 0.43.0

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

@@ -24,6 +24,8 @@ module RuboCop
       # own meaning. Correcting ActiveRecord methods with this cop should be
       # considered unsafe.
       class Detect < Cop
+        include SafeMode
+
         MSG = 'Use `%s` instead of `%s.%s`.'.freeze
         REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
 
@@ -31,7 +33,7 @@ module RuboCop
         DANGEROUS_METHODS = [:first, :last].freeze
 
         def on_send(node)
-          return unless should_run?
+          return if rails_safe_mode?
           receiver, second_method, *args = *node
           return if accept_second_call?(receiver, second_method, args)
 
@@ -62,12 +64,6 @@ module RuboCop
 
         private
 
-        def should_run?
-          !(cop_config['SafeMode'.freeze] ||
-            config['Rails'.freeze] &&
-            config['Rails'.freeze]['Enabled'.freeze])
-        end
-
         def accept_second_call?(receiver, method, args)
           !receiver ||
             !DANGEROUS_METHODS.include?(method) ||

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

@@ -33,19 +33,11 @@ module RuboCop
           first_call_args,
           second_call_args = two_start_end_with_calls(node)
 
-          if receiver && second_call_args.all?(&:pure?)
-            add_offense(
-              node,
-              :expression,
-              format(
-                MSG,
-                receiver: receiver.source,
-                method: method,
-                combined_args: combine_args(first_call_args, second_call_args),
-                original_code: node.source
-              )
-            )
-          end
+          return unless receiver && second_call_args.all?(&:pure?)
+
+          combined_args = combine_args(first_call_args, second_call_args)
+
+          add_offense_for_double_call(node, receiver, method, combined_args)
         end
 
         private
@@ -54,6 +46,18 @@ module RuboCop
           (first_call_args + second_call_args).map(&:source).join(', ')
         end
 
+        def add_offense_for_double_call(node, receiver, method, combined_args)
+          add_offense(node,
+                      :expression,
+                      format(
+                        MSG,
+                        receiver: receiver.source,
+                        method: method,
+                        combined_args: combined_args,
+                        original_code: node.source
+                      ))
+        end
+
         def_node_matcher :two_start_end_with_calls, <<-END
           (or
             (send $_recv [{:start_with? :end_with?} $_method] $...)

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

@@ -13,13 +13,10 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          counter(node) do |variable, arg|
-            return if contains_splat?(variable)
-            return if contains_double_splat?(variable)
-            return if !arg.nil? && string_argument?(arg.first)
-            if node.parent
-              return if node.parent.casgn_type? || node.parent.block_type?
-            end
+          return if allowed_parent?(node.parent)
+
+          counter(node) do |var, arg|
+            return if allowed_variable?(var) || allowed_argument?(arg)
 
             add_offense(node, :expression)
           end
@@ -27,23 +24,31 @@ module RuboCop
 
         private
 
+        def allowed_variable?(var)
+          contains_splat?(var) || contains_double_splat?(var)
+        end
+
+        def allowed_argument?(arg)
+          arg && non_string_argument?(arg.first)
+        end
+
+        def allowed_parent?(node)
+          node && (node.casgn_type? || node.block_type?)
+        end
+
         def contains_splat?(node)
           return unless node.array_type?
 
-          node.children.any? do |child|
-            child.respond_to?(:splat_type?) && child.splat_type?
-          end
+          node.each_child_node(:splat).any?
         end
 
         def contains_double_splat?(node)
           return unless node.hash_type?
 
-          node.children.any? do |child|
-            child.respond_to?(:kwsplat_type?) && child.kwsplat_type?
-          end
+          node.each_child_node(:kwsplat).any?
         end
 
-        def string_argument?(node)
+        def non_string_argument?(node)
           node && !node.str_type?
         end
       end

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

@@ -20,16 +20,17 @@ module RuboCop
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'.freeze
-        FLATTEN = [:flatten, :flatten!].freeze
+        FLATTEN_METHODS = [:flatten, :flatten!].freeze
+        MAP_METHODS = [:map, :collect].freeze
 
         def on_send(node)
           left, second_method, flatten_param = *node
-          return unless FLATTEN.include?(second_method)
+          return unless flatten_method?(second_method)
 
           flatten_level, = *flatten_param
           expression, = *left
           _array, first_method = *expression
-          return unless first_method == :map || first_method == :collect
+          return unless map_method?(first_method)
 
           if cop_config['EnabledForFlattenWithoutParams'] && flatten_level.nil?
             offense_for_levels(node, expression, first_method, second_method)
@@ -46,9 +47,8 @@ module RuboCop
           array, = *receiver
 
           lambda do |corrector|
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              node.loc.dot.begin_pos,
-                                              node.source_range.end_pos)
+            range = range_between(node.loc.dot.begin_pos,
+                                  node.source_range.end_pos)
 
             corrector.remove(range)
             corrector.replace(array.loc.selector, 'flat_map')
@@ -57,6 +57,14 @@ module RuboCop
 
         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)
           message = MSG + FLATTEN_MULTIPLE_LEVELS
           offense(node, expression, first_method, second_method, message)
@@ -67,9 +75,8 @@ module RuboCop
         end
 
         def offense(node, expression, first_method, second_method, message)
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            expression.loc.selector.begin_pos,
-                                            node.loc.selector.end_pos)
+          range = range_between(expression.loc.selector.begin_pos,
+                                node.loc.selector.end_pos)
 
           add_offense(node, range, format(message, first_method, second_method))
         end

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

@@ -70,9 +70,8 @@ module RuboCop
         def correct_args(node, corrector)
           args = node.parent.children[1]
           used_arg = "|#{@args.detect { |_k, v| v }.first}|"
-          args_range = Parser::Source::Range.new(node.parent.source,
-                                                 args.loc.begin.begin_pos,
-                                                 args.loc.end.end_pos)
+          args_range = range_between(args.loc.begin.begin_pos,
+                                     args.loc.end.end_pos)
           corrector.replace(args_range, used_arg)
         end
 

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

@@ -24,18 +24,16 @@ module RuboCop
 
         def on_send(node)
           lstrip_rstrip(node) do |first_send, method_one, method_two|
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              first_send.loc.selector.begin_pos,
-                                              node.source_range.end_pos)
+            range = range_between(first_send.loc.selector.begin_pos,
+                                  node.source_range.end_pos)
             add_offense(node, range, format(MSG, method_one, method_two))
           end
         end
 
         def autocorrect(node)
           first_send, = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            first_send.loc.selector.begin_pos,
-                                            node.source_range.end_pos)
+          range = range_between(first_send.loc.selector.begin_pos,
+                                node.source_range.end_pos)
           ->(corrector) { corrector.replace(range, 'strip') }
         end
       end

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

@@ -40,9 +40,12 @@ module RuboCop
         end
 
         def autocorrect(node)
+          receiver, _method, arg = *node
+
           # Regexp#match can take a second argument, but this cop doesn't
           # register an offense in that case
-          receiver, _method, arg = *node
+          return unless arg.regexp_type?
+
           new_source = receiver.source + ' =~ ' + arg.source
           ->(corrector) { corrector.replace(node.source_range, new_source) }
         end

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

@@ -16,12 +16,9 @@ module RuboCop
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
         def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
-        def_node_matcher :modifier_flow_control, <<-END
+        def_node_matcher :modifier_flow_control?, <<-END
           [{if while until} modifier_form?]
         END
-        def_node_matcher :each_with_object_node, <<-END
-          (block (send _ :each_with_object _) (args _ $_) ...)
-        END
 
         def on_send(node)
           each_redundant_merge(node) do |receiver, pairs|
@@ -33,21 +30,13 @@ module RuboCop
 
         def autocorrect(node)
           redundant_merge(node) do |receiver, pairs|
-            lambda do |corrector|
-              new_source = to_assignments(receiver, pairs).join("\n")
-
-              parent = node.parent
-              if parent && pairs.size > 1
-                if modifier_flow_control(parent)
-                  new_source = rewrite_with_modifier(node, parent, new_source)
-                  node = parent
-                else
-                  padding = "\n#{leading_spaces(node)}"
-                  new_source.gsub!(/\n/, padding)
-                end
-              end
-
-              corrector.replace(node.source_range, new_source)
+            new_source = to_assignments(receiver, pairs).join("\n")
+
+            parent = node.parent
+            if parent && pairs.size > 1
+              correct_multiple_elements(node, parent, new_source)
+            else
+              correct_single_element(node, new_source)
             end
           end
         end
@@ -57,7 +46,7 @@ module RuboCop
         def each_redundant_merge(node)
           redundant_merge(node) do |receiver, pairs|
             next if node.value_used? &&
-                    !value_used_inside_each_with_object?(node, receiver)
+                    !EachWithObjectInspector.new(node, receiver).value_used?
             next if pairs.size > 1 && !receiver.pure?
             next if pairs.size > max_key_value_pairs
 
@@ -65,21 +54,20 @@ module RuboCop
           end
         end
 
-        def value_used_inside_each_with_object?(node, receiver)
-          while receiver.respond_to?(:send_type?) && receiver.send_type?
-            receiver, = *receiver
-          end
-
-          unless receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
-            return false
+        def correct_multiple_elements(node, parent, new_source)
+          if modifier_flow_control?(parent)
+            new_source = rewrite_with_modifier(node, parent, new_source)
+            node = parent
+          else
+            padding = "\n#{leading_spaces(node)}"
+            new_source.gsub!(/\n/, padding)
           end
 
-          parent = node.parent
-          grandparent = parent.parent if parent.begin_type?
-          second_arg = each_with_object_node(grandparent || parent)
-          return false if second_arg.nil?
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
 
-          receiver.loc.name.source == second_arg.loc.name.source
+        def correct_single_element(node, new_source)
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
 
         def to_assignments(receiver, pairs)
@@ -115,6 +103,49 @@ module RuboCop
         def max_key_value_pairs
           cop_config['MaxKeyValuePairs'].to_i
         end
+
+        # A utility class for checking the use of values within an
+        # `each_with_object` call.
+        class EachWithObjectInspector
+          extend NodePattern::Macros
+
+          def initialize(node, receiver)
+            @node = node
+            @receiver = unwind(receiver)
+          end
+
+          def value_used?
+            return false unless eligible_receiver? && second_argument
+
+            receiver.loc.name.source == second_argument.loc.name.source
+          end
+
+          private
+
+          attr_reader :node, :receiver
+
+          def eligible_receiver?
+            receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
+          end
+
+          def second_argument
+            parent = node.parent
+            parent = parent.parent if parent.begin_type?
+
+            @second_argument ||= each_with_object_node(parent)
+          end
+
+          def unwind(receiver)
+            while receiver.respond_to?(:send_type?) && receiver.send_type?
+              receiver, = *receiver
+            end
+            receiver
+          end
+
+          def_node_matcher :each_with_object_node, <<-END
+            (block (send _ :each_with_object _) (args _ $_) ...)
+          END
+        end
       end
     end
   end

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

@@ -25,19 +25,20 @@ module RuboCop
 
         def on_block(node)
           redundant_sort_by(node) do |send, var_name|
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              send.loc.selector.begin_pos,
-                                              node.loc.end.end_pos)
+            range = sort_by_range(send, node)
             add_offense(node, range, format(MSG, var_name, var_name))
           end
         end
 
         def autocorrect(node)
           send, = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            send.loc.selector.begin_pos,
-                                            node.loc.end.end_pos)
-          ->(corrector) { corrector.replace(range, 'sort') }
+          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
+        end
+
+        private
+
+        def sort_by_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end
       end
     end

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

@@ -23,13 +23,10 @@ module RuboCop
 
         def on_send(node)
           reverse_each?(node) do |receiver|
-            source_buffer = node.source_range.source_buffer
             location_of_reverse = receiver.loc.selector.begin_pos
             end_location = node.loc.selector.end_pos
 
-            range = Parser::Source::Range.new(source_buffer,
-                                              location_of_reverse,
-                                              end_location)
+            range = range_between(location_of_reverse, end_location)
             add_offense(node, range, MSG)
           end
         end

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

@@ -28,22 +28,35 @@ module RuboCop
         MSG = 'Use `size` instead of `count`.'.freeze
 
         def on_send(node)
-          receiver, method, args = *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
+          return unless eligible_node?(node)
 
           add_offense(node, node.loc.selector)
         end
 
+        private
+
         def autocorrect(node)
           ->(corrector) { corrector.replace(node.loc.selector, 'size') }
         end
 
-        private
+        def eligible_node?(node)
+          receiver, method, args = *node
+
+          return false unless method == :count
+          return false if args
+
+          eligible_receiver?(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