class RuboCop::Cop::Layout::MultilineBlockLayout

}
bar(i)
foo(i)
blah { |i|
# good
}
bar(i)
blah { |i| foo(i)
# bad
end
bar(i)
foo(i)
blah do |i|
# good
end
bar(i)
|i| foo(i)
blah do
# bad
end
bar(i)
blah do |i| foo(i)
# bad
@example
arguments, if any, are on the same line as the start of the block.
after the start of the block. Additionally, it checks whether the block
This cop checks whether the multiline do end blocks have a newline

def add_offense_for_expression(node, expr, msg) 

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 args_on_beginning_line?(node) 

def args_on_beginning_line?(node)
  !node.arguments? ||
    node.loc.begin.line == node.arguments.loc.last_line
end

def autocorrect(node) 

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

def autocorrect_arguments(corrector, node) 

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) 

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) 

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

def on_block(node) 

def on_block(node)
  return if node.single_line?
  unless args_on_beginning_line?(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