class RuboCop::Cop::Style::RedundantReturn


end
return x, y
def test
# good
@example AllowMultipleReturnValues: true
end
return x, y
def test
# bad
@example AllowMultipleReturnValues: false (default)
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)
  corrector.insert_before(node.children.first, '{')
  corrector.insert_after(node.children.last, '}')
end

def add_brackets(corrector, node) 

def add_brackets(corrector, node)
  corrector.insert_before(node.children.first, '[')
  corrector.insert_after(node.children.last, ']')
end

def allow_multiple_return_values? 

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

def check_begin_node(node) 

def check_begin_node(node)
  last_expr = node.children.last
  check_branch(last_expr)
end

def check_branch(node)

rubocop:disable Metrics/CyclomaticComplexity 
def check_branch(node)
  return unless 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 then check_rescue_node(node)
  when :resbody then check_resbody_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)
  node.when_branches.each { |when_node| check_branch(when_node.body) }
  check_branch(node.else_branch)
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?
  check_branch(node.if_branch)
  check_branch(node.else_branch)
end

def check_resbody_node(node) 

def check_resbody_node(node)
  check_branch(node.body)
end

def check_rescue_node(node) 

def check_rescue_node(node)
  node.branches.each { |branch| check_branch(branch) }
  check_branch(node.body) unless node.else?
end

def check_return_node(node) 

def check_return_node(node)
  return if cop_config['AllowMultipleReturnValues'] &&
            node.children.size > 1
  add_offense(node.loc.keyword, message: message(node)) do |corrector|
    if node.arguments?
      correct_with_arguments(node, corrector)
    else
      correct_without_arguments(node, corrector)
    end
  end
end

def correct_with_arguments(return_node, corrector) 

def correct_with_arguments(return_node, corrector)
  if return_node.arguments.size > 1
    add_brackets(corrector, return_node)
  elsif hash_without_braces?(return_node.first_argument)
    add_braces(corrector, return_node.first_argument)
  end
  keyword = range_with_surrounding_space(range: return_node.loc.keyword,
                                         side: :right)
  corrector.remove(keyword)
end

def correct_without_arguments(return_node, corrector) 

def correct_without_arguments(return_node, corrector)
  corrector.replace(return_node, 'nil')
end

def hash_without_braces?(node) 

def hash_without_braces?(node)
  node.hash_type? && !node.braces?
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)
  check_branch(node.body)
end