class RuboCop::Cop::Rails::HasManyOrHasOneDependent

end
end
true
def readonly?
has_one :avatar
has_many :comments
class User < ActiveRecord::Base
end
has_many :patients, through: :appointments
has_many :articles, dependent: nil
has_one :avatar, dependent: :destroy
has_many :comments, dependent: :restrict_with_exception
class User < ActiveRecord::Base
# good
end
has_one :avatar
has_many :comments
class User < ActiveRecord::Base
# bad
@example
is specified, or if the model is read-only.
It doesn’t register an offense if ‘:through` or `dependent: nil`
specify a `:dependent` option.
Looks for `has_many` or `has_one` associations that don’t

def active_resource?(node) 

def active_resource?(node)
  return false if node.nil?
  active_resource_class?(node)
end

def contain_valid_options_in_with_options_block?(node) 

def contain_valid_options_in_with_options_block?(node)
  if (options = with_options_block(node))
    return true if valid_options?(options)
    return false unless node.parent
    return true if contain_valid_options_in_with_options_block?(node.parent.parent)
  end
  false
end

def extract_option_if_kwsplat(options) 

def extract_option_if_kwsplat(options)
  if options.first.kwsplat_type? && options.first.children.first.hash_type?
    return options.first.children.first.pairs
  end
  options
end

def on_send(node) 

def on_send(node)
  return if active_resource?(node.parent) || readonly_model?(node)
  return if !association_without_options?(node) && valid_options?(association_with_options?(node))
  return if valid_options_in_with_options_block?(node)
  add_offense(node.loc.selector)
end

def readonly_model?(node) 

def readonly_model?(node)
  return false unless (parent = node.parent)
  parent.each_descendant(:def).any? { |def_node| readonly?(def_node) }
end

def valid_options?(options) 

def valid_options?(options)
  return false if options.nil?
  options = extract_option_if_kwsplat(options)
  return true unless options
  return true if options.any? do |o|
    dependent_option?(o) || present_option?(o)
  end
  false
end

def valid_options_in_with_options_block?(node) 

def valid_options_in_with_options_block?(node)
  return true unless node.parent
  n = node.parent.begin_type? || association_extension_block?(node.parent) ? node.parent.parent : node.parent
  contain_valid_options_in_with_options_block?(n)
end