Class: ActiveModel::Serializer

Inherits:

Object

• Object
• ActiveModel::Serializer

show all

Extended by:

ActiveModelSerializers::Deprecate, ActiveSupport::Autoload

Includes:

Associations, Attributes, Caching, Configuration, Links, Meta, Type

Defined in:

lib/active_model/serializer.rb,
lib/active_model/serializer/type.rb,
lib/active_model/serializer/null.rb,
lib/active_model/serializer/meta.rb,
lib/active_model/serializer/field.rb,
lib/active_model/serializer/links.rb,
lib/active_model/serializer/adapter.rb,
lib/active_model/serializer/version.rb,
lib/active_model/serializer/caching.rb,
lib/active_model/serializer/fieldset.rb,
lib/active_model/serializer/attribute.rb,
lib/active_model/serializer/reflection.rb,
lib/active_model/serializer/attributes.rb,
lib/active_model/serializer/association.rb,
lib/active_model/serializer/include_tree.rb,
lib/active_model/serializer/adapter/null.rb,
lib/active_model/serializer/adapter/json.rb,
lib/active_model/serializer/adapter/base.rb,
lib/active_model/serializer/associations.rb,
lib/active_model/serializer/configuration.rb,
lib/active_model/serializer/adapter/json_api.rb,
lib/active_model/serializer/array_serializer.rb,
lib/active_model/serializer/adapter/attributes.rb,
lib/active_model/serializer/has_one_reflection.rb,
lib/active_model/serializer/has_many_reflection.rb,
lib/active_model/serializer/singular_reflection.rb,
lib/active_model/serializer/collection_reflection.rb,
lib/active_model/serializer/belongs_to_reflection.rb,
lib/active_model/serializer/collection_serializer.rb

Defined Under Namespace

Modules: Adapter, Associations, Attributes, Caching, Configuration, Links, Lint, Meta, Type Classes: ArraySerializer, Association, Attribute, BelongsToReflection, CollectionReflection, CollectionSerializer, ErrorSerializer, ErrorsSerializer, Field, Fieldset, HasManyReflection, HasOneReflection, IncludeTree, Null, Reflection, SingularReflection

Constant Summary

VERSION =

'0.10.0.rc5'.freeze

Constants included from Caching

Caching::CALLER_FILE

Constants included from Associations

Associations::DEFAULT_INCLUDE_TREE

Instance Attribute Summary (collapse)

• - (Object) object

  Returns the value of attribute object.

• - (Object) root

  Returns the value of attribute root.

• - (Object) scope

  Returns the value of attribute scope.

Class Method Summary (collapse)

• + (Object) adapter

  Deprecated.

• + (Object) get_serializer_for(klass) private

  Find a serializer from a class and caches the lookup.

• + (ActiveModel::Serializer) serializer_for(resource, options = {})

  Preferentially returns 1.

• + (Object) serializer_lookup_chain_for(klass) private
• + (Object) serializers_cache

  Used to cache serializer name => serializer class when looked up by Serializer.get_serializer_for.

Instance Method Summary (collapse)

• - (Object) as_json(adapter_opts = nil)

  TODO: When moving attributes adapter logic here, @see #serializable_hash So that the below is true: @param options [nil, Hash] The same valid options passed to `as_json` (:root, :only, :except, :methods, and :include).

• - (Serializer) initialize(object, options = {}) constructor

  `scope_name` is set as :current_user by default in the controller.

• - (Object) json_key

  Used by adapter as resource root.

• - (Object) read_attribute_for_serialization(attr)
• - (Hash) serializable_hash(adapter_opts = nil) (also: #to_hash, #to_h)

  associations, similar to how ActiveModel::Serializers::JSON is used in ActiveRecord::Base.

• - (Boolean) success?

Methods included from ActiveModelSerializers::Deprecate

delegate_and_deprecate, deprecate

Methods included from Associations

#associations

104
105
106
107
108
109
110
111
112
113
114

# File 'lib/active_model/serializer.rb', line 104

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

99
100
101

# File 'lib/active_model/serializer.rb', line 99

def object
  @object
end

99
100
101

# File 'lib/active_model/serializer.rb', line 99

def root
  @root
end

99
100
101

# File 'lib/active_model/serializer.rb', line 99

def scope
  @scope
end

51
52
53

# File 'lib/active_model/serializer.rb', line 51

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

1. class name appended with "Serializer"
2. try again with superclass, if present
3. nil

85
86
87
88
89
90
91
92
93
94
95
96
97

# File 'lib/active_model/serializer.rb', line 85

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

39
40
41
42
43
44
45
46
47

# File 'lib/active_model/serializer.rb', line 39

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

60
61
62
63
64
65
66
67
68
69
70
71

# File 'lib/active_model/serializer.rb', line 60

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

75
76
77

# File 'lib/active_model/serializer.rb', line 75

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

@param options [nil, Hash] The same valid options passed to `as_json`
   (:root, :only, :except, :methods, and :include).
The default for `root` is nil.
The default value for include_root is false. You can change it to true if the given
JSON string includes a single root node.

167
168
169

# File 'lib/active_model/serializer.rb', line 167

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

172
173
174

# File 'lib/active_model/serializer.rb', line 172

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

176
177
178
179
180
181
182
183
184

# File 'lib/active_model/serializer.rb', line 176

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

@param options [nil, Hash] The same valid options passed to `serializable_hash`
   (:only, :except, :methods, and :include).

  See
  https://github.com/rails/rails/blob/v5.0.0.beta2/activemodel/lib/active_model/serializers/json.rb#L17-L101
  https://github.com/rails/rails/blob/v5.0.0.beta2/activemodel/lib/active_model/serialization.rb#L85-L123
  https://github.com/rails/rails/blob/v5.0.0.beta2/activerecord/lib/active_record/serialization.rb#L11-L17
  https://github.com/rails/rails/blob/v5.0.0.beta2/activesupport/lib/active_support/core_ext/object/json.rb#L147-L162

@example
  # The :only and :except options can be used to limit the attributes included, and work
  # similar to the attributes method.
  serializer.as_json(only: [:id, :name])
  serializer.as_json(except: [:id, :created_at, :age])

  # To include the result of some method calls on the model use :methods:
  serializer.as_json(methods: :permalink)

  # To include associations use :include:
  serializer.as_json(include: :posts)
  # Second level and higher order associations work as well:
  serializer.as_json(include: { posts: { include: { comments: { only: :body } }, only: :title } })

150
151
152
153
154
155

# File 'lib/active_model/serializer.rb', line 150

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

116
117
118

# File 'lib/active_model/serializer.rb', line 116

def success?
  true
end