runcoderun-aasm 2.0.2.2 → 2.0.2.3

data/CHANGELOG

@@ -1,3 +1,5 @@
+* call the :success callback for non-persistent state machines in addition to persistent ones [Rob Sanheim]
+
 * In AR persistence, move state column from class level variables into the StateMachine object for the class
 
 * allowed :to array and :on_transition callback [Kevin Triplett]

data/README.rdoc

@@ -31,7 +31,7 @@ A release and a gem are forthcoming.
 === Building your own gems
 
   % rake gem
-  % sudo gem install pkg/aasm-2.0.2.gem
+  % sudo gem install pkg/aasm-2.0.1.gem
 
 
 == Simple Example
@@ -44,51 +44,19 @@ Here's a quick example highlighting some of the features.
     aasm_initial_state :new
 
     aasm_state :new
-    aasm_state :read, :enter => :mark_thread_as_read
+    aasm_state :read
     aasm_state :closed
 
 
     aasm_event :view do
-      # Transitions can take an optional on_transition option to execute some logic when the event is happening.
-      # It can take a single string or symbol (denoting a method), an array of string or symbols
-      # (denoting several methods), or an inline lambda
-      transitions :to => :read, :from => [:new], :on_transition => :set_last_read_at, :guard => :user_authorized
+      transitions :to => :read, :from => [:new]
     end
 
     aasm_event :close do
       transitions :to => :closed, :from => [:read, :new]
     end
-    
-    # Update last_read_at timestamp when the conversation is viewed
-    def set_last_read_at
-      self.last_read_at = Time.now
-    end
-    
   end
 
-
-== Explanation of transitions
-
-The current state machine has the following process. If we were to call 
-<tt>Conversation#view!</tt>, we would get:
-
-     state:new
-         |
-         | <-- :exit called on state[new]
-         |
-         | <-- :guard called on state[read]
-         |
-         | <-- :on_transition called on state[read]
-         |
-         | <-- aasm_current_state set to "read"
-         |
-         | <-- :success called on state[read]
-         |
-         | <-- :enter called on state[read]
-         |
-     state:read
-
-
 = Other Stuff
 
 Author::  Scott Barron <scott at elitists dot net>

data/Rakefile

@@ -14,7 +14,7 @@ rescue Exception
   nil
 end
 
-if `ruby -Ilib -rversion -e "print AASM::VERSION::STRING"` =~ /([0-9.]+)$/
+if `ruby -Ilib -raasm -e "print AASM.Version"` =~ /([0-9.]+)$/
   CURRENT_VERSION = $1
 else
   CURRENT_VERSION = '0.0.0'
@@ -23,8 +23,7 @@ $package_version = CURRENT_VERSION
 
 PKG_FILES = FileList['[A-Z]*',
 'lib/**/*.rb',
-'doc/**/*',
-'spec/**/*'
+'doc/**/*'
 ]
 
 desc 'Generate documentation for the acts as state machine plugin.'

data/lib/aasm.rb

@@ -4,6 +4,10 @@ require File.join(File.dirname(__FILE__), 'state_machine')
 require File.join(File.dirname(__FILE__), 'persistence')
 
 module AASM
+  def self.Version
+    '2.0.2.3'
+  end
+
   class InvalidTransition < RuntimeError
   end
   
@@ -14,15 +18,14 @@ module AASM
     base.extend AASM::ClassMethods
     AASM::Persistence.set_persistence(base)
     AASM::StateMachine[base] = AASM::StateMachine.new('')
-
-    base.class_eval do
-      def base.inherited(klass)
-        AASM::StateMachine[klass] = AASM::StateMachine[self].dup
-      end
-    end
   end
 
   module ClassMethods
+    def inherited(klass)
+      AASM::StateMachine[klass] = AASM::StateMachine[self].dup
+      super
+    end
+
     def aasm_initial_state(set_state=nil)
       if set_state
         AASM::StateMachine[self].initial_state = set_state
@@ -96,11 +99,14 @@ module AASM
   end
 
   private
-  def aasm_current_state_with_persistence=(state)
+  def set_aasm_current_state_with_persistence(state)
+    save_success = true
     if self.respond_to?(:aasm_write_state) || self.private_methods.include?('aasm_write_state')
-      aasm_write_state(state)
+      save_success = aasm_write_state(state)
     end
-    self.aasm_current_state = state
+    self.aasm_current_state = state if save_success
+
+    save_success
   end
 
   def aasm_current_state=(state)
@@ -120,21 +126,24 @@ module AASM
     new_state = self.class.aasm_events[name].fire(self, *args)
     
     unless new_state.nil?
+      aasm_state_object_for_state(new_state).call_action(:enter, self)
+      
+      persist_successful = true
       if persist
-        self.aasm_current_state_with_persistence = new_state
+        persist_successful = set_aasm_current_state_with_persistence(new_state)
+        self.class.aasm_events[name].execute_success_callback(self) if persist_successful
       else
         self.aasm_current_state = new_state
+        self.class.aasm_events[name].execute_success_callback(self)
       end
-      
-      self.send(self.class.aasm_events[name].success) if self.class.aasm_events[name].success
-      
-      aasm_state_object_for_state(new_state).call_action(:enter, self)
-      
-      if self.respond_to?(:aasm_event_fired)
-        self.aasm_event_fired(self.aasm_current_state, new_state)
+
+      if persist_successful 
+        self.aasm_event_fired(self.aasm_current_state, new_state) if self.respond_to?(:aasm_event_fired)
+      else
+        self.aasm_event_failed(name) if self.respond_to?(:aasm_event_failed)
       end
 
-      true
+      persist_successful
     else
       if self.respond_to?(:aasm_event_failed)
         self.aasm_event_failed(name)

data/lib/event.rb

@@ -32,6 +32,17 @@ module AASM
         @transitions.any? { |t| t.from == state }
       end
       
+      def execute_success_callback(obj)
+        case success
+        when String, Symbol:
+          obj.send(success)
+        when Array:
+          success.each { |meth| obj.send(meth) }
+        when Proc:
+          success.call(obj)
+        end
+      end
+
       private
       def transitions(trans_opts)
         Array(trans_opts[:from]).each do |s|

data/lib/persistence/active_record_persistence.rb

@@ -188,7 +188,15 @@ module AASM
         #
         # NOTE: intended to be called from an event
         def aasm_write_state(state)
-          update_attribute(self.class.aasm_column, state.to_s)
+          old_value = read_attribute(self.class.aasm_column)
+          write_attribute(self.class.aasm_column, state.to_s)
+          
+          unless self.save
+            write_attribute(self.class.aasm_column, old_value)
+            return false
+          end
+          
+          true
         end
       end
 

data/lib/state_transition.rb

@@ -21,8 +21,6 @@ module AASM
       
       def execute(obj, *args)
         case @on_transition
-        when Array
-          @on_transition.each { |t| obj.send(t, *args) }
         when Symbol, String
           obj.send(@on_transition, *args)
         when Proc

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: runcoderun-aasm
 version: !ruby/object:Gem::Version 
-  version: 2.0.2.2
+  version: 2.0.2.3
 platform: ruby
 authors: 
 - Scott Barron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -07:00
+date: 2008-10-09 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +30,6 @@ files:
 - Rakefile
 - README.rdoc
 - TODO
-- aasm.gemspec
 - lib/aasm.rb
 - lib/event.rb
 - lib/persistence/active_record_persistence.rb
@@ -40,16 +39,6 @@ files:
 - lib/state_transition.rb
 - lib/version.rb
 - doc/jamis.rb
-- spec/functional
-- spec/functional/conversation.rb
-- spec/functional/conversation_spec.rb
-- spec/spec_helper.rb
-- spec/unit
-- spec/unit/aasm_spec.rb
-- spec/unit/active_record_persistence_spec.rb
-- spec/unit/event_spec.rb
-- spec/unit/state_spec.rb
-- spec/unit/state_transition_spec.rb
 has_rdoc: true
 homepage: http://github.com/rubyist/aasm
 post_install_message: 

data/aasm.gemspec

@@ -1,19 +0,0 @@
-PKG_FILES = ["CHANGELOG", "MIT-LICENSE", "Rakefile", "README.rdoc", "TODO", "aasm.gemspec", "lib/aasm.rb", "lib/event.rb", "lib/persistence/active_record_persistence.rb", "lib/persistence.rb", "lib/state.rb", "lib/state_machine.rb", "lib/state_transition.rb", "lib/version.rb", "doc/jamis.rb", "spec/functional", "spec/functional/conversation.rb", "spec/functional/conversation_spec.rb", "spec/spec_helper.rb", "spec/unit", "spec/unit/aasm_spec.rb", "spec/unit/active_record_persistence_spec.rb", "spec/unit/event_spec.rb", "spec/unit/state_spec.rb", "spec/unit/state_transition_spec.rb"]
-
-Gem::Specification.new do |s|
-  s.name = 'aasm'
-  s.version = "2.0.2.2"
-  s.summary = 'State machine mixin for Ruby objects'
-  s.description = <<-EOF
-AASM is a continuation of the acts as state machine rails plugin, built for plain Ruby objects.
-EOF
-  s.files = PKG_FILES
-  s.require_path = 'lib'
-  s.has_rdoc = true
-  s.extra_rdoc_files = ['README.rdoc', 'MIT-LICENSE', 'TODO', 'CHANGELOG']
-  s.rdoc_options = ['--line-numbers', '--inline-source', '--main', 'README.rdoc', '--title', 'AASM']
-  
-  s.author = 'Scott Barron'
-  s.email = 'scott@elitists.net'
-  s.homepage = 'http://github.com/rubyist/aasm'
-end

data/lib/version.rb

@@ -1,5 +0,0 @@
-module AASM
-  module VERSION
-    STRING = '2.0.2.2'
-  end
-end

data/spec/functional/conversation.rb

@@ -1,49 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'aasm')
-
-class Conversation
-  include AASM
-
-  aasm_initial_state :needs_attention
-
-  aasm_state :needs_attention
-  aasm_state :read
-  aasm_state :closed
-  aasm_state :awaiting_response
-  aasm_state :junk
-
-  aasm_event :new_message do
-  end
-
-  aasm_event :view do
-    transitions :to => :read, :from => [:needs_attention]
-  end
-
-  aasm_event :reply do
-  end
-
-  aasm_event :close do
-    transitions :to => :closed, :from => [:read, :awaiting_response]
-  end
-
-  aasm_event :junk do
-    transitions :to => :junk, :from => [:read]
-  end
-
-  aasm_event :unjunk do
-  end
-
-  def initialize(persister)
-    @persister = persister
-  end
-
-
-  private
-  def aasm_read_state
-    @persister.read_state
-  end
-
-  def aasm_write_state(state)
-    @persister.write_state(state)
-  end
-
-end

data/spec/functional/conversation_spec.rb

@@ -1,5 +0,0 @@
-describe Conversation, 'description' do
-  it '.aasm_states should contain all of the states' do
-    Conversation.aasm_states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
-  end
-end

data/spec/spec_helper.rb

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'aasm')

data/spec/unit/aasm_spec.rb

@@ -1,360 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-class Foo
-  include AASM
-  aasm_initial_state :open
-  aasm_state :open, :exit => :exit
-  aasm_state :closed, :enter => :enter
-
-  aasm_event :close, :success => :success_callback do
-    transitions :to => :closed, :from => [:open]
-  end
-
-  aasm_event :null do
-    transitions :to => :closed, :from => [:open], :guard => :always_false
-  end
-
-  def always_false
-    false
-  end
-
-  def success_callback
-  end
-
-  def enter
-  end
-  def exit
-  end
-end
-
-class Bar
-  include AASM
-
-  aasm_state :read
-  aasm_state :ended
-
-  aasm_event :foo do
-    transitions :to => :ended, :from => [:read]
-  end
-end
-
-class Baz < Bar
-end
-
-
-describe AASM, '- class level definitions' do
-  it 'should define a class level aasm_initial_state() method on its including class' do
-    Foo.should respond_to(:aasm_initial_state)
-  end
-
-  it 'should define a class level aasm_state() method on its including class' do
-    Foo.should respond_to(:aasm_state)
-  end
-
-  it 'should define a class level aasm_event() method on its including class' do
-    Foo.should respond_to(:aasm_event)
-  end
-  
-  it 'should define a class level aasm_states() method on its including class' do
-    Foo.should respond_to(:aasm_states)
-  end
-  
-  it 'should define a class level aasm_states_for_select() method on its including class' do
-    Foo.should respond_to(:aasm_states_for_select)
-  end
-
-  it 'should define a class level aasm_events() method on its including class' do
-    Foo.should respond_to(:aasm_events)
-  end
-
-end
-
-
-describe AASM, '- aasm_states_for_select' do
-  it "should return a select friendly array of states in the form of [['Friendly name', 'state_name']]" do
-    Foo.aasm_states_for_select.should == [['Open', 'open'], ['Closed', 'closed']]
-  end
-end
-
-describe AASM, '- instance level definitions' do
-  before(:each) do
-    @foo = Foo.new
-  end
-
-  it 'should define a state querying instance method on including class' do
-    @foo.should respond_to(:open?)
-  end
-
-  it 'should define an event! inance method' do
-    @foo.should respond_to(:close!)
-  end
-end
-
-describe AASM, '- initial states' do
-  before(:each) do
-    @foo = Foo.new
-    @bar = Bar.new
-  end
-
-  it 'should set the initial state' do
-    @foo.aasm_current_state.should == :open
-  end
-
-  it '#open? should be initially true' do
-    @foo.open?.should be_true
-  end
-
-  it '#closed? should be initially false' do
-    @foo.closed?.should be_false
-  end
-
-  it 'should use the first state defined if no initial state is given' do
-    @bar.aasm_current_state.should == :read
-  end
-end
-
-describe AASM, '- event firing with persistence' do
-  it 'should fire the Event' do
-    foo = Foo.new
-
-    Foo.aasm_events[:close].should_receive(:fire).with(foo)
-    foo.close!
-  end
-
-  it 'should update the current state' do
-    foo = Foo.new
-    foo.close!
-
-    foo.aasm_current_state.should == :closed
-  end
-
-  it 'should call the success callback if one was provided' do
-    foo = Foo.new
-
-    foo.should_receive(:success_callback)
-
-    foo.close!
-  end
-
-  it 'should attempt to persist if aasm_write_state is defined' do
-    foo = Foo.new
-    
-    def foo.aasm_write_state
-    end
-
-    foo.should_receive(:aasm_write_state)
-
-    foo.close!
-  end
-end
-
-describe AASM, '- event firing without persistence' do
-  it 'should fire the Event' do
-    foo = Foo.new
-
-    Foo.aasm_events[:close].should_receive(:fire).with(foo)
-    foo.close
-  end
-
-  it 'should update the current state' do
-    foo = Foo.new
-    foo.close
-
-    foo.aasm_current_state.should == :closed
-  end
-
-  it 'should attempt to persist if aasm_write_state is defined' do
-    foo = Foo.new
-    
-    def foo.aasm_write_state
-    end
-
-    foo.should_receive(:aasm_write_state_without_persistence)
-
-    foo.close
-  end
-end
-
-describe AASM, '- persistence' do
-  it 'should read the state if it has not been set and aasm_read_state is defined' do
-    foo = Foo.new
-    def foo.aasm_read_state
-    end
-
-    foo.should_receive(:aasm_read_state)
-
-    foo.aasm_current_state
-  end
-end
-
-describe AASM, '- getting events for a state' do
-  it '#aasm_events_for_current_state should use current state' do
-    foo = Foo.new
-    foo.should_receive(:aasm_current_state)
-    foo.aasm_events_for_current_state
-  end
-
-  it '#aasm_events_for_current_state should use aasm_events_for_state' do
-    foo = Foo.new
-    foo.stub!(:aasm_current_state).and_return(:foo)
-    foo.should_receive(:aasm_events_for_state).with(:foo)
-    foo.aasm_events_for_current_state
-  end
-end
-
-describe AASM, '- event callbacks' do
-  it 'should call aasm_event_fired if defined and successful for bang fire' do
-    foo = Foo.new
-    def foo.aasm_event_fired(from, to)
-    end
-
-    foo.should_receive(:aasm_event_fired)
-
-    foo.close!
-  end
-
-    it 'should call aasm_event_fired if defined and successful for non-bang fire' do
-    foo = Foo.new
-    def foo.aasm_event_fired(from, to)
-    end
-
-    foo.should_receive(:aasm_event_fired)
-
-    foo.close
-  end
-
-  it 'should call aasm_event_failed if defined and transition failed for bang fire' do
-    foo = Foo.new
-    def foo.aasm_event_failed(event)
-    end
-
-    foo.should_receive(:aasm_event_failed)
-
-    foo.null!
-  end
-
-  it 'should call aasm_event_failed if defined and transition failed for non-bang fire' do
-    foo = Foo.new
-    def foo.aasm_event_failed(event)
-    end
-
-    foo.should_receive(:aasm_event_failed)
-
-    foo.null
-  end
-end
-
-describe AASM, '- state actions' do
-  it "should call enter when entering state" do
-    foo = Foo.new
-    foo.should_receive(:enter)
-
-    foo.close
-  end
-
-  it "should call exit when exiting state" do
-    foo = Foo.new
-    foo.should_receive(:exit)
-
-    foo.close
-  end
-end
-
-
-describe Baz do
-  it "should have the same states as it's parent" do
-    Baz.aasm_states.should == Bar.aasm_states
-  end
-
-  it "should have the same events as it's parent" do
-    Baz.aasm_events.should == Bar.aasm_events
-  end
-end
-
-
-class ChetanPatil
-  include AASM
-  aasm_initial_state :sleeping
-  aasm_state :sleeping
-  aasm_state :showering
-  aasm_state :working
-  aasm_state :dating
-
-  aasm_event :wakeup do
-    transitions :from => :sleeping, :to => [:showering, :working]
-  end
-
-  aasm_event :dress do
-    transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
-    transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
-  end
-  
-  aasm_event :go_to_bed do
-    transitions :from => [:working, :dating], :to => :sleeping, :on_transition => [:take_off_clothes, :brush_teeth]
-  end
-
-  def wear_clothes(shirt_color, trouser_type)
-  end
-  
-  def take_off_clothes
-  end
-  
-  def brush_teeth
-  end
-end
-
-
-describe ChetanPatil do
-  it 'should transition to specified next state (sleeping to showering)' do
-    cp = ChetanPatil.new
-    cp.wakeup! :showering
-    
-    cp.aasm_current_state.should == :showering
-  end
-
-  it 'should transition to specified next state (sleeping to working)' do
-    cp = ChetanPatil.new
-    cp.wakeup! :working
-
-    cp.aasm_current_state.should == :working
-  end
-
-  it 'should transition to default (first or showering) state' do
-    cp = ChetanPatil.new
-    cp.wakeup!
-
-    cp.aasm_current_state.should == :showering
-  end
-
-  it 'should transition to default state when on_transition invoked' do
-    cp = ChetanPatil.new
-    cp.dress!(nil, 'purple', 'dressy')
-
-    cp.aasm_current_state.should == :working
-  end
-
-  it 'should call on_transition method with args' do
-    cp = ChetanPatil.new
-    cp.wakeup! :showering
-
-    cp.should_receive(:wear_clothes).with('blue', 'jeans')
-    cp.dress! :working, 'blue', 'jeans'
-  end
-
-  it 'should call on_transition proc' do
-    cp = ChetanPatil.new
-    cp.wakeup! :showering
-
-    cp.should_receive(:wear_clothes).with('purple', 'slacks')
-    cp.dress!(:dating, 'purple', 'slacks')
-  end
-  
-  it 'should call all on_transition methods if its an array' do
-    cp = ChetanPatil.new
-    cp.dress! :working, 'purple', 'slacks'
-    
-    cp.should_receive(:take_off_clothes)
-    cp.should_receive(:brush_teeth)
-    cp.go_to_bed!
-  end
-end

data/spec/unit/active_record_persistence_spec.rb

@@ -1,212 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'aasm')
-
-begin
-  require 'rubygems'
-  require 'active_record'
-
-  # A dummy class for mocking the activerecord connection class
-  class Connection
-  end
-
-  class FooBar < ActiveRecord::Base
-    include AASM
-
-    # Fake this column for testing purposes
-    attr_accessor :aasm_state
-
-    aasm_state :open
-    aasm_state :closed
-
-    aasm_event :view do
-      transitions :to => :read, :from => [:needs_attention]
-    end
-  end
-
-  class Fi < ActiveRecord::Base
-    def aasm_read_state
-      "fi"
-    end    
-    include AASM
-  end
-
-  class Fo < ActiveRecord::Base
-    def aasm_write_state(state)
-      "fo"
-    end    
-    include AASM
-  end
-
-  class Fum < ActiveRecord::Base
-    def aasm_write_state_without_persistence(state)
-      "fum"
-    end    
-    include AASM
-  end
-
-  class June < ActiveRecord::Base
-    include AASM
-    aasm_column :status
-  end
-  
-  class Beaver < June
-  end
-
-  describe "aasm model", :shared => true do
-    it "should include AASM::Persistence::ActiveRecordPersistence" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::InstanceMethods" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
-    end    
-  end
-
-  describe FooBar, "class methods" do
-    before(:each) do
-      @klass = FooBar
-    end
-    it_should_behave_like "aasm model"
-    it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::WriteState" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
-    end    
-  end
-
-  describe Fi, "class methods" do
-    before(:each) do
-      @klass = Fi
-    end
-    it_should_behave_like "aasm model"
-    it "should not include AASM::Persistence::ActiveRecordPersistence::ReadState" do
-      @klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::WriteState" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
-    end    
-  end
-
-  describe Fo, "class methods" do
-    before(:each) do
-      @klass = Fo
-    end
-    it_should_behave_like "aasm model"
-    it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
-    end    
-    it "should not include AASM::Persistence::ActiveRecordPersistence::WriteState" do
-      @klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
-    end    
-  end
-
-  describe Fum, "class methods" do
-    before(:each) do
-      @klass = Fum
-    end
-    it_should_behave_like "aasm model"
-    it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
-    end    
-    it "should include AASM::Persistence::ActiveRecordPersistence::WriteState" do
-      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
-    end    
-    it "should not include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
-      @klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
-    end    
-  end
-
-  describe FooBar, "instance methods" do
-    before(:each) do
-      connection = mock(Connection, :columns => [])
-      FooBar.stub!(:connection).and_return(connection)
-    end
-
-    it "should respond to aasm read state when not previously defined" do
-      FooBar.new.should respond_to(:aasm_read_state)
-    end
-
-    it "should respond to aasm write state when not previously defined" do
-      FooBar.new.should respond_to(:aasm_write_state)
-    end
-
-    it "should respond to aasm write state without persistence when not previously defined" do
-      FooBar.new.should respond_to(:aasm_write_state_without_persistence)
-    end
-
-    it "should return the initial state when new and the aasm field is nil" do
-      FooBar.new.aasm_current_state.should == :open
-    end
-
-    it "should return the aasm column when new and the aasm field is not nil" do
-      foo = FooBar.new
-      foo.aasm_state = "closed"
-      foo.aasm_current_state.should == :closed
-    end
-
-    it "should return the aasm column when not new and the aasm_column is not nil" do
-      foo = FooBar.new
-      foo.stub!(:new_record?).and_return(false)
-      foo.aasm_state = "state"
-      foo.aasm_current_state.should == :state
-    end
-
-    it "should allow a nil state" do
-      foo = FooBar.new
-      foo.stub!(:new_record?).and_return(false)
-      foo.aasm_state = nil
-      foo.aasm_current_state.should be_nil
-    end
-
-    it "should have aasm_ensure_initial_state" do
-      foo = FooBar.new
-      foo.send :aasm_ensure_initial_state
-    end
-
-    it "should call aasm_ensure_initial_state on validation before create" do
-      foo = FooBar.new
-      foo.should_receive(:aasm_ensure_initial_state).and_return(true)
-      foo.valid?
-    end
-
-    it "should call aasm_ensure_initial_state on validation before create" do
-      foo = FooBar.new
-      foo.stub!(:new_record?).and_return(false)
-      foo.should_not_receive(:aasm_ensure_initial_state)
-      foo.valid?
-    end
-    
-  end
-
-  describe 'Beavers' do
-    it "should have the same states as it's parent" do
-      Beaver.aasm_states.should == June.aasm_states
-    end
-    
-    it "should have the same events as it's parent" do
-      Beaver.aasm_events.should == June.aasm_events
-    end
-    
-    it "should have the same column as it's parent" do
-      Beaver.aasm_column.should == :status
-    end
-  end
-  
-
-  # TODO: figure out how to test ActiveRecord reload! without a database
-
-rescue LoadError => e
-  if e.message == "no such file to load -- active_record"
-    puts "You must install active record to run this spec.  Install with sudo gem install activerecord"
-  else
-    raise
-  end
-end

data/spec/unit/event_spec.rb

@@ -1,51 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe AASM::SupportingClasses::Event do
-  before(:each) do
-    @name = :close_order
-    @success = :success_callback
-  end
-
-  def new_event
-    @event = AASM::SupportingClasses::Event.new(@name, {:success => @success}) do
-      transitions :to => :closed, :from => [:open, :received]
-    end
-  end
-
-  it 'should set the name' do
-    new_event
-    @event.name.should == @name
-  end
-
-  it 'should set the success option' do
-    new_event
-    @event.success.should == @success
-  end
-
-  it 'should create StateTransitions' do
-    AASM::SupportingClasses::StateTransition.should_receive(:new).with({:to => :closed, :from => :open})
-    AASM::SupportingClasses::StateTransition.should_receive(:new).with({:to => :closed, :from => :received})
-    new_event
-  end
-end
-
-describe AASM::SupportingClasses::Event, 'when firing an event' do
-  it 'should raise an AASM::InvalidTransition error if the transitions are empty' do
-    obj = mock('object')
-    obj.stub!(:aasm_current_state)
-
-    event = AASM::SupportingClasses::Event.new(:event)
-    lambda { event.fire(obj) }.should raise_error(AASM::InvalidTransition)
-  end
-
-  it 'should return the state of the first matching transition it finds' do
-    event = AASM::SupportingClasses::Event.new(:event) do
-      transitions :to => :closed, :from => [:open, :received]
-    end
-
-    obj = mock('object')
-    obj.stub!(:aasm_current_state).and_return(:open)
-
-    event.fire(obj).should == :closed
-  end
-end

data/spec/unit/state_spec.rb

@@ -1,62 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-# TODO These are specs ported from original aasm
-describe AASM::SupportingClasses::State do
-  before(:each) do
-    @name    = :astate
-    @options = { :crazy_custom_key => 'key' }
-  end
-
-  def new_state(options={})
-    AASM::SupportingClasses::State.new(@name, @options.merge(options))
-  end
-
-  it 'should set the name' do
-    state = new_state
-
-    state.name.should == :astate
-  end
-  
-  it 'should set the options and expose them as options' do
-    state = new_state
-    
-    state.options.should == @options
-  end
-
-  it 'should be equal to a symbol of the same name' do
-    state = new_state
-
-    state.should == :astate
-  end
-
-  it 'should be equal to a State of the same name' do
-    new_state.should == new_state
-  end
-
-  it 'should send a message to the record for an action if the action is present as a symbol' do
-    state = new_state(:entering => :foo)
-
-    record = mock('record')
-    record.should_receive(:foo)
-
-    state.call_action(:entering, record)
-  end
-
-  it 'should send a message to the record for an action if the action is present as a string' do
-    state = new_state(:entering => 'foo')
-
-    record = mock('record')
-    record.should_receive(:foo)
-
-    state.call_action(:entering, record)
-  end
-
-  it 'should call a proc, passing in the record for an action if the action is present' do
-    state = new_state(:entering => Proc.new {|r| r.foobar})
-
-    record = mock('record')
-    record.should_receive(:foobar)
-    
-    state.call_action(:entering, record)
-  end
-end

data/spec/unit/state_transition_spec.rb

@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe AASM::SupportingClasses::StateTransition do
-  it 'should set from, to, and opts attr readers' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    st.from.should == opts[:from]
-    st.to.should == opts[:to]
-    st.opts.should == opts
-  end
-
-  it 'should pass equality check if from and to are the same' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    obj = mock('object')
-    obj.stub!(:from).and_return(opts[:from])
-    obj.stub!(:to).and_return(opts[:to])
-
-    st.should == obj
-  end
-
-  it 'should fail equality check if from are not the same' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    obj = mock('object')
-    obj.stub!(:from).and_return('blah')
-    obj.stub!(:to).and_return(opts[:to])
-
-    st.should_not == obj
-  end
-  
-  it 'should fail equality check if to are not the same' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    obj = mock('object')
-    obj.stub!(:from).and_return(opts[:from])
-    obj.stub!(:to).and_return('blah')
-
-    st.should_not == obj
-  end
-end
-
-describe AASM::SupportingClasses::StateTransition, '- when performing guard checks' do
-  it 'should return true of there is no guard' do
-    opts = {:from => 'foo', :to => 'bar'}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    st.perform(nil).should be_true
-  end
-
-  it 'should call the method on the object if guard is a symbol' do
-    opts = {:from => 'foo', :to => 'bar', :guard => :test}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    obj = mock('object')
-    obj.should_receive(:test)
-    
-    st.perform(obj)
-  end
-
-  it 'should call the method on the object if guard is a string' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'test'}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    obj = mock('object')
-    obj.should_receive(:test)
-    
-    st.perform(obj)
-  end
-
-  it 'should call the proc passing the object if the guard is a proc' do
-    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test}}
-    st = AASM::SupportingClasses::StateTransition.new(opts)
-
-    obj = mock('object')
-    obj.should_receive(:test)
-
-    st.perform(obj)
-  end
-end