aasm 4.0.8 → 4.2.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

@@ -35,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

data/lib/aasm/persistence/sequel_persistence.rb

@@ -72,6 +72,7 @@ module AASM
         #
         def aasm_ensure_initial_state
           aasm.enter_initial_state if
+            (new? || values.key?(self.class.aasm.attribute_name)) &&
             send(self.class.aasm.attribute_name).to_s.strip.empty?
         end
 

data/lib/aasm/persistence.rb

@@ -10,6 +10,8 @@ module AASM
           include_persistence base, :active_record
         elsif hierarchy.include?("Mongoid::Document")
           include_persistence base, :mongoid
+        elsif hierarchy.include?("MongoMapper::Document")
+          include_persistence base, :mongo_mapper
         elsif hierarchy.include?("Sequel::Model")
           include_persistence base, :sequel
         else

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.0.8"
+  VERSION = "4.2.0"
 end

data/spec/models/active_record/derivate_new_dsl.rb

@@ -0,0 +1,3 @@
+require_relative 'simple_new_dsl'
+class DerivateNewDsl < SimpleNewDsl
+end

data/spec/models/active_record/false_state.rb

@@ -0,0 +1,17 @@
+class FalseState < ActiveRecord::Base
+  include AASM
+
+  def initialize(*args)
+    super
+    self.aasm_state = false
+  end
+
+  aasm do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end

data/spec/models/active_record/gate.rb

@@ -0,0 +1,19 @@
+class Gate < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  # attr_accessor :aasm_state
+
+  def value
+    'value'
+  end
+
+  aasm do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end

data/spec/models/active_record/localizer_test_model.rb

@@ -0,0 +1,34 @@
+class LocalizerTestModel < ActiveRecord::Base
+  include AASM
+
+  aasm do
+    state :opened, :initial => true
+    state :closed
+    event :close
+    event :open
+  end
+end
+
+describe 'localized state names' do
+  before(:all) do
+    I18n.load_path << 'spec/en.yml'
+    I18n.default_locale = :en
+    I18n.reload!
+  end
+
+  after(:all) do
+    I18n.load_path.clear
+  end
+
+  it 'should localize' do
+    state = LocalizerTestModel.aasm.states.detect {|s| s == :opened}
+    expect(state.localized_name).to eq("It's open now!")
+    expect(state.human_name).to eq("It's open now!")
+  end
+
+  it 'should use fallback' do
+    state = LocalizerTestModel.aasm.states.detect {|s| s == :closed}
+    expect(state.localized_name).to eq('Closed')
+    expect(state.human_name).to eq('Closed')
+  end
+end

data/spec/models/active_record/no_direct_assignment.rb

@@ -0,0 +1,10 @@
+class NoDirectAssignment < ActiveRecord::Base
+  include AASM
+  aasm :no_direct_assignment => true do
+    state :pending, :initial => true
+    state :running
+    event :run do
+      transitions :from => :pending, :to => :running
+    end
+  end
+end

data/spec/models/active_record/no_scope.rb

@@ -0,0 +1,10 @@
+class NoScope < ActiveRecord::Base
+  include AASM
+  aasm :create_scopes => false do
+    state :pending, :initial => true
+    state :running
+    event :run do
+      transitions :from => :pending, :to => :running
+    end
+  end
+end

data/spec/models/active_record/persisted_state.rb

@@ -0,0 +1,12 @@
+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

data/spec/models/active_record/provided_and_persisted_state.rb

@@ -0,0 +1,24 @@
+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/active_record/reader.rb

@@ -0,0 +1,7 @@
+class Reader < ActiveRecord::Base
+  include AASM
+
+  def aasm_read_state
+    "fi"
+  end
+end

data/spec/models/active_record/simple_new_dsl.rb

@@ -0,0 +1,8 @@
+class SimpleNewDsl < ActiveRecord::Base
+  include AASM
+  aasm :column => :status
+  aasm do
+    state :unknown_scope
+    state :new
+  end
+end

data/spec/models/active_record/thief.rb

@@ -0,0 +1,14 @@
+class Thief < ActiveRecord::Base
+  if ActiveRecord::VERSION::MAJOR >= 3
+    self.table_name = 'thieves'
+  else
+    set_table_name "thieves"
+  end
+  include AASM
+  aasm do
+    state :rich
+    state :jailed
+    initial_state Proc.new {|thief| thief.skilled ? :rich : :jailed }
+  end
+  attr_accessor :skilled, :aasm_state
+end

data/spec/models/active_record/transient.rb

@@ -0,0 +1,6 @@
+class Transient < ActiveRecord::Base
+  def aasm_write_state_without_persistence(state)
+    "fum"
+  end
+  include AASM
+end

data/spec/models/active_record/with_enum.rb

@@ -0,0 +1,19 @@
+class WithEnum < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  def self.test
+    {}
+  end
+
+  aasm :enum => :test do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end

data/spec/models/active_record/with_false_enum.rb

@@ -0,0 +1,15 @@
+class WithFalseEnum < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  aasm :enum => false do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end

data/spec/models/active_record/with_true_enum.rb

@@ -0,0 +1,19 @@
+class WithTrueEnum < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  def value
+    'value'
+  end
+
+  aasm :enum => true do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end

data/spec/models/active_record/writer.rb

@@ -0,0 +1,6 @@
+class Writer < ActiveRecord::Base
+  def aasm_write_state(state)
+    "fo"
+  end
+  include AASM
+end

data/spec/models/callbacks/with_args.rb

@@ -44,15 +44,15 @@ module Callbacks
 
     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_enter_open(*args); log("before_enter_open(#{args.map(&:inspect).join(',')})"); end
+    def before_exit_open(*args); log("before_exit_open(#{args.map(&:inspect).join(',')})"); end
+    def after_enter_open(*args); log("after_enter_open(#{args.map(&:inspect).join(',')})"); end
+    def after_exit_open(*args); log("after_exit_open(#{args.map(&:inspect).join(',')})"); end
+
+    def before_enter_closed(*args); log("before_enter_closed(#{args.map(&:inspect).join(',')})"); end
+    def before_exit_closed(*args); log("before_enter_closed(#{args.map(&:inspect).join(',')})"); end
+    def after_enter_closed(*args); log("after_enter_closed(#{args.map(&:inspect).join(',')})"); end
+    def after_exit_closed(*args); log("after_exit_closed(#{args.map(&:inspect).join(',')})"); 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

data/spec/models/{auth_machine.rb → complex_example.rb}

@@ -1,4 +1,4 @@
-class AuthMachine
+class ComplexExample
   include AASM
 
   attr_accessor :activation_code, :activated_at, :deleted_at

data/spec/models/default_state.rb

@@ -0,0 +1,12 @@
+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

data/spec/models/initial_state_proc.rb

@@ -0,0 +1,15 @@
+class InitialStateProc
+  RICH = 1_000_000
+
+  attr_accessor :balance
+
+  include AASM
+  aasm do
+    state :retired
+    state :selling_bad_mortgages
+    initial_state Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
+  end
+
+  def initialize(balance = 0); self.balance = balance; end
+  def rich?; self.balance >= RICH; 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

data/spec/models/{bar.rb → no_initial_state.rb}

@@ -1,4 +1,4 @@
-class Bar
+class NoInitialState
   include AASM
 
   aasm do
@@ -10,6 +10,3 @@ class Bar
     end
   end
 end
-
-class Baz < Bar
-end

data/spec/models/provided_state.rb

@@ -0,0 +1,24 @@
+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

data/spec/models/simple_example.rb

@@ -0,0 +1,15 @@
+class SimpleExample
+  include AASM
+  aasm do
+    state :initialised, :initial => true
+    state :filled_out
+    state :authorised
+
+    event :fill_out do
+      transitions :from => :initialised, :to => :filled_out
+    end
+    event :authorise do
+      transitions :from => :filled_out, :to => :authorised
+    end
+  end
+end

data/spec/models/state_machine_with_failed_event.rb

@@ -0,0 +1,12 @@
+class StateMachineWithFailedEvent
+  include AASM
+
+  aasm do
+    state :init, :initial => true
+    state :failed
+
+    event :failed do
+      transitions :from => :init, :to => :failed
+    end
+  end
+end

data/spec/models/sub_class.rb

@@ -0,0 +1,3 @@
+require_relative 'super_class'
+class SubClass < SuperClass
+end

data/spec/models/sub_class_with_more_states.rb

@@ -0,0 +1,7 @@
+require_relative 'super_class'
+class SubClassWithMoreStates < SuperClass
+  include AASM
+  aasm do
+    state :foo
+  end
+end

data/spec/models/super_class.rb

@@ -0,0 +1,18 @@
+class SuperClass
+  include AASM
+
+  aasm do
+    state :read
+    state :ended
+
+    event :foo do
+      transitions :to => :ended, :from => [:read]
+    end
+  end
+
+  def update_state
+    if may_foo?
+      foo!
+    end
+  end
+end