class ActiveModel::Serializer

def self.adapter
  ActiveModelSerializers::Adapter.lookup(config.adapter)
end

def self.get_serializer_for(klass)
  return nil unless config.serializer_lookup_enabled
  serializers_cache.fetch_or_store(klass) do
    # NOTE(beauby): When we drop 1.9.3 support we can lazify the map for perfs.
    serializer_class = serializer_lookup_chain_for(klass).map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
    if serializer_class
      serializer_class
    elsif klass.superclass
      get_serializer_for(klass.superclass)
    end
  end
end

def self.serializer_for(resource, options = {})
  if resource.respond_to?(:serializer_class)
    resource.serializer_class
  elsif resource.respond_to?(:to_ary)
    config.collection_serializer
  else
    options.fetch(:serializer) { get_serializer_for(resource.class) }
  end
end

def self.serializer_lookup_chain_for(klass)
  chain = []
  resource_class_name = klass.name.demodulize
  resource_namespace = klass.name.deconstantize
  serializer_class_name = "#{resource_class_name}Serializer"
  chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
  chain.push("#{resource_namespace}::#{serializer_class_name}")
  chain
end

def self.serializers_cache
  @serializers_cache ||= ThreadSafe::Cache.new
end

def as_json(adapter_opts = nil)
  serializable_hash(adapter_opts)
end

def initialize(object, options = {})
  self.object = object
  self.instance_options = options
  self.root = instance_options[:root]
  self.scope = instance_options[:scope]
  scope_name = instance_options[:scope_name]
  if scope_name && !respond_to?(scope_name)
    define_singleton_method scope_name, lambda { scope }
  end
end

def json_key
  root || _type || object.class.model_name.to_s.underscore
end

def read_attribute_for_serialization(attr)
  if respond_to?(attr)
    send(attr)
  elsif self.class._fragmented
    self.class._fragmented.read_attribute_for_serialization(attr)
  else
    object.read_attribute_for_serialization(attr)
  end
end

def serializable_hash(adapter_opts = nil)
  adapter_opts ||= {}
  adapter_opts = { include: '*', adapter: :attributes }.merge!(adapter_opts)
  adapter = ActiveModelSerializers::Adapter.create(self, adapter_opts)
  adapter.serializable_hash(adapter_opts)
end

def success?
  true
end