class RuboCop::Cop::Lint::ElseLayout

end
do_that
elsif do_this
# …
if something
# If ‘do_this` is a condition, `elsif` should be used instead of `else`.
# This code is incompatible with the bad case.
end
do_that
do_this
else
# …
if something
# This code is compatible with the bad case. It will be autocorrected like this.
# good
@example
end
do_that
else do_this
# …
if something
# bad
@example
with `elsif` and `else`, you will have to correct it manually.
is compatible correction for bad case syntax, but if your code makes a mistake
Its autocorrection tweaks layout to keep the syntax. So, this autocorrection
which is usually a mistake.
having an expression on the same line as the `else` keyword,
Checks for odd `else` block layout - like

def autocorrect(corrector, node, first_else) 

def autocorrect(corrector, node, first_else)
  corrector.insert_after(node.loc.else, "\n")
  blank_range = range_between(node.loc.else.end_pos, first_else.source_range.begin_pos)
  corrector.replace(blank_range, indentation(node))
end

def check(node) 

def check(node)
  return unless node.else_branch
  if node.else? && node.loc.else.is?('else')
    check_else(node)
  elsif node.if?
    check(node.else_branch)
  end
end

def check_else(node) 

def check_else(node)
  else_branch = node.else_branch
  first_else = else_branch.begin_type? ? else_branch.children.first : else_branch
  return unless first_else
  return unless same_line?(first_else, node.loc.else)
  add_offense(first_else) { |corrector| autocorrect(corrector, node, first_else) }
end

def on_if(node) 

def on_if(node)
  return if node.ternary?
  # If the if is on a single line, it'll be handled by `Style/OneLineConditional`
  return if node.single_line?
  check(node)
end