module FastJsonapi::ObjectSerializer

Constants

SERIALIZABLE_HASH_NOTIFICATION
SERIALIZED_JSON_NOTIFICATION

Public Class Methods

new(resource, options = {}) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 26
def initialize(resource, options = {})
  process_options(options)

  @resource = resource
end

Public Instance Methods

hash_for_collection() click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 51
def hash_for_collection
  serializable_hash = {}

  data = []
  included = []
  fieldset = @fieldsets[self.class.record_type.to_sym]
  @resource.each do |record|
    data << self.class.record_hash(record, fieldset, @params)
    included.concat self.class.get_included_records(record, @includes, @known_included_objects, @fieldsets, @params) if @includes.present?
  end

  serializable_hash[:data] = data
  serializable_hash[:included] = included if @includes.present?
  serializable_hash[:meta] = @meta if @meta.present?
  serializable_hash[:links] = @links if @links.present?
  serializable_hash
end
hash_for_one_record() click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 39
def hash_for_one_record
  serializable_hash = { data: nil }
  serializable_hash[:meta] = @meta if @meta.present?
  serializable_hash[:links] = @links if @links.present?

  return serializable_hash unless @resource

  serializable_hash[:data] = self.class.record_hash(@resource, @fieldsets[self.class.record_type.to_sym], @params)
  serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects, @fieldsets, @params) if @includes.present?
  serializable_hash
end
serializable_hash() click to toggle source
# File lib/fast_jsonapi/instrumentation/serializable_hash.rb, line 8
def serializable_hash
  ActiveSupport::Notifications.instrument(SERIALIZABLE_HASH_NOTIFICATION, { name: self.class.name }) do
    serializable_hash_without_instrumentation
  end
end
serializable_hash_without_instrumentation()
Alias for: serializable_hash
serialized_json() click to toggle source
# File lib/fast_jsonapi/instrumentation/serialized_json.rb, line 8
def serialized_json
  ActiveSupport::Notifications.instrument(SERIALIZED_JSON_NOTIFICATION, { name: self.class.name }) do
    serialized_json_without_instrumentation
  end
end
serialized_json_without_instrumentation()
Alias for: serialized_json
to_hash()
Alias for: serializable_hash

Private Instance Methods

add_relationship(relationship) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 201
def add_relationship(relationship)
  self.relationships_to_serialize = {} if relationships_to_serialize.nil?
  self.cachable_relationships_to_serialize = {} if cachable_relationships_to_serialize.nil?
  self.uncachable_relationships_to_serialize = {} if uncachable_relationships_to_serialize.nil?

  if !relationship.cached
    self.uncachable_relationships_to_serialize[relationship.name] = relationship
  else
    self.cachable_relationships_to_serialize[relationship.name] = relationship
  end
  self.relationships_to_serialize[relationship.name] = relationship
end
attributes(*attributes_list, &block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 183
def attributes(*attributes_list, &block)
  attributes_list = attributes_list.first if attributes_list.first.class.is_a?(Array)
  options = attributes_list.last.is_a?(Hash) ? attributes_list.pop : {}
  self.attributes_to_serialize = {} if self.attributes_to_serialize.nil?

  attributes_list.each do |attr_name|
    method_name = attr_name
    key = run_key_transform(method_name)
    attributes_to_serialize[key] = Attribute.new(
      key: key,
      method: block || method_name,
      options: options
    )
  end
end
belongs_to(relationship_name, options = {}, &block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 224
def belongs_to(relationship_name, options = {}, &block)
  relationship = create_relationship(relationship_name, :belongs_to, options, block)
  add_relationship(relationship)
end
cache_options(cache_options) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 177
def cache_options(cache_options)
  self.cached = cache_options[:enabled] || false
  self.cache_length = cache_options[:cache_length] || 5.minutes
  self.race_condition_ttl = cache_options[:race_condition_ttl] || 5.seconds
end
compute_id_method_name(custom_id_method_name, id_method_name_from_relationship, block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 266
def compute_id_method_name(custom_id_method_name, id_method_name_from_relationship, block)
  if block.present?
    custom_id_method_name || :id
  else
    custom_id_method_name || id_method_name_from_relationship
  end
end
compute_serializer_name(serializer_key) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 274
def compute_serializer_name(serializer_key)
  return serializer_key unless serializer_key.is_a? Symbol
  namespace = self.name.gsub(/()?\w+Serializer$/, '')
  serializer_name = serializer_key.to_s.classify + 'Serializer'
  (namespace + serializer_name).to_sym
end
create_relationship(base_key, relationship_type, options, block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 233
def create_relationship(base_key, relationship_type, options, block)
  name = base_key.to_sym
  if relationship_type == :has_many
    base_serialization_key = base_key.to_s.singularize
    base_key_sym = base_serialization_key.to_sym
    id_postfix = '_ids'
  else
    base_serialization_key = base_key
    base_key_sym = name
    id_postfix = '_id'
  end
  Relationship.new(
    key: options[:key] || run_key_transform(base_key),
    name: name,
    id_method_name: compute_id_method_name(
      options[:id_method_name],
      "#{base_serialization_key}#{id_postfix}".to_sym,
      block
    ),
    record_type: options[:record_type] || run_key_transform(base_key_sym),
    object_method_name: options[:object_method_name] || name,
    object_block: block,
    serializer: compute_serializer_name(options[:serializer] || base_key_sym),
    relationship_type: relationship_type,
    cached: options[:cached],
    polymorphic: fetch_polymorphic_option(options),
    conditional_proc: options[:if],
    transform_method: @transform_method,
    links: options[:links],
    lazy_load_data: options[:lazy_load_data]
  )
end
deep_symbolize(collection) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 94
def deep_symbolize(collection)
  if collection.is_a? Hash
    Hash[collection.map do |k, v|
      [k.to_sym, deep_symbolize(v)]
    end]
  elsif collection.is_a? Array
    collection.map { |i| deep_symbolize(i) }
  else
    collection.to_sym
  end
end
fetch_polymorphic_option(options) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 281
def fetch_polymorphic_option(options)
  option = options[:polymorphic]
  return false unless option.present?
  return option if option.respond_to? :keys
  {}
end
has_many(relationship_name, options = {}, &block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 214
def has_many(relationship_name, options = {}, &block)
  relationship = create_relationship(relationship_name, :has_many, options, block)
  add_relationship(relationship)
end
has_one(relationship_name, options = {}, &block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 219
def has_one(relationship_name, options = {}, &block)
  relationship = create_relationship(relationship_name, :has_one, options, block)
  add_relationship(relationship)
end
inherited(subclass) click to toggle source
Calls superclass method
# File lib/fast_jsonapi/object_serializer.rb, line 114
def inherited(subclass)
  super(subclass)
  subclass.attributes_to_serialize = attributes_to_serialize.dup if attributes_to_serialize.present?
  subclass.relationships_to_serialize = relationships_to_serialize.dup if relationships_to_serialize.present?
  subclass.cachable_relationships_to_serialize = cachable_relationships_to_serialize.dup if cachable_relationships_to_serialize.present?
  subclass.uncachable_relationships_to_serialize = uncachable_relationships_to_serialize.dup if uncachable_relationships_to_serialize.present?
  subclass.transform_method = transform_method
  subclass.cache_length = cache_length
  subclass.race_condition_ttl = race_condition_ttl
  subclass.data_links = data_links.dup if data_links.present?
  subclass.cached = cached
  subclass.set_type(subclass.reflected_record_type) if subclass.reflected_record_type
  subclass.meta_to_serialize = meta_to_serialize
end
is_collection?(resource, force_is_collection = nil) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 106
def is_collection?(resource, force_is_collection = nil)
  return force_is_collection unless force_is_collection.nil?

  resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
end
meta(&block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 229
def meta(&block)
  self.meta_to_serialize = block
end
process_options(options) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 75
def process_options(options)
  @fieldsets = deep_symbolize(options[:fields].presence || {})
  @params = {}

  return if options.blank?

  @known_included_objects = {}
  @meta = options[:meta]
  @links = options[:links]
  @is_collection = options[:is_collection]
  @params = options[:params] || {}
  raise ArgumentError.new("`params` option passed to serializer must be a hash") unless @params.is_a?(Hash)

  if options[:include].present?
    @includes = options[:include].delete_if(&:blank?).map(&:to_sym)
    self.class.validate_includes!(@includes)
  end
end
reflected_record_type() click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 129
def reflected_record_type
  return @reflected_record_type if defined?(@reflected_record_type)

  @reflected_record_type ||= begin
    if self.name.end_with?('Serializer')
      self.name.split('::').last.chomp('Serializer').underscore.to_sym
    end
  end
end
run_key_transform(input) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 156
def run_key_transform(input)
  if self.transform_method.present?
    input.to_s.send(*@transform_method).to_sym
  else
    input.to_sym
  end
end
set_id(id_name = nil, &block) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 173
def set_id(id_name = nil, &block)
  self.record_id = block || id_name
end
set_key_transform(transform_name) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 139
def set_key_transform(transform_name)
  mapping = {
    camel: :camelize,
    camel_lower: [:camelize, :lower],
    dash: :dasherize,
    underscore: :underscore
  }
  self.transform_method = mapping[transform_name.to_sym]

  # ensure that the record type is correctly transformed
  if record_type
    set_type(record_type)
  elsif reflected_record_type
    set_type(reflected_record_type)
  end
end
set_type(type_name) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 169
def set_type(type_name)
  self.record_type = run_key_transform(type_name)
end
use_hyphen() click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 164
def use_hyphen
  warn('DEPRECATION WARNING: use_hyphen is deprecated and will be removed from fast_jsonapi 2.0 use (set_key_transform :dash) instead')
  set_key_transform :dash
end
validate_includes!(includes) click to toggle source
# File lib/fast_jsonapi/object_serializer.rb, line 299
def validate_includes!(includes)
  return if includes.blank?

  includes.detect do |include_item|
    klass = self
    parse_include_item(include_item).each do |parsed_include|
      relationships_to_serialize = klass.relationships_to_serialize || {}
      relationship_to_include = relationships_to_serialize[parsed_include]
      raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include
      klass = relationship_to_include.serializer.to_s.constantize unless relationship_to_include.polymorphic.is_a?(Hash)
    end
  end
end