rubocop 0.38.0 → 0.39.0

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

@@ -18,6 +18,11 @@ module RuboCop
       #   # good
       #   [].detect { |item| true }
       #   [].reverse.detect { |item| true }
+      #
+      # `ActiveRecord` compatibility:
+      # `ActiveRecord` does not implement a `detect` method and `find` has its
+      # own meaning. Correcting ActiveRecord methods with this cop should be
+      # considered unsafe.
       class Detect < Cop
         MSG = 'Use `%s` instead of `%s.%s`.'.freeze
         REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
@@ -26,6 +31,7 @@ module RuboCop
         DANGEROUS_METHODS = [:first, :last].freeze
 
         def on_send(node)
+          return unless should_run?
           receiver, second_method, *args = *node
           return unless check_second_call(receiver, second_method, args)
 
@@ -67,6 +73,12 @@ module RuboCop
 
         private
 
+        def should_run?
+          !(cop_config['SafeMode'.freeze] ||
+            config['Rails'.freeze] &&
+            config['Rails'.freeze]['Enabled'.freeze])
+        end
+
         def check_second_call(receiver, method, args)
           receiver &&
             DANGEROUS_METHODS.include?(method) &&

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

@@ -17,10 +17,19 @@ module RuboCop
 
         def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
         def_node_matcher :modifier_flow_control, '[{if while until} #modifier?]'
+        def_node_matcher :each_with_object_node, <<-END
+          (block (send _ :each_with_object _) (args _ $_) ...)
+        END
 
         def on_send(node)
           redundant_merge(node) do |receiver, pairs|
-            next if node.value_used?
+            if node.value_used?
+              parent = node.parent
+              grandparent = parent.parent if parent.begin_type?
+              second_arg = each_with_object_node(grandparent || parent)
+              next if second_arg.nil?
+              next unless receiver.loc.name.source == second_arg.loc.name.source
+            end
             next if pairs.size > 1 && !receiver.pure?
             next if pairs.size > max_key_value_pairs
 

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

@@ -42,6 +42,20 @@ module RuboCop
           {(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})"
+
+          lambda do |corrector|
+            corrector.replace(send_node.loc.expression, replacement)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/case_indentation.rb

@@ -64,20 +64,27 @@ module RuboCop
         end
 
         def autocorrect(node)
+          whitespace = whitespace_range(node)
+          return false unless whitespace.source.strip.empty?
+
+          ->(corrector) { corrector.replace(whitespace, replacement(node)) }
+        end
+
+        def whitespace_range(node)
           when_column = node.location.keyword.column
-          source_buffer = node.source_range.source_buffer
           begin_pos = node.loc.keyword.begin_pos
-          whitespace = Parser::Source::Range.new(source_buffer,
-                                                 begin_pos - when_column,
-                                                 begin_pos)
-          return false unless whitespace.source.strip.empty?
 
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    begin_pos - when_column,
+                                    begin_pos)
+        end
+
+        def replacement(node)
           case_node = node.each_ancestor(:case).first
           base_type = cop_config[parameter_name] == 'end' ? :end : :case
           column = base_column(case_node, base_type)
           column += configured_indentation_width if cop_config['IndentOneStep']
-
-          ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+          ' ' * column
         end
       end
     end

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -28,13 +28,6 @@ module RuboCop
           when_branches.map { |branch| branch.children[1] }
         end
 
-        def correct_branches(corrector, branches)
-          branches.each do |branch|
-            *_, assignment = *branch
-            corrector.replace(branch.source_range, assignment.source)
-          end
-        end
-
         def tail(branch)
           branch.begin_type? ? [*branch].last : branch
         end
@@ -89,7 +82,7 @@ module RuboCop
             indices = node.children[2...-1].map(&:source).join(', ')
             "#{receiver}[#{indices}] = "
           elsif node.method_name.to_s.end_with?(EQUAL) &&
-                ![:!=, :==].include?(node.method_name)
+                ![:!=, :==, :===, :>=, :<=].include?(node.method_name)
             "#{receiver}.#{node.method_name[0...-1]} = "
           else
             "#{receiver} #{node.method_name} "
@@ -102,6 +95,8 @@ module RuboCop
       # condition can be used instead.
       #
       # @example
+      #   EnforcedStyle: assign_to_condition
+      #
       #   # bad
       #   if foo
       #     bar = 1
@@ -145,12 +140,61 @@ module RuboCop
       #            some_other_method
       #            2
       #          end
+      #
+      #   EnforcedStyle: assign_inside_condition
+      #   # bad
+      #   bar = if foo
+      #           1
+      #         else
+      #           2
+      #         end
+      #
+      #   bar += case foo
+      #          when 'a'
+      #            1
+      #          else
+      #            2
+      #          end
+      #
+      #   bar << if foo
+      #            some_method
+      #            1
+      #          else
+      #            some_other_method
+      #            2
+      #          end
+      #
+      #   # good
+      #   if foo
+      #     bar = 1
+      #   else
+      #     bar = 2
+      #   end
+      #
+      #   case foo
+      #   when 'a'
+      #     bar += 1
+      #   else
+      #     bar += 2
+      #   end
+      #
+      #   if foo
+      #     some_method
+      #     bar = 1
+      #   else
+      #     some_other_method
+      #     bar = 2
+      #   end
       class ConditionalAssignment < Cop
         include IfNode
         include ConditionalAssignmentHelper
+        include ConfigurableEnforcedStyle
+        include IgnoredNode
 
         MSG = 'Use the return of the conditional for variable assignment ' \
               'and comparison.'.freeze
+        ASSIGN_TO_CONDITION_MSG =
+          'Assign variables inside of conditionals'.freeze
         VARIABLE_ASSIGNMENT_TYPES =
           [:casgn, :cvasgn, :gvasgn, :ivasgn, :lvasgn].freeze
         ASSIGNMENT_TYPES =
@@ -164,13 +208,40 @@ module RuboCop
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'.freeze
         WIDTH = 'Width'.freeze
         METHODS = [:[]=, :<<, :=~, :!~, :<=>].freeze
+        CONDITION_TYPES = [:if, :case].freeze
 
-        def lhs_all_match?(branches)
-          first_lhs = lhs(branches.first)
-          branches.all? { |branch| lhs(branch) == first_lhs }
+        ASSIGNMENT_TYPES.each do |type|
+          define_method "on_#{type}" do |node|
+            return if part_of_ignored_node?(node)
+            check_assignment_to_condition(node)
+          end
+        end
+
+        def on_send(node)
+          return unless assignment_type?(node)
+          check_assignment_to_condition(node)
+        end
+
+        def check_assignment_to_condition(node)
+          return unless style == :assign_inside_condition
+          ignore_node(node)
+          *_variable, assignment = *node
+          if assignment.respond_to?(:type)
+            if assignment.begin_type? && assignment.children.size == 1
+              assignment, = *assignment
+            end
+
+            return unless CONDITION_TYPES.include?(assignment.type)
+          end
+          _condition, *branches, else_branch = *assignment
+          return unless else_branch # empty else
+          return if single_line_conditions_only? &&
+                    [*branches, else_branch].any?(&:begin_type?)
+          add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
         end
 
         def on_if(node)
+          return unless style == :assign_to_condition
           return if elsif?(node)
 
           _condition, if_branch, else_branch = *node
@@ -183,6 +254,7 @@ module RuboCop
         end
 
         def on_case(node)
+          return unless style == :assign_to_condition
           _condition, *when_branches, else_branch = *node
           return unless else_branch # empty else
 
@@ -193,21 +265,42 @@ module RuboCop
         end
 
         def autocorrect(node)
+          if assignment_type?(node)
+            move_assignment_inside_condition(node)
+          else
+            move_assignment_outside_condition(node)
+          end
+        end
+
+        private
+
+        def move_assignment_outside_condition(node)
           if ternary_op?(node)
             TernaryCorrector.correct(node)
+          elsif node.loc.keyword.is?(IF)
+            IfCorrector.correct(self, node)
+          elsif node.loc.keyword.is?(UNLESS)
+            UnlessCorrector.correct(self, node)
           else
-            case node.loc.keyword.source
-            when IF
-              IfCorrector.correct(self, node)
-            when UNLESS
-              UnlessCorrector.correct(self, node)
-            else
-              CaseCorrector.correct(self, node)
-            end
+            CaseCorrector.correct(self, node)
           end
         end
 
-        private
+        def move_assignment_inside_condition(node)
+          *_assignment, condition = *node
+          if ternary_op?(condition) || ternary_op?(condition.children[0])
+            TernaryCorrector.move_assignment_inside_condition(node)
+          elsif condition.case_type?
+            CaseCorrector.move_assignment_inside_condition(node)
+          elsif condition.if_type?
+            IfCorrector.move_assignment_inside_condition(node)
+          end
+        end
+
+        def lhs_all_match?(branches)
+          first_lhs = lhs(branches.first)
+          branches.all? { |branch| lhs(branch) == first_lhs }
+        end
 
         def assignment_types_match?(*nodes)
           return unless assignment_type?(nodes.first)
@@ -283,10 +376,47 @@ module RuboCop
         end
       end
 
+      # Helper module to provide common methods to ConditionalAssignment
+      # correctors
+      module ConditionalCorrectorHelper
+        def remove_whitespace_in_branches(corrector, branch, condition, column)
+          branch.each_node do |child|
+            child_expression = child.loc.expression
+            white_space =
+              Parser::Source::Range.new(child_expression.source_buffer,
+                                        child_expression.begin_pos -
+                                         (child.loc.expression.column -
+                                          column - 2),
+                                        child_expression.begin_pos)
+
+            corrector.remove(white_space) if white_space.source.strip.empty?
+          end
+
+          [condition.loc.else, condition.loc.end].each do |loc|
+            corrector.remove_preceding(loc, loc.column - column)
+          end
+        end
+
+        def assignment(node)
+          *_, condition = *node
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.expression.begin_pos,
+                                    condition.loc.expression.begin_pos)
+        end
+
+        def correct_branches(corrector, branches)
+          branches.each do |branch|
+            *_, assignment = *branch
+            corrector.replace(branch.source_range, assignment.source)
+          end
+        end
+      end
+
       # Corrector to correct conditional assignment in ternary conditions.
       class TernaryCorrector
         class << self
           include ConditionalAssignmentHelper
+          include ConditionalCorrectorHelper
 
           def correct(node)
             condition, if_branch, else_branch = *node
@@ -306,6 +436,25 @@ module RuboCop
               corrector.replace(node.source_range, correction)
             end
           end
+
+          def move_assignment_inside_condition(node)
+            *_var, rhs = *node
+            condition, = *rhs if rhs.begin_type? && rhs.children.size == 1
+            assignment = assignment(node)
+            _condition, if_branch, else_branch = *(condition || rhs)
+
+            lambda do |corrector|
+              corrector.remove(assignment)
+              if rhs.begin_type?
+                corrector.remove(rhs.loc.begin)
+                corrector.remove(rhs.loc.end)
+              end
+              corrector.insert_before(if_branch.loc.expression,
+                                      assignment.source)
+              corrector.insert_before(else_branch.loc.expression,
+                                      assignment.source)
+            end
+          end
         end
       end
 
@@ -313,6 +462,7 @@ module RuboCop
       class IfCorrector
         class << self
           include ConditionalAssignmentHelper
+          include ConditionalCorrectorHelper
 
           def correct(cop, node)
             _condition, if_branch, else_branch = *node
@@ -332,6 +482,31 @@ module RuboCop
               corrector.insert_before(node.loc.end, indent(cop, lhs(if_branch)))
             end
           end
+
+          def move_assignment_inside_condition(node)
+            column = node.loc.expression.column
+            *_var, condition = *node
+            _condition, if_branch, else_branch = *condition
+            elsif_branches, else_branch = expand_elses(else_branch)
+            assignment = assignment(node)
+
+            lambda do |corrector|
+              corrector.remove(assignment)
+
+              [if_branch, *elsif_branches, else_branch].each do |branch|
+                branch_assignment = tail(branch)
+                corrector.insert_before(branch_assignment.loc.expression,
+                                        assignment.source)
+
+                remove_whitespace_in_branches(corrector, branch,
+                                              condition, column)
+
+                corrector
+                  .remove_preceding(branch.parent.loc.else,
+                                    branch.parent.loc.else.column - column)
+              end
+            end
+          end
         end
       end
 
@@ -339,6 +514,7 @@ module RuboCop
       class CaseCorrector
         class << self
           include ConditionalAssignmentHelper
+          include ConditionalCorrectorHelper
 
           def correct(cop, node)
             _condition, *when_branches, else_branch = *node
@@ -357,6 +533,31 @@ module RuboCop
                                       indent(cop, lhs(else_branch)))
             end
           end
+
+          def move_assignment_inside_condition(node)
+            column = node.loc.expression.column
+            *_var, condition = *node
+            _condition, *when_branches, else_branch = *condition
+            when_branches = expand_when_branches(when_branches)
+            assignment = assignment(node)
+
+            lambda do |corrector|
+              corrector.remove(assignment)
+
+              [*when_branches, else_branch].each do |branch|
+                branch_assignment = tail(branch)
+                corrector.insert_before(branch_assignment.loc.expression,
+                                        assignment.source)
+
+                remove_whitespace_in_branches(corrector, branch,
+                                              condition, column)
+
+                corrector
+                  .remove_preceding(branch.parent.loc.keyword,
+                                    branch.parent.loc.keyword.column - column)
+              end
+            end
+          end
         end
       end