rubocop 0.51.0 → 0.87.0

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

@@ -26,59 +26,92 @@ module RuboCop
       # The closing brace of a multi-line hash literal must be on the same
       # line as the last element of the hash.
       #
-      # @example
+      # @example EnforcedStyle: symmetrical (default)
       #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
+      #     # bad
       #     { a: 1,
       #       b: 2
       #     }
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
       #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
+      # @example EnforcedStyle: new_line
+      #     # bad
       #     {
       #       a: 1,
       #       b: 2 }
       #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
+      #     # bad
       #     { a: 1,
       #       b: 2 }
       #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # good
       #     {
       #       a: 1,
       #       b: 2
       #     }
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
       class MultilineHashBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
         SAME_LINE_MESSAGE = 'Closing hash brace must be on the same line as ' \
           'the last hash element when opening brace is on the same line as ' \
-          'the first hash element.'.freeze
+          'the first hash element.'
 
         NEW_LINE_MESSAGE = 'Closing hash brace must be on the line after ' \
           'the last hash element when opening brace is on a separate line ' \
-          'from the first hash element.'.freeze
+          'from the first hash element.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing hash brace must be on the line ' \
-          'after the last hash element.'.freeze
+          'after the last hash element.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
-          'line as the last hash element.'.freeze
-
-        def self.autocorrect_incompatible_with
-          [Style::BracesAroundHashParameters]
-        end
+          'line as the last hash element.'
 
         def on_hash(node)
           check_brace_layout(node)
         end
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
+        end
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop ensures that each key in a multi-line hash
+      # starts on a separate line.
+      #
+      # @example
+      #
+      #   # bad
+      #   {
+      #     a: 1, b: 2,
+      #     c: 3
+      #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     c: 3
+      #   }
+      class MultilineHashKeyLineBreaks < Cop
+        include MultilineElementLineBreaks
+
+        MSG = 'Each key in a multi-line hash must start on a ' \
+          'separate line.'
+
+        def on_hash(node)
+          # This cop only deals with hashes wrapped by a set of curly
+          # braces like {foo: 1}. That is, not a kwargs hashes.
+          # Style/MultilineMethodArgumentLineBreaks handles those.
+          return unless starts_with_curly_brace?(node)
+
+          check_line_breaks(node, node.children) if node.loc.begin
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+
+        private
+
+        def starts_with_curly_brace?(node)
+          node.loc.begin
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop ensures that each argument in a multi-line method call
+      # starts on a separate line.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      class MultilineMethodArgumentLineBreaks < Cop
+        include(MultilineElementLineBreaks)
+
+        MSG = 'Each argument in a multi-line method call must start ' \
+          'on a separate line.'
+
+        def on_send(node)
+          return if node.method?(:[]=)
+
+          args = node.arguments
+
+          # If there is a trailing hash arg without explicit braces, like this:
+          #
+          #    method(1, 'key1' => value1, 'key2' => value2)
+          #
+          # ...then each key/value pair is treated as a method 'argument'
+          # when determining where line breaks should appear.
+          if (last_arg = args.last)
+            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
+          end
+
+          check_line_breaks(node, args)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

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

@@ -26,56 +26,93 @@ module RuboCop
       # The closing brace of a multi-line method call must be on the same
       # line as the last argument of the call.
       #
-      # @example
-      #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
-      #     foo(a,
-      #       b
-      #     )
-      #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
-      #     foo(
-      #       a,
-      #       b)
-      #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
-      #     foo(a,
-      #       b)
-      #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
-      #     foo(
-      #       a,
-      #       b
-      #     )
+      # @example EnforcedStyle: symmetrical (default)
+      #   # bad
+      #   foo(a,
+      #     b
+      #   )
+      #
+      #   # bad
+      #   foo(
+      #     a,
+      #     b)
+      #
+      #   # good
+      #   foo(a,
+      #     b)
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      # @example EnforcedStyle: new_line
+      #   # bad
+      #   foo(
+      #     a,
+      #     b)
+      #
+      #   # bad
+      #   foo(a,
+      #     b)
+      #
+      #   # good
+      #   foo(a,
+      #     b
+      #   )
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      # @example EnforcedStyle: same_line
+      #   # bad
+      #   foo(a,
+      #     b
+      #   )
+      #
+      #   # bad
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b)
+      #
+      #   # good
+      #   foo(a,
+      #     b)
       class MultilineMethodCallBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
         SAME_LINE_MESSAGE = 'Closing method call brace must be on the ' \
           'same line as the last argument when opening brace is on the same ' \
-          'line as the first argument.'.freeze
+          'line as the first argument.'
 
         NEW_LINE_MESSAGE = 'Closing method call brace must be on the ' \
           'line after the last argument when opening brace is on a separate ' \
-          'line from the first argument.'.freeze
+          'line from the first argument.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing method call brace must be on ' \
-          'the line after the last argument.'.freeze
+          'the line after the last argument.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
-          'the same line as the last argument.'.freeze
+          'the same line as the last argument.'
 
         def on_send(node)
           check_brace_layout(node)
         end
 
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
+        end
+
         private
 
         def children(node)

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

@@ -6,34 +6,34 @@ module RuboCop
       # This cop checks the indentation of the method name part in method calls
       # that span more than one line.
       #
-      # @example
+      # @example EnforcedStyle: aligned (default)
       #   # bad
       #   while myvariable
       #   .b
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle: aligned
+      #   # good
       #   while myvariable
       #         .b
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle: aligned
+      #   # good
       #   Thing.a
       #        .b
       #        .c
       #
-      #   # good, EnforcedStyle:    indented,
-      #           IndentationWidth: 2
+      # @example EnforcedStyle: indented
+      #   # good
       #   while myvariable
       #     .b
       #
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle:    indented_relative_to_receiver,
-      #           IndentationWidth: 2
+      # @example EnforcedStyle: indented_relative_to_receiver
+      #   # good
       #   while myvariable
       #           .a
       #           .b
@@ -41,15 +41,14 @@ module RuboCop
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle:    indented_relative_to_receiver,
-      #           IndentationWidth: 2
+      #   # good
       #   myvariable = Thing
       #                  .a
       #                  .b
       #                  .c
       class MultilineMethodCallIndentation < Cop
         include ConfigurableEnforcedStyle
-        include AutocorrectAlignment
+        include Alignment
         include MultilineExpressionIndentation
 
         def validate_config
@@ -62,6 +61,10 @@ module RuboCop
                 '`EnforcedStyle` is `indented`.'
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def relevant_node?(send_node)
@@ -167,7 +170,7 @@ module RuboCop
           return unless rhs.source.start_with?('.')
 
           node = semantic_alignment_node(node)
-          return unless node
+          return unless node&.loc&.selector
 
           node.loc.dot.join(node.loc.selector)
         end
@@ -180,7 +183,7 @@ module RuboCop
           node = node.parent
           node = node.parent until node.loc.dot
 
-          node.receiver.source_range if node
+          node&.receiver&.source_range
         end
 
         def semantic_alignment_node(node)
@@ -190,17 +193,16 @@ module RuboCop
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.dot
+          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
+
+          return if node.loc.dot.line != node.first_line
 
-          return if node.loc.dot.line != node.loc.line
           node
         end
 
         def operation_rhs(node)
-          receiver, = *node
-
-          operation_rhs = receiver.each_ancestor(:send).find do |rhs|
-            operator_rhs?(rhs, receiver)
+          operation_rhs = node.receiver.each_ancestor(:send).find do |rhs|
+            operator_rhs?(rhs, node.receiver)
           end
 
           return unless operation_rhs

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

@@ -26,56 +26,105 @@ module RuboCop
       # The closing brace of a multi-line method definition must be on the same
       # line as the last parameter of the definition.
       #
-      # @example
-      #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
-      #     def foo(a,
-      #       b
-      #     )
-      #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
-      #     def foo(
-      #       a,
-      #       b)
-      #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
-      #     def foo(a,
-      #       b)
-      #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
-      #     def foo(
-      #       a,
-      #       b
-      #     )
+      # @example EnforcedStyle: symmetrical (default)
+      #   # bad
+      #   def foo(a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # bad
+      #   def foo(
+      #     a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b
+      #   )
+      #   end
+      #
+      # @example EnforcedStyle: new_line
+      #   # bad
+      #   def foo(
+      #     a,
+      #     b)
+      #   end
+      #
+      #   # bad
+      #   def foo(a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b
+      #   )
+      #   end
+      #
+      # @example EnforcedStyle: same_line
+      #   # bad
+      #   def foo(a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # bad
+      #   def foo(
+      #     a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(a,
+      #     b)
+      #   end
       class MultilineMethodDefinitionBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
         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.'.freeze
+          '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.'.freeze
+          'line from the first parameter.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the line after the last parameter.'.freeze
+          '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.'.freeze
+          'on the same line as the last parameter.'
 
         def on_def(node)
           check_brace_layout(node.arguments)
         end
         alias on_defs on_def
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
+        end
       end
     end
   end

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

@@ -6,21 +6,44 @@ module RuboCop
       # This cop checks the indentation of the right hand side operand in
       # binary operations that span more than one line.
       #
-      # @example
+      # 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.
+      #
+      # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +
-      #   b
-      #     something
+      #       b
+      #     something &&
+      #     something_else
       #   end
       #
       #   # good
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #       something_else
+      #   end
+      #
+      # @example EnforcedStyle: indented
+      #   # bad
+      #   if a +
+      #      b
+      #     something &&
+      #     something_else
+      #   end
+      #
+      #   # good
+      #   if a +
+      #       b
+      #     something &&
+      #       something_else
       #   end
+      #
       class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
-        include AutocorrectAlignment
+        include Alignment
         include MultilineExpressionIndentation
 
         def on_and(node)
@@ -40,9 +63,15 @@ module RuboCop
                                 '`EnforcedStyle` is `indented`.'
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def relevant_node?(node)
+          return false if node.send_type? && node.unary_operation?
+
           !node.loc.dot # Don't check method calls with dot operator.
         end
 
@@ -54,7 +83,6 @@ module RuboCop
 
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
-          return false if lhs.loc.line == rhs.line # Needed for unary op.
           return false if not_for_this_cop?(node)
 
           correct_column = if should_align?(node, rhs, given_style)