class RuboCop::Cop::Style::EndlessMethod


.baz
.bar
def my_method() = x.foo
# bad
def my_method; x end
# bad
@example EnforcedStyle: disallow
.baz
.bar
def my_method() = x.foo
# good
def my_method() = x
# good
@example EnforcedStyle: allow_always
.baz
.bar
def my_method() = x.foo
# bad, multi-line endless method
def my_method() = x
# good
@example EnforcedStyle: allow_single_line (default)
corrected to a multi-line definition.
NOTE: Incorrect endless method definitions will always be
* disallow - all endless method definitions are disallowed.
* allow_always - all endless method definitions are allowed.
* allow_single_line (default) - only single line endless method definitions are allowed.
The supported styles are:
Other method definition types are not considered by this cop.
for single-lined method bodies, or disallow endless methods.
It can enforce either the use of endless methods definitions
This cop checks for endless methods.

def arguments(node, missing = '') 

def arguments(node, missing = '')
  node.arguments.any? ? node.arguments.source : missing
end

def correct_to_multiline(corrector, node) 

def correct_to_multiline(corrector, node)
  replacement = <<~RUBY.strip
    def #{node.method_name}#{arguments(node)}
      #{node.body.source}
    end
  RUBY
  corrector.replace(node, replacement)
end

def handle_allow_style(node) 

def handle_allow_style(node)
  return unless node.endless?
  return if node.single_line? || style == :allow_always
  add_offense(node, message: MSG_MULTI_LINE) do |corrector|
    correct_to_multiline(corrector, node)
  end
end

def handle_disallow_style(node) 

def handle_disallow_style(node)
  return unless node.endless?
  add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
end

def on_def(node) 

def on_def(node)
  if style == :disallow
    handle_disallow_style(node)
  else
    handle_allow_style(node)
  end
end