aasm 3.0.16 → 3.0.17

data/lib/aasm/persistence/base.rb

@@ -2,6 +2,44 @@ module AASM
   module Persistence
     module Base
 
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      # Returns the value of the aasm_column - called from <tt>aasm.current_state</tt>
+      #
+      # If it's a new record, and the aasm state column is blank it returns the initial state
+      # (example provided here for ActiveRecord, but it's true for Mongoid as well):
+      #
+      #   class Foo < ActiveRecord::Base
+      #     include AASM
+      #     aasm :column => :status do
+      #       state :opened
+      #       state :closed
+      #     end
+      #   end
+      #
+      #   foo = Foo.new
+      #   foo.current_state # => :opened
+      #   foo.close
+      #   foo.current_state # => :closed
+      #
+      #   foo = Foo.find(1)
+      #   foo.current_state # => :opened
+      #   foo.aasm_state = nil
+      #   foo.current_state # => nil
+      #
+      # NOTE: intended to be called from an event
+      #
+      # This allows for nil aasm states - be sure to add validation to your model
+      def aasm_read_state
+        if new_record?
+          send(self.class.aasm_column).blank? ? aasm.determine_state_name(self.class.aasm_initial_state) : send(self.class.aasm_column).to_sym
+        else
+          send(self.class.aasm_column).nil? ? nil : send(self.class.aasm_column).to_sym
+        end
+      end
+
       module ClassMethods
         # Maps to the aasm_column in the database.  Defaults to "aasm_state".  You can write
         # (example provided here for ActiveRecord, but it's true for Mongoid as well):
@@ -39,18 +77,20 @@ module AASM
           # @aasm_column
           AASM::StateMachine[self].config.column
         end
-      end
+      end # ClassMethods
 
     end # Base
   end # Persistence
 
   class Base
+    # make sure to create a (named) scope for each state
     def state_with_scope(name, *args)
       state_without_scope(name, *args)
       unless @clazz.respond_to?(name)
         if @clazz.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
-          scope_options = {:conditions => { "#{@clazz.table_name}.#{@clazz.aasm_column}" => name.to_s}}
+          scope_options_hash = {:conditions => { "#{@clazz.table_name}.#{@clazz.aasm_column}" => name.to_s}}
           scope_method = ActiveRecord::VERSION::MAJOR >= 3 ? :scope : :named_scope
+          scope_options = ActiveRecord::VERSION::MAJOR >= 4 ? lambda {  where(scope_options_hash[:conditions])} : scope_options_hash
           @clazz.send(scope_method, name, scope_options)
         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}) }

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -6,11 +6,6 @@ module AASM
       # * extends the model with ClassMethods
       # * includes InstanceMethods
       #
-      # Unless the corresponding methods are already defined, it includes
-      # * ReadState
-      # * WriteState
-      # * WriteStateWithoutPersistence
-      #
       # Adds
       #
       #   before_validation :aasm_ensure_initial_state
@@ -34,12 +29,9 @@ module AASM
       #   end
       #
       def self.included(base)
-        base.extend AASM::Persistence::Base::ClassMethods
+        base.send(:include, AASM::Persistence::Base)
         base.extend AASM::Persistence::MongoidPersistence::ClassMethods
         base.send(:include, AASM::Persistence::MongoidPersistence::InstanceMethods)
-        base.send(:include, AASM::Persistence::ReadState) unless base.method_defined?(:aasm_read_state)
-        base.send(:include, AASM::Persistence::MongoidPersistence::WriteState) unless base.method_defined?(:aasm_write_state)
-        base.send(:include, AASM::Persistence::MongoidPersistence::WriteStateWithoutPersistence) unless base.method_defined?(:aasm_write_state_without_persistence)
 
         # Mongoid's Validatable gem dependency goes not have a before_validation_on_xxx hook yet.
         # base.before_validation_on_create :aasm_ensure_initial_state
@@ -70,48 +62,28 @@ module AASM
 
       module InstanceMethods
 
-        # Returns the current aasm_state of the object.  Respects reload and
-        # any changes made to the aasm_state field directly
-        #
-        # Internally just calls <tt>aasm_read_state</tt>
+        # Writes <tt>state</tt> to the state column and persists it to the database
+        # using update_attribute (which bypasses validation)
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :pending
-        #   foo.aasm_state = "opened"
         #   foo.aasm_current_state # => :opened
-        #   foo.close # => calls aasm_write_state_without_persistence
+        #   foo.close!
         #   foo.aasm_current_state # => :closed
-        #   foo.reload
-        #   foo.aasm_current_state # => :pending
+        #   Foo.find(1).aasm_current_state # => :closed
         #
-        def aasm_current_state
-          @current_state = aasm_read_state
-        end
+        # 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)
 
-        private
+          unless self.save(:validate => false)
+            write_attribute(self.class.aasm_column, old_value)
+            return false
+          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
-        #
-        #   foo = Foo.new
-        #   foo.aasm_state # => nil
-        #   foo.valid?
-        #   foo.aasm_state # => "open" (where :open is the initial state)
-        #
-        #
-        #   foo = Foo.find(:first)
-        #   foo.aasm_state # => 1
-        #   foo.aasm_state = nil
-        #   foo.valid?
-        #   foo.aasm_state # => nil
-        #
-        def aasm_ensure_initial_state
-          send("#{self.class.aasm_column}=", self.aasm_enter_initial_state.to_s) if send(self.class.aasm_column).blank?
+          true
         end
 
-      end
-
-      module WriteStateWithoutPersistence
         # Writes <tt>state</tt> to the state column, but does not persist it to the database
         #
         #   foo = Foo.find(1)
@@ -127,31 +99,28 @@ module AASM
         def aasm_write_state_without_persistence(state)
           write_attribute(self.class.aasm_column, state.to_s)
         end
-      end
 
-      module WriteState
-        # Writes <tt>state</tt> to the state column and persists it to the database
-        # using update_attribute (which bypasses validation)
+      private
+
+        # Ensures that if the aasm_state column is nil and the record is new
+        # that the initial state gets populated before validation on create
         #
-        #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
-        #   foo.close!
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   foo = Foo.new
+        #   foo.aasm_state # => nil
+        #   foo.valid?
+        #   foo.aasm_state # => "open" (where :open is the initial state)
         #
-        # 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)
-
-          unless self.save(:validate => false)
-            write_attribute(self.class.aasm_column, old_value)
-            return false
-          end
-
-          true
+        #
+        #   foo = Foo.find(:first)
+        #   foo.aasm_state # => 1
+        #   foo.aasm_state = nil
+        #   foo.valid?
+        #   foo.aasm_state # => nil
+        #
+        def aasm_ensure_initial_state
+          send("#{self.class.aasm_column}=", aasm.enter_initial_state.to_s) if send(self.class.aasm_column).blank?
         end
-      end
+      end # InstanceMethods
 
       module NamedScopeMethods
         def aasm_state_with_named_scope name, options = {}
@@ -161,4 +130,4 @@ module AASM
       end
     end
   end
-end
+end

data/lib/aasm/state.rb

@@ -0,0 +1,78 @@
+module AASM
+  class State
+    attr_reader :name, :options
+
+    def initialize(name, clazz, options={})
+      @name = name
+      @clazz = clazz
+      update(options)
+    end
+
+    def ==(state)
+      if state.is_a? Symbol
+        name == state
+      else
+        name == state.name
+      end
+    end
+
+    def <=>(state)
+      if state.is_a? Symbol
+        name <=> state
+      else
+        name <=> state.name
+      end
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def fire_callbacks(action, record)
+      action = @options[action]
+      catch :halt_aasm_chain do
+        action.is_a?(Array) ?
+                action.each {|a| _fire_callbacks(a, record)} :
+                _fire_callbacks(action, record)
+      end
+    end
+
+    def display_name
+      @display_name ||= begin
+        if Module.const_defined?(:I18n)
+          localized_name
+        else
+          name.to_s.gsub(/_/, ' ').capitalize
+        end
+      end
+    end
+
+    def localized_name
+      AASM::Localizer.new.human_state_name(@clazz, self)
+    end
+
+    def for_select
+      [display_name, name.to_s]
+    end
+
+  private
+
+    def update(options = {})
+      if options.key?(:display) then
+        @display_name = options.delete(:display)
+      end
+      @options = options
+      self
+    end
+
+    def _fire_callbacks(action, record)
+      case action
+        when Symbol, String
+          record.send(action)
+        when Proc
+          action.call(record)
+      end
+    end
+
+  end
+end # AASM

data/lib/aasm/state_machine.rb

@@ -29,8 +29,8 @@ module AASM
       @events = @events.dup
     end
 
-    def create_state(name, clazz, options)
-      @states << AASM::SupportingClasses::State.new(name, clazz, options) unless @states.include?(name)
+    def add_state(name, clazz, options)
+      @states << AASM::State.new(name, clazz, options) unless @states.include?(name)
     end
 
   end # StateMachine

data/lib/aasm/transition.rb

@@ -0,0 +1,49 @@
+module AASM
+  class Transition
+    attr_reader :from, :to, :opts
+    alias_method :options, :opts
+
+    def initialize(opts)
+      @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
+      @opts = opts
+    end
+
+    # TODO: should be named allowed? or similar
+    def perform(obj, *args)
+      case @guard
+        when Symbol, String
+          obj.send(@guard, *args)
+        when Proc
+          @guard.call(obj, *args)
+        else
+          true
+      end
+    end
+
+    def execute(obj, *args)
+      @on_transition.is_a?(Array) ?
+              @on_transition.each {|ot| _execute(obj, ot, *args)} :
+              _execute(obj, @on_transition, *args)
+    end
+
+    def ==(obj)
+      @from == obj.from && @to == obj.to
+    end
+
+    def from?(value)
+      @from == value
+    end
+
+    private
+
+    def _execute(obj, on_transition, *args)
+      case on_transition
+      when Proc
+        on_transition.arity == 0 ? on_transition.call : on_transition.call(obj, *args)
+      when Symbol, String
+        obj.send(:method, on_transition.to_sym).arity == 0 ? obj.send(on_transition) : obj.send(on_transition, *args)
+      end
+    end
+
+  end
+end # AASM

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.0.16"
+  VERSION = "3.0.17"
 end

data/spec/models/active_record/api.rb

@@ -0,0 +1,75 @@
+class DefaultState
+  attr_accessor :transient_store, :persisted_store
+  include AASM
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+    state :gamma
+    event :release do
+      transitions :from => [:alpha, :beta, :gamma], :to => :beta
+    end
+  end
+end
+
+class ProvidedState
+  attr_accessor :transient_store, :persisted_store
+  include AASM
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+    state :gamma
+    event :release do
+      transitions :from => [:alpha, :beta, :gamma], :to => :beta
+    end
+  end
+
+  def aasm_read_state
+    :beta
+  end
+
+  def aasm_write_state(new_state)
+    @persisted_store = new_state
+  end
+
+  def aasm_write_state_without_persistence(new_state)
+    @transient_store = new_state
+  end
+end
+
+class PersistedState < ActiveRecord::Base
+  attr_accessor :transient_store, :persisted_store
+  include AASM
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+    state :gamma
+    event :release do
+      transitions :from => [:alpha, :beta, :gamma], :to => :beta
+    end
+  end
+end
+
+class ProvidedAndPersistedState < ActiveRecord::Base
+  attr_accessor :transient_store, :persisted_store
+  include AASM
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+    state :gamma
+    event :release do
+      transitions :from => [:alpha, :beta, :gamma], :to => :beta
+    end
+  end
+
+  def aasm_read_state
+    :gamma
+  end
+
+  def aasm_write_state(new_state)
+    @persisted_store = new_state
+  end
+
+  def aasm_write_state_without_persistence(new_state)
+    @transient_store = new_state
+  end
+end

data/spec/models/auth_machine.rb

@@ -46,7 +46,7 @@ class AuthMachine
   def initialize
     # the AR backend uses a before_validate_on_create :aasm_ensure_initial_state
     # lets do something similar here for testing purposes.
-    aasm_enter_initial_state
+    aasm.enter_initial_state
   end
 
   def make_activation_code

data/spec/models/bar.rb

@@ -0,0 +1,15 @@
+class Bar
+  include AASM
+
+  aasm do
+    state :read
+    state :ended
+
+    event :foo do
+      transitions :to => :ended, :from => [:read]
+    end
+  end
+end
+
+class Baz < Bar
+end