aasm 3.0.24 → 3.4.0

data/lib/aasm/aasm.rb

@@ -5,7 +5,7 @@ module AASM
 
     # do not overwrite existing state machines, which could have been created by
     # inheritance, see class method inherited
-    AASM::StateMachine[base] ||= AASM::StateMachine.new('')
+    AASM::StateMachine[base] ||= AASM::StateMachine.new
 
     AASM::Persistence.load_persistence(base)
     super
@@ -26,52 +26,56 @@ module AASM
       @aasm
     end
 
-    # TODO: maybe better: aasm.initial_state
+    # TODO remove this method in v4.0.0
     def aasm_initial_state(set_state=nil)
       if set_state
-        # deprecated way to set the value
+        warn ".aasm_initial_state(:name) is deprecated and will be removed in version 4.0.0; please use .aasm.initial_state = :name instead!"
         AASM::StateMachine[self].initial_state = set_state
       else
+        warn ".aasm_initial_state is deprecated and will be removed in version 4.0.0; please use .aasm.initial_state instead!"
         AASM::StateMachine[self].initial_state
       end
     end
 
-    # is this better?: aasm.states.name.from_states
+    # TODO remove this method in v4.0.0
     def aasm_from_states_for_state(state, options={})
-      if options[:transition]
-        aasm.events[options[:transition]].transitions_to_state(state).flatten.map(&:from).flatten
-      else
-        aasm.events.map {|k,v| v.transitions_to_state(state)}.flatten.map(&:from).flatten
-      end
+      warn ".aasm_from_states_for_state is deprecated and will be removed in version 4.0.0; please use .aasm.from_states_for_state instead!"
+      aasm.from_states_for_state(state, options)
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def aasm_initial_state=(state)
+      warn ".aasm_initial_state= is deprecated and will be removed in version 4.0.0"
       AASM::StateMachine[self].initial_state = state
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def aasm_state(name, options={})
+      warn ".aasm_state is deprecated and will be removed in version 4.0.0; please use .aasm.state instead!"
       aasm.state(name, options)
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def aasm_event(name, options = {}, &block)
+      warn ".aasm_event is deprecated and will be removed in version 4.0.0; please use .aasm.event instead!"
       aasm.event(name, options, &block)
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def aasm_states
+      warn ".aasm_states is deprecated and will be removed in version 4.0.0; please use .aasm.states instead!"
       aasm.states
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def aasm_events
+      warn ".aasm_events is deprecated and will be removed in version 4.0.0; please use .aasm.events instead!"
       aasm.events
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def aasm_states_for_select
+      warn ".aasm_states_for_select is deprecated and will be removed in version 4.0.0; please use .aasm.states_for_select instead!"
       aasm.states_for_select
     end
 
@@ -103,46 +107,46 @@ module AASM
     true
   end
 
-  # deprecated
+    # TODO remove this method in v4.0.0
   def aasm_current_state
-    # warn "#aasm_current_state is deprecated and will be removed in version 3.2.0; please use #aasm.state instead!"
+    warn "#aasm_current_state is deprecated and will be removed in version 4.0.0; please use #aasm.current_state instead!"
     aasm.current_state
   end
 
-  # deprecated
+    # TODO remove this method in v4.0.0
   def aasm_enter_initial_state
-    # warn "#aasm_enter_initial_state is deprecated and will be removed in version 3.2.0; please use #aasm.enter_initial_state instead!"
+    warn "#aasm_enter_initial_state is deprecated and will be removed in version 4.0.0; please use #aasm.enter_initial_state instead!"
     aasm.enter_initial_state
   end
 
-  # deprecated
+    # TODO remove this method in v4.0.0
   def aasm_events_for_current_state
-    # warn "#aasm_events_for_current_state is deprecated and will be removed in version 3.2.0; please use #aasm.events instead!"
+    warn "#aasm_events_for_current_state is deprecated and will be removed in version 4.0.0; please use #aasm.events(aasm.current_state) instead!"
     aasm.events(aasm.current_state)
   end
 
-  # deprecated
+    # TODO remove this method in v4.0.0
   def aasm_permissible_events_for_current_state
-    # warn "#aasm_permissible_events_for_current_state is deprecated and will be removed in version 3.2.0; please use #aasm.permissible_events instead!"
+    warn "#aasm_permissible_events_for_current_state is deprecated and will be removed in version 4.0.0; please use #aasm.permissible_events instead!"
     aasm.permissible_events
   end
 
-  # deprecated
+    # TODO remove this method in v4.0.0
   def aasm_events_for_state(state_name)
-    # warn "#aasm_events_for_state(state_name) is deprecated and will be removed in version 3.2.0; please use #aasm.events(state_name) instead!"
+    warn "#aasm_events_for_state(state_name) is deprecated and will be removed in version 4.0.0; please use #aasm.events(state_name) instead!"
     aasm.events(state_name)
   end
 
-  # deprecated
+    # TODO remove this method in v4.0.0
   def aasm_human_state
-    # warn "#aasm_human_state is deprecated and will be removed in version 3.2.0; please use #aasm.human_state instead!"
+    warn "#aasm_human_state is deprecated and will be removed in version 4.0.0; please use #aasm.human_state instead!"
     aasm.human_state
   end
 
 private
 
   def aasm_fire_event(event_name, options, *args, &block)
-    event = self.class.aasm_events[event_name]
+    event = self.class.aasm.events[event_name]
     begin
       old_state = aasm.state_object_for_name(aasm.current_state)
       old_state.fire_callbacks(:exit, self)
@@ -151,16 +155,16 @@ private
       event.fire_callbacks(:before, self)
 
       if new_state_name = event.fire(self, *args)
-        fired(event, old_state, new_state_name, options, &block)
+        aasm_fired(event, old_state, new_state_name, options, &block)
       else
-        failed(event_name, old_state)
+        aasm_failed(event_name, old_state)
       end
     rescue StandardError => e
       event.fire_callbacks(:error, self, e) || raise(e)
     end
   end
 
-  def fired(event, old_state, new_state_name, options)
+  def aasm_fired(event, old_state, new_state_name, options)
     persist = options[:persist]
 
     new_state = aasm.state_object_for_name(new_state_name)
@@ -196,7 +200,7 @@ private
     persist_successful
   end
 
-  def failed(event_name, old_state)
+  def aasm_failed(event_name, old_state)
     if self.respond_to?(:aasm_event_failed)
       self.aasm_event_failed(event_name, old_state.name)
     end

data/lib/aasm/base.rb

@@ -1,67 +1,66 @@
 module AASM
   class Base
 
-    def initialize(clazz, options={}, &block)
-      @clazz = clazz
-      @state_machine = AASM::StateMachine[@clazz]
+    def initialize(klass, options={}, &block)
+      @klass = klass
+      @state_machine = AASM::StateMachine[@klass]
       @state_machine.config.column = options[:column].to_sym if options[:column]
+      @options = options
 
-      if options.key?(:whiny_transitions)
-        @state_machine.config.whiny_transitions = options[:whiny_transitions]
-      elsif @state_machine.config.whiny_transitions.nil?
-        @state_machine.config.whiny_transitions = true # this is the default, so let's cry
-      end
+      # let's cry if the transition is invalid
+      configure :whiny_transitions, true
 
-      if options.key?(:create_scopes)
-        @state_machine.config.create_scopes = options[:create_scopes]
-      elsif @state_machine.config.create_scopes.nil?
-        @state_machine.config.create_scopes = true # this is the default, so let's create scopes
-      end
+      # create named scopes for each state
+      configure :create_scopes, true
 
-      if options.key?(:skip_validation_on_save)
-        @state_machine.config.skip_validation_on_save = options[:skip_validation_on_save]
-      elsif @state_machine.config.skip_validation_on_save.nil?
-        @state_machine.config.skip_validation_on_save = false # this is the default, so don't store any new state if the model is invalid
-      end
+      # don't store any new state if the model is invalid
+      configure :skip_validation_on_save, false
+
+      # use requires_new for nested transactions
+      configure :requires_new_transaction, true
+
+      configure :enum, nil
     end
 
-    def initial_state
-      @state_machine.initial_state
+    def initial_state(new_initial_state=nil)
+      if new_initial_state
+        @state_machine.initial_state = new_initial_state
+      else
+        @state_machine.initial_state
+      end
     end
 
     # define a state
     def state(name, options={})
-      # @clazz.aasm_state(name, options)
-      @state_machine.add_state(name, @clazz, options)
-      @state_machine.initial_state = name if options[:initial] || !@state_machine.initial_state
+      @state_machine.add_state(name, @klass, options)
 
-      @clazz.send(:define_method, "#{name.to_s}?") do
+      @klass.send(:define_method, "#{name.to_s}?") do
         aasm.current_state == name
       end
 
-      unless @clazz.const_defined?("STATE_#{name.to_s.upcase}")
-        @clazz.const_set("STATE_#{name.to_s.upcase}", name)
+      unless @klass.const_defined?("STATE_#{name.to_s.upcase}")
+        @klass.const_set("STATE_#{name.to_s.upcase}", name)
       end
     end
 
     # define an event
     def event(name, options={}, &block)
-      # @clazz.aasm_event(name, options, &block)
-
       @state_machine.events[name] = AASM::Event.new(name, options, &block)
 
       # an addition over standard aasm so that, before firing an event, you can ask
       # may_event? and get back a boolean that tells you whether the guard method
       # on the transition will let this happen.
-      @clazz.send(:define_method, "may_#{name.to_s}?") do |*args|
+      @klass.send(:define_method, "may_#{name.to_s}?") do |*args|
         aasm.may_fire_event?(name, *args)
       end
 
-      @clazz.send(:define_method, "#{name.to_s}!") do |*args, &block|
+      @klass.send(:define_method, "#{name.to_s}!") do |*args, &block|
+        aasm.current_event = "#{name.to_s}!".to_sym
         aasm_fire_event(name, {:persist => true}, *args, &block)
       end
 
-      @clazz.send(:define_method, "#{name.to_s}") do |*args, &block|
+      @klass.send(:define_method, "#{name.to_s}") do |*args, &block|
+        aasm.current_event = name.to_sym
         aasm_fire_event(name, {:persist => false}, *args, &block)
       end
     end
@@ -78,5 +77,24 @@ module AASM
       states.map { |state| state.for_select }
     end
 
+    def from_states_for_state(state, options={})
+      if options[:transition]
+        events[options[:transition]].transitions_to_state(state).flatten.map(&:from).flatten
+      else
+        events.map {|k,v| v.transitions_to_state(state)}.flatten.map(&:from).flatten
+      end
+    end
+
+    private
+
+    def configure(key, default_value)
+      @state_machine.config.send(:new_ostruct_member, key)
+      if @options.key?(key)
+        @state_machine.config.send("#{key}=", @options[key])
+      elsif @state_machine.config.send(key).nil?
+        @state_machine.config.send("#{key}=", default_value)
+      end
+    end
+
   end
 end

data/lib/aasm/event.rb

@@ -6,6 +6,7 @@ module AASM
     def initialize(name, options = {}, &block)
       @name = name
       @transitions = []
+      @guards = Array(options[:guard] || options[:guards])
       update(options, &block)
     end
 
@@ -25,7 +26,7 @@ module AASM
     end
 
     def transitions_from_state(state)
-      @transitions.select { |t| t.from == state }
+      @transitions.select { |t| t.from.nil? or t.from == state }
     end
 
     def transitions_to_state?(state)
@@ -36,9 +37,9 @@ module AASM
       @transitions.select { |t| t.to == state }
     end
 
-    # deprecated
+    # TODO remove this method in v4.0.0
     def all_transitions
-      # warn "Event#all_transitions is deprecated and will be removed in version 3.2.0; please use Event#transitions instead!"
+      warn "Event#all_transitions is deprecated and will be removed in version 4.0.0; please use Event#transitions instead!"
       transitions
     end
 
@@ -54,8 +55,31 @@ module AASM
       end
     end
 
+    ## DSL interface
+    def transitions(definitions=nil)
+      if definitions # define new transitions
+        # Create a separate transition for each from-state to the given state
+        Array(definitions[:from]).each do |s|
+          @transitions << AASM::Transition.new(attach_event_guards(definitions.merge(:from => s.to_sym)))
+        end
+        # Create a transition if :to is specified without :from (transitions from ANY state)
+        if @transitions.empty? && definitions[:to]
+          @transitions << AASM::Transition.new(attach_event_guards(definitions))
+        end
+      end
+      @transitions
+    end
+
   private
 
+    def attach_event_guards(definitions)
+      unless @guards.empty?
+        given_guards = Array(definitions.delete(:guard) || definitions.delete(:guards))
+        definitions[:guards] = given_guards + @guards
+      end
+      definitions
+    end
+
     def update(options = {}, &block)
       @options = options
       if block then
@@ -68,7 +92,7 @@ module AASM
     def _fire(obj, test, to_state=nil, *args)
       result = test ? false : nil
       if @transitions.map(&:from).any?
-        transitions = @transitions.select { |t| t.from == obj.aasm_current_state }
+        transitions = @transitions.select { |t| t.from == obj.aasm.current_state }
         return result if transitions.size == 0
       else
         transitions = @transitions
@@ -106,19 +130,6 @@ module AASM
       end
     end
 
-    ## DSL interface
-    def transitions(trans_opts=nil)
-      if trans_opts # define new transitions
-        # Create a separate transition for each from state to the given state
-        Array(trans_opts[:from]).each do |s|
-          @transitions << AASM::Transition.new(trans_opts.merge({:from => s.to_sym}))
-        end
-        # Create a transition if to is specified without from (transitions from ANY state)
-        @transitions << AASM::Transition.new(trans_opts) if @transitions.empty? && trans_opts[:to]
-      end
-      @transitions
-    end
-
     [:after, :before, :error, :success].each do |callback_name|
       define_method callback_name do |*args, &block|
         options[callback_name] = Array(options[callback_name])

data/lib/aasm/instance_base.rb

@@ -1,6 +1,8 @@
 module AASM
   class InstanceBase
 
+    attr_accessor :from_state, :to_state, :current_event
+
     def initialize(instance)
       @instance = instance
     end
@@ -15,7 +17,7 @@ module AASM
     end
 
     def enter_initial_state
-      state_name = determine_state_name(@instance.class.aasm_initial_state)
+      state_name = determine_state_name(@instance.class.aasm.initial_state)
       state_object = state_object_for_name(state_name)
 
       state_object.fire_callbacks(:before_enter, @instance)
@@ -33,7 +35,7 @@ module AASM
     def states(options={})
       if options[:permissible]
         # ugliness level 1000
-        transitions = @instance.class.aasm.events.values.map {|e| e.transitions_from_state(current_state) }
+        transitions = @instance.class.aasm.events.values_at(*permissible_events).compact.map {|e| e.transitions_from_state(current_state) }
         tos = transitions.map {|t| t[0] ? t[0].to : nil}.flatten.compact.map(&:to_sym).uniq
         @instance.class.aasm.states.select {|s| tos.include?(s.name.to_sym)}
       else
@@ -73,8 +75,11 @@ module AASM
     end
 
     def may_fire_event?(name, *args)
-      event = @instance.class.aasm.events[name]
-      event.may_fire?(@instance, *args)
+      if event = @instance.class.aasm.events[name]
+        event.may_fire?(@instance, *args)
+      else
+        false # unknown event
+      end
     end
 
     def set_current_state_with_persistence(state)

data/lib/aasm/localizer.rb

@@ -47,7 +47,7 @@ module AASM
 
     def ancestors_list(klass)
       klass.ancestors.select do |ancestor|
-        ancestor.respond_to?(:model_name) unless ancestor == ActiveRecord::Base
+        ancestor.respond_to?(:model_name) unless ancestor.name == 'ActiveRecord::Base'
       end
     end
   end

data/lib/aasm/persistence/active_record_persistence.rb

@@ -36,6 +36,12 @@ module AASM
         else
           base.before_validation_on_create(:aasm_ensure_initial_state)
         end
+
+        # ensure initial aasm state even when validations are skipped
+        base.before_create(:aasm_ensure_initial_state)
+
+        # ensure state is in the list of states
+        base.validate :aasm_validate_states
       end
 
       module ClassMethods
@@ -71,18 +77,19 @@ module AASM
         # Writes <tt>state</tt> to the state column and persists it to the database
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :opened
         #   foo.close!
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
         def aasm_write_state(state)
           old_value = read_attribute(self.class.aasm_column)
-          write_attribute(self.class.aasm_column, state.to_s)
+          aasm_write_attribute state
 
-          success = if AASM::StateMachine[self.class].config.skip_validation_on_save
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm_column => state.to_s) == 1
+          success = if aasm_skipping_validations
+            value = aasm_raw_attribute_value state
+            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm_column => value) == 1
           else
             self.save
           end
@@ -97,20 +104,52 @@ module AASM
         # Writes <tt>state</tt> to the state column, but does not persist it to the database
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :opened
         #   foo.close
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :opened
         #   foo.save
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
         def aasm_write_state_without_persistence(state)
-          write_attribute(self.class.aasm_column, state.to_s)
+          aasm_write_attribute state
         end
 
       private
+        def aasm_enum
+          case AASM::StateMachine[self.class].config.enum
+            when false then nil
+            when true then aasm_guess_enum_method
+            when nil then aasm_guess_enum_method if aasm_column_looks_like_enum
+            else AASM::StateMachine[self.class].config.enum
+          end
+        end
+
+        def aasm_column_looks_like_enum
+          self.class.columns_hash[self.class.aasm_column.to_s].type == :integer
+        end
+
+        def aasm_guess_enum_method
+          self.class.aasm_column.to_s.pluralize.to_sym
+        end
+
+        def aasm_skipping_validations
+          AASM::StateMachine[self.class].config.skip_validation_on_save
+        end
+
+        def aasm_write_attribute(state)
+          write_attribute self.class.aasm_column, aasm_raw_attribute_value(state)
+        end
+
+        def aasm_raw_attribute_value(state)
+          if aasm_enum
+            value = self.class.send(aasm_enum)[state]
+          else
+            value = state.to_s
+          end
+        end
 
         # Ensures that if the aasm_state column is nil and the record is new
         # that the initial state gets populated before validation on create
@@ -132,17 +171,27 @@ module AASM
         end
 
         def aasm_fire_event(name, options, *args, &block)
-          success = self.class.transaction(:requires_new => true) do
-            super
-          end
+          success = options[:persist] ? self.class.transaction(:requires_new => requires_new?) { super } : super
 
-          if success
+          if success && options[:persist]
             new_state = aasm.state_object_for_name(aasm.current_state)
             new_state.fire_callbacks(:after_commit, self)
           end
 
           success
         end
+
+        def requires_new?
+          AASM::StateMachine[self.class].config.requires_new_transaction
+        end
+
+        def aasm_validate_states
+          unless AASM::StateMachine[self.class].config.skip_validation_on_save
+            if aasm.current_state && !aasm.states.include?(aasm.current_state)
+              self.errors.add(AASM::StateMachine[self.class].config.column , "is invalid")
+            end
+          end
+        end
       end # InstanceMethods
 
     end

data/lib/aasm/persistence/base.rb

@@ -35,7 +35,7 @@ module AASM
       def aasm_read_state
         state = send(self.class.aasm_column)
         if new_record?
-          state.blank? ? aasm.determine_state_name(self.class.aasm_initial_state) : state.to_sym
+          state.blank? ? aasm.determine_state_name(self.class.aasm.initial_state) : state.to_sym
         else
           state.nil? ? nil : state.to_sym
         end
@@ -87,26 +87,22 @@ module AASM
     # make sure to create a (named) scope for each state
     def state_with_scope(name, *args)
       state_without_scope(name, *args)
-      if AASM::StateMachine[@clazz].config.create_scopes && !@clazz.respond_to?(name)
-        if @clazz.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
+      if AASM::StateMachine[@klass].config.create_scopes && !@klass.respond_to?(name)
+        if @klass.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
 
-          conditions = {"#{@clazz.table_name}.#{@clazz.aasm_column}" => name.to_s}
-          if ActiveRecord::VERSION::MAJOR >= 4
-            @clazz.class_eval do
+          conditions = {"#{@klass.table_name}.#{@klass.aasm_column}" => name.to_s}
+          if ActiveRecord::VERSION::MAJOR >= 3
+            @klass.class_eval do
               scope name, lambda { where(conditions) }
             end
-          elsif ActiveRecord::VERSION::MAJOR >= 3
-            @clazz.class_eval do
-              scope name, where(conditions)
-            end
           else
-            @clazz.class_eval do
+            @klass.class_eval do
               named_scope name, :conditions => conditions
             end
           end
-        elsif @clazz.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
-          scope_options = lambda { @clazz.send(:where, {@clazz.aasm_column.to_sym => name.to_s}) }
-          @clazz.send(:scope, name, scope_options)
+        elsif @klass.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
+          scope_options = lambda { @klass.send(:where, {@klass.aasm_column.to_sym => name.to_s}) }
+          @klass.send(:scope, name, scope_options)
         end
       end
     end

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -36,6 +36,8 @@ module AASM
         # Mongoid's Validatable gem dependency goes not have a before_validation_on_xxx hook yet.
         # base.before_validation_on_create :aasm_ensure_initial_state
         base.before_validation :aasm_ensure_initial_state
+        # ensure initial aasm state even when validations are skipped
+        base.before_create :aasm_ensure_initial_state
       end
 
       module ClassMethods
@@ -66,10 +68,10 @@ module AASM
         # using update_attribute (which bypasses validation)
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :opened
         #   foo.close!
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
         def aasm_write_state(state)
@@ -87,13 +89,13 @@ module AASM
         # Writes <tt>state</tt> to the state column, but does not persist it to the database
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :opened
         #   foo.close
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :opened
         #   foo.save
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
         def aasm_write_state_without_persistence(state)