fcoury-aasm 2.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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