class RuboCop::Cop::Style::TrailingMethodEndStatement


end
end
bar
block do
def foo
end
baz.map { |b| b.this(x) }
def do_this(x)
end
do_stuff
def some_method
# good
end end
bar
block do
def foo
baz.map { |b| b.this(x) } end
def do_this(x)
do_stuff; end
def some_method
# bad
@example
This cop checks for trailing code after the method definition.

def autocorrect(node) 

def autocorrect(node)
  lambda do |corrector|
    break_line_before_end(node, corrector)
    remove_semicolon(node, corrector)
  end
end

def body_and_end_on_same_line?(node) 

def body_and_end_on_same_line?(node)
  end_token(node).line == token_before_end(node).line
end

def break_line_before_end(node, corrector) 

def break_line_before_end(node, corrector)
  corrector.insert_before(
    end_token(node).pos,
    "\n" + ' ' * configured_indentation_width
  )
end

def end_token(node) 

def end_token(node)
  @end_token ||= tokens(node).reverse.find(&:end?)
end

def on_def(node) 

def on_def(node)
  return unless trailing_end?(node)
  add_offense(node.to_a.last, location: end_token(node).pos)
end

def remove_semicolon(node, corrector) 

def remove_semicolon(node, corrector)
  return unless token_before_end(node).semicolon?
  corrector.remove(token_before_end(node).pos)
end

def token_before_end(node) 

def token_before_end(node)
  @token_before_end ||= begin
    i = tokens(node).index(end_token(node))
    tokens(node)[i - 1]
  end
end

def trailing_end?(node) 

def trailing_end?(node)
  node.body &&
    node.multiline? &&
    body_and_end_on_same_line?(node)
end