runcoderun-aasm 2.0.2.1 → 2.0.2.2

data/CHANGELOG

@@ -1,5 +1,3 @@
-* 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.1.gem
+  % sudo gem install pkg/aasm-2.0.2.gem
 
 
 == Simple Example
@@ -44,19 +44,51 @@ Here's a quick example highlighting some of the features.
     aasm_initial_state :new
 
     aasm_state :new
-    aasm_state :read
+    aasm_state :read, :enter => :mark_thread_as_read
     aasm_state :closed
 
 
     aasm_event :view do
-      transitions :to => :read, :from => [:new]
+      # 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
     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 -raasm -e "print AASM.Version"` =~ /([0-9.]+)$/
+if `ruby -Ilib -rversion -e "print AASM::VERSION::STRING"` =~ /([0-9.]+)$/
   CURRENT_VERSION = $1
 else
   CURRENT_VERSION = '0.0.0'
@@ -23,7 +23,8 @@ $package_version = CURRENT_VERSION
 
 PKG_FILES = FileList['[A-Z]*',
 'lib/**/*.rb',
-'doc/**/*'
+'doc/**/*',
+'spec/**/*'
 ]
 
 desc 'Generate documentation for the acts as state machine plugin.'

data/aasm.gemspec

@@ -0,0 +1,19 @@
+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/aasm.rb

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

data/lib/event.rb

@@ -32,17 +32,6 @@ 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,15 +188,7 @@ module AASM
         #
         # 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
-            write_attribute(self.class.aasm_column, old_value)
-            return false
-          end
-          
-          true
+          update_attribute(self.class.aasm_column, state.to_s)
         end
       end
 

data/lib/state_transition.rb

@@ -21,6 +21,8 @@ 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

data/lib/version.rb

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

data/spec/functional/conversation.rb

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

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

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

data/spec/unit/aasm_spec.rb

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

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

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

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: runcoderun-aasm
 version: !ruby/object:Gem::Version 
-  version: 2.0.2.1
+  version: 2.0.2.2
 platform: ruby
 authors: 
 - Scott Barron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-09 00:00:00 -07:00
+date: 2008-08-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +30,7 @@ files:
 - Rakefile
 - README.rdoc
 - TODO
+- aasm.gemspec
 - lib/aasm.rb
 - lib/event.rb
 - lib/persistence/active_record_persistence.rb
@@ -39,6 +40,16 @@ 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: