class ActiveModel::Serializer

def associate(klass, *attrs)
  options = attrs.extract_options!
  attrs.each do |attr|
    define_method attr do
      object.send attr
    end unless method_defined?(attr)
    @_associations[attr] = klass.new(attr, options)
  end
end

def associations
  associations = self.class._associations
  included_associations = filter(associations.keys)
  associations.each_with_object({}) do |(name, association), hash|
    if included_associations.include? name
      if association.embed_ids?
        hash[association.key] = serialize_ids association
      elsif association.embed_objects?
        hash[association.embedded_key] = serialize association
      end
    end
  end
end

def attributes(*attrs)
  @_attributes.concat attrs
  attrs.each do |attr|
    define_method attr do
      object.read_attribute_for_serialization attr
    end unless method_defined?(attr)
  end
end

def attributes
  filter(self.class._attributes.dup).each_with_object({}) do |name, hash|
    hash[name] = send(name)
  end
end

def build_serializer(association)
  object = send(association.name)
  association.build_serializer(object, scope: scope)
end

def embed(type, options={})
  CONFIG.embed = type
  CONFIG.embed_in_root = true if options[:embed_in_root] || options[:include]
  ActiveSupport::Deprecation.warn <<-WARN
ice: embed is deprecated. **
e of .embed method on a Serializer will be soon removed, as this should have a global scope and not a class scope.
 use the global .setup method instead:
Model::Serializer.setup do |config|
ig.embed = :#{type}
ig.embed_in_root = #{CONFIG.embed_in_root || false}
  WARN
end

def embedded_in_root_associations
  associations = self.class._associations
  included_associations = filter(associations.keys)
  associations.each_with_object({}) do |(name, association), hash|
    if included_associations.include? name
      if association.embed_in_root?
        association_serializer = build_serializer(association)
        hash.merge! association_serializer.embedded_in_root_associations
        serialized_data = association_serializer.serializable_object
        key = association.root_key
        if hash.has_key?(key)
          hash[key].concat(serialized_data).uniq!
        else
          hash[key] = serialized_data
        end
      end
    end
  end
end

def filter(keys)
  keys
end

def has_many(*attrs)
  associate(Association::HasMany, *attrs)
end

def has_one(*attrs)
  associate(Association::HasOne, *attrs)
end

def inherited(base)
  base._root = _root
  base._attributes = (_attributes || []).dup
  base._associations = (_associations || {}).dup
end

def initialize(object, options={})
  @object        = object
  @scope         = options[:scope]
  @root          = options.fetch(:root, self.class._root)
  @meta_key      = options[:meta_key] || :meta
  @meta          = options[@meta_key]
  @wrap_in_array = options[:_wrap_in_array]
end

def json_key
  if root == true || root.nil?
    self.class.root_name
  else
    root
  end
end

def root_name
  name.demodulize.underscore.sub(/_serializer$/, '') if name
end

def serializable_object(options={})
  return nil if object.nil?
  hash = attributes
  hash.merge! associations
  @wrap_in_array ? [hash] : hash
end

def serialize(association)
  build_serializer(association).serializable_object
end

def serialize_ids(association)
  associated_data = send(association.name)
  if associated_data.respond_to?(:to_ary)
    associated_data.map { |elem| elem.read_attribute_for_serialization(association.embed_key) }
  else
    associated_data.read_attribute_for_serialization(association.embed_key) if associated_data
  end
end

def serializer_for(resource)
  if resource.respond_to?(:to_ary)
    ArraySerializer
  else
    begin
      Object.const_get "#{resource.class.name}Serializer"
    rescue NameError
      nil
    end
  end
end

def serializer_for(resource)
  if resource.respond_to?(:to_ary)
    ArraySerializer
  else
    "#{resource.class.name}Serializer".safe_constantize
  end
end

def setup
  @mutex.synchronize do
    yield CONFIG
  end
end