class RuboCop::Cop::Layout::EmptyLinesAroundArguments


)
x: y<br>,
some_method(
thud: fred)
baz: qux,
process(bar,
)
foo
do_something(
# good
)
x: y<br>,
some_method(
thud: fred)
baz: qux,
process(bar,
)
foo
do_something(
# bad
@example
of a method invocation.
Checks if empty lines exist around the arguments

def empty_lines(node) 

def empty_lines(node)
  lines = processed_lines(node)
  lines.select! { |code, _| code.empty? }
  lines.map { |_, line| line }
end

def extra_lines(node) 

def extra_lines(node)
  empty_lines(node).each do |line|
    range = source_range(processed_source.buffer, line, 0)
    yield(range)
  end
end

def inner_lines(node) 

def inner_lines(node)
  [node.first_line + 1, node.last_line - 1]
end

def line_numbers(node) 

def line_numbers(node)
  inner_lines = []
  line_nums = node.arguments.each_with_object([]) do |arg_node, lines|
    lines << outer_lines(arg_node)
    inner_lines << inner_lines(arg_node) if arg_node.multiline?
  end
  line_nums.flatten.uniq - inner_lines.flatten - outer_lines(node)
end

def on_send(node) 

def on_send(node)
  return if node.single_line? || node.arguments.empty? ||
            receiver_and_method_call_on_different_lines?(node)
  extra_lines(node) do |range|
    add_offense(range) do |corrector|
      corrector.remove(range)
    end
  end
end

def outer_lines(node) 

def outer_lines(node)
  [node.first_line - 1, node.last_line + 1]
end

def processed_lines(node) 

def processed_lines(node)
  line_numbers(node).each_with_object([]) do |num, array|
    array << [processed_source.lines[num - 1], num]
  end
end

def receiver_and_method_call_on_different_lines?(node) 

def receiver_and_method_call_on_different_lines?(node)
  node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
end