Class: ActiveData::Model::Associations::NestedAttributes::NestedAttributesMethods

Inherits:
Object
  • Object
show all
Defined in:
lib/active_data/model/associations/nested_attributes.rb

Constant Summary collapse

REJECT_ALL_BLANK_PROC = 
proc { |attributes| attributes.all? { |key, value| key == DESTROY_ATTRIBUTE || value.blank? } }

Class Method Summary collapse

Class Method Details

.accepts_nested_attributes_for(klass, *attr_names) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 17

def self.accepts_nested_attributes_for(klass, *attr_names)
  options = { allow_destroy: false, update_only: false }
  options.update(attr_names.extract_options!)
  options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
  options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank

  attr_names.each do |association_name|
    if reflection = klass.reflect_on_association(association_name)
      klass.nested_attributes_options = klass.nested_attributes_options.merge(association_name.to_sym => options)

      klass.validates_nested association_name if klass.respond_to?(:validates_nested)
      type = (reflection.collection? ? :collection : :one_to_one)
      klass.class_eval "        def \#{association_name}_attributes=(attributes)\n          ActiveData::Model::Associations::NestedAttributes::NestedAttributesMethods\n            .assign_nested_attributes_for_\#{type}_association(self, :\#{association_name}, attributes)\n        end\n      METHOD\n    else\n      raise ArgumentError, \"No association found for name `\#{association_name}'. Has it been defined yet?\"\n    end\n  end\nend\n", __FILE__, __LINE__ + 1

.assign_nested_attributes_for_collection_association(object, association_name, attributes_collection) ⇒ Object

Raises:



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 68

def self.assign_nested_attributes_for_collection_association(object, association_name, attributes_collection)
  options = object.nested_attributes_options[association_name]

  unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
    raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
  end

  check_record_limit!(options[:limit], attributes_collection)

  association = object.association(association_name)
  primary_attribute_name = primary_name_for(association.reflection.klass)

  raise ActiveData::UndefinedPrimaryAttribute.new(object.class, association_name) unless primary_attribute_name

  if attributes_collection.is_a? Hash
    keys = attributes_collection.keys
    attributes_collection = if keys.include?(primary_attribute_name) || keys.include?(primary_attribute_name.to_sym)
      [attributes_collection]
    else
      attributes_collection.values
    end
  end

  attributes_collection.each do |attributes|
    attributes = attributes.with_indifferent_access

    if attributes[primary_attribute_name].blank?
      unless reject_new_object?(object, association_name, attributes)
        association.build(attributes.except(*unassignable_keys(object)))
      end
    else
      existing_record = association.target.detect do |record|
        primary_attribute_value = record.attribute(primary_attribute_name)
          .typecast(attributes[primary_attribute_name])
        record.primary_attribute == primary_attribute_value
      end
      if existing_record
        if !call_reject_if(object, association_name, attributes)
          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
        end
      else
        if association.reflection.embedded?
          unless reject_new_object?(object, association_name, attributes)
            association.reflection.klass.with_sanitize(false) do
              association.build(attributes.except(DESTROY_ATTRIBUTE))
            end
          end
        else
          raise ActiveData::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
        end
      end
    end
  end
end

.assign_nested_attributes_for_one_to_one_association(object, association_name, attributes) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 41

def self.assign_nested_attributes_for_one_to_one_association(object, association_name, attributes)
  options = object.nested_attributes_options[association_name]
  attributes = attributes.with_indifferent_access

  association = object.association(association_name)
  existing_record = association.target
  primary_attribute_name = primary_name_for(association.reflection.klass)
  if existing_record
    primary_attribute = existing_record.attribute(primary_attribute_name)
    primary_attribute_value = primary_attribute.typecast(attributes[primary_attribute_name]) if primary_attribute
  end

  if existing_record && (!primary_attribute || options[:update_only] || existing_record.primary_attribute == primary_attribute_value)
    assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(object, association_name, attributes)
  elsif attributes[primary_attribute_name].present?
    raise ActiveData::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
  elsif !reject_new_object?(object, association_name, attributes)
    assignable_attributes = attributes.except(*unassignable_keys(object))

    if existing_record && !existing_record.persisted?
      existing_record.assign_attributes(assignable_attributes)
    else
      association.build(assignable_attributes)
    end
  end
end

.assign_to_or_mark_for_destruction(object, attributes, allow_destroy) ⇒ Object 



140
141
142
143
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 140

def self.assign_to_or_mark_for_destruction(object, attributes, allow_destroy)
  object.assign_attributes(attributes.except(*unassignable_keys(object)))
  object.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
end

.call_reject_if(object, association_name, attributes) ⇒ Object 



153
154
155
156
157
158
159
160
161
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 153

def self.call_reject_if(object, association_name, attributes)
  return false if has_destroy_flag?(attributes)
  case callback = object.nested_attributes_options[association_name][:reject_if]
  when Symbol
    method(callback).arity == 0 ? send(callback) : send(callback, attributes)
  when Proc
    callback.call(attributes)
  end
end

.check_record_limit!(limit, attributes_collection) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 123

def self.check_record_limit!(limit, attributes_collection)
  if limit
    limit = case limit
    when Symbol
      send(limit)
    when Proc
      limit.call
    else
      limit
    end

    if limit && attributes_collection.size > limit
      raise ActiveData::TooManyObjects.new(limit, attributes_collection.size)
    end
  end
end

.has_destroy_flag?(hash) ⇒ Boolean

Returns:



145
146
147
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 145

def self.has_destroy_flag?(hash)
  ActiveData.typecaster(Boolean).call(hash[DESTROY_ATTRIBUTE])
end

.primary_name_for(klass) ⇒ Object 



167
168
169
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 167

def self.primary_name_for(klass)
  klass < ActiveData::Model ? klass.primary_name : 'id'
end

.reject_new_object?(object, association_name, attributes) ⇒ Boolean

Returns:



149
150
151
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 149

def self.reject_new_object?(object, association_name, attributes)
  has_destroy_flag?(attributes) || call_reject_if(object, association_name, attributes)
end

.unassignable_keys(object) ⇒ Object 



163
164
165
 
# File 'lib/active_data/model/associations/nested_attributes.rb', line 163

def self.unassignable_keys(object)
  [primary_name_for(object.class), DESTROY_ATTRIBUTE].compact
end