factorylabs-aasm 2.0.5.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,159 @@
1
+ require File.join(File.dirname(__FILE__), 'event')
2
+ require File.join(File.dirname(__FILE__), 'state')
3
+ require File.join(File.dirname(__FILE__), 'state_machine')
4
+ require File.join(File.dirname(__FILE__), 'persistence')
5
+
6
+ module AASM
7
+ def self.Version
8
+ '2.0.5'
9
+ end
10
+
11
+ class InvalidTransition < RuntimeError
12
+ end
13
+
14
+ class UndefinedState < RuntimeError
15
+ end
16
+
17
+ def self.included(base) #:nodoc:
18
+ # TODO - need to ensure that a machine is being created because
19
+ # AASM was either included or arrived at via inheritance. It
20
+ # cannot be both.
21
+ base.extend AASM::ClassMethods
22
+ AASM::Persistence.set_persistence(base)
23
+ AASM::StateMachine[base] = AASM::StateMachine.new('')
24
+ end
25
+
26
+ module ClassMethods
27
+ def inherited(klass)
28
+ AASM::StateMachine[klass] = AASM::StateMachine[self].clone
29
+ super
30
+ end
31
+
32
+ def aasm_initial_state(set_state=nil)
33
+ if set_state
34
+ AASM::StateMachine[self].initial_state = set_state
35
+ else
36
+ AASM::StateMachine[self].initial_state
37
+ end
38
+ end
39
+
40
+ def aasm_initial_state=(state)
41
+ AASM::StateMachine[self].initial_state = state
42
+ end
43
+
44
+ def aasm_state(name, options={})
45
+ sm = AASM::StateMachine[self]
46
+ sm.create_state(name, options)
47
+ sm.initial_state = name unless sm.initial_state
48
+
49
+ define_method("#{name.to_s}?") do
50
+ aasm_current_state == name
51
+ end
52
+ end
53
+
54
+ def aasm_event(name, options = {}, &block)
55
+ sm = AASM::StateMachine[self]
56
+
57
+ unless sm.events.has_key?(name)
58
+ sm.events[name] = AASM::SupportingClasses::Event.new(name, options, &block)
59
+ end
60
+
61
+ define_method("#{name.to_s}!") do |*args|
62
+ aasm_fire_event(name, true, *args)
63
+ end
64
+
65
+ define_method("#{name.to_s}") do |*args|
66
+ aasm_fire_event(name, false, *args)
67
+ end
68
+ end
69
+
70
+ def aasm_states
71
+ AASM::StateMachine[self].states
72
+ end
73
+
74
+ def aasm_events
75
+ AASM::StateMachine[self].events
76
+ end
77
+
78
+ def aasm_states_for_select
79
+ AASM::StateMachine[self].states.map { |state| state.for_select }
80
+ end
81
+
82
+ end
83
+
84
+ # Instance methods
85
+ def aasm_current_state
86
+ return @aasm_current_state if @aasm_current_state
87
+
88
+ if self.respond_to?(:aasm_read_state) || self.private_methods.include?('aasm_read_state')
89
+ @aasm_current_state = aasm_read_state
90
+ end
91
+ return @aasm_current_state if @aasm_current_state
92
+ self.class.aasm_initial_state
93
+ end
94
+
95
+ def aasm_events_for_current_state
96
+ aasm_events_for_state(aasm_current_state)
97
+ end
98
+
99
+ def aasm_events_for_state(state)
100
+ events = self.class.aasm_events.values.select {|event| event.transitions_from_state?(state) }
101
+ events.map {|event| event.name}
102
+ end
103
+
104
+ private
105
+ def set_aasm_current_state_with_persistence(state)
106
+ save_success = true
107
+ if self.respond_to?(:aasm_write_state) || self.private_methods.include?('aasm_write_state')
108
+ save_success = aasm_write_state(state)
109
+ end
110
+ self.aasm_current_state = state if save_success
111
+
112
+ save_success
113
+ end
114
+
115
+ def aasm_current_state=(state)
116
+ if self.respond_to?(:aasm_write_state_without_persistence) || self.private_methods.include?('aasm_write_state_without_persistence')
117
+ aasm_write_state_without_persistence(state)
118
+ end
119
+ @aasm_current_state = state
120
+ end
121
+
122
+ def aasm_state_object_for_state(name)
123
+ obj = self.class.aasm_states.find {|s| s == name}
124
+ raise AASM::UndefinedState, "State :#{name} doesn't exist" if obj.nil?
125
+ obj
126
+ end
127
+
128
+ def aasm_fire_event(name, persist, *args)
129
+ aasm_state_object_for_state(aasm_current_state).call_action(:exit, self)
130
+
131
+ new_state = self.class.aasm_events[name].fire(self, *args)
132
+
133
+ unless new_state.nil?
134
+ aasm_state_object_for_state(new_state).call_action(:enter, self)
135
+
136
+ persist_successful = true
137
+ if persist
138
+ persist_successful = set_aasm_current_state_with_persistence(new_state)
139
+ self.class.aasm_events[name].execute_success_callback(self) if persist_successful
140
+ else
141
+ self.aasm_current_state = new_state
142
+ end
143
+
144
+ if persist_successful
145
+ self.aasm_event_fired(self.aasm_current_state, new_state) if self.respond_to?(:aasm_event_fired)
146
+ else
147
+ self.aasm_event_failed(name) if self.respond_to?(:aasm_event_failed)
148
+ end
149
+
150
+ persist_successful
151
+ else
152
+ if self.respond_to?(:aasm_event_failed)
153
+ self.aasm_event_failed(name)
154
+ end
155
+
156
+ false
157
+ end
158
+ end
159
+ end
@@ -0,0 +1,54 @@
1
+ require File.join(File.dirname(__FILE__), 'state_transition')
2
+
3
+ module AASM
4
+ module SupportingClasses
5
+ class Event
6
+ attr_reader :name, :success
7
+
8
+ def initialize(name, options = {}, &block)
9
+ @name = name
10
+ @success = options[:success]
11
+ @transitions = []
12
+ instance_eval(&block) if block
13
+ end
14
+
15
+ def fire(obj, to_state=nil, *args)
16
+ transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
17
+ raise AASM::InvalidTransition, "Event '#{name}' cannot transition from '#{obj.aasm_current_state}'" if transitions.size == 0
18
+
19
+ next_state = nil
20
+ transitions.each do |transition|
21
+ next if to_state and !Array(transition.to).include?(to_state)
22
+ if transition.perform(obj)
23
+ next_state = to_state || Array(transition.to).first
24
+ transition.execute(obj, *args)
25
+ break
26
+ end
27
+ end
28
+ next_state
29
+ end
30
+
31
+ def transitions_from_state?(state)
32
+ @transitions.any? { |t| t.from == state }
33
+ end
34
+
35
+ def execute_success_callback(obj)
36
+ case success
37
+ when String, Symbol
38
+ obj.send(success)
39
+ when Array
40
+ success.each { |meth| obj.send(meth) }
41
+ when Proc
42
+ success.call(obj)
43
+ end
44
+ end
45
+
46
+ private
47
+ def transitions(trans_opts)
48
+ Array(trans_opts[:from]).each do |s|
49
+ @transitions << SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
50
+ end
51
+ end
52
+ end
53
+ end
54
+ end
@@ -0,0 +1,16 @@
1
+ module AASM
2
+ module Persistence
3
+
4
+ # Checks to see this class or any of it's superclasses inherit from
5
+ # ActiveRecord::Base and if so includes ActiveRecordPersistence
6
+ def self.set_persistence(base)
7
+ # Use a fancier auto-loading thingy, perhaps. When there are more persistence engines.
8
+ hierarchy = base.ancestors.map {|klass| klass.to_s}
9
+
10
+ if hierarchy.include?("ActiveRecord::Base")
11
+ require File.join(File.dirname(__FILE__), 'persistence', 'active_record_persistence')
12
+ base.send(:include, AASM::Persistence::ActiveRecordPersistence)
13
+ end
14
+ end
15
+ end
16
+ end
@@ -0,0 +1,248 @@
1
+ module AASM
2
+ module Persistence
3
+ module ActiveRecordPersistence
4
+ # This method:
5
+ #
6
+ # * extends the model with ClassMethods
7
+ # * includes InstanceMethods
8
+ #
9
+ # Unless the corresponding methods are already defined, it includes
10
+ # * ReadState
11
+ # * WriteState
12
+ # * WriteStateWithoutPersistence
13
+ #
14
+ # Adds
15
+ #
16
+ # before_validation_on_create :aasm_ensure_initial_state
17
+ #
18
+ # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
19
+ #
20
+ # class Foo < ActiveRecord::Base
21
+ # def aasm_write_state(state)
22
+ # "bar"
23
+ # end
24
+ # include AASM
25
+ # end
26
+ #
27
+ # class Foo < ActiveRecord::Base
28
+ # include AASM
29
+ # def aasm_write_state(state)
30
+ # "bar"
31
+ # end
32
+ # end
33
+ #
34
+ def self.included(base)
35
+ base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
36
+ base.send(:include, AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
37
+ base.send(:include, AASM::Persistence::ActiveRecordPersistence::ReadState) unless base.method_defined?(:aasm_read_state)
38
+ base.send(:include, AASM::Persistence::ActiveRecordPersistence::WriteState) unless base.method_defined?(:aasm_write_state)
39
+ base.send(:include, AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence) unless base.method_defined?(:aasm_write_state_without_persistence)
40
+
41
+ if base.respond_to?(:named_scope)
42
+ base.extend(AASM::Persistence::ActiveRecordPersistence::NamedScopeMethods)
43
+
44
+ base.class_eval do
45
+ class << self
46
+ unless method_defined?(:aasm_state_without_named_scope)
47
+ alias_method :aasm_state_without_named_scope, :aasm_state
48
+ alias_method :aasm_state, :aasm_state_with_named_scope
49
+ end
50
+ end
51
+ end
52
+ end
53
+
54
+ base.before_validation_on_create :aasm_ensure_initial_state
55
+ end
56
+
57
+ module ClassMethods
58
+ # Maps to the aasm_column in the database. Deafults to "aasm_state". You can write:
59
+ #
60
+ # create_table :foos do |t|
61
+ # t.string :name
62
+ # t.string :aasm_state
63
+ # end
64
+ #
65
+ # class Foo < ActiveRecord::Base
66
+ # include AASM
67
+ # end
68
+ #
69
+ # OR:
70
+ #
71
+ # create_table :foos do |t|
72
+ # t.string :name
73
+ # t.string :status
74
+ # end
75
+ #
76
+ # class Foo < ActiveRecord::Base
77
+ # include AASM
78
+ # aasm_column :status
79
+ # end
80
+ #
81
+ # This method is both a getter and a setter
82
+ def aasm_column(column_name=nil)
83
+ if column_name
84
+ AASM::StateMachine[self].config.column = column_name.to_sym
85
+ # @aasm_column = column_name.to_sym
86
+ else
87
+ AASM::StateMachine[self].config.column ||= :aasm_state
88
+ # @aasm_column ||= :aasm_state
89
+ end
90
+ # @aasm_column
91
+ AASM::StateMachine[self].config.column
92
+ end
93
+
94
+ def find_in_state(number, state, *args)
95
+ with_state_scope state do
96
+ find(number, *args)
97
+ end
98
+ end
99
+
100
+ def count_in_state(state, *args)
101
+ with_state_scope state do
102
+ count(*args)
103
+ end
104
+ end
105
+
106
+ def calculate_in_state(state, *args)
107
+ with_state_scope state do
108
+ calculate(*args)
109
+ end
110
+ end
111
+
112
+ protected
113
+ def with_state_scope(state)
114
+ with_scope :find => {:conditions => ["#{table_name}.#{aasm_column} = ?", state.to_s]} do
115
+ yield if block_given?
116
+ end
117
+ end
118
+ end
119
+
120
+ module InstanceMethods
121
+
122
+ # Returns the current aasm_state of the object. Respects reload and
123
+ # any changes made to the aasm_state field directly
124
+ #
125
+ # Internally just calls <tt>aasm_read_state</tt>
126
+ #
127
+ # foo = Foo.find(1)
128
+ # foo.aasm_current_state # => :pending
129
+ # foo.aasm_state = "opened"
130
+ # foo.aasm_current_state # => :opened
131
+ # foo.close # => calls aasm_write_state_without_persistence
132
+ # foo.aasm_current_state # => :closed
133
+ # foo.reload
134
+ # foo.aasm_current_state # => :pending
135
+ #
136
+ def aasm_current_state
137
+ @current_state = aasm_read_state
138
+ end
139
+
140
+ private
141
+
142
+ # Ensures that if the aasm_state column is nil and the record is new
143
+ # that the initial state gets populated before validation on create
144
+ #
145
+ # foo = Foo.new
146
+ # foo.aasm_state # => nil
147
+ # foo.valid?
148
+ # foo.aasm_state # => "open" (where :open is the initial state)
149
+ #
150
+ #
151
+ # foo = Foo.find(:first)
152
+ # foo.aasm_state # => 1
153
+ # foo.aasm_state = nil
154
+ # foo.valid?
155
+ # foo.aasm_state # => nil
156
+ #
157
+ def aasm_ensure_initial_state
158
+ send("#{self.class.aasm_column}=", self.aasm_current_state.to_s)
159
+ end
160
+
161
+ end
162
+
163
+ module WriteStateWithoutPersistence
164
+ # Writes <tt>state</tt> to the state column, but does not persist it to the database
165
+ #
166
+ # foo = Foo.find(1)
167
+ # foo.aasm_current_state # => :opened
168
+ # foo.close
169
+ # foo.aasm_current_state # => :closed
170
+ # Foo.find(1).aasm_current_state # => :opened
171
+ # foo.save
172
+ # foo.aasm_current_state # => :closed
173
+ # Foo.find(1).aasm_current_state # => :closed
174
+ #
175
+ # NOTE: intended to be called from an event
176
+ def aasm_write_state_without_persistence(state)
177
+ write_attribute(self.class.aasm_column, state.to_s)
178
+ end
179
+ end
180
+
181
+ module WriteState
182
+ # Writes <tt>state</tt> to the state column and persists it to the database
183
+ # using update_attribute (which bypasses validation)
184
+ #
185
+ # foo = Foo.find(1)
186
+ # foo.aasm_current_state # => :opened
187
+ # foo.close!
188
+ # foo.aasm_current_state # => :closed
189
+ # Foo.find(1).aasm_current_state # => :closed
190
+ #
191
+ # NOTE: intended to be called from an event
192
+ def aasm_write_state(state)
193
+ old_value = read_attribute(self.class.aasm_column)
194
+ write_attribute(self.class.aasm_column, state.to_s)
195
+
196
+ unless self.save
197
+ write_attribute(self.class.aasm_column, old_value)
198
+ return false
199
+ end
200
+
201
+ true
202
+ end
203
+ end
204
+
205
+ module ReadState
206
+
207
+ # Returns the value of the aasm_column - called from <tt>aasm_current_state</tt>
208
+ #
209
+ # If it's a new record, and the aasm state column is blank it returns the initial state:
210
+ #
211
+ # class Foo < ActiveRecord::Base
212
+ # include AASM
213
+ # aasm_column :status
214
+ # aasm_state :opened
215
+ # aasm_state :closed
216
+ # end
217
+ #
218
+ # foo = Foo.new
219
+ # foo.current_state # => :opened
220
+ # foo.close
221
+ # foo.current_state # => :closed
222
+ #
223
+ # foo = Foo.find(1)
224
+ # foo.current_state # => :opened
225
+ # foo.aasm_state = nil
226
+ # foo.current_state # => nil
227
+ #
228
+ # NOTE: intended to be called from an event
229
+ #
230
+ # This allows for nil aasm states - be sure to add validation to your model
231
+ def aasm_read_state
232
+ if new_record?
233
+ send(self.class.aasm_column).blank? ? self.class.aasm_initial_state : send(self.class.aasm_column).to_sym
234
+ else
235
+ send(self.class.aasm_column).nil? ? nil : send(self.class.aasm_column).to_sym
236
+ end
237
+ end
238
+ end
239
+
240
+ module NamedScopeMethods
241
+ def aasm_state_with_named_scope name, options = {}
242
+ aasm_state_without_named_scope name, options
243
+ self.named_scope name, :conditions => {self.aasm_column => name.to_s} unless self.respond_to?(name)
244
+ end
245
+ end
246
+ end
247
+ end
248
+ end