Class: DatastaxRails::Reflection::AssociationReflection

Inherits:
MacroReflection show all
Defined in:
lib/datastax_rails/reflection.rb

Overview

Holds all the meta-data about an association as it was specified in the DatastaxRails class.

Direct Known Subclasses

ThroughReflection

Instance Attribute Summary collapse

Attributes inherited from MacroReflection

#datastax_rails, #denorms, #macro, #name, #options, #plural_name

Instance Method Summary collapse

Methods inherited from MacroReflection

#==, #class_name, #sanitized_conditions

Constructor Details

#initialize(macro, name, options, datastax_rails) ⇒ AssociationReflection


157
158
159
160
# File 'lib/datastax_rails/reflection.rb', line 157

def initialize(macro, name, options, datastax_rails)
  super
  @collection = macro.in?([:has_many, :has_and_belongs_to_many])
end

Instance Attribute Details

#collectionObject (readonly) Also known as: collection?

Returns whether or not this association reflection is for a collection association. Returns true if the macro is either has_many or has_and_belongs_to_many, false otherwise.


139
140
141
# File 'lib/datastax_rails/reflection.rb', line 139

def collection
  @collection
end

Instance Method Details

#association_classObject


267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
# File 'lib/datastax_rails/reflection.rb', line 267

def association_class
  case macro
  when :belongs_to
    Associations::BelongsToAssociation
  when :has_and_belongs_to_many
    Associations::HasAndBelongsToManyAssociation
  when :has_many
    if options[:through]
      Associations::HasManyThroughAssociation
    else
      Associations::HasManyAssociation
    end
  when :has_one
    if options[:through]
      Associations::HasOneThroughAssociation
    else
      Associations::HasOneAssociation
    end
  end
end

#association_foreign_keyObject


192
193
194
# File 'lib/datastax_rails/reflection.rb', line 192

def association_foreign_key
  @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
end

#association_primary_key(klass = nil) ⇒ Object

klass option is necessary to support loading polymorphic associations


197
198
199
# File 'lib/datastax_rails/reflection.rb', line 197

def association_primary_key(klass = nil)
  options[:primary_key] || primary_key(klass || self.klass)
end

#belongs_to?Boolean

Returns true if self is a belongs_to reflection.


263
264
265
# File 'lib/datastax_rails/reflection.rb', line 263

def belongs_to?
  macro == :belongs_to
end

#build_association(*options, &block) ⇒ Object

Returns a new, unsaved instance of the associated class. options will be passed to the class's constructor.


164
165
166
# File 'lib/datastax_rails/reflection.rb', line 164

def build_association(*options, &block)
  klass.new(*options, &block)
end

#chainObject

A chain of reflections from this one back to the owner. For more see the explanation in ThroughReflection.


226
227
228
# File 'lib/datastax_rails/reflection.rb', line 226

def chain
  [self]
end

#check_validity!Object


205
206
207
# File 'lib/datastax_rails/reflection.rb', line 205

def check_validity!
  check_validity_of_inverse!
end

#check_validity_of_inverse!Object


209
210
211
212
213
214
# File 'lib/datastax_rails/reflection.rb', line 209

def check_validity_of_inverse!
  return if options[:polymorphic]
  if inverse? && inverse_of.nil?
    fail InverseOfAssociationNotFoundError.new(self)
  end
end

#column_familyObject


168
169
170
# File 'lib/datastax_rails/reflection.rb', line 168

def column_family
  @column_family ||= klass.column_family
end

#conditionsObject

An array of arrays of conditions. Each item in the outside array corresponds to a reflection in the #chain. The inside arrays are simply conditions (and each condition may itself be a hash, array, arel predicate, etc…)


233
234
235
# File 'lib/datastax_rails/reflection.rb', line 233

def conditions
  [[options[:conditions]].compact]
end

#datastax_rails_primary_keyObject


201
202
203
# File 'lib/datastax_rails/reflection.rb', line 201

def datastax_rails_primary_key
  @datastax_rails_primary_key ||= options[:primary_key] || primary_key(datastax_rails)
end

#foreign_keyObject


176
177
178
# File 'lib/datastax_rails/reflection.rb', line 176

def foreign_key
  @foreign_key ||= options[:foreign_key] || derive_foreign_key
end

#foreign_typeObject


180
181
182
# File 'lib/datastax_rails/reflection.rb', line 180

def foreign_type
  @foreign_type ||= options[:foreign_type] || "#{name}_type"
end

#inverse?Boolean


239
240
241
# File 'lib/datastax_rails/reflection.rb', line 239

def inverse?
  @options[:inverse_of]
end

#inverse_ofObject


243
244
245
246
247
# File 'lib/datastax_rails/reflection.rb', line 243

def inverse_of
  if inverse?
    @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
  end
end

#klassObject

Returns the target association's class.

class Author < DatastaxRails::Base
  has_many :books
end

Author.reflect_on_association(:books).klass
# => Book

Note: Do not call klass.new or klass.create to instantiate a new association object. Use build_association or create_association instead. This allows plugins to hook into association object creation.


153
154
155
# File 'lib/datastax_rails/reflection.rb', line 153

def klass
  @klass ||= datastax_rails.send(:compute_type, class_name)
end

#nested?Boolean


288
289
290
# File 'lib/datastax_rails/reflection.rb', line 288

def nested?
  false
end

#primary_key_columnObject


188
189
190
# File 'lib/datastax_rails/reflection.rb', line 188

def primary_key_column
  @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
end

#quoted_column_familyObject


172
173
174
# File 'lib/datastax_rails/reflection.rb', line 172

def quoted_column_family
  column_family
end

#source_reflectionObject


220
221
222
# File 'lib/datastax_rails/reflection.rb', line 220

def source_reflection
  nil
end

#through_reflectionObject


216
217
218
# File 'lib/datastax_rails/reflection.rb', line 216

def through_reflection
  nil
end

#typeObject


184
185
186
# File 'lib/datastax_rails/reflection.rb', line 184

def type
  @type ||= options[:as] && "#{options[:as]}_type"
end

#validate?Boolean

Returns whether or not the association should be validated as part of the parent's validation.

Unless you explicitly disable validation with :validate => false, validation will take place when:

  • you explicitly enable validation; :validate => true

  • you use autosave; :autosave => true

  • the association is a has_many association


258
259
260
# File 'lib/datastax_rails/reflection.rb', line 258

def validate?
  !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
end