aasm 3.0.24 → 3.4.0

data/lib/aasm/persistence/sequel_persistence.rb

@@ -0,0 +1,108 @@
+module AASM
+  module Persistence
+    module SequelPersistence
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::SequelPersistence::InstanceMethods)
+      end
+
+      module InstanceMethods
+        def before_validation
+          aasm_ensure_initial_state
+          super
+        end
+
+        def before_create
+          aasm_ensure_initial_state
+          super
+        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
+        #
+        #   class Foo < Sequel::Model
+        #     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[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
+          state = send(self.class.aasm_column)
+          if new? && state.to_s.strip.empty?
+            aasm.determine_state_name(self.class.aasm.initial_state)
+          elsif state.nil?
+            nil
+          else
+            state.to_sym
+          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
+          aasm.enter_initial_state if
+            send(self.class.aasm_column).to_s.strip.empty?
+        end
+
+        # Writes <tt>state</tt> to the state column and persists it to the database
+        #
+        #   foo = Foo[1]
+        #   foo.aasm.current_state # => :opened
+        #   foo.close!
+        #   foo.aasm.current_state # => :closed
+        #   Foo[1].aasm.current_state # => :closed
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state state
+          aasm_column = self.class.aasm_column
+          update_only({aasm_column => state.to_s}, aasm_column)
+        end
+
+        # Writes <tt>state</tt> to the state column, but does not persist it to the database
+        #
+        #   foo = Foo[1]
+        #   foo.aasm.current_state # => :opened
+        #   foo.close
+        #   foo.aasm.current_state # => :closed
+        #   Foo[1].aasm.current_state # => :opened
+        #   foo.save
+        #   foo.aasm.current_state # => :closed
+        #   Foo[1].aasm.current_state # => :closed
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state_without_persistence state
+          send("#{self.class.aasm_column}=", state.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/aasm/persistence.rb

@@ -12,6 +12,9 @@ module AASM
         elsif hierarchy.include?("Mongoid::Document")
           require_files_for(:mongoid)
           base.send(:include, AASM::Persistence::MongoidPersistence)
+        elsif hierarchy.include?("Sequel::Model")
+          require_files_for(:sequel)
+          base.send(:include, AASM::Persistence::SequelPersistence)
         end
       end
 

data/lib/aasm/state.rb

@@ -2,9 +2,9 @@ module AASM
   class State
     attr_reader :name, :options
 
-    def initialize(name, clazz, options={})
+    def initialize(name, klass, options={})
       @name = name
-      @clazz = clazz
+      @klass = klass
       update(options)
     end
 
@@ -48,8 +48,9 @@ module AASM
     end
 
     def localized_name
-      AASM::Localizer.new.human_state_name(@clazz, self)
+      AASM::Localizer.new.human_state_name(@klass, self)
     end
+    alias human_name localized_name
 
     def for_select
       [display_name, name.to_s]

data/lib/aasm/state_machine.rb

@@ -2,20 +2,17 @@ module AASM
   class StateMachine
 
     # the following two methods provide the storage of all state machines
-    def self.[](clazz)
-      (@machines ||= {})[clazz.to_s]
+    def self.[](klass)
+      (@machines ||= {})[klass.to_s]
     end
 
-    def self.[]=(clazz, machine)
-      (@machines ||= {})[clazz.to_s] = machine
+    def self.[]=(klass, machine)
+      (@machines ||= {})[klass.to_s] = machine
     end
 
     attr_accessor :states, :events, :initial_state, :config
-    attr_reader :name
 
-    # QUESTION: what's the name for? [alto, 2012-11-28]
-    def initialize(name)
-      @name = name
+    def initialize
       @initial_state = nil
       @states = []
       @events = {}
@@ -29,8 +26,19 @@ module AASM
       @events = @events.dup
     end
 
-    def add_state(name, clazz, options)
-      @states << AASM::State.new(name, clazz, options) unless @states.include?(name)
+    def add_state(name, klass, options)
+      set_initial_state(name, options)
+
+      # allow reloading, extending or redefining a state
+      @states.delete(name) if @states.include?(name)
+
+      @states << AASM::State.new(name, klass, options)
+    end
+
+    private
+
+    def set_initial_state(name, options)
+      @initial_state = name if options[:initial] || !initial_state
     end
 
   end # StateMachine

data/lib/aasm/transition.rb

@@ -4,20 +4,24 @@ module AASM
     alias_method :options, :opts
 
     def initialize(opts)
-      @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
+      @from = opts[:from]
+      @to = opts[:to]
+      @guards = Array(opts[:guard] || opts[:guards])
+      @on_transition = opts[:on_transition]
       @opts = opts
     end
 
     # TODO: should be named allowed? or similar
     def perform(obj, *args)
-      case @guard
+      @guards.each do |guard|
+        case guard
         when Symbol, String
-          obj.send(@guard, *args)
+          return false unless obj.send(guard, *args)
         when Proc
-          @guard.call(obj, *args)
-        else
-          true
+          return false unless guard.call(obj, *args)
+        end
       end
+      true
     end
 
     def execute(obj, *args)
@@ -37,6 +41,9 @@ module AASM
     private
 
     def _execute(obj, on_transition, *args)
+      obj.aasm.from_state = @from if obj.aasm.respond_to?(:from_state=)
+      obj.aasm.to_state = @to if obj.aasm.respond_to?(:to_state=)
+
       case on_transition
       when Proc
         on_transition.arity == 0 ? on_transition.call : on_transition.call(obj, *args)

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.0.24"
+  VERSION = "3.4.0"
 end

data/lib/aasm.rb

@@ -13,6 +13,3 @@ require 'ostruct'
     persistence
     aasm
   ).each { |file| require File.join(File.dirname(__FILE__), 'aasm', file) }
-
-# load the deprecated methods and modules
-Dir[File.join(File.dirname(__FILE__), 'aasm', 'deprecated', '*.rb')].sort.each { |f| require File.expand_path(f) }

data/spec/database.rb

@@ -0,0 +1,33 @@
+ActiveRecord::Migration.suppress_messages do
+  %w{gates readers writers transients simples simple_new_dsls no_scopes thieves localizer_test_models persisted_states provided_and_persisted_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 "validators", :force => true do |t|
+    t.string "name"
+    t.string "status"
+  end
+
+  ActiveRecord::Migration.create_table "transactors", :force => true do |t|
+    t.string "name"
+    t.string "status"
+    t.integer "worker_id"
+  end
+
+  ActiveRecord::Migration.create_table "workers", :force => true do |t|
+    t.string "name"
+    t.string "status"
+  end
+
+  ActiveRecord::Migration.create_table "invalid_persistors", :force => true do |t|
+    t.string "name"
+    t.string "status"
+  end
+
+  ActiveRecord::Migration.create_table "fathers", :force => true do |t|
+    t.string "aasm_state"
+    t.string "type"
+  end
+end

data/spec/models/double_definer.rb

@@ -0,0 +1,21 @@
+class DoubleDefiner
+  include AASM
+
+  aasm do
+    state :started
+    state :finished
+
+    event :finish do
+      transitions :from => :started, :to => :finished
+    end
+
+    # simulating a reload
+    state :finished, :enter => :do_enter
+    event :finish do
+      transitions :from => :started, :to => :finished, :on_transition => :do_on_transition
+    end
+  end
+
+  def do_enter; end
+  def do_on_transition; end
+end

data/spec/models/foo.rb

@@ -3,13 +3,14 @@ class Foo
   aasm do
     state :open, :initial => true, :exit => :exit
     state :closed, :enter => :enter
+    state :final
 
     event :close, :success => :success_callback do
       transitions :from => [:open], :to => [:closed]
     end
 
     event :null do
-      transitions :from => [:open], :to => :closed, :guard => :always_false
+      transitions :from => [:open], :to => [:closed, :final], :guard => :always_false
     end
   end
 

data/spec/models/guardian.rb

@@ -0,0 +1,48 @@
+class Guardian
+  include AASM
+
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+
+    event :use_one_guard_that_succeeds do
+      transitions :from => :alpha, :to => :beta, :guard => :succeed
+    end
+    event :use_one_guard_that_fails do
+      transitions :from => :alpha, :to => :beta, :guard => :fail
+    end
+
+    event :use_guards_that_succeed do
+      transitions :from => :alpha, :to => :beta, :guards => [:succeed, :another_succeed]
+    end
+    event :use_guards_where_the_first_fails do
+      transitions :from => :alpha, :to => :beta, :guards => [:succeed, :fail]
+    end
+    event :use_guards_where_the_second_fails do
+      transitions :from => :alpha, :to => :beta, :guards => [:fail, :succeed]
+    end
+
+    event :use_event_guards_that_succeed, :guards => [:succeed, :another_succeed] do
+      transitions :from => :alpha, :to => :beta
+    end
+    event :use_event_and_transition_guards_that_succeed, :guards => [:succeed, :another_succeed] do
+      transitions :from => :alpha, :to => :beta, :guards => [:more_succeed]
+    end
+    event :use_event_guards_where_the_first_fails, :guards => [:succeed, :fail] do
+      transitions :from => :alpha, :to => :beta
+    end
+    event :use_event_guards_where_the_second_fails, :guards => [:fail, :succeed] do
+      transitions :from => :alpha, :to => :beta, :guard => :another_succeed
+    end
+    event :use_event_and_transition_guards_where_third_fails, :guards => [:succeed, :another_succeed] do
+      transitions :from => :alpha, :to => :beta, :guards => [:fail]
+    end
+  end
+
+  def fail; false; end
+
+  def succeed; true; end
+  def another_succeed; true; end
+  def more_succeed; true; end
+
+end

data/spec/models/mongoid/no_scope_mongoid.rb

@@ -2,7 +2,7 @@ class NoScopeMongoid
   include Mongoid::Document
   include AASM
 
-  field :status, type: String
+  field :status, :type => String
 
   aasm :create_scopes => false, :column => :status do
     state :ignored_scope

data/spec/models/mongoid/simple_mongoid.rb

@@ -2,9 +2,10 @@ class SimpleMongoid
   include Mongoid::Document
   include AASM
 
-  field :status, type: String
+  field :status, :type => String
 
-  aasm_column :status
-  aasm_state :unknown_scope
-  aasm_state :new
+  aasm column: :status do
+    state :unknown_scope
+    state :new
+  end
 end

data/spec/models/mongoid/simple_new_dsl_mongoid.rb

@@ -2,7 +2,7 @@ class SimpleNewDslMongoid
   include Mongoid::Document
   include AASM
 
-  field :status, type: String
+  field :status, :type => String
 
   aasm :column => :status
   aasm do

data/spec/models/not_auto_loaded/process.rb

@@ -2,16 +2,18 @@ module Models
   class Process
     include AASM
 
-    aasm_state :sleeping
-    aasm_state :running
-    aasm_state :suspended
+    aasm do
+      state :sleeping
+      state :running
+      state :suspended
 
-    aasm_event :start do
-      transitions :from => :sleeping, :to => :running
-    end
+      event :start do
+        transitions :from => :sleeping, :to => :running
+      end
 
-    aasm_event :stop do
-      transitions :from => :running, :to => :suspended
+      event :stop do
+        transitions :from => :running, :to => :suspended
+      end
     end
 
   end

data/spec/models/persistence.rb

@@ -36,13 +36,6 @@ class Transient < ActiveRecord::Base
   include AASM
 end
 
-class Simple < ActiveRecord::Base
-  include AASM
-  aasm_column :status
-  aasm_state :unknown_scope
-  aasm_state :new
-end
-
 class SimpleNewDsl < ActiveRecord::Base
   include AASM
   aasm :column => :status
@@ -59,9 +52,6 @@ class NoScope < ActiveRecord::Base
   end
 end
 
-class Derivate < Simple
-end
-
 class DerivateNewDsl < SimpleNewDsl
 end
 
@@ -72,8 +62,10 @@ class Thief < ActiveRecord::Base
     set_table_name "thieves"
   end
   include AASM
-  aasm_initial_state  Proc.new { |thief| thief.skilled ? :rich : :jailed }
-  aasm_state          :rich
-  aasm_state          :jailed
+  aasm do
+    state :rich
+    state :jailed
+    initial_state Proc.new {|thief| thief.skilled ? :rich : :jailed }
+  end
   attr_accessor :skilled, :aasm_state
 end

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
   ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
   ActiveRecord::Base.establish_connection(config['sqlite3'])
-  load(File.dirname(__FILE__) + "/schema.rb")
+  require File.dirname(__FILE__) + "/database.rb"
 end
 
 # custom spec helpers

data/spec/unit/api_spec.rb

@@ -3,19 +3,19 @@ require 'models/active_record/api.rb'
 
 describe "reading the current state" do
   it "uses the AASM default" do
-    DefaultState.new.aasm.current_state.should eql :alpha
+    expect(DefaultState.new.aasm.current_state).to eql :alpha
   end
 
   it "uses the provided method" do
-    ProvidedState.new.aasm.current_state.should eql :beta
+    expect(ProvidedState.new.aasm.current_state).to eql :beta
   end
 
   it "uses the persistence storage" do
-    PersistedState.new.aasm.current_state.should eql :alpha
+    expect(PersistedState.new.aasm.current_state).to eql :alpha
   end
 
   it "uses the provided method even if persisted" do
-    ProvidedAndPersistedState.new.aasm.current_state.should eql :gamma
+    expect(ProvidedAndPersistedState.new.aasm.current_state).to eql :gamma
   end
 end
 
@@ -23,25 +23,25 @@ describe "writing and persisting the current state" do
   it "uses the AASM default" do
     o = DefaultState.new
     o.release!
-    o.persisted_store.should be_nil
+    expect(o.persisted_store).to be_nil
   end
 
   it "uses the provided method" do
     o = ProvidedState.new
     o.release!
-    o.persisted_store.should eql :beta
+    expect(o.persisted_store).to eql :beta
   end
 
   it "uses the persistence storage" do
     o = PersistedState.new
     o.release!
-    o.persisted_store.should be_nil
+    expect(o.persisted_store).to be_nil
   end
 
   it "uses the provided method even if persisted" do
     o = ProvidedAndPersistedState.new
     o.release!
-    o.persisted_store.should eql :beta
+    expect(o.persisted_store).to eql :beta
   end
 end
 
@@ -49,24 +49,24 @@ describe "writing the current state without persisting it" do
   it "uses the AASM default" do
     o = DefaultState.new
     o.release
-    o.transient_store.should be_nil
+    expect(o.transient_store).to be_nil
   end
 
   it "uses the provided method" do
     o = ProvidedState.new
     o.release
-    o.transient_store.should eql :beta
+    expect(o.transient_store).to eql :beta
   end
 
   it "uses the persistence storage" do
     o = PersistedState.new
     o.release
-    o.transient_store.should be_nil
+    expect(o.transient_store).to be_nil
   end
 
   it "uses the provided method even if persisted" do
     o = ProvidedAndPersistedState.new
     o.release
-    o.transient_store.should eql :beta
+    expect(o.transient_store).to eql :beta
   end
 end