Class: FactoryGirl::DefinitionProxy

Inherits:
Object
  • Object
show all
Defined in:
lib/factory_girl/definition_proxy.rb

Constant Summary

UNPROXIED_METHODS = 
%w(__send__ __id__ nil? send object_id extend instance_eval initialize block_given? raise caller)

Instance Attribute Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (DefinitionProxy) initialize(definition, ignore = false)

A new instance of DefinitionProxy



11
12
13
14
15
 
# File 'lib/factory_girl/definition_proxy.rb', line 11

def initialize(definition, ignore = false)
  @definition      = definition
  @ignore          = ignore
  @child_factories = []
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

- (Object) method_missing(name, *args, &block)

Calls add_attribute using the missing method name as the name of the attribute, so that:

factory :user do
  name 'Billy Idol'
end

and:

factory :user do
  add_attribute :name, 'Billy Idol'
end

are equivalent.

If no argument or block is given, factory_girl will look for a sequence or association with the same name. This means that:

factory :user do
  email { create(:email) }
  association :account
end

and:

factory :user do
  email
  
end

are equivalent.



83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/factory_girl/definition_proxy.rb', line 83

def method_missing(name, *args, &block)
  if args.empty? && block.nil?
    @definition.declare_attribute(Declaration::Implicit.new(name, @definition, @ignore))
  elsif args.first.respond_to?(:has_key?) && args.first.has_key?(:factory)
    association(name, *args)
  elsif FactoryGirl.callback_names.include?(name)
    callback_when, callback_name = name.to_s.split('_', 2)
    ActiveSupport::Deprecation.warn "Calling #{name} is deprecated; use the syntax #{callback_when}(:#{callback_name}) {}", caller
    @definition.add_callback(Callback.new(name, block))
  else
    add_attribute(name, *args, &block)
  end
end

Instance Attribute Details

- (Object) child_factories (readonly)

Returns the value of attribute child_factories



9
10
11
 
# File 'lib/factory_girl/definition_proxy.rb', line 9

def child_factories
  @child_factories
end

Instance Method Details

- (Object) add_attribute(name, value = nil, &block)

Adds an attribute that should be assigned on generated instances for this factory.

This method should be called with either a value or block, but not both. If called with a block, the attribute will be generated "lazily," whenever an instance is generated. Lazy attribute blocks will not be called if that attribute is overridden for a specific instance.

When defining lazy attributes, an instance of FactoryGirl::Strategy will be yielded, allowing associations to be built using the correct build strategy.

Arguments:

  • name: Symbol or String The name of this attribute. This will be assigned using "name=" for generated instances.

  • value: Object If no block is given, this value will be used for this attribute.

Raises:



35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/factory_girl/definition_proxy.rb', line 35

def add_attribute(name, value = nil, &block)
  raise AttributeDefinitionError, 'Both value and block given' if value && block_given?

  declaration = if block_given?
    Declaration::Dynamic.new(name, @ignore, block)
  else
    Declaration::Static.new(name, value, @ignore)
  end

  @definition.declare_attribute(declaration)
end

- (Object) after(name, &block) 



169
170
171
 
# File 'lib/factory_girl/definition_proxy.rb', line 169

def after(name, &block)
  callback("after_#{name}", &block)
end

- (Object) association(name, options = {})

Adds an attribute that builds an association. The associated instance will be built using the same build strategy as the parent instance.

Example:

factory :user do
  name 'Joey'
end

factory :post do
  association :author, factory: :user
end

Arguments:

  • name: Symbol The name of this attribute.

  • options: Hash

Options:

  • factory: Symbol or String

    The name of the factory to use when building the associated instance.
If no name is given, the name of the attribute is assumed to be the
name of the factory. For example, a "user" association will by
default use the "user" factory.


141
142
143
 
# File 'lib/factory_girl/definition_proxy.rb', line 141

def association(name, options = {})
  @definition.declare_attribute(Declaration::Association.new(name, options))
end

- (Object) before(name, &block) 



165
166
167
 
# File 'lib/factory_girl/definition_proxy.rb', line 165

def before(name, &block)
  callback("before_#{name}", &block)
end

- (Object) callback(name, &block) 



173
174
175
176
 
# File 'lib/factory_girl/definition_proxy.rb', line 173

def callback(name, &block)
  FactoryGirl.register_callback(name)
  @definition.add_callback(Callback.new(name, block))
end

- (Object) factory(name, options = {}, &block) 



153
154
155
 
# File 'lib/factory_girl/definition_proxy.rb', line 153

def factory(name, options = {}, &block)
  @child_factories << [name, options, block]
end

- (Object) ignore(&block) 



47
48
49
50
 
# File 'lib/factory_girl/definition_proxy.rb', line 47

def ignore(&block)
  proxy = DefinitionProxy.new(@definition, true)
  proxy.instance_eval(&block)
end

- (Object) initialize_with(&block) 



161
162
163
 
# File 'lib/factory_girl/definition_proxy.rb', line 161

def initialize_with(&block)
  @definition.define_constructor(&block)
end

- (Object) sequence(name, *args, &block)

Adds an attribute that will have unique values generated by a sequence with a specified format.

The result of:

factory :user do
  sequence(:email) { |n| "person#{n}@example.com" }
end

Is equal to:

sequence(:email) { |n| "person#{n}@example.com" }

factory :user do
  email { FactoryGirl.create(:email) }
end

Except that no globally available sequence will be defined.



113
114
115
116
 
# File 'lib/factory_girl/definition_proxy.rb', line 113

def sequence(name, *args, &block)
  sequence = Sequence.new(name, *args, &block)
  add_attribute(name) { sequence.next }
end

- (Object) skip_create 



149
150
151
 
# File 'lib/factory_girl/definition_proxy.rb', line 149

def skip_create
  @definition.skip_create
end

- (Object) to_create(&block) 



145
146
147
 
# File 'lib/factory_girl/definition_proxy.rb', line 145

def to_create(&block)
  @definition.to_create(&block)
end

- (Object) trait(name, &block) 



157
158
159
 
# File 'lib/factory_girl/definition_proxy.rb', line 157

def trait(name, &block)
  @definition.define_trait(Trait.new(name, &block))
end