class RuboCop::Cop::Style::EmptyLineBetweenDefs

separated by empty lines.
This cop checks whether method definitions are

def autocorrect(node) 

def autocorrect(node)
  prev_def = prev_node(node)
  end_pos = prev_def.loc.end.end_pos
  source_buffer = prev_def.loc.end.source_buffer
  newline_pos = source_buffer.source.index("\n", end_pos)
  newline = Parser::Source::Range.new(source_buffer,
                                      newline_pos,
                                      newline_pos + 1)
  ->(corrector) { corrector.insert_after(newline, "\n") }
end

def blank_lines_between?(first_def_node, second_def_node) 

def blank_lines_between?(first_def_node, second_def_node)
  lines_between_defs(first_def_node, second_def_node).any?(&:blank?)
end

def check_defs(nodes) 

def check_defs(nodes)
  return if blank_lines_between?(*nodes)
  return if nodes.all?(&:single_line?) &&
            cop_config['AllowAdjacentOneLineDefs']
  add_offense(nodes.last, :keyword)
end

def def_end(node) 

def def_end(node)
  node.loc.end.line
end

def def_node?(node) 

def def_node?(node)
  return unless node
  node.def_type? || node.defs_type?
end

def def_start(node) 

def def_start(node)
  node.loc.keyword.line
end

def lines_between_defs(first_def_node, second_def_node) 

def lines_between_defs(first_def_node, second_def_node)
  line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
  processed_source.lines[line_range]
end

def on_begin(node)

it on each def.
doing a linear scan over siblings, so we don't want to call
efficiently access a node's predecessor; #prev_node ends up
so that we can walk over pairs of consecutive nodes and
We operate on `begin` nodes, instead of using `OnMethodDef`, 
def on_begin(node)
  node.children.each_cons(2) do |prev, n|
    nodes = [prev, n]
    check_defs(nodes) if nodes.all?(&method(:def_node?))
  end
end

def prev_node(node) 

def prev_node(node)
  return nil unless node.sibling_index > 0
  node.parent.children[node.sibling_index - 1]
end