rubocop 0.39.0 → 0.40.0

data/lib/rubocop/cop/mixin/if_node.rb

@@ -5,6 +5,10 @@ module RuboCop
   module Cop
     # Common functionality for checking if nodes.
     module IfNode
+      def ternary?(node)
+        node.loc.respond_to?(:question)
+      end
+
       def modifier_if?(node)
         node.loc.respond_to?(:keyword) &&
           %w(if unless).include?(node.loc.keyword.source) &&

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -1,8 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
-require 'pp'
-
 module RuboCop
   module Cop
     # Common functionality for checking multiline method calls and binary
@@ -36,16 +34,20 @@ module RuboCop
         if operator?(method_name) && args.any?
           args.first.source_range # not used for method calls
         else
-          dot = send_node.loc.dot
-          selector = send_node.loc.selector
-          if dot && selector && dot.line == selector.line
-            dot.join(selector)
-          elsif selector
-            selector
-          elsif dot.line == send_node.loc.begin.line
-            # lambda.(args)
-            dot.join(send_node.loc.begin)
-          end
+          regular_method_right_hand_side(send_node)
+        end
+      end
+
+      def regular_method_right_hand_side(send_node)
+        dot = send_node.loc.dot
+        selector = send_node.loc.selector
+        if dot && selector && dot.line == selector.line
+          dot.join(selector)
+        elsif selector
+          selector
+        elsif dot.line == send_node.loc.begin.line
+          # lambda.(args)
+          dot.join(send_node.loc.begin)
         end
       end
 

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -3,21 +3,23 @@
 
 module RuboCop
   module Cop
-    # Common functionality for checking that the closing brace of a literal is
-    # symmetrical with respect to the opening brace and contained elements.
+    # Common functionality for checking the closing brace of a literal is
+    # either on the same line as the last contained elements, or a new line.
     module MultilineLiteralBraceLayout
+      include ConfigurableEnforcedStyle
+
       def check_brace_layout(node)
         return unless node.loc.begin # Ignore implicit literals.
         return if children(node).empty? # Ignore empty literals.
 
-        if opening_brace_on_same_line?(node)
-          return if closing_brace_on_same_line?(node)
-
-          add_offense(node, :expression, self.class::SAME_LINE_MESSAGE)
-        else
-          return unless closing_brace_on_same_line?(node)
+        # If the last node is or contains a conflicting HEREDOC, we don't want
+        # to adjust the brace layout because this will result in invalid code.
+        return if last_line_heredoc?(children(node).last)
 
-          add_offense(node, :expression, self.class::NEW_LINE_MESSAGE)
+        case style
+        when :symmetrical then handle_symmetrical(node)
+        when :new_line then handle_new_line(node)
+        when :same_line then handle_same_line(node)
         end
       end
 
@@ -38,6 +40,30 @@ module RuboCop
 
       private
 
+      def handle_new_line(node)
+        return unless closing_brace_on_same_line?(node)
+
+        add_offense(node, :expression, self.class::ALWAYS_NEW_LINE_MESSAGE)
+      end
+
+      def handle_same_line(node)
+        return if closing_brace_on_same_line?(node)
+
+        add_offense(node, :expression, self.class::ALWAYS_SAME_LINE_MESSAGE)
+      end
+
+      def handle_symmetrical(node)
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node, :expression, self.class::SAME_LINE_MESSAGE)
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node, :expression, self.class::NEW_LINE_MESSAGE)
+        end
+      end
+
       def children(node)
         node.children
       end
@@ -53,6 +79,46 @@ module RuboCop
       def closing_brace_on_same_line?(node)
         node.loc.end.line == children(node).last.loc.last_line
       end
+
+      # Starting with the parent node and recursively for the parent node's
+      # children, check if the node is a HEREDOC and if the HEREDOC ends below
+      # or on the last line of the parent node.
+      #
+      # Example:
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => false
+      #   foo(a,
+      #     b: {
+      #       a: 1,
+      #       c: <<-EOM
+      #         baz
+      #       EOM
+      #     }
+      #   )
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => true
+      #   foo(a,
+      #     b: <<-EOM
+      #       baz
+      #     EOM
+      #   )
+      def last_line_heredoc?(node, parent = nil)
+        parent ||= node
+
+        return false unless node.respond_to?(:loc)
+
+        if node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.loc.last_line
+          return true
+        end
+
+        return false unless node.respond_to?(:children)
+        return false if node.children.empty?
+
+        node.children.any? { |child| last_line_heredoc?(child, parent) }
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -13,7 +13,7 @@ module RuboCop
 
       def invoke_hook_for_normal_if_unless(node)
         # We won't check modifier or ternary conditionals.
-        return if modifier_if?(node) || ternary_op?(node)
+        return if modifier_if?(node) || ternary?(node)
         on_normal_if_unless(node)
       end
 

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -20,8 +20,7 @@ module RuboCop
       end
 
       def space_forbidden_before_rcurly?
-        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
-        style = cfg['EnforcedStyle'] || 'space'
+        style = space_style_before_rcurly
         style == 'no_space'
       end
 

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -36,7 +36,7 @@ module RuboCop
                         extra_info)
           end
         elsif should_have_comma?(style, node)
-          put_comma(items, kind, sb)
+          put_comma(node, items, kind, sb)
         end
       end
 
@@ -87,10 +87,11 @@ module RuboCop
 
         _receiver, _method_name, *args = *node
         args.flat_map do |a|
-          # For each argument, if it is a multi-line hash,
+          # For each argument, if it is a multi-line hash without braces,
           # then promote the hash elements to method arguments
           # for the purpose of determining multi-line-ness.
-          if a.hash_type? && a.loc.first_line != a.loc.last_line
+          if a.hash_type? && a.loc.first_line != a.loc.last_line &&
+             !brackets?(a)
             a.children
           else
             a
@@ -111,7 +112,7 @@ module RuboCop
                     "#{extra_info}.")
       end
 
-      def put_comma(items, kind, sb)
+      def put_comma(node, items, kind, sb)
         last_item = items.last
         return if last_item.type == :block_pass
 
@@ -120,11 +121,20 @@ module RuboCop
         ix += last_expr.source[ix..-1] =~ /\S/
         range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
                                           last_expr.end_pos)
-        add_offense(range, range,
+        autocorrect_range = avoid_autocorrect?(elements(node)) ? nil : range
+
+        add_offense(autocorrect_range, range,
                     format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
       end
 
+      # By default, there's no reason to avoid auto-correct.
+      def avoid_autocorrect?(_)
+        false
+      end
+
       def autocorrect(range)
+        return unless range
+
         lambda do |corrector|
           case range.source
           when ',' then corrector.remove(range)

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

@@ -57,23 +57,17 @@ module RuboCop
         MSG = 'Place `when` conditions with a splat ' \
               'at the end of the `when` branches.'.freeze
         ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
-        OPEN_BRACKET = '['.freeze
         PERCENT_W = '%w'.freeze
         PERCENT_CAPITAL_W = '%W'.freeze
         PERCENT_I = '%i'.freeze
         PERCENT_CAPITAL_I = '%I'.freeze
 
-        def initialize(*)
-          super
-          @reordered_splat_condition = false
-        end
-
         def on_case(node)
           _case_branch, *when_branches, _else_branch = *node
           when_conditions =
             when_branches.each_with_object([]) do |branch, conditions|
-              condition, = *branch
-              conditions << condition
+              *condition, _ = *branch
+              condition.each { |c| conditions << c }
             end
 
           splat_offenses(when_conditions).reverse_each do |condition|
@@ -85,19 +79,74 @@ module RuboCop
         end
 
         def autocorrect(node)
-          condition, = *node
-          variable, = *condition
-          if variable.array_type?
-            correct_array_literal(condition, variable)
-          else
-            return if @reordered_splat_condition
-            @reordered_splat_condition = true
-            reorder_splat_condition(node)
+          *conditions, _body = *node
+
+          new_condition =
+            conditions.each_with_object([]) do |condition, correction|
+              variable, = *condition
+              if variable.respond_to?(:array_type?) && variable.array_type?
+                correction << expand_percent_array(variable)
+                next
+              end
+
+              correction << condition.source
+            end
+          new_condition = new_condition.join(', ')
+
+          lambda do |corrector|
+            if needs_reorder?(conditions)
+              reorder_condition(corrector, node, new_condition)
+            else
+              inline_fix_branch(corrector, node, conditions, new_condition)
+            end
           end
         end
 
         private
 
+        def inline_fix_branch(corrector, node, conditions, new_condition)
+          range =
+            Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                      conditions[0].loc.expression.begin_pos,
+                                      conditions[-1].loc.expression.end_pos)
+          corrector.replace(range, new_condition)
+        end
+
+        def reorder_condition(corrector, node, new_condition)
+          *_conditions, body = *node
+          parent = node.parent
+          _case_branch, *when_branches, _else_branch = *parent
+          current_index = when_branches.index { |branch| branch == node }
+          next_branch = when_branches[current_index + 1]
+          range = Parser::Source::Range.new(parent,
+                                            node.source_range.begin_pos,
+                                            next_branch.source_range.begin_pos)
+
+          corrector.remove(range)
+
+          correction = if same_line?(node, body)
+                         new_condition_with_then(node, new_condition)
+                       else
+                         new_branch_without_then(node, body, new_condition)
+                       end
+
+          corrector.insert_after(when_branches.last.source_range, correction)
+        end
+
+        def same_line?(node, other)
+          node.loc.first_line == other.loc.first_line
+        end
+
+        def new_condition_with_then(node, new_condition)
+          "\n#{' ' * node.loc.column}when " \
+            "#{new_condition} then #{node.children.last.source}"
+        end
+
+        def new_branch_without_then(node, body, new_condition)
+          "\n#{' ' * node.loc.column}when #{new_condition}\n" \
+            "#{' ' * body.loc.column}#{node.children.last.source}"
+        end
+
         def splat_offenses(when_conditions)
           found_non_splat = false
           when_conditions.reverse.each_with_object([]) do |condition, result|
@@ -115,34 +164,10 @@ module RuboCop
             !condition.splat_type?
         end
 
-        def correct_array_literal(condition, variable)
-          lambda do |corrector|
-            array_start = variable.loc.begin.source
-
-            if array_start.start_with?(OPEN_BRACKET)
-              corrector.remove(condition.loc.operator)
-              corrector.remove(variable.loc.begin)
-              corrector.remove(variable.loc.end)
-            else
-              corrector.replace(condition.source_range,
-                                expand_percent_array(variable))
-            end
-          end
-        end
-
-        def reorder_splat_condition(node)
-          _case_branch, *when_branches, _else_branch = *node.parent
-          current_index = when_branches.index { |branch| branch == node }
-          next_branch = when_branches[current_index + 1]
-          correction = "\n#{offset(node)}#{node.source}"
-          range =
-            Parser::Source::Range.new(node.parent,
-                                      node.source_range.begin_pos,
-                                      next_branch.source_range.begin_pos)
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.insert_after(when_branches.last.source_range, correction)
+        def needs_reorder?(conditions)
+          conditions.any? do |condition|
+            variable, = *condition
+            condition.splat_type? && !(variable && variable.array_type?)
           end
         end
 
@@ -159,6 +184,8 @@ module RuboCop
             ":#{elements.join(', :')}"
           elsif array_start.start_with?(PERCENT_CAPITAL_I)
             %(:"#{elements.join('", :"')}")
+          else
+            elements.join(', ')
           end
         end
       end

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

@@ -33,23 +33,12 @@ module RuboCop
         def on_send(node)
           return unless should_run?
           receiver, second_method, *args = *node
-          return unless check_second_call(receiver, second_method, args)
+          return if accept_second_call?(receiver, second_method, args)
 
           receiver, _args, body = *receiver if receiver.block_type?
-          caller, first_method, args = *receiver
-
-          # check that we have usual block or block pass
-          return if body.nil? && (args.nil? || !args.block_pass_type?)
-          return unless SELECT_METHODS.include?(first_method)
-          return if lazy?(caller)
+          return if accept_first_call?(receiver, body)
 
-          range = receiver.loc.selector.join(node.loc.selector)
-
-          message = second_method == :last ? REVERSE_MSG : MSG
-          add_offense(node, range, format(message,
-                                          preferred_method,
-                                          first_method,
-                                          second_method))
+          offense(node, receiver, second_method)
         end
 
         def autocorrect(node)
@@ -79,10 +68,31 @@ module RuboCop
             config['Rails'.freeze]['Enabled'.freeze])
         end
 
-        def check_second_call(receiver, method, args)
-          receiver &&
-            DANGEROUS_METHODS.include?(method) &&
-            args.empty?
+        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
+
+          # 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
+
+        def offense(node, receiver, second_method)
+          _caller, first_method, _args = *receiver
+          range = receiver.loc.selector.join(node.loc.selector)
+
+          message = second_method == :last ? REVERSE_MSG : MSG
+          add_offense(node, range, format(message,
+                                          preferred_method,
+                                          first_method,
+                                          second_method))
         end
 
         def preferred_method