class RuboCop::Cop::Style::ReturnNil

end
return nil if arg
def foo(arg)
# good
end
return if arg
def foo(arg)
# bad
@example EnforcedStyle: return_nil
end
return if arg
def foo(arg)
# good
end
return nil if arg
def foo(arg)
# bad
@example EnforcedStyle: return (default)
Supported styles are ‘return` and `return_nil`.
while the latter might be used when the return value is of specific concern.
between `return` and `return nil`. The former can be seen as just halting evaluation,
This cop is disabled by default. Because there seems to be a perceived semantic difference
Enforces consistency between `return nil` and `return`.

def correct_style?(node) 

def correct_style?(node)
  (style == :return && !return_nil_node?(node)) ||
    (style == :return_nil && !return_node?(node))
end

def message(_node) 

def message(_node)
  style == :return ? RETURN_MSG : RETURN_NIL_MSG
end

def on_return(node) 

def on_return(node)
  # Check Lint/NonLocalExitFromIterator first before this cop
  node.each_ancestor(:block, :def, :defs) do |n|
    break if scoped_node?(n)
    send_node, args_node, _body_node = *n
    # if a proc is passed to `Module#define_method` or
    # `Object#define_singleton_method`, `return` will not cause a
    # non-local exit error
    break if define_method?(send_node)
    next if args_node.children.empty?
    return nil if chained_send?(send_node)
  end
  return if correct_style?(node)
  add_offense(node) do |corrector|
    corrected = style == :return ? 'return' : 'return nil'
    corrector.replace(node, corrected)
  end
end

def scoped_node?(node) 

def scoped_node?(node)
  node.type?(:def, :defs) || node.lambda?
end