Module: ActiveModel::Serialization

### Home Classes Methods

### In Files

- lib/active_model/serialization.rb

### Methods

- #serializable_hash

### Class/Module Index

Quicksearch

- ActiveModel
- ActiveModel::AttributeMethods
- ActiveModel::AttributeMethods::ClassMethods
- ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
- ActiveModel::BlockValidator
- ActiveModel::Callbacks
- ActiveModel::Conversion
- ActiveModel::Dirty
- ActiveModel::EachValidator
- ActiveModel::Errors
- ActiveModel::Lint
- ActiveModel::Lint::Tests
- ActiveModel::MassAssignmentSecurity
- ActiveModel::MassAssignmentSecurity::BlackList
- ActiveModel::MassAssignmentSecurity::ClassMethods
- ActiveModel::MassAssignmentSecurity::Error
- ActiveModel::MassAssignmentSecurity::LoggerSanitizer
- ActiveModel::MassAssignmentSecurity::PermissionSet
- ActiveModel::MassAssignmentSecurity::Sanitizer
- ActiveModel::MassAssignmentSecurity::StrictSanitizer
- ActiveModel::MassAssignmentSecurity::WhiteList
- ActiveModel::MissingAttributeError
- ActiveModel::Name
- ActiveModel::Naming
- ActiveModel::Observer
- ActiveModel::ObserverArray
- ActiveModel::Observing
- ActiveModel::Observing::ClassMethods
- ActiveModel::SecurePassword
- ActiveModel::SecurePassword::ClassMethods
- ActiveModel::SecurePassword::InstanceMethodsOnActivation
- ActiveModel::Serialization
- ActiveModel::Serializers
- ActiveModel::Serializers::JSON
- ActiveModel::Serializers::Xml
- ActiveModel::StrictValidationFailed
- ActiveModel::Translation
- ActiveModel::Validations
- ActiveModel::Validations::AcceptanceValidator
- ActiveModel::Validations::Callbacks
- ActiveModel::Validations::Callbacks::ClassMethods
- ActiveModel::Validations::ClassMethods
- ActiveModel::Validations::ConfirmationValidator
- ActiveModel::Validations::ExclusionValidator
- ActiveModel::Validations::FormatValidator
- ActiveModel::Validations::HelperMethods
- ActiveModel::Validations::InclusionValidator
- ActiveModel::Validations::LengthValidator
- ActiveModel::Validations::NumericalityValidator
- ActiveModel::Validations::PresenceValidator
- ActiveModel::Validations::WithValidator
- ActiveModel::Validator

No matching classes.

# ActiveModel::Serialization

## Active Model Serialization

Provides a basic serialization to a serializable_hash for your object.

A minimal implementation could be:

    class Person

      include ActiveModel::Serialization

      attr_accessor :name

      def attributes
        {'name' => name}
      end

    end

Which would provide you with:

    person = Person.new
    person.serializable_hash   # => {"name"=>nil}
    person.name = "Bob"
    person.serializable_hash   # => {"name"=>"Bob"}

You need to declare some sort of attributes hash which contains the attributes you want to serialize and their current value.

Most of the time though, you will want to include the JSON or XML serializations. Both of these modules automatically include the ActiveModel::Serialization module, so there is no need to explicitly include it.

So a minimal implementation including XML and JSON would be:

    class Person

      include ActiveModel::Serializers::JSON
      include ActiveModel::Serializers::Xml

      attr_accessor :name

      def attributes
        {'name' => name}
      end

    end

Which would provide you with:

    person = Person.new
    person.serializable_hash   # => {"name"=>nil}
    person.as_json             # => {"name"=>nil}
    person.to_json             # => "{\"name\":null}"
    person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...

    person.name = "Bob"
    person.serializable_hash   # => {"name"=>"Bob"}
    person.as_json             # => {"name"=>"Bob"}
    person.to_json             # => "{\"name\":\"Bob\"}"
    person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...

Valid options are `:only`, `:except` and `:methods` .

### Public Instance Methods

serializable_hash(options = nil) click to toggle source

    # File lib/active_model/serialization.rb, line 71
    def serializable_hash(options = nil)
      options ||= {}

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

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

      method_names = Array.wrap(options[:methods]).select { |n| respond_to?(n) }
      method_names.each { |n| hash[n] = send(n) }

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

      hash
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.