Module: ActiveModel::Serializers::JSON

### Home Classes Methods

### In Files

- lib/active_model/serializers/json.rb

### Methods

- #as_json
- #from_json

### Included Modules

- ActiveModel::Serialization

### 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::Serializers::JSON

## Active Model JSON Serializer

### Public Instance Methods

as_json(options = nil) click to toggle source

Returns a hash representing the model. Some configuration can be passed through `options`.

The option `include_root_in_json` controls the top-level behavior of `as_json`. If true (the default) `as_json` will emit a single root node named after the object's type. For example:

    user = User.find(1)
    user.as_json
    # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
                    "created_at": "2006/08/01", "awesome": true} }

    ActiveRecord::Base.include_root_in_json = false
    user.as_json
    # => {"id": 1, "name": "Konata Izumi", "age": 16,
          "created_at": "2006/08/01", "awesome": true}

This behavior can also be achieved by setting the `:root` option to `false` as in:

    user = User.find(1)
    user.as_json(root: false)
    # =>  {"id": 1, "name": "Konata Izumi", "age": 16,
           "created_at": "2006/08/01", "awesome": true}

The remainder of the examples in this section assume include_root_in_json is set to `false`.

Without any `options`, the returned Hash will include all the model's attributes. For example:

    user = User.find(1)
    user.as_json
    # => {"id": 1, "name": "Konata Izumi", "age": 16,
          "created_at": "2006/08/01", "awesome": true}

The `:only` and `:except` options can be used to limit the attributes included, and work similar to the `attributes` method. For example:

    user.as_json(:only => [ :id, :name ])
    # => {"id": 1, "name": "Konata Izumi"}

    user.as_json(:except => [ :id, :created_at, :age ])
    # => {"name": "Konata Izumi", "awesome": true}

To include the result of some method calls on the model use `:methods`:

    user.as_json(:methods => :permalink)
    # => {"id": 1, "name": "Konata Izumi", "age": 16,
          "created_at": "2006/08/01", "awesome": true,
          "permalink": "1-konata-izumi"}

To include associations use `:include`:

    user.as_json(:include => :posts)
    # => {"id": 1, "name": "Konata Izumi", "age": 16,
          "created_at": "2006/08/01", "awesome": true,
          "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
                    {"id": 2, author_id: 1, "title": "So I was thinking"}]}

Second level and higher order associations work as well:

    user.as_json(:include => { :posts => {
                                   :include => { :comments => {
                                                 :only => :body } },
                                   :only => :title } })
    # => {"id": 1, "name": "Konata Izumi", "age": 16,
          "created_at": "2006/08/01", "awesome": true,
          "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
                     "title": "Welcome to the weblog"},
                    {"comments": [{"body": "Don't think too hard"}],
                     "title": "So I was thinking"}]}

    # File lib/active_model/serializers/json.rb, line 89
    def as_json(options = nil)
      root = include_root_in_json
      root = options[:root] if options.try(:key?, :root)
      if root
        root = self.class.model_name.element if root == true
        { root => serializable_hash(options) }
      else
        serializable_hash(options)
      end
    end

from_json(json, include_root=include_root_in_json) click to toggle source

    # File lib/active_model/serializers/json.rb, line 100
    def from_json(json, include_root=include_root_in_json)
      hash = ActiveSupport::JSON.decode(json)
      hash = hash.values.first if include_root
      self.attributes = hash
      self
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.