aasm 4.0.3 → 4.1.0

data/lib/aasm/persistence/mongo_mapper_persistence.rb

@@ -0,0 +1,174 @@
+require_relative 'base'
+
+module AASM
+  module Persistence
+    module MongoMapperPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   before_validation :aasm_ensure_initial_state, :on => :create
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo
+      #     include MongoMapper::Document
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo < ActiveRecord::Base
+      #     include MongoMapper::Document
+      #     include AASM
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #   end
+      #
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.extend AASM::Persistence::MongoMapperPersistence::ClassMethods
+        base.send(:include, AASM::Persistence::MongoMapperPersistence::InstanceMethods)
+
+        base.before_create :aasm_ensure_initial_state
+
+        # ensure state is in the list of states
+        base.validate :aasm_validate_states
+      end
+
+      module ClassMethods
+
+        def find_in_state(number, state, *args)
+          with_state_scope(state).find!(number, *args)
+        end
+
+        def count_in_state(state, *args)
+          with_state_scope(state).count(*args)
+        end
+
+        def calculate_in_state(state, *args)
+          with_state_scope(state).calculate(*args)
+        end
+
+        protected
+        def with_state_scope(state)
+          where(aasm.attribute_name.to_sym => state.to_s)
+        end
+      end
+
+      module InstanceMethods
+
+        # Writes <tt>state</tt> to the state column and persists it to the database
+        #
+        #   foo = Foo.find(1)
+        #   foo.aasm.current_state # => :opened
+        #   foo.close!
+        #   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.attribute_name)
+          aasm_write_attribute state
+
+          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.attribute_name => value) == 1
+          else
+            self.save
+          end
+          unless success
+            write_attribute(self.class.aasm.attribute_name, old_value)
+            return false
+          end
+
+          true
+        end
+
+        # 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.close
+        #   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
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state_without_persistence(state)
+          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.keys[self.class.aasm.attribute_name.to_s].type == Integer
+        end
+
+        def aasm_guess_enum_method
+          self.class.aasm.attribute_name.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.attribute_name, aasm_raw_attribute_value(state)
+        end
+
+        def aasm_raw_attribute_value(state)
+          if aasm_enum
+            self.class.send(aasm_enum)[state]
+          else
+            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
+        #
+        #   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
+          return send("#{self.class.aasm.attribute_name}=", aasm.enter_initial_state.to_s) if send(self.class.aasm.attribute_name).blank?
+        end
+
+        def aasm_validate_states
+          send("#{self.class.aasm.attribute_name}=", aasm.enter_initial_state.to_s) if send(self.class.aasm.attribute_name).blank?
+          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
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -1,3 +1,5 @@
+require_relative 'base'
+
 module AASM
   module Persistence
     module MongoidPersistence
@@ -33,11 +35,7 @@ module AASM
         base.extend AASM::Persistence::MongoidPersistence::ClassMethods
         base.send(:include, AASM::Persistence::MongoidPersistence::InstanceMethods)
 
-        # 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
+        base.after_initialize :aasm_ensure_initial_state
       end
 
       module ClassMethods
@@ -131,5 +129,5 @@ module AASM
         end
       end
     end
-  end
-end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/plain_persistence.rb

@@ -0,0 +1,24 @@
+module AASM
+  module Persistence
+    module PlainPersistence
+
+      def aasm_read_state
+        # all the following lines behave like @current_state ||= aasm.enter_initial_state
+        current = aasm.instance_variable_get("@current_state")
+        return current if current
+        aasm.instance_variable_set("@current_state", aasm.enter_initial_state)
+      end
+
+      # may be overwritten by persistence mixins
+      def aasm_write_state(new_state)
+        true
+      end
+
+      # may be overwritten by persistence mixins
+      def aasm_write_state_without_persistence(new_state)
+        true
+      end
+
+    end
+  end
+end

data/lib/aasm/persistence/sequel_persistence.rb

@@ -1,3 +1,5 @@
+require_relative 'base'
+
 module AASM
   module Persistence
     module SequelPersistence

data/lib/aasm/persistence.rb

@@ -7,23 +7,31 @@ module AASM
         hierarchy = base.ancestors.map {|klass| klass.to_s}
 
         if hierarchy.include?("ActiveRecord::Base")
-          require_files_for(:active_record)
-          base.send(:include, AASM::Persistence::ActiveRecordPersistence)
+          include_persistence base, :active_record
         elsif hierarchy.include?("Mongoid::Document")
-          require_files_for(:mongoid)
-          base.send(:include, AASM::Persistence::MongoidPersistence)
+          include_persistence base, :mongoid
+        elsif hierarchy.include?("MongoMapper::Document")
+          include_persistence base, :mongo_mapper
         elsif hierarchy.include?("Sequel::Model")
-          require_files_for(:sequel)
-          base.send(:include, AASM::Persistence::SequelPersistence)
+          include_persistence base, :sequel
+        else
+          include_persistence base, :plain
         end
       end
 
-    private
+      private
 
-      def require_files_for(persistence)
-        ['base', "#{persistence}_persistence"].each do |file_name|
-          require File.join(File.dirname(__FILE__), 'persistence', file_name)
-        end
+      def include_persistence(base, type)
+        require File.join(File.dirname(__FILE__), 'persistence', "#{type}_persistence")
+        base.send(:include, constantize("AASM::Persistence::#{capitalize(type)}Persistence"))
+      end
+
+      def capitalize(string_or_symbol)
+        string_or_symbol.to_s.split('_').map {|segment| segment[0].upcase + segment[1..-1]}.join('')
+      end
+
+      def constantize(string)
+        instance_eval(string)
       end
 
     end # class << self

data/lib/aasm/state_machine.rb

@@ -32,7 +32,7 @@ module AASM
       # allow reloading, extending or redefining a state
       @states.delete(name) if @states.include?(name)
 
-      @states << AASM::State.new(name, klass, options)
+      @states << AASM::Core::State.new(name, klass, options)
     end
 
     private

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.0.3"
+  VERSION = "4.1.0"
 end

data/lib/aasm.rb

@@ -1,17 +1,15 @@
 require 'ostruct'
 
-%w(
-    version
-    errors
-    configuration
-    base
-    dsl_helper
-    instance_base
-    transition
-    event
-    state
-    localizer
-    state_machine
-    persistence
-    aasm
-  ).each { |file| require File.join(File.dirname(__FILE__), 'aasm', file) }
+require 'aasm/version'
+require 'aasm/errors'
+require 'aasm/configuration'
+require 'aasm/base'
+require 'aasm/dsl_helper'
+require 'aasm/instance_base'
+require 'aasm/core/transition'
+require 'aasm/core/event'
+require 'aasm/core/state'
+require 'aasm/localizer'
+require 'aasm/state_machine'
+require 'aasm/persistence'
+require 'aasm/aasm'

data/spec/database.rb

@@ -1,10 +1,14 @@
 ActiveRecord::Migration.suppress_messages do
-  %w{gates readers writers transients simples simple_new_dsls no_scopes no_direct_assignments thieves localizer_test_models persisted_states provided_and_persisted_states}.each do |table_name|
+  %w{gates readers writers transients simples  no_scopes no_direct_assignments thieves localizer_test_models persisted_states provided_and_persisted_states with_enums with_true_enums with_false_enums false_states}.each do |table_name|
     ActiveRecord::Migration.create_table table_name, :force => true do |t|
       t.string "aasm_state"
     end
   end
 
+  ActiveRecord::Migration.create_table "simple_new_dsls", :force => true do |t|
+    t.string "status"
+  end
+
   ActiveRecord::Migration.create_table "validators", :force => true do |t|
     t.string "name"
     t.string "status"

data/spec/models/callbacks/basic.rb

@@ -0,0 +1,75 @@
+module Callbacks
+  class Basic
+    include AASM
+
+    def initialize(options={})
+      @fail_event_guard = options[:fail_event_guard]
+      @fail_transition_guard = options[:fail_transition_guard]
+      @log = options[:log]
+      reset_data
+    end
+
+    def reset_data
+      @data = []
+    end
+
+    def data
+      @data.join(' ')
+    end
+
+    aasm do
+      state :open, :initial => true,
+        :before_enter => :before_enter_open,
+        :enter        => :enter_open,
+        :after_enter  => :after_enter_open,
+        :before_exit  => :before_exit_open,
+        :exit         => :exit_open,
+        :after_exit   => :after_exit_open
+
+      state :closed,
+        :before_enter => :before_enter_closed,
+        :enter        => :enter_closed,
+        :after_enter  => :after_enter_closed,
+        :before_exit  => :before_exit_closed,
+        :exit         => :exit_closed,
+        :after_exit   => :after_exit_closed
+
+      event :close, :before => :before_event, :after => :after_event, :guard => :event_guard do
+        transitions :to => :closed, :from => [:open], :guard => :transition_guard, :after => :after_transition
+      end
+
+      event :open, :before => :before_event, :after => :after_event do
+        transitions :to => :open, :from => :closed
+      end
+    end
+
+    def log(text)
+      @data << text
+      puts text if @log
+    end
+
+    def aasm_write_state(*args); log('aasm_write_state'); true; end
+
+    def before_enter_open;    log('before_enter_open');   end
+    def enter_open;           log('enter_open');          end
+    def before_exit_open;     log('before_exit_open');    end
+    def after_enter_open;     log('after_enter_open');    end
+    def exit_open;            log('exit_open');           end
+    def after_exit_open;      log('after_exit_open');     end
+
+    def before_enter_closed;  log('before_enter_closed'); end
+    def enter_closed;         log('enter_closed');        end
+    def before_exit_closed;   log('before_exit_closed');  end
+    def exit_closed;          log('exit_closed');         end
+    def after_enter_closed;   log('after_enter_closed');  end
+    def after_exit_closed;    log('after_exit_closed');   end
+
+    def event_guard;          log('event_guard');         !@fail_event_guard;      end
+    def transition_guard;     log('transition_guard');    !@fail_transition_guard; end
+
+    def after_transition;     log('after_transition');    end
+
+    def before_event;         log('before_event');        end
+    def after_event;          log('after_event');         end
+  end
+end

data/spec/models/callbacks/guard_within_block.rb

@@ -0,0 +1,66 @@
+module Callbacks
+  class GuardWithinBlock
+    include AASM
+
+    def initialize(options={})
+      @fail_event_guard = options[:fail_event_guard]
+      @fail_transition_guard = options[:fail_transition_guard]
+      @log = options[:log]
+    end
+
+    aasm do
+      state :open, :initial => true,
+        :before_enter => :before_enter_open,
+        :enter        => :enter_open,
+        :after_enter  => :after_enter_open,
+        :before_exit  => :before_exit_open,
+        :exit         => :exit_open,
+        :after_exit   => :after_exit_open
+
+      state :closed,
+        :before_enter => :before_enter_closed,
+        :enter        => :enter_closed,
+        :after_enter  => :after_enter_closed,
+        :before_exit  => :before_exit_closed,
+        :exit         => :exit_closed,
+        :after_exit   => :after_exit_closed
+
+      event :close, :before => :before, :after => :after, :guard => :event_guard do
+        transitions :to => :closed, :from => [:open], :after => :transitioning do
+          guard do
+            transition_guard
+          end
+        end
+      end
+
+      event :open, :before => :before, :after => :after do
+        transitions :to => :open, :from => :closed
+      end
+    end
+
+    def log(text)
+      puts text if @log
+    end
+
+    def before_enter_open; log('before_enter_open'); end
+    def enter_open; log('enter_open'); end
+    def before_exit_open; log('before_exit_open'); end
+    def after_enter_open; log('after_enter_open'); end
+    def exit_open; log('exit_open'); end
+    def after_exit_open; log('after_exit_open'); end
+
+    def before_enter_closed; log('before_enter_closed'); end
+    def enter_closed; log('enter_closed'); end
+    def before_exit_closed; log('before_exit_closed'); end
+    def exit_closed; log('exit_closed'); end
+    def after_enter_closed; log('after_enter_closed'); end
+    def after_exit_closed; log('after_exit_closed'); end
+
+    def event_guard; log('event_guard'); !@fail_event_guard; end
+    def transition_guard; log('transition_guard'); !@fail_transition_guard; end
+    def transitioning; log('transitioning'); end
+
+    def before; log('before'); end
+    def after; log('after'); end
+  end
+end

data/spec/models/callbacks/private_method.rb

@@ -0,0 +1,44 @@
+module Callbacks
+  class PrivateMethod
+    include AASM
+
+    def initialize(options={})
+      @fail_event_guard = options[:fail_event_guard]
+      @fail_transition_guard = options[:fail_transition_guard]
+      @log = options[:log]
+      reset_data
+    end
+
+    def reset_data
+      @data = []
+    end
+
+    def data
+      @data.join(' ')
+    end
+
+    aasm do
+      state :open, :initial => true
+      state :closed
+
+      event :close, :after => :after_event do
+        transitions :to => :closed, :from => [:open]
+      end
+
+      event :open, :after => :after_event do
+        transitions :to => :open, :from => :closed
+      end
+    end
+
+    def log(text)
+      @data << text
+      puts text if @log
+    end
+
+    def aasm_write_state(*args); log('aasm_write_state'); true; end
+
+    private
+
+    def after_event; log('after_event'); end
+  end
+end

data/spec/models/callbacks/with_args.rb

@@ -0,0 +1,61 @@
+module Callbacks
+  class WithArgs
+    include AASM
+
+    def initialize(options={})
+      @log = options[:log]
+      reset_data
+    end
+
+    def reset_data
+      @data = []
+    end
+
+    def data
+      @data.join(' ')
+    end
+
+    aasm do
+      state :open, :initial => true,
+        :before_enter => :before_enter_open,
+        :after_enter  => :after_enter_open,
+        :before_exit  => :before_exit_open,
+        :after_exit   => :after_exit_open
+
+      state :closed,
+        :before_enter => :before_enter_closed,
+        :after_enter  => :after_enter_closed,
+        :before_exit  => :before_exit_closed,
+        :after_exit   => :after_exit_closed
+
+      event :close, :before => :before, :after => :after do
+        transitions :to => :closed, :from => [:open], :after => :transition_proc
+      end
+
+      event :open, :before => :before, :after => :after do
+        transitions :to => :open, :from => :closed
+      end
+    end
+
+    def log(text)
+      @data << text
+      puts text if @log
+    end
+
+    def aasm_write_state(*args); log('aasm_write_state'); true; end
+
+    def before_enter_open; log('before_enter_open'); end
+    def before_exit_open; log('before_exit_open'); end
+    def after_enter_open; log('after_enter_open'); end
+    def after_exit_open; log('after_exit_open'); end
+
+    def before_enter_closed; log('before_enter_closed'); end
+    def before_exit_closed; log('before_enter_closed'); end
+    def after_enter_closed; log('after_enter_closed'); end
+    def after_exit_closed; log('after_exit_closed'); end
+
+    def before(arg1, *args); log("before(#{arg1.inspect},#{args.map(&:inspect).join(',')})"); end
+    def transition_proc(arg1, arg2); log("transition_proc(#{arg1.inspect},#{arg2.inspect})"); end
+    def after(*args); log("after(#{args.map(&:inspect).join(',')})"); end
+  end
+end

data/spec/models/callbacks/with_state_args.rb

@@ -0,0 +1,26 @@
+module Callbacks
+  class WithStateArg
+
+    include AASM
+
+    aasm do
+      state :open, :inital => true
+      state :closed
+      state :out_to_lunch
+
+      event :close, :before => :before_method, :after => :after_method do
+        transitions :to => :closed, :from => [:open], :after => :transition_method
+        transitions :to => :out_to_lunch, :from => [:open], :after => :transition_method2
+      end
+    end
+
+    def before_method(arg); end
+
+    def after_method(arg); end
+
+    def transition_method(arg); end
+
+    def transition_method2(arg); end
+
+  end
+end

data/spec/models/mongo_mapper/no_scope_mongo_mapper.rb

@@ -0,0 +1,10 @@
+class NoScopeMongoMapper
+  include MongoMapper::Document
+  include AASM
+
+  key :status, String
+
+  aasm :create_scopes => false, :column => :status do
+    state :ignored_scope
+  end
+end

data/spec/models/mongo_mapper/simple_mongo_mapper.rb

@@ -0,0 +1,11 @@
+class SimpleMongoMapper
+  include MongoMapper::Document
+  include AASM
+
+  key :status, String
+
+  aasm column: :status do
+    state :unknown_scope
+    state :next
+  end
+end

data/spec/models/mongo_mapper/simple_new_dsl_mongo_mapper.rb

@@ -0,0 +1,12 @@
+class SimpleNewDslMongoMapper
+  include MongoMapper::Document
+  include AASM
+
+  key :status, String
+
+  aasm :column => :status
+  aasm do
+    state :unknown_scope
+    state :next
+  end
+end

data/spec/models/mongoid/simple_new_dsl_mongoid.rb

@@ -6,7 +6,7 @@ class SimpleNewDslMongoid
 
   aasm :column => :status
   aasm do
-    state :unknown_scope
+    state :unknown_scope, :initial => true
     state :new
   end
 end