class RuboCop::Cop::Style::EmptyMethod

end
def self.foo(bar)
end
def foo(bar)
# good
def self.foo(bar); end
def foo(bar); end
# bad
@example EnforcedStyle: expanded
def self.foo(bar); end
end
# baz
def foo(bar)
def foo(bar); end
# good
end
def self.foo(bar)
end
def foo(bar)
# bad
@example EnforcedStyle: compact (default)
‘Layout/LineLength`, but an offense will still be registered.
if the resulting code is longer than the `Max` configuration for
NOTE: Autocorrection will not be applied for the `compact` style
comments.
NOTE: A method definition is not considered empty if it contains
to go on its own line (expanded style).
line (compact style), but it can be configured to enforce the `end`
By default it enforces empty method definitions to go on a single
Checks for the formatting of empty method definitions.

def compact?(node) 

def compact?(node)
  node.single_line?
end

def compact_style? 

def compact_style?
  style == :compact
end

def correct_style?(node) 

def correct_style?(node)
  (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
end

def corrected(node) 

def corrected(node)
  scope = node.receiver ? "#{node.receiver.source}." : ''
  arguments = if node.arguments?
                args = node.arguments.map(&:source).join(', ')
                parentheses?(node.arguments) ? "(#{args})" : " #{args}"
              end
  signature = [scope, node.method_name, arguments].join
  ["def #{signature}", 'end'].join(joint(node))
end

def expanded?(node) 

def expanded?(node)
  node.multiline?
end

def expanded_style? 

def expanded_style?
  style == :expanded
end

def joint(node) 

def joint(node)
  indent = ' ' * node.loc.column
  compact_style? ? '; ' : "\n#{indent}"
end

def max_line_length 

def max_line_length
  return unless config.for_cop('Layout/LineLength')['Enabled']
  config.for_cop('Layout/LineLength')['Max']
end

def message(_range) 

def message(_range)
  compact_style? ? MSG_COMPACT : MSG_EXPANDED
end

def on_def(node) 

def on_def(node)
  return if node.body || processed_source.contains_comment?(node.source_range)
  return if correct_style?(node)
  add_offense(node) do |corrector|
    correction = corrected(node)
    next if compact_style? && max_line_length && correction.size > max_line_length
    corrector.replace(node, correction)
  end
end