Class: ActiveObject::Serialization::Serializer

Inherits:
Object
  • Object
show all
Defined in:
lib/active_object/serialization.rb

Overview

:nodoc:

Direct Known Subclasses

JsonSerializer, XmlSerializer

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(object, options = {}) ⇒ Serializer 



6
7
8
 
# File 'lib/active_object/serialization.rb', line 6

def initialize(object, options = {})
  @object, @options = object, options.dup
end

Instance Attribute Details

#options ⇒ Object (readonly)

Returns the value of attribute options.



4
5
6
 
# File 'lib/active_object/serialization.rb', line 4

def options
  @options
end

Instance Method Details

#add_includes(&block) ⇒ Object

Add associations specified via the :includes option. Expects a block that takes as arguments:

+association+ - name of the association
+objects+     - the association object(s) to be serialized
+opts+        - options for the association objects



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/active_object/serialization.rb', line 46

def add_includes(&block)
  if include_associations = options.delete(:include)
    base_only_or_except = { :except => options[:except],
                            :only => options[:only] }

    include_has_options = include_associations.is_a?(Hash)
    associations = include_has_options ? include_associations.keys : Array(include_associations)

    for association in associations
      objects = @object.send association

      objects = objects.objects if objects.is_a?(ActiveObject::Associations::HasManyAssociation::Collection)

      unless objects.nil?
        association_options = include_has_options ? include_associations[association] : base_only_or_except
        opts = options.merge(association_options)
        yield(association, objects, opts)
      end
    end

    options[:include] = include_associations
  end
end

#serializable_attribute_names ⇒ Object

To replicate the behavior in ActiveObject#attributes, :except takes precedence over :only. If :only is not set for a N level model but is set for the N+1 level models, then because :except is set to a default value, the second level model can have both :except and :only set. So if :only is set, always delete :except.



16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/active_object/serialization.rb', line 16

def serializable_attribute_names
  attribute_names = @object.attributes

  if options[:only]
    options.delete(:except)
    attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
  else
    options[:except] = Array(options[:except])
    attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
  end

  attribute_names
end

#serializable_method_names ⇒ Object 



30
31
32
33
34
35
 
# File 'lib/active_object/serialization.rb', line 30

def serializable_method_names
  Array(options[:methods]).inject([]) do |method_attributes, name|
    method_attributes << name if @object.respond_to?(name.to_s)
    method_attributes
  end
end

#serializable_names ⇒ Object 



37
38
39
 
# File 'lib/active_object/serialization.rb', line 37

def serializable_names
  serializable_attribute_names + serializable_method_names
end

#serializable_object ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/active_object/serialization.rb', line 70

def serializable_object
  returning(serializable_object = {}) do
    serializable_names.each { |name| serializable_object[name] = @object.send(name) }

    add_includes do |association, objects, opts|
      if objects.is_a?(Enumerable)
        serializable_object[association] = objects.collect { |r| self.class.new(r, opts).serializable_object }
        serializable_object.delete("#{association}_ids")
      else
        serializable_object[association] = self.class.new(objects, opts).serializable_object
        serializable_object.delete("#{association}_id")
      end

    end
  end
end

#serialize ⇒ Object 



87
88
89
 
# File 'lib/active_object/serialization.rb', line 87

def serialize
  # overwrite to implement
end

#to_s(&block) ⇒ Object 



91
92
93
 
# File 'lib/active_object/serialization.rb', line 91

def to_s(&block)
  serialize(&block)
end