rubocop 0.93.1 → 1.79.2

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the method name part in method calls
+      # Checks the indentation of the method name part in method calls
       # that span more than one line.
       #
       # @example EnforcedStyle: aligned (default)
@@ -46,38 +46,51 @@ module RuboCop
       #                  .a
       #                  .b
       #                  .c
-      class MultilineMethodCallIndentation < Cop
+      class MultilineMethodCallIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        extend AutoCorrector
 
         def validate_config
           return unless style == :aligned && cop_config['IndentationWidth']
 
           raise ValidationError,
-                'The `Layout/MultilineMethodCallIndentation`' \
-                ' cop only accepts an `IndentationWidth` ' \
+                'The `Layout/MultilineMethodCallIndentation` ' \
+                'cop only accepts an `IndentationWidth` ' \
                 'configuration parameter when ' \
                 '`EnforcedStyle` is `indented`.'
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def relevant_node?(send_node)
           send_node.loc.dot # Only check method calls with dot operator
         end
 
+        def right_hand_side(send_node)
+          dot = send_node.loc.dot
+          selector = send_node.loc.selector
+          if (send_node.dot? || send_node.safe_navigation?) && selector && same_line?(dot, selector)
+            dot.join(selector)
+          elsif selector
+            selector
+          elsif send_node.implicit_call?
+            dot.join(send_node.loc.begin)
+          end
+        end
+
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
           return false if not_for_this_cop?(node)
 
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
-                             @base.column + extra_indentation(given_style)
+                             @base.column + extra_indentation(given_style, node.parent)
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
@@ -85,9 +98,13 @@ module RuboCop
           rhs if @column_delta.nonzero?
         end
 
-        def extra_indentation(given_style)
+        def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            configured_indentation_width
+            if parent&.type?(:splat, :kwsplat)
+              configured_indentation_width - parent.loc.operator.length
+            else
+              configured_indentation_width
+            end
           else
             0
           end
@@ -135,8 +152,7 @@ module RuboCop
         def alignment_base(node, rhs, given_style)
           case given_style
           when :aligned
-            semantic_alignment_base(node, rhs) ||
-              syntactic_alignment_base(node, rhs)
+            semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
           when :indented
             nil
           when :indented_relative_to_receiver
@@ -153,24 +169,20 @@ module RuboCop
 
           # a = b
           #     .c
-          part_of_assignment_rhs(lhs, rhs) do |base|
-            return assignment_rhs(base).source_range
-          end
+          part_of_assignment_rhs(lhs, rhs) { |base| return assignment_rhs(base).source_range }
 
           # a + b
           #     .c
-          operation_rhs(lhs) do |base|
-            return base.source_range
-          end
+          operation_rhs(lhs) { |base| return base.source_range }
         end
 
         # a.b
         #  .c
         def semantic_alignment_base(node, rhs)
-          return unless rhs.source.start_with?('.')
+          return unless rhs.source.start_with?('.', '&.')
 
           node = semantic_alignment_node(node)
-          return unless node&.loc&.selector
+          return unless node&.loc&.selector && node.loc.dot
 
           node.loc.dot.join(node.loc.selector)
         end
@@ -189,13 +201,45 @@ module RuboCop
         def semantic_alignment_node(node)
           return if argument_in_method_call(node, :with_parentheses)
 
+          dot_right_above = get_dot_right_above(node)
+          return dot_right_above if dot_right_above
+
+          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
+            return multiline_block_chain_node
+          end
+
+          node = first_call_has_a_dot(node)
+          return if node.loc.dot.line != node.first_line
+
+          node
+        end
+
+        def get_dot_right_above(node)
+          node.each_ancestor.find do |a|
+            dot = a.loc.dot if a.loc?(:dot)
+            next unless dot
+
+            dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
+          end
+        end
+
+        def find_multiline_block_chain_node(node)
+          return unless (block_node = node.each_descendant(:any_block).first)
+          return unless block_node.multiline? && block_node.parent.call_type?
+
+          if node.receiver.call_type?
+            node.receiver
+          else
+            block_node.parent
+          end
+        end
+
+        def first_call_has_a_dot(node)
           # descend to root of method chain
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
-
-          return if node.loc.dot.line != node.first_line
+          node = node.parent until node.loc?(:dot)
 
           node
         end
@@ -211,8 +255,7 @@ module RuboCop
         end
 
         def operator_rhs?(node, receiver)
-          node.operator_method? && node.arguments? &&
-            within_node?(receiver, node.first_argument)
+          node.operator_method? && node.arguments? && within_node?(receiver, node.first_argument)
         end
       end
     end

data/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks that the closing brace in a method definition is either
+      # Checks that the closing brace in a method definition is either
       # on the same line as the last method parameter, or a new line.
       #
       # When using the `symmetrical` (default) style:
@@ -12,7 +12,7 @@ module RuboCop
       # first parameter of the definition, then the closing brace should be
       # on the same line as the last parameter of the definition.
       #
-      # If an method definition's opening brace is on the line above the first
+      # If a method definition's opening brace is on the line above the first
       # parameter of the definition, then the closing brace should be on the
       # line below the last parameter of the definition.
       #
@@ -105,18 +105,18 @@ module RuboCop
         extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-          'same line as the last parameter when opening brace is on the same ' \
-          'line as the first parameter.'
+                            'same line as the last parameter when opening brace is on the same ' \
+                            'line as the first parameter.'
 
         NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-          'line after the last parameter when opening brace is on a separate ' \
-          'line from the first parameter.'
+                           'line after the last parameter when opening brace is on a separate ' \
+                           'line from the first parameter.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the line after the last parameter.'
+                                  'on the line after the last parameter.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the same line as the last parameter.'
+                                   'on the same line as the last parameter.'
 
         def on_def(node)
           check_brace_layout(node.arguments)

data/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Ensures that each parameter in a multi-line method definition
+      # starts on a separate line.
+      #
+      # NOTE: This cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b = {
+      #       foo: "bar",
+      #     }
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      class MultilineMethodParameterLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
+
+        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
+        end
+        alias on_defs on_def
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -3,13 +3,12 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the right hand side operand in
-      # binary operations that span more than one line.
+      # Checks the indentation of the right hand side operand in binary operations that
+      # span more than one line.
       #
-      # The `aligned` style checks that operators are aligned if they are part
-      # of an `if` or `while` condition, a `return` statement, etc. In other
-      # contexts, the second operand should be indented regardless of enforced
-      # style.
+      # The `aligned` style checks that operators are aligned if they are part of an `if` or `while`
+      # condition, an explicit `return` statement, etc. In other contexts, the second operand should
+      # be indented regardless of enforced style.
       #
       # @example EnforcedStyle: aligned (default)
       #   # bad
@@ -41,10 +40,11 @@ module RuboCop
       #       something_else
       #   end
       #
-      class MultilineOperationIndentation < Cop
+      class MultilineOperationIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        extend AutoCorrector
 
         def on_and(node)
           check_and_or(node)
@@ -57,18 +57,18 @@ module RuboCop
         def validate_config
           return unless style == :aligned && cop_config['IndentationWidth']
 
-          raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
-                                ' cop only accepts an `IndentationWidth` ' \
-                                'configuration parameter when ' \
-                                '`EnforcedStyle` is `indented`.'
-        end
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation` ' \
+                                 'cop only accepts an `IndentationWidth` ' \
+                                 'configuration parameter when ' \
+                                 '`EnforcedStyle` is `indented`.'
         end
 
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def relevant_node?(node)
           return false if node.send_type? && node.unary_operation?
 
@@ -76,9 +76,8 @@ module RuboCop
         end
 
         def check_and_or(node)
-          lhs, rhs = *node
-          range = offending_range(node, lhs, rhs.source_range, style)
-          check(range, node, lhs, rhs.source_range)
+          range = offending_range(node, node.lhs, node.rhs.source_range, style)
+          check(range, node, node.lhs, node.rhs.source_range)
         end
 
         def offending_range(node, lhs, rhs, given_style)
@@ -117,6 +116,10 @@ module RuboCop
               "spaces for indenting #{what} spanning multiple lines."
           end
         end
+
+        def right_hand_side(send_node)
+          send_node.first_argument&.source_range
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/parameter_alignment.rb

@@ -3,11 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the parameters on a multi-line method call or
-      # definition are aligned.
+      # Check that the parameters on a multi-line method call or definition are aligned.
       #
-      # To set the alignment of the first argument, use the cop
-      # FirstParameterIndentation.
+      # To set the alignment of the first argument, use the
+      # `Layout/FirstParameterIndentation` cop.
       #
       # @example EnforcedStyle: with_first_parameter (default)
       #   # good
@@ -68,14 +67,15 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class ParameterAlignment < Cop
+      class ParameterAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
-          'they span more than one line.'
+                           'they span more than one line.'
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method definition.'
+                           'following the first line of a multi-line method definition.'
 
         def on_def(node)
           return if node.arguments.size < 2
@@ -84,12 +84,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end

data/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether certain expressions, e.g. method calls, that could fit
+      # completely on a single line, are broken up into multiple lines unnecessarily.
+      #
+      # @example
+      #   # bad
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      #   # good
+      #   foo(a, b)
+      #
+      #   # bad
+      #   puts 'string that fits on ' \
+      #        'a single line'
+      #
+      #   # good
+      #   puts 'string that fits on a single line'
+      #
+      #   # bad
+      #   things
+      #     .select { |thing| thing.cond? }
+      #     .join('-')
+      #
+      #   # good
+      #   things.select { |thing| thing.cond? }.join('-')
+      #
+      # @example InspectBlocks: false (default)
+      #   # good
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      # @example InspectBlocks: true
+      #   # bad
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      #   # good
+      #   foo(a) { |x| puts x }
+      #
+      class RedundantLineBreak < Base
+        include CheckAssignment
+        include CheckSingleLineSuitability
+        extend AutoCorrector
+
+        MSG = 'Redundant line break detected.'
+
+        def on_lvasgn(node)
+          super unless end_with_percent_blank_string?(processed_source)
+        end
+
+        def on_send(node)
+          # Include "the whole expression".
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
+
+          return unless offense?(node) && !part_of_ignored_node?(node)
+
+          register_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
+        def check_assignment(node, _rhs)
+          return unless offense?(node)
+
+          register_offense(node)
+        end
+
+        def register_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node, to_single_line(node.source).strip)
+          end
+          ignore_node(node)
+        end
+
+        def offense?(node)
+          return false unless node.multiline? && suitable_as_single_line?(node)
+          return require_backslash?(node) if node.operator_keyword?
+
+          !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
+
+        def require_backslash?(node)
+          processed_source.lines[node.loc.operator.line - 1].end_with?('\\')
+        end
+
+        def index_access_call_chained?(node)
+          return false unless node.send_type? && node.method?(:[])
+
+          node.children.first.send_type? && node.children.first.method?(:[])
+        end
+
+        def configured_to_not_be_inspected?(node)
+          return true if other_cop_takes_precedence?(node)
+          return false if cop_config['InspectBlocks']
+
+          node.any_block_type? || any_descendant?(node, :any_block, &:multiline?)
+        end
+
+        def other_cop_takes_precedence?(node)
+          single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
+            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+          end
+        end
+
+        def single_line_block_chain_enabled?
+          @config.cop_enabled?('Layout/SingleLineBlockChain')
+        end
+
+        def convertible_block?(node)
+          return false unless (parent = node.parent)
+
+          parent.any_block_type? && node == parent.send_node &&
+            (node.parenthesized? || !node.arguments?)
+        end
+      end
+    end
+  end
+end