def serializable_hash(options = nil)
      options ||= {}

      attribute_names = attributes.keys
      if only = options[:only]
        attribute_names &= Array(only).map(&:to_s)
      elsif except = options[:except]
        attribute_names -= Array(except).map(&:to_s)
      end

      hash = {}
      attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }

      Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }

      serializable_add_includes(options) do |association, records, opts|
        hash[association.to_s] = if records.respond_to?(:to_ary)
          records.to_ary.map { |a| a.serializable_hash(opts) }
        else
          records.serializable_hash(opts)
        end
      end

      hash
    end
def serializable_hash(options = nil)
      options ||= {}

      attribute_names = attributes.keys
      if only = options[:only]
        attribute_names &= Array(only).map(&:to_s)
      elsif except = options[:except]
        attribute_names -= Array(except).map(&:to_s)
      end

      hash = {}
      attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }

      Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }

      serializable_add_includes(options) do |association, records, opts|
        hash[association.to_s] = if records.respond_to?(:to_ary)
          records.to_ary.map { |a| a.serializable_hash(opts) }
        else
          records.serializable_hash(opts)
        end
      end

      hash
    end
Returns a serialized hash of your object.

   class Person
     include ActiveModel::Serialization

     attr_accessor :name, :age

     def attributes
       {'name' => nil, 'age' => nil}
     end

     def capitalized_name
       name.capitalize
     end
   end

   person = Person.new
   person.name = 'bob'
   person.age  = 22
   person.serializable_hash                # => {"name"=>"bob", "age"=>22}
   person.serializable_hash(only: :name)   # => {"name"=>"bob"}
   person.serializable_hash(except: :name) # => {"age"=>22}
   person.serializable_hash(methods: :capitalized_name)
   # => {"name"=>"bob", "age"=>22, "capitalized_name"=>"Bob"}

 Example with <tt>:include</tt> option

   class User
     include ActiveModel::Serializers::JSON
     attr_accessor :name, :notes # Emulate has_many :notes
     def attributes
       {'name' => nil}
     end
   end

   class Note
     include ActiveModel::Serializers::JSON
     attr_accessor :title, :text
     def attributes
       {'title' => nil, 'text' => nil}
     end
   end

   note = Note.new
   note.title = 'Battle of Austerlitz'
   note.text = 'Some text here'

   user = User.new
   user.name = 'Napoleon'
   user.notes = [note]

   user.serializable_hash
   # => {"name" => "Napoleon"}
   user.serializable_hash(include: { notes: { only: 'title' }})
   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}