class RuboCop::Cop::Rails::Delegate

delegate :bar, to: :foo, prefix: true
# good
end
foo.bar
def foo_bar
# good
# EnforceForPrefixed: false
delegate :bar, to: :foo, prefix: true
# good
end
foo.bar
def foo_bar
# bad
# EnforceForPrefixed: true
end
foo.bar
def bar
private
# good
end
foo&.bar
def bar
# good
delegate :bar, to: :foo
# good
end
foo.bar
def bar
# bad
@example
When set to ‘false`, this case is legal.
without using the `delegate` method will be a violation.
using the target object as a prefix of the method name
The `EnforceForPrefixed` option (defaulted to `true`) means that
responds to the delegated method.
option checks not just for nil but also delegates if nil
Safe navigation `&.` is ignored because Rails’ ‘allow_nil`
automatically with the `delegate` method.
This cop looks for delegations that could have been created

def arguments_match?(arg_array, body) 

def arguments_match?(arg_array, body)
  argument_array = body.arguments
  arg_array == argument_array ||
    arg_array.map(&:children) == argument_array.map(&:children)
end

def autocorrect(node) 

def autocorrect(node)
  method_name, _args, body = *node
  delegation = ["delegate :#{body.method_name}",
                "to: :#{body.receiver.method_name}"]
  if method_name == prefixed_method_name(body)
    delegation << ['prefix: true']
  end
  lambda do |corrector|
    corrector.replace(node.source_range, delegation.join(', '))
  end
end

def include_prefix_case? 

def include_prefix_case?
  cop_config['EnforceForPrefixed']
end

def method_name_matches?(method_name, body) 

def method_name_matches?(method_name, body)
  method_name == body.method_name ||
    include_prefix_case? && method_name == prefixed_method_name(body)
end

def on_def(node) 

def on_def(node)
  return unless trivial_delegate?(node)
  return if private_or_protected_delegation(node)
  add_offense(node, location: :keyword)
end

def prefixed_method_name(body) 

def prefixed_method_name(body)
  [body.receiver.method_name, body.method_name].join('_').to_sym
end

def private_or_protected_before(line) 

def private_or_protected_before(line)
  (processed_source[0..line].map(&:strip) & %w[private protected]).any?
end

def private_or_protected_delegation(node) 

def private_or_protected_delegation(node)
  line = node.first_line
  private_or_protected_before(line) ||
    private_or_protected_inline(line)
end

def private_or_protected_inline(line) 

def private_or_protected_inline(line)
  processed_source[line - 1].strip =~ /\A(private )|(protected )/
end

def trivial_delegate?(def_node) 

def trivial_delegate?(def_node)
  method_name, args, body = *def_node
  delegate?(def_node) &&
    method_name_matches?(method_name, body) &&
    arguments_match?(args, body)
end