class RuboCop::Cop::Style::RedundantReturn


end
end
else
elsif y
if x
def test
# good
end
return something if something_else
def test
# good
end
return something
three
two
one
def test
# bad
end
return something
def test
# bad
# if/else or a case expression with a default branch.
# These bad cases should be extended to handle methods whose body is
@example
This cop checks for redundant ‘return` expressions.

def add_braces(corrector, node) 

def add_braces(corrector, node)
  kids = node.children.map(&:source_range)
  corrector.insert_before(kids.first, '{')
  corrector.insert_after(kids.last, '}')
end

def add_brackets(corrector, node) 

def add_brackets(corrector, node)
  kids = node.children.map(&:source_range)
  corrector.insert_before(kids.first, '[')
  corrector.insert_after(kids.last, ']')
end

def allow_multiple_return_values? 

def allow_multiple_return_values?
  cop_config['AllowMultipleReturnValues'] || false
end

def arguments?(args) 

def arguments?(args)
  return false if args.empty?
  return true if args.size > 1
  !args.first.begin_type? || !args.first.children.empty?
end

def autocorrect(node) # rubocop:disable Metrics/MethodLength

rubocop:disable Metrics/MethodLength 
def autocorrect(node) # rubocop:disable Metrics/MethodLength
  lambda do |corrector|
    unless arguments?(node.children)
      corrector.replace(node.source_range, 'nil')
      next
    end
    return_value, = *node
    if node.children.size > 1
      add_brackets(corrector, node)
    elsif return_value.hash_type?
      add_braces(corrector, return_value) unless return_value.braces?
    end
    return_kw = range_with_surrounding_space(range: node.loc.keyword,
                                             side: :right)
    corrector.remove(return_kw)
  end
end

def check_begin_node(node) 

def check_begin_node(node)
  expressions = *node
  last_expr = expressions.last
  return unless last_expr && last_expr.return_type?
  check_return_node(last_expr)
end

def check_branch(node)

rubocop:disable Metrics/CyclomaticComplexity 
def check_branch(node)
  case node.type
  when :return then check_return_node(node)
  when :case   then check_case_node(node)
  when :if     then check_if_node(node)
  when :rescue, :resbody
    check_rescue_node(node)
  when :ensure then check_ensure_node(node)
  when :begin, :kwbegin
    check_begin_node(node)
  end
end

def check_case_node(node) 

def check_case_node(node)
  _cond, *when_nodes, else_node = *node
  when_nodes.each { |when_node| check_when_node(when_node) }
  check_branch(else_node) if else_node
end

def check_ensure_node(node) 

def check_ensure_node(node)
  rescue_node = node.node_parts[0]
  check_branch(rescue_node)
end

def check_if_node(node) 

def check_if_node(node)
  return if node.modifier_form? || node.ternary?
  _cond, if_node, else_node = *node.node_parts
  check_branch(if_node) if if_node
  check_branch(else_node) if else_node
end

def check_rescue_node(node) 

def check_rescue_node(node)
  node.child_nodes.each do |child_node|
    check_branch(child_node)
  end
end

def check_return_node(node) 

def check_return_node(node)
  return if cop_config['AllowMultipleReturnValues'] &&
            node.children.size > 1
  add_offense(node, location: :keyword)
end

def check_when_node(node) 

def check_when_node(node)
  return unless node
  _cond, body = *node
  check_branch(body) if body
end

def message(node) 

def message(node)
  if !allow_multiple_return_values? && node.children.size > 1
    "#{MSG} #{MULTI_RETURN_MSG}"
  else
    MSG
  end
end

def on_def(node) 

def on_def(node)
  return unless node.body
  check_branch(node.body)
end