Class: FluentFixtures::Factory

Inherits:
Object
  • Object
show all
Extended by:
Loggability
Includes:
Enumerable
Defined in:
lib/fluent_fixtures/factory.rb

Overview

The fluent fixture monadic factory class.

Constant Summary collapse

CREATE_METHODS =

The methods to look for to save new instances when #create is called

%i[ save_changes save ]
DEFAULT_GENERATOR_LIMIT =

The default limit for generators

10_000

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(fixture_module, *args, &block) ⇒ Factory

Create a new FluentFactory that will act as a monadic factory for the specified fixture_module, and use the given args in the construction of new objects.



27
28
29
30
31
32
 
# File 'lib/fluent_fixtures/factory.rb', line 27

def initialize( fixture_module, *args, &block )
	@fixture_module = fixture_module
	@constructor_args = args
	@constructor_block = block
	@decorators = []
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args, &block) ⇒ Object (protected)

Proxy method – look up the decorator with the same name as the method being called, and if one is found, returned a new instance of the factory with the additional decorator.



280
281
282
 
# File 'lib/fluent_fixtures/factory.rb', line 280

def method_missing( sym, *args, &block )
	return self.mutate( sym, *args, &block )
end

Instance Attribute Details

#constructor_args ⇒ Object (readonly)

The Array of arguments to pass to the constructor when creating a new fixtured object.



51
52
53
 
# File 'lib/fluent_fixtures/factory.rb', line 51

def constructor_args
  @constructor_args
end

#constructor_block ⇒ Object (readonly)

The block to pass to the constructor when creating a new fixtured object.



55
56
57
 
# File 'lib/fluent_fixtures/factory.rb', line 55

def constructor_block
  @constructor_block
end

#decorators ⇒ Object (readonly)

The decorators that will be applied to the fixtured object when it’s created.



47
48
49
 
# File 'lib/fluent_fixtures/factory.rb', line 47

def decorators
  @decorators
end

#fixture_module ⇒ Object (readonly)

The fixture module that contains the decorator declarations



43
44
45
 
# File 'lib/fluent_fixtures/factory.rb', line 43

def fixture_module
  @fixture_module
end

Instance Method Details

#create(args = {}, &block) ⇒ Object

Return a saved #instance of the fixtured object.



105
106
107
108
109
110
111
112
113
 
# File 'lib/fluent_fixtures/factory.rb', line 105

def create( args={}, &block )
	obj = self.with_transaction do
		obj = self.instance( args, &block )
		obj = self.try_to_save( obj )
		obj
	end

	return obj
end

#decorated_with(&block) ⇒ Object

Return a copy of the factory that will apply the specified block as a decorator.



117
118
119
 
# File 'lib/fluent_fixtures/factory.rb', line 117

def decorated_with( &block )
	return self.mutate( nil, &block )
end

#each(&block) ⇒ Object

Iterate over DEFAULT_GENERATOR_LIMIT instances of the fixtured object, yielding each new instance if a block is provided. If no block is provided, returns an Enumerator.



125
126
127
128
 
# File 'lib/fluent_fixtures/factory.rb', line 125

def each( &block )
	return self.generator unless block
	return self.generator.each( &block )
end

#generator(create: false, limit: DEFAULT_GENERATOR_LIMIT, &block) ⇒ Object

Return an infinite generator for unsaved instances of the fixtured object.



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/fluent_fixtures/factory.rb', line 132

def generator( create: false, limit: DEFAULT_GENERATOR_LIMIT, &block )
	return Enumerator.new( limit || Float::INFINITY ) do |yielder|
		count = 0
		constructor = create ? :create : :instance
		loop do
			break if limit && count >= limit

			obj = if block
					self.send( constructor, &block.curry(2)[count] )
				else
					self.send( constructor )
				end

			yielder.yield( obj )

			count += 1
		end
	end
end

#initialize_copy(original) ⇒ Object

Copy constructor – make a distinct copy of the clone’s decorators.



36
37
38
 
# File 'lib/fluent_fixtures/factory.rb', line 36

def initialize_copy( original )
	@decorators = @decorators.dup
end

#inspect ⇒ Object

Return a human-readable representation of the object suitable for debugging.



154
155
156
157
158
159
160
161
162
163
 
# File 'lib/fluent_fixtures/factory.rb', line 154

def inspect
	decorator_description = self.decorators.map( &:first ).join( ' + ' )

	return "#<%p:%0#16x for %p%s>" % [
		self.class,
		self.__id__ * 2,
		self.fixture_module,
		decorator_description.empty? ? '' : ' + ' + decorator_description
	]
end

#instance(args = {}, &block) ⇒ Object

Create an instance, apply declared decorators in order, and return the resulting object.



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
 
# File 'lib/fluent_fixtures/factory.rb', line 69

def instance( args={}, &block )
	instance = self.fixture_module.
		fixtured_instance( *self.constructor_args, &self.constructor_block )

	self.decorators.each do |decorator_name, decorator_args, block|
		# :TODO: Reify other fixtures in `decorator_args` here?
		if !decorator_name
			self.apply_inline_decorator( instance, block )
		elsif self.fixture_module.decorators.key?( decorator_name )
			instance = self.apply_named_decorator( instance, decorator_args, decorator_name )
		else
			self.apply_method_decorator( instance, decorator_args, decorator_name, block )
		end
	end

	args.each_pair do |attrname, value|
		# :TODO: Reify the `value` if it responds to #create?
		instance.public_send( "#{attrname}=", value )
	end

	# If the factory was called with a block, use it as a final decorator before
	# returning it.
	if block
		self.log.debug "Applying inline decorator %p" % [ block ]
		if block.arity.zero?
			instance.instance_exec( &block )
		else
			block.call( instance )
		end
	end

	return instance
end

#mutate(name, *args, &block) ⇒ Object

Return a new clone of the receiver with an additional decorator composed of the specified name, args, and block.



60
61
62
63
64
 
# File 'lib/fluent_fixtures/factory.rb', line 60

def mutate( name, *args, &block )
	new_instance = self.dup
	new_instance.decorators << [ name, args, block ]
	return new_instance
end