rubocop 0.75.1

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the multiline do end blocks have a newline
+      # after the start of the block. Additionally, it checks whether the block
+      # arguments, if any, are on the same line as the start of the
+      # block. Putting block arguments on separate lines, because the whole
+      # line would otherwise be too long, is accepted.
+      #
+      # @example
+      #   # bad
+      #   blah do |i| foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # bad
+      #   blah do
+      #     |i| foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i| foo(i)
+      #     bar(i)
+      #   }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #     bar(i)
+      #   }
+      #
+      #   # good
+      #   blah { |
+      #     long_list,
+      #     of_parameters,
+      #     that_would_not,
+      #     fit_on_one_line
+      #   |
+      #     foo(i)
+      #     bar(i)
+      #   }
+      class MultilineBlockLayout < Cop
+        include RangeHelp
+
+        MSG = 'Block body expression is on the same line as ' \
+              'the block start.'
+        ARG_MSG = 'Block argument expression is not on the same line as the ' \
+                  'block start.'
+        PIPE_SIZE = '|'.length
+
+        def on_block(node)
+          return if node.single_line?
+
+          unless args_on_beginning_line?(node) ||
+                 line_break_necessary_in_args?(node)
+            add_offense_for_expression(node, node.arguments, ARG_MSG)
+          end
+
+          return unless node.body && node.loc.begin.line == node.body.first_line
+
+          add_offense_for_expression(node, node.body, MSG)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            unless args_on_beginning_line?(node)
+              autocorrect_arguments(corrector, node)
+              expr_before_body = node.arguments.source_range.end
+            end
+
+            return unless node.body
+
+            expr_before_body ||= node.loc.begin
+
+            if expr_before_body.line == node.body.first_line
+              autocorrect_body(corrector, node, node.body)
+            end
+          end
+        end
+
+        private
+
+        def args_on_beginning_line?(node)
+          !node.arguments? ||
+            node.loc.begin.line == node.arguments.loc.last_line
+        end
+
+        def line_break_necessary_in_args?(node)
+          needed_length = node.source_range.column +
+                          node.source.lines.first.length +
+                          block_arg_string(node.arguments).length + PIPE_SIZE
+          needed_length > max_line_length
+        end
+
+        def add_offense_for_expression(node, expr, msg)
+          expression = expr.source_range
+          range = range_between(expression.begin_pos, expression.end_pos)
+
+          add_offense(node, location: range, message: msg)
+        end
+
+        def autocorrect_arguments(corrector, node)
+          end_pos = range_with_surrounding_space(
+            range: node.arguments.source_range,
+            side: :right,
+            newlines: false
+          ).end_pos
+          range = range_between(node.loc.begin.end.begin_pos, end_pos)
+          corrector.replace(range, " |#{block_arg_string(node.arguments)}|")
+        end
+
+        def autocorrect_body(corrector, node, block_body)
+          first_node = if block_body.begin_type?
+                         block_body.children.first
+                       else
+                         block_body
+                       end
+
+          block_start_col = node.source_range.column
+
+          corrector.insert_before(first_node.source_range,
+                                  "\n  #{' ' * block_start_col}")
+        end
+
+        def block_arg_string(args)
+          args.children.map do |arg|
+            if arg.mlhs_type?
+              "(#{block_arg_string(arg)})"
+            else
+              arg.source
+            end
+          end.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks that the closing brace in a hash literal is either
+      # on the same line as the last hash element, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a hash's opening brace is on the same line as the first element
+      # of the hash, then the closing brace should be on the same line as
+      # the last element of the hash.
+      #
+      # If a hash's opening brace is on the line above the first element
+      # of the hash, then the closing brace should be on the line below
+      # the last element of the hash.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line hash literal must be on the line
+      # after the last element of the hash.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line hash literal must be on the same
+      # line as the last element of the hash.
+      #
+      # @example EnforcedStyle: symmetrical (default)
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
+      #
+      # @example EnforcedStyle: new_line
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2 }
+      #
+      #     # 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.'
+
+        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.'
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing hash brace must be on the line ' \
+          'after the last hash element.'
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
+          'line as the last hash element.'
+
+        def self.autocorrect_incompatible_with
+          [Style::BracesAroundHashParameters]
+        end
+
+        def on_hash(node)
+          check_brace_layout(node)
+        end
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
+        end
+      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,54 @@
+# 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_name == :[]=
+
+          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)
+            if last_arg.hash_type? && !last_arg.braces?
+              args = args.concat(args.pop.children)
+            end
+          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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks that the closing brace in a method call is either
+      # on the same line as the last method argument, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a method call's opening brace is on the same line as the first
+      # argument of the call, then the closing brace should be on the same
+      # line as the last argument of the call.
+      #
+      # If an method call's opening brace is on the line above the first
+      # argument of the call, then the closing brace should be on the line
+      # below the last argument of the call.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method call must be on the line
+      # after the last argument of the call.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method call must be on the same
+      # line as the last argument of the call.
+      #
+      # @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.'
+
+        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.'
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method call brace must be on ' \
+          'the line after the last argument.'
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
+          '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)
+          node.arguments
+        end
+
+        def ignored_literal?(node)
+          single_line_ignoring_receiver?(node) || super
+        end
+
+        def single_line_ignoring_receiver?(node)
+          return false unless node.loc.begin && node.loc.end
+
+          node.loc.begin.line == node.loc.end.line
+        end
+      end
+    end
+  end
+end