fcoury-aasm 2.1.3

Sign up to get free protection for your applications and to get access to all the features.
data/lib/aasm/event.rb ADDED
@@ -0,0 +1,98 @@
1
+ require File.join(File.dirname(__FILE__), 'state_transition')
2
+
3
+ module AASM
4
+ module SupportingClasses
5
+ class Event
6
+ attr_reader :name, :success, :options
7
+
8
+ def initialize(name, options = {}, &block)
9
+ @name = name
10
+ @transitions = []
11
+ update(options, &block)
12
+ end
13
+
14
+ def fire(obj, to_state=nil, *args)
15
+ transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
16
+ raise AASM::InvalidTransition, "Event '#{name}' cannot transition from '#{obj.aasm_current_state}'" if transitions.size == 0
17
+
18
+ next_state = nil
19
+ transitions.each do |transition|
20
+ next if to_state and !Array(transition.to).include?(to_state)
21
+ if transition.perform(obj)
22
+ next_state = to_state || Array(transition.to).first
23
+ transition.execute(obj, *args)
24
+ break
25
+ end
26
+ end
27
+ next_state
28
+ end
29
+
30
+ def transitions_from_state?(state)
31
+ @transitions.any? { |t| t.from == state }
32
+ end
33
+
34
+ def transitions_from_state(state)
35
+ @transitions.select { |t| t.from == state }
36
+ end
37
+
38
+ def all_transitions
39
+ @transitions
40
+ end
41
+
42
+ def call_action(action, record)
43
+ action = @options[action]
44
+ action.is_a?(Array) ?
45
+ action.each {|a| _call_action(a, record)} :
46
+ _call_action(action, record)
47
+ end
48
+
49
+ def ==(event)
50
+ if event.is_a? Symbol
51
+ name == event
52
+ else
53
+ name == event.name
54
+ end
55
+ end
56
+
57
+ def update(options = {}, &block)
58
+ if options.key?(:success) then
59
+ @success = options[:success]
60
+ end
61
+ if block then
62
+ instance_eval(&block)
63
+ end
64
+ @options = options
65
+ self
66
+ end
67
+
68
+ def execute_success_callback(obj, success = nil)
69
+ callback = success || @success
70
+ case(callback)
71
+ when String, Symbol
72
+ obj.send(callback)
73
+ when Proc
74
+ callback.call(obj)
75
+ when Array
76
+ callback.each{|meth|self.execute_success_callback(obj, meth)}
77
+ end
78
+ end
79
+
80
+ private
81
+
82
+ def _call_action(action, record)
83
+ case action
84
+ when Symbol, String
85
+ record.send(action)
86
+ when Proc
87
+ action.call(record)
88
+ end
89
+ end
90
+
91
+ def transitions(trans_opts)
92
+ Array(trans_opts[:from]).each do |s|
93
+ @transitions << SupportingClasses::StateTransition.new(trans_opts.merge({:from => s.to_sym}))
94
+ end
95
+ end
96
+ end
97
+ end
98
+ 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") or hierarchy.include?("MongoMapper::EmbeddedDocument")
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_enter_initial_state.to_s) if send(self.class.aasm_column).blank?
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(false)
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? ? aasm_determine_state_name(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 => { "#{table_name}.#{self.aasm_column}" => name.to_s} unless self.respond_to?(name)
244
+ end
245
+ end
246
+ end
247
+ end
248
+ end
data/lib/aasm/state.rb ADDED
@@ -0,0 +1,55 @@
1
+ module AASM
2
+ module SupportingClasses
3
+ class State
4
+ attr_reader :name, :options
5
+
6
+ def initialize(name, options={})
7
+ @name = name
8
+ update(options)
9
+ end
10
+
11
+ def ==(state)
12
+ if state.is_a? Symbol
13
+ name == state
14
+ else
15
+ name == state.name
16
+ end
17
+ end
18
+
19
+ def call_action(action, record)
20
+ action = @options[action]
21
+ action.is_a?(Array) ?
22
+ action.each {|a| _call_action(a, record)} :
23
+ _call_action(action, record)
24
+ end
25
+
26
+ def display_name
27
+ @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
28
+ end
29
+
30
+ def for_select
31
+ [display_name, name.to_s]
32
+ end
33
+
34
+ def update(options = {})
35
+ if options.key?(:display) then
36
+ @display_name = options.delete(:display)
37
+ end
38
+ @options = options
39
+ self
40
+ end
41
+
42
+ private
43
+
44
+ def _call_action(action, record)
45
+ case action
46
+ when Symbol, String
47
+ record.send(action)
48
+ when Proc
49
+ action.call(record)
50
+ end
51
+ end
52
+
53
+ end
54
+ end
55
+ end
@@ -0,0 +1,36 @@
1
+ require 'ostruct'
2
+
3
+ module AASM
4
+ class StateMachine
5
+ def self.[](*args)
6
+ (@machines ||= {})[args]
7
+ end
8
+
9
+ def self.[]=(*args)
10
+ val = args.pop
11
+ (@machines ||= {})[args] = val
12
+ end
13
+
14
+ attr_accessor :states, :events, :initial_state, :config
15
+ attr_reader :name
16
+
17
+ def initialize(name)
18
+ @name = name
19
+ @initial_state = nil
20
+ @states = []
21
+ @events = {}
22
+ @config = OpenStruct.new
23
+ end
24
+
25
+ def clone
26
+ klone = super
27
+ klone.states = states.clone
28
+ klone.events = events.clone
29
+ klone
30
+ end
31
+
32
+ def create_state(name, options)
33
+ @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
34
+ end
35
+ end
36
+ end