class FastSerializer::Schema

Attributes

_root[R]
params[R]
serialization_schema[R]
strict[R]

Public Class Methods

new(params = {}, root = nil, strict = nil) click to toggle source
# File lib/fast_serializer/schema.rb, line 9
def initialize(params = {}, root = nil, strict = nil)
  @root                   = root
  @strict                 = strict || FastSerializer.config.strict
  @serialization_schema   = FastSerializer::JsonModel::Object.new
  @params                 = FastSerializer::Utils.symbolize_keys(params || {})
  @params[:self]          = self
  @params[:include_index] = {}
  @params[:exclude_index] = {}

  self.include = @params.delete(:include)
  self.exclude = @params.delete(:exclude)
end

Public Instance Methods

attribute(attribute_name, opts = {}, &block) click to toggle source

Defines an attribute for serialization

@param attribute_name [String, Symbol] an attribute name @param opts [Hash] attribute options @option opts [Proc] :if conditional clause. accepts a proc/lambda which has to return a boolean @option opts [Proc] :unless (see opts:if) @param block [Proc] result is used as the attribute value

# File lib/fast_serializer/schema.rb, line 59
def attribute(attribute_name, opts = {}, &block)
  serialization_schema.add_attribute(
    JsonModel::Attribute.new(
      key: attribute_name,
      method: block,
      opts: opts
    )
  )
end
attributes(*attribute_names) click to toggle source

Defines a list of attributes for serialization

@param attribute_names [Array<String, Symbol>] a list of attributes to serialize each of these attributes value is fetched calling a corresponding method from a resource instance passed to the serializer

# File lib/fast_serializer/schema.rb, line 43
def attributes(*attribute_names)
  attribute_names.each do |attribute_name|
    serialization_schema.add_attribute(
      JsonModel::Attribute.new(key: attribute_name, method: attribute_name)
    )
  end
end
belongs_to(attribute_name, opts = {})
Alias for: has_one
deep_copy() click to toggle source
# File lib/fast_serializer/schema.rb, line 123
def deep_copy
  schema = FastSerializer::Schema.new(params, _root, strict)

  serialization_schema.attributes.each do |key, attribute|
    schema.serialization_schema.attributes[key] = attribute
  end

  schema
end
exclude=(list) click to toggle source
# File lib/fast_serializer/schema.rb, line 30
def exclude=(list)
  return unless list
  return if list.empty?

  @params[:exclude]       = list.map(&:to_sym)
  @params[:exclude_index] = @params[:exclude].map { |key| [key, nil] }.to_h
end
has_many(attribute_name, opts = {}) click to toggle source

@param attribute_name [String] @param opts [Hash] attribute options

# File lib/fast_serializer/schema.rb, line 92
def has_many(attribute_name, opts = {})
  serialization_schema.add_attribute(
    JsonModel::HasManyRelationship.new(
      key: opts.delete(:key) || attribute_name,
      method: opts.delete(:method) || attribute_name,
      opts: opts,
      schema: opts.delete(:schema),
      serializer: opts.delete(:serializer)
    )
  )
end
has_one(attribute_name, opts = {}) click to toggle source

Defines an attribute for serialization

@param attribute_name [String, Symbol] an attribute name @param opts [Hash] attribute options @option opts [Proc] :if conditional clause. accepts a proc/lambda which has to return a boolean @option opts [Proc] :unless (see opts:if) @option opts [FastSerializer::Schema::Mixin, nil] :serializer a serializer class with injected module or a inherited class @option opts [FastSerializer::Schema] :schema

# File lib/fast_serializer/schema.rb, line 78
def has_one(attribute_name, opts = {})
  serialization_schema.add_attribute JsonModel::HasOneRelationship.new(
    key: opts.delete(:key) || attribute_name,
    method: opts.delete(:method) || attribute_name,
    opts: opts,
    schema: opts.delete(:schema),
    serializer: opts.delete(:serializer)
  )
end
Also aliased as: belongs_to
include=(list) click to toggle source
# File lib/fast_serializer/schema.rb, line 22
def include=(list)
  return unless list
  return if list.empty?

  @params[:include]       = list.map(&:to_sym)
  @params[:include_index] = @params[:include].map { |key| [key, nil] }.to_h
end
list(attribute_name, opts = {}) click to toggle source

@param [String] attribute_name @param [Hash] opts - attribute options

# File lib/fast_serializer/schema.rb, line 106
def list(attribute_name, opts = {})
  serialization_schema.add_attribute(
    JsonModel::Array.new(
      key: attribute_name,
      method: attribute_name,
      opts: opts,
      schema: opts.delete(:schema),
      serializer: opts.delete(:serializer)
    )
  )
end
root(root_key) click to toggle source

@param [String] root_key - a key under which serialization result is nested

# File lib/fast_serializer/schema.rb, line 119
def root(root_key)
  @_root = root_key
end
serialize_resource(resource, params = {}, context = self) click to toggle source
# File lib/fast_serializer/schema.rb, line 133
def serialize_resource(resource, params = {}, context = self)
  Utils.ref_merge(self.params, params)
  _params_dup = FastSerializer::Utils.symbolize_keys(self.params)
  meta        = _params_dup.delete(:meta)

  is_collection = if _params_dup.key?(:is_collection)
    _params_dup.delete(:is_collection)
    params.delete(:is_collection)
  else
    resource.respond_to?(:each) && !resource.respond_to?(:each_pair)
  end

  root = (_root || _params_dup.delete(:root))

  res = if is_collection

          if !context.is_a?(self.class)
            # need to bind context
            resource.map { |entry| context.class.new(entry, _params_dup).serializable_hash }
          else
            JsonModel::Array.new(schema: serialization_schema).serialize(resource, _params_dup, context)
          end

        else
          serialization_schema.serialize(resource, _params_dup, context)
        end

  res = { root => res } if root && !root.empty?

  res[:meta] = meta if res.is_a?(Hash) && meta

  res
end
serialize_resource_to_json(resource, params = {}, context = self) click to toggle source
# File lib/fast_serializer/schema.rb, line 167
def serialize_resource_to_json(resource, params = {}, context = self)
  FastSerializer.config.coder.dump(serialize_resource(resource, params, context))
end