Module: ActiveFacets::Serializer::Base

Extended by:
ActiveSupport::Concern
Defined in:
lib/active_facets/serializer/base.rb

Defined Under Namespace

Modules: ClassMethods

Instance Method Summary collapse

Instance Method Details

#as_json(resources, options = {}) ⇒ JSON

This method returns a JSON of hash values representing the resource(s)

Parameters:

  • resource (ActiveRecord || Array) —
    CollectionProxy object ::or

    a collection of resources

  • options (Hash) (defaults to: {}) —

    collection of values required that are not available in lexical field_set

Returns:

  • (JSON) —

    representing the resource



184
185
186
187
188
189
 
# File 'lib/active_facets/serializer/base.rb', line 184

def as_json(resources, options = {})
  resource_itterator(resources) do |resource|
    facade = ActiveFacets::Serializer::Facade.new(self, resource, options)
    facade.as_json
  end
end

#config ⇒ Config

Memoized instance getter

Returns:



193
194
195
 
# File 'lib/active_facets/serializer/base.rb', line 193

def config
  @config ||= self.class.config
end

#custom_includes(field, options) ⇒ Field Set

Returns field_set serialized for dependant resources in custom attribute serializers & extensions

Parameters:

  • field (Field)

Returns:

  • (Field Set) 


144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/active_facets/serializer/base.rb', line 144

def custom_includes(field, options)
  attribute = resource_attribute_name(field)
  custom_serializer_name = config.serializers[attribute]

  if custom_serializer_name
    custom_serializer = get_custom_serializer_class(custom_serializer_name, options)
    if custom_serializer.respond_to? :custom_scope
      custom_serializer.custom_scope
    else
      nil
    end
  else
    nil
  end
end

#exposed_aliases(field_set_alias = :all, include_relations = false, include_nested_field_sets = false) ⇒ Array

Gets flattened fields from a Field Set Alias

Parameters:

  • field_set_alias (Symbol) (defaults to: :all) —

    to retrieve aliased field_sets for

  • include_relations (Boolean) (defaults to: false)
  • include_nested_field_sets (Boolean) (defaults to: false)

Returns:

  • (Array) —

    of symbols



165
166
167
168
169
170
 
# File 'lib/active_facets/serializer/base.rb', line 165

def exposed_aliases(field_set_alias = :all, include_relations = false, include_nested_field_sets = false)
  return include_nested_field_sets ? field_set_alias : [field_set_alias] unless normalized_field_sets = config.normalized_field_sets[field_set_alias]
  result = normalized_field_sets[include_relations ? :fields : :attributes]
  return result if include_nested_field_sets
  result.keys.map(&:to_sym).sort
end

#from_hash(resource, attributes, options = {}) ⇒ ActiveRecord

This method returns a ActiveRecord model updated to match a JSON of hash values

Parameters:

  • resource (ActiveRecord) —

    to hydrate

  • attribute (Hash) —

    subset of the values returned by ActiveFacets::Serializer::Base.resourceresource.as_json

Returns:

  • (ActiveRecord) —

    resource



176
177
178
 
# File 'lib/active_facets/serializer/base.rb', line 176

def from_hash(resource, attributes, options = {})
  ActiveFacets::Serializer::Facade.new(self, resource, options).from_hash(attributes)
end

#get_association_reflection(field) ⇒ Reflection | nil

Constantizes an appropriate resource serializer class for relations

Parameters:

  • field (Symbol) —

    to find relation reflection for

Returns:

  • (Reflection | nil) 


209
210
211
212
 
# File 'lib/active_facets/serializer/base.rb', line 209

def get_association_reflection(field)
  @association_reflections ||= {}
  @association_reflections[field] ||= resource_class.reflect_on_association(resource_attribute_name(field).to_sym)
end

#get_association_serializer_class(field, options) ⇒ Class | nil

Constantizes an appropriate resource serializer class

Parameters:

  • field (Symbol) —

    to test as relation and find serializer class for

Returns:

  • (Class | nil) 


217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/active_facets/serializer/base.rb', line 217

def get_association_serializer_class(field, options)
  @association_serializers ||= {}
  unless @association_serializers.key? field
    @association_serializers[field] = nil
    #return nil if field isn't an association
    if reflection = get_association_reflection(field)
      #return nil if association doesn't have a custom class
      @association_serializers[field] = ActiveFacets::ResourceManager.instance.serializer_for(reflection.klass, options)
    end
  end
  @association_serializers[field]
end

#get_custom_serializer_class(attribute, options) ⇒ Class | nil

Constantizes an appropriate attribute serializer class

Parameters:

  • attribute (Symbol) —

    base_name of attribute serializer class to find

  • options (Hash)

Returns:

  • (Class | nil) 


234
235
236
237
 
# File 'lib/active_facets/serializer/base.rb', line 234

def get_custom_serializer_class(attribute, options)
  @custom_serializers ||= {}
  @custom_serializers[attribute] ||= ActiveFacets::ResourceManager.instance.attribute_serializer_class_for(resource_class, attribute, options)
end

#is_association?(field) ⇒ Boolean

Determines if public attribute maps to a private relation

Parameters:

  • field (Symbol) —

    public attribute name

Returns:

  • (Boolean) 


242
243
244
 
# File 'lib/active_facets/serializer/base.rb', line 242

def is_association?(field)
  !!get_association_reflection(field)
end

#resource_attribute_name(field, direction = :from) ⇒ Symbol

Renames attribute between resource.attribute_name and json.attribute_name

Parameters:

  • field (Symbol) —

    attribute name

  • direction (Symbol) (defaults to: :from) —

    to apply translation

Returns:

  • (Symbol) 


250
251
252
 
# File 'lib/active_facets/serializer/base.rb', line 250

def resource_attribute_name(field, direction = :from)
  (config.transforms(direction)[field] || field).to_sym
end

#resource_class ⇒ Class

Constantizes the appropriate resource serializer class

Returns:

  • (Class) 


202
203
204
 
# File 'lib/active_facets/serializer/base.rb', line 202

def resource_class
  @resource_class ||= config.resource_class
end

#scoped_include(field, nested_field_set, options) ⇒ Object 



128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/active_facets/serializer/base.rb', line 128

def scoped_include(field, nested_field_set, options)
  if is_association? field
    attribute = resource_attribute_name(field)
    if nested_field_set
      serializer_class = get_association_serializer_class(field, options)
      attribute = { attribute => serializer_class.present? ? serializer_class.scoped_includes(nested_field_set, options) : nested_field_set }
    end
    attribute
  else
    custom_includes(field, options)
  end
end

#scoped_includes(field_set = nil, options = {}) ⇒ Hash

This method returns a hash suitable to pass into ActiveRecord.includes to avoid N+1 given:

:basic is a defined collection
:extended is a defined collection
:orders is a defined association
:line_items is a defined association on OrderSerializer

examples:

:basic
[:basic]
{basic: nil}
[:basic, :extended]
[:basic, :extended, :orders]
[:basic, :extended, {orders: :basic}]
[:basic, :extended, {orders: [:basic, :extended]}]
[:basic, :extended, {orders: [:basic, :line_items]}]
[:basic, :extended, {orders: [:basic, {line_items: :extended}]}]

Parameters:

  • field_set (Field Set) (defaults to: nil) —

    collections of fields to be serialized from this resource later

Returns:

  • (Hash) 


114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/active_facets/serializer/base.rb', line 114

def scoped_includes(field_set = nil, options = {})
  result = {}
  config.field_set_itterator(field_set) do |field, nested_field_set|
    case value = scoped_include(field, nested_field_set, options)
    when nil
    when Hash
      result.deep_merge! value
    else
      result[value] ||= nil
    end
  end
  result
end