aq1018-acts_as_multiple_state_machines 0.1

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-01-09
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+rails/init.rb
+lib/acts_as_multiple_state_machines.rb
+lib/acts/as/multiple/state_machines/active_record_extension.rb
+lib/acts/as/multiple/state_machines/exceptions.rb
+lib/acts/as/multiple/state_machines/supporting_classes.rb
+lib/acts/as/multiple/state_machines/supporting_classes/event.rb
+lib/acts/as/multiple/state_machines/supporting_classes/state.rb
+lib/acts/as/multiple/state_machines/supporting_classes/state_machine.rb
+lib/acts/as/multiple/state_machines/supporting_classes/state_machine_factory.rb
+lib/acts/as/multiple/state_machines/supporting_classes/state_transition.rb
+test/test_acts_as_multiple_state_machines.rb
+test/fixtures/conversations.yml

data/README.txt

@@ -0,0 +1,48 @@
+= ActsAsMultipleStateMachines
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'hoe'
+require 'spec/rake/spectask'
+require 'pathname'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'lib/acts_as_multiple_state_machines.rb'
+
+AUTHOR = "Aaron Qian"
+EMAIL  = "aaron [a] ekohe [d] com"
+GEM_NAME = "acts_as_multiple_state_machines"
+GEM_VERSION = Acts::As::Multiple::StateMachines::VERSION
+
+GEM_CLEAN = ["log", "pkg"]
+GEM_EXTRAS = { :has_rdoc => true }
+ 
+PROJECT_NAME = "acts_as_multiple_state_machines"
+PROJECT_URL  = "http://acts-as-multiple-state-machines.rubyforge.com"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY = "similar to acts_as_state_machine, but provides multiple State Machines per ActiveRecord Model"
+
+Hoe.new(GEM_NAME, GEM_VERSION) do |p|
+  p.rubyforge_name = "acts-as-multiple-state-machines"
+  p.developer('Aaron Qian', 'aaron [a] ekohe [d] com')
+end
+
+desc 'Default: run unit tests.'
+task :default => [:clean_db, :test]
+ 
+WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
+SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
+ 
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
+task :install => [ :package ] do
+  sh "#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources", :verbose => false
+end
+ 
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
+end
+ 
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+ 
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end
+
+desc 'Remove the stale db file'
+task :clean_db do
+  `rm -f #{File.dirname(__FILE__)}/test/state_machine.sqlite.db`
+end
+
+desc 'Test the acts as multiple state machines plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end

data/lib/acts/as/multiple/state_machines/active_record_extension.rb

@@ -0,0 +1,86 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        def self.included(base)        #:nodoc:
+          base.extend ActMacro
+        end
+    
+        module ActMacro
+          # Configuration options are
+          #
+          # * +column+ - specifies the column name to use for keeping the state (default: state)
+          # * +initial+ - specifies an initial state for newly created objects (required)
+          def acts_as_state_machine(options = {}, &block)
+            class_eval do
+              extend ClassMethods
+              include InstanceMethods
+            
+              # make sure only does it once...
+              unless respond_to?(:state_machine_classes)
+                write_inheritable_attribute :state_machine_classes, {}
+                class_inheritable_reader    :state_machine_classes
+                before_create               :set_initial_state
+                after_create                :run_initial_state_actions
+              end
+            
+              name = options.delete(:name) || 'default'
+              name = name.to_sym
+
+              raise DuplicateStateMachine unless state_machine_classes[name].nil?
+              state_machine_classes[name] = SupportingClasses::StateMachineFactory.build(name, self, options, &block)
+            end
+
+          end
+      
+          module ClassMethods
+            def state_machines
+              read_inheritable_attribute :state_machine_classes
+            end
+                    
+            def find_in_state(state_machine_name, number, state, *args)
+              with_state_scope state_machine_name, state do
+                find(number, *args)
+              end
+            end
+
+            def count_in_state(state_machine_name, state, *args)
+              with_state_scope state_machine_name, state do
+                count(*args)
+              end
+            end
+
+            def calculate_in_state(state_machine_name, state, *args)
+              with_state_scope state_machine_name, state do
+                calculate(*args)
+              end
+            end
+          
+            def with_state_scope(state_machine_name, state)
+              sm = state_machine_classes[state_machine_name.to_sym]
+              raise InvalidState unless sm.states.include?(state.to_sym)
+
+              with_scope :find => {:conditions => ["#{table_name}.#{sm.state_column} = ?", state.to_s]} do
+                yield if block_given?
+              end
+            end
+          end
+        
+          module InstanceMethods
+            def state_machines
+              @state_machines ||= state_machine_classes.inject({}) {|sm, (name,klass) | sm[name] = klass.new(self); sm}
+            end
+          
+            def set_initial_state
+              state_machines.values.each(&:set_initial_state)
+            end
+          
+            def run_initial_state_actions
+              state_machines.values.each(&:run_initial_state_actions)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/exceptions.rb

@@ -0,0 +1,17 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        class InvalidState < Exception #:nodoc:
+        end
+
+        class NoInitialState < Exception #:nodoc:
+        end
+      
+        class DuplicateStateMachine < Exception #:nodoc:
+        end
+
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/supporting_classes.rb

@@ -0,0 +1,12 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        module SupportingClasses
+          # Default transition action.  Always returns true.
+          NOOP = lambda { |o| true }
+        end
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/supporting_classes/event.rb

@@ -0,0 +1,46 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        module SupportingClasses
+          class Event
+        
+            attr_reader :name
+            attr_reader :transitions
+            attr_reader :opts
+            attr_reader :sm
+
+            def initialize(state_machine, name, opts, transition_table, &block)
+              @name = name.to_sym
+              @transitions = transition_table[@name] = []
+              @sm = state_machine
+            
+              instance_eval(&block) if block
+              @opts = opts
+              @opts.freeze
+              @transitions.freeze
+              freeze
+            end
+
+            def next_states(record)
+              @transitions.select { |t| t.from == sm.current_state(record).to_s }
+            end
+
+            def fire(record)
+              next_states(record).each do |transition|
+                break true if transition.perform(record)
+              end
+            end
+
+            def transitions(trans_opts)
+              Array(trans_opts[:from]).each do |s|
+                @transitions << SupportingClasses::StateTransition.new(sm, trans_opts.merge({:from => s.to_sym}))
+              end
+            end
+        
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/supporting_classes/state.rb

@@ -0,0 +1,36 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        module SupportingClasses
+          class State
+        
+            attr_reader :name, :value, :sm
+
+            def initialize(state_machine, name, options)
+              @name  = name.to_sym
+              @value = (options[:value] || @name).to_s
+              @after = Array(options[:after])
+              @enter = options[:enter] || NOOP
+              @exit  = options[:exit] || NOOP
+              @sm = state_machine
+            end
+
+            def entering(record)
+              sm.send(:run_transition_action, record, @enter)
+            end
+
+            def entered(record)
+              @after.each { |action| sm.send(:run_transition_action, record, action) }
+            end
+
+            def exited(record)
+              sm.send(:run_transition_action, record, @exit)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/supporting_classes/state_machine.rb

@@ -0,0 +1,112 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        module SupportingClasses
+          class StateMachine
+            class_inheritable_reader    :name, 
+                                        :initial_state, 
+                                        :state_column, 
+                                        :state_map, 
+                                        :transition_table, 
+                                        :event_table
+
+            attr_reader                 :record
+          
+            def initialize(record)
+              @record = record
+            end
+          
+            class << self
+              def states
+                state_map.keys.collect { |state| state.to_sym }
+              end
+
+              def current_state(record)
+                record.send(state_column).to_sym
+              end
+
+              def event(event, opts={}, &block)
+                e = SupportingClasses::Event.new(self, event, opts, transition_table, &block)
+                event_table[event.to_sym] = e
+                class_eval "
+                  def #{event}!
+                    event_table[:#{event}].fire(record)
+                  end
+                "
+              end
+
+              def state(name, opts={})
+                state = SupportingClasses::State.new(self, name, opts)
+                state_map[state.value] = state
+                state_name = state.name
+                class_eval "
+                  def #{state.name}?
+                    current_state.to_s == state_map['#{state.value}'].value
+                  end
+                "
+              end
+            
+              private
+              def set_config_options(name, options)
+                write_inheritable_attribute :name,              name
+                write_inheritable_attribute :state_map,         {}
+                write_inheritable_attribute :initial_state,     options[:initial]
+                write_inheritable_attribute :transition_table,  {}
+                write_inheritable_attribute :event_table,       {}
+                write_inheritable_attribute :state_column,      options[:column] || 'state'
+              end
+            
+              def freeze_config!
+                state_map.freeze
+                transition_table.freeze
+                event_table.freeze
+              end
+            
+              def configure(name, options, &block)
+                set_config_options(name, options)              
+                instance_eval(&block)
+                freeze_config!
+              end
+            
+              def run_transition_action(record, action)
+                Symbol === action ? record.method(action).call : action.call(record)
+              end
+            end
+
+            def set_initial_state
+              record.write_attribute state_column, initial_state.to_s
+            end
+
+            def run_initial_state_actions
+              initial = state_map[initial_state.to_s]
+              initial.entering(record)
+              initial.entered(record)
+            end
+
+            # Returns the current state the object is in, as a Ruby symbol.
+            def current_state
+              self.class.current_state(record)
+            end
+
+            # Returns what the next state for a given event would be, as a Ruby symbol.
+            def next_state_for_event(event)
+              ns = next_states_for_event(event)
+              ns.empty? ? nil : ns.first.to.to_sym
+            end
+
+            def next_states_for_event(event)
+              transition_table[event.to_sym].select do |s|
+                s.from == current_state.to_s
+              end
+            end
+
+            def states
+              self.class.states
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/supporting_classes/state_machine_factory.rb

@@ -0,0 +1,25 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        module SupportingClasses
+          class StateMachineFactory
+            class << self
+              def build(name, model, options, &block)
+                raise NoInitialState unless options[:initial]
+                klass = model.const_set(state_machine_class_name(name), Class.new(SupportingClasses::StateMachine))
+                klass.send :configure, name, options, &block
+                klass            
+              end
+            
+              def state_machine_class_name(name)
+                "#{name.to_s.classify}StateMachine"
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/acts/as/multiple/state_machines/supporting_classes/state_transition.rb

@@ -0,0 +1,47 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        module SupportingClasses
+          class StateTransition
+
+            attr_reader :from, :to, :opts, :sm
+
+            def initialize(state_machine, options)
+              @from  = options[:from].to_s
+              @to    = options[:to].to_s
+              @guard = options[:guard] || NOOP
+              @opts  = options
+              @sm = state_machine
+            end
+
+            def guard(obj)
+              @guard ? sm.send(:run_transition_action, obj, @guard) : true
+            end
+
+            def perform(record)
+              return false unless guard(record)
+              loopback = sm.current_state(record).to_s == to
+              states = sm.state_map
+              next_state = states[to]
+              old_state = states[sm.current_state(record).to_s]
+
+              next_state.entering(record) unless loopback
+
+              record.update_attribute(sm.state_column, next_state.value)
+
+              next_state.entered(record) unless loopback
+              old_state.exited(record) unless loopback
+              true
+            end
+
+            def ==(obj)
+              @from == obj.from && @to == obj.to
+            end
+        
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_multiple_state_machines.rb

@@ -0,0 +1,9 @@
+module Acts
+  module As
+    module Multiple
+      module StateMachines
+        VERSION = '0.1'
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../lib/acts_as_multiple_state_machines'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/exceptions'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/supporting_classes'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/supporting_classes/event'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/supporting_classes/state'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/supporting_classes/state_transition'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/supporting_classes/state_machine'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/supporting_classes/state_machine_factory'
+require File.dirname(__FILE__) + '/../lib/acts/as/multiple/state_machines/active_record_extension'
+
+ActiveRecord::Base.class_eval do
+  include ::Acts::As::Multiple::StateMachines
+end

data/test/fixtures/conversations.yml

@@ -0,0 +1,11 @@
+first:
+  id: 1
+  state_machine: read
+  subject: This is a test
+  closed: false
+  
+second:
+  id: 2
+  state_machine: read
+  subject: Foo
+  closed: false

data/test/test_acts_as_multiple_state_machines.rb

@@ -0,0 +1,697 @@
+RAILS_ROOT = File.dirname(__FILE__)
+
+require "rubygems"
+require "test/unit"
+require "active_record"
+require "active_record/fixtures"
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require File.dirname(__FILE__) + "/../rails/init"
+
+# Log everything to a global StringIO object instead of a file.
+require "stringio"
+$LOG = StringIO.new
+$LOGGER = Logger.new($LOG)
+ActiveRecord::Base.logger = $LOGGER
+
+ActiveRecord::Base.configurations = {
+  "sqlite" => {
+    :adapter => "sqlite",
+    :dbfile  => "state_machine.sqlite.db"
+  },
+
+  "sqlite3" => {
+    :adapter => "sqlite3",
+    :dbfile  => ":memory:"
+  },
+
+  "mysql" => {
+    :adapter  => "mysql",
+    :host     => "localhost",
+    :username => "rails",
+    :password => nil,
+    :database => "state_machine_test"
+  },
+
+  "postgresql" => {
+    :min_messages => "ERROR",
+    :adapter      => "postgresql",
+    :username     => "postgres",
+    :password     => "postgres",
+    :database     => "state_machine_test"
+  }
+}
+
+# Connect to the database.
+ActiveRecord::Base.establish_connection(ENV["DB"] || "sqlite3")
+
+# Create table for conversations.
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :conversations, :force => true do |t|
+    t.column :state_machine, :string
+    t.column :subject,       :string
+    t.column :closed,        :boolean
+    t.column :another_state_machine, :string
+  end
+end
+
+class Test::Unit::TestCase
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names, &block)
+  end
+end
+
+class Conversation < ActiveRecord::Base
+  attr_writer :can_close
+  attr_accessor :read_enter, :read_exit,
+                :needs_attention_enter, :needs_attention_after,
+                :read_after_first, :read_after_second,
+                :closed_after
+
+  # How's THAT for self-documenting? ;-)
+  def always_true
+    true
+  end
+
+  def can_close?
+    !!@can_close
+  end
+
+  def read_enter_action
+    self.read_enter = true
+  end
+
+  def read_after_first_action
+    self.read_after_first = true
+  end
+
+  def read_after_second_action
+    self.read_after_second = true
+  end
+
+  def closed_after_action
+    self.closed_after = true
+  end
+end
+
+class ActsAsStateMachineTest < Test::Unit::TestCase
+  include ::Acts::As::Multiple::StateMachines
+  fixtures :conversations
+
+  def teardown
+    Conversation.class_eval do
+      state_machine_classes.keys.each do |name|
+        remove_const SupportingClasses::StateMachineFactory.state_machine_class_name(name)
+      end
+      
+      write_inheritable_attribute  :state_machine_classes, {}
+
+      # Clear out any callbacks that were set by acts_as_state_machine.
+      write_inheritable_attribute :before_create, []
+      write_inheritable_attribute :after_create, []
+    end
+  end
+
+  def test_no_initial_value_raises_exception
+    assert_raises(NoInitialState) do
+      Conversation.class_eval { acts_as_state_machine }
+    end
+  end
+
+  def test_state_column
+    Conversation.class_eval do
+      acts_as_state_machine(:initial => :needs_attention, :column => "state_machine") do
+        state :needs_attention
+      end
+    end
+
+    assert_equal "state_machine", Conversation.state_machines[:default].state_column
+  end
+
+  def test_initial_state_value
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+      end
+    end
+
+    assert_equal :needs_attention, Conversation.state_machines[:default].initial_state
+  end
+
+  def test_initial_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal :needs_attention, c.state_machines[:default].current_state
+    assert c.state_machines[:default].needs_attention?
+  end
+
+  def test_states_were_set
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+        state :junk
+      end
+    end
+
+    [:needs_attention, :read, :closed, :awaiting_response, :junk].each do |state|
+      assert Conversation.state_machines[:default].states.include?(state)
+    end
+  end
+
+  def test_query_methods_created
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+        state :junk
+      end
+    end
+
+    c = Conversation.create!
+    [:needs_attention?, :read?, :closed?, :awaiting_response?, :junk?].each do |query|
+      assert c.state_machines[:default].respond_to?(query)
+    end
+  end
+
+  def test_event_methods_created
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+        state :junk
+
+        event(:new_message) {}
+        event(:view) {}
+        event(:reply) {}
+        event(:close) {}
+        event(:junk, :note => "finished") {}
+        event(:unjunk) {}
+      end
+    end
+
+    c = Conversation.create!
+    [:new_message!, :view!, :reply!, :close!, :junk!, :unjunk!].each do |event|
+      assert c.state_machines[:default].respond_to?(event)
+    end
+  end
+
+  def test_transition_table
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+        state :junk
+
+        event :new_message do
+          transitions :to => :needs_attention, :from => [:read, :closed, :awaiting_response]
+        end
+      end
+    end
+
+    sm = Conversation.state_machines[:default]
+    tt = sm.transition_table
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(sm, :from => :read, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(sm, :from => :closed, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(sm, :from => :awaiting_response, :to => :needs_attention))
+  end
+
+  def test_next_state_for_event
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal :read, c.state_machines[:default].next_state_for_event(:view)
+  end
+
+  def test_change_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+      end
+    end
+
+    c = Conversation.create!
+    c.state_machines[:default].view!
+    assert c.state_machines[:default].read?
+  end
+
+  def test_can_go_from_read_to_closed_because_guard_passes
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+
+        event :reply do
+          transitions :to => :awaiting_response, :from => [:read, :closed]
+        end
+
+        event :close do
+          transitions :to => :closed, :from => [:read, :awaiting_response], :guard => lambda { |o| o.can_close? }
+        end
+      end
+    end
+
+    c = Conversation.create!
+    c.can_close = true
+    c.state_machines[:default].view!
+    c.state_machines[:default].reply!
+    c.state_machines[:default].close!
+    assert_equal :closed, c.state_machines[:default].current_state
+  end
+
+  def test_cannot_go_from_read_to_closed_because_of_guard
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+
+        event :reply do
+          transitions :to => :awaiting_response, :from => [:read, :closed]
+        end
+
+        event :close do
+          transitions :to => :closed, :from => [:read, :awaiting_response], :guard => lambda { |o| o.can_close? }
+          transitions :to => :read, :from => [:read, :awaiting_response], :guard => :always_true
+        end
+      end
+    end
+
+    c = Conversation.create!
+    c.can_close = false
+    c.state_machines[:default].view!
+    c.state_machines[:default].reply!
+    c.state_machines[:default].close!
+    assert_equal :read, c.state_machines[:default].current_state
+  end
+
+  def test_ignore_invalid_events
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read
+        state :closed
+        state :awaiting_response
+        state :junk
+
+        event :new_message do
+          transitions :to => :needs_attention, :from => [:read, :closed, :awaiting_response]
+        end
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+
+        event :junk, :note => "finished" do
+          transitions :to => :junk, :from => [:read, :closed, :awaiting_response]
+        end
+      end
+    end
+    
+    c = Conversation.create
+    c.state_machines[:default].view!
+    c.state_machines[:default].junk!
+
+    # This is the invalid event
+    c.state_machines[:default].new_message!
+    assert_equal :junk, c.state_machines[:default].current_state
+  end
+
+  def test_entry_action_executed
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read, :enter => :read_enter_action
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+      end
+    end
+
+    c = Conversation.create!
+    c.read_enter = false
+    c.state_machines[:default].view!
+    assert c.read_enter
+  end
+
+  def test_after_actions_executed
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :closed, :after => :closed_after_action
+        state :read, :enter => :read_enter_action,
+        :exit  => Proc.new { |o| o.read_exit = true },
+        :after => [:read_after_first_action, :read_after_second_action]
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+
+        event :close do
+          transitions :to => :closed, :from => [:read, :awaiting_response]
+        end
+      end
+    end
+
+    c = Conversation.create!
+
+    c.read_after_first = false
+    c.read_after_second = false
+    c.closed_after = false
+
+    c.state_machines[:default].view!
+    assert c.read_after_first
+    assert c.read_after_second
+
+    c.can_close = true
+    c.state_machines[:default].close!
+
+    assert c.closed_after
+    assert_equal :closed, c.state_machines[:default].current_state
+  end
+
+  def test_after_actions_not_run_on_loopback_transition
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :closed, :after => :closed_after_action
+        state :read, :after => [:read_after_first_action, :read_after_second_action]
+
+        event :view do
+          transitions :to => :read, :from => :needs_attention
+        end
+
+        event :close do
+          transitions :to => :closed, :from => :read
+        end
+      end
+    end
+
+    c = Conversation.create!
+
+    c.state_machines[:default].view!
+    c.read_after_first = false
+    c.read_after_second = false
+    c.state_machines[:default].view!
+
+    assert !c.read_after_first
+    assert !c.read_after_second
+
+    c.can_close = true
+
+    c.state_machines[:default].close!
+    c.closed_after = false
+    c.state_machines[:default].close!
+
+    assert !c.closed_after
+  end
+
+  def test_exit_action_executed
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :junk
+        state :needs_attention
+        state :read, :exit => lambda { |o| o.read_exit = true }
+
+        event :view do
+          transitions :to => :read, :from => :needs_attention
+        end
+
+        event :junk, :note => "finished" do
+          transitions :to => :junk, :from => :read
+        end
+      end
+    end
+
+    c = Conversation.create!
+    c.read_exit = false
+    c.state_machines[:default].view!
+    c.state_machines[:default].junk!
+    assert c.read_exit
+  end
+
+  def test_entry_and_exit_not_run_on_loopback_transition
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+        state :read, :exit => lambda { |o| o.read_exit = true }
+
+        event :view do
+          transitions :to => :read, :from => [:needs_attention, :read]
+        end
+      end
+    end
+
+    c = Conversation.create!
+    c.state_machines[:default].view!
+    c.read_enter = false
+    c.read_exit  = false
+    c.state_machines[:default].view!
+    assert !c.read_enter
+    assert !c.read_exit
+  end
+
+  def test_entry_and_after_actions_called_for_initial_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention, :enter => lambda { |o| o.needs_attention_enter = true },
+        :after => lambda { |o| o.needs_attention_after = true }
+      end
+    end
+
+    c = Conversation.create!
+    assert c.needs_attention_enter
+    assert c.needs_attention_after
+  end
+
+  def test_run_transition_action_is_private
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention do
+        state :needs_attention
+      end
+    end
+
+    c = Conversation.create!
+    assert_raises(NoMethodError) { c.state_machines[:default].run_transition_action :foo }
+  end
+
+  def test_find_all_in_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    cs = Conversation.find_in_state(:default, :all, :read)
+    assert_equal 2, cs.size
+  end
+  
+  def test_find_first_in_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    c = Conversation.find_in_state(:default, :first, :read)
+    assert_equal conversations(:first).id, c.id
+  end
+  
+  def test_find_all_in_state_with_conditions
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    cs = Conversation.find_in_state(:default, :all, :read, :conditions => ['subject = ?', conversations(:second).subject])
+  
+    assert_equal 1, cs.size
+    assert_equal conversations(:second).id, cs.first.id
+  end
+  
+  def test_find_first_in_state_with_conditions
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    c = Conversation.find_in_state(:default, :first, :read, :conditions => ['subject = ?', conversations(:second).subject])
+    assert_equal conversations(:second).id, c.id
+  end
+  
+  def test_count_in_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    cnt0 = Conversation.count(:conditions => ['state_machine = ?', 'read'])
+    cnt  = Conversation.count_in_state(:default, :read)
+  
+    assert_equal cnt0, cnt
+  end
+  
+  def test_count_in_state_with_conditions
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    cnt0 = Conversation.count(:conditions => ['state_machine = ? AND subject = ?', 'read', 'Foo'])
+    cnt  = Conversation.count_in_state(:default, :read, :conditions => ['subject = ?', 'Foo'])
+  
+    assert_equal cnt0, cnt
+  end
+  
+  def test_find_in_invalid_state_raises_exception
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    assert_raises(InvalidState) do
+      Conversation.find_in_state(:default, :all, :dead)
+    end
+  end
+  
+  def test_count_in_invalid_state_raises_exception
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :read
+      end
+    end
+  
+    assert_raise(InvalidState) do
+      Conversation.count_in_state(:default, :dead)
+    end
+  end
+
+  def test_can_access_events_via_event_table
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :junk
+
+        event :junk, :note => "finished" do
+          transitions :to => :junk, :from => :needs_attention
+        end
+      end
+    end
+
+    event = Conversation.state_machines[:default].event_table[:junk]
+    assert_equal :junk, event.name
+    assert_equal "finished", event.opts[:note]
+  end
+
+  def test_custom_state_values
+    Conversation.class_eval do
+      acts_as_state_machine :initial => "NEEDS_ATTENTION", :column => "state_machine" do
+        state :needs_attention, :value => "NEEDS_ATTENTION"
+        state :read, :value => "READ"
+
+        event :view do
+          transitions :to => "READ", :from => ["NEEDS_ATTENTION", "READ"]
+        end
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal "NEEDS_ATTENTION", c.state_machine
+    assert c.state_machines[:default].needs_attention?
+    c.state_machines[:default].view!
+    assert_equal "READ", c.state_machine
+    assert c.state_machines[:default].read?
+  end
+  
+  
+  def test_can_define_multiple_state_machines
+    Conversation.class_eval do
+      acts_as_state_machine :name => 'default', :initial => :needs_attention, :column => "state_machine" do
+        state :needs_attention
+        state :junk
+
+        event :junk do
+          transitions :to => :junk, :from => :needs_attention
+        end
+      end
+      
+      acts_as_state_machine :name => 'user', :initial => :pending, :column => "another_state_machine" do
+        state :pending
+        state :active
+
+        event :activate do
+          transitions :to => :active, :from => :pending
+        end
+      end
+    end
+    
+    c = Conversation.create!
+    assert_equal 'needs_attention', c.state_machine
+    assert_equal 'pending', c.another_state_machine
+    assert c.state_machines[:default].needs_attention?
+    assert c.state_machines[:user].pending?
+    c.state_machines[:default].junk!
+    assert c.state_machines[:default].junk?
+    assert c.state_machines[:user].pending?
+    c.state_machines[:user].activate!
+    assert c.state_machines[:default].junk?
+    assert c.state_machines[:user].active?       
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: aq1018-acts_as_multiple_state_machines
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Aaron Qian
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-08 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: similar to acts_as_state_machine, but provides multiple State Machines per ActiveRecord Model
+email: aaron [a] ekohe [d] com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- rails/init.rb
+- lib/acts_as_multiple_state_machines.rb
+- lib/acts/as/multiple/state_machines/active_record_extension.rb
+- lib/acts/as/multiple/state_machines/exceptions.rb
+- lib/acts/as/multiple/state_machines/supporting_classes.rb
+- lib/acts/as/multiple/state_machines/supporting_classes/event.rb
+- lib/acts/as/multiple/state_machines/supporting_classes/state.rb
+- lib/acts/as/multiple/state_machines/supporting_classes/state_machine.rb
+- lib/acts/as/multiple/state_machines/supporting_classes/state_machine_factory.rb
+- lib/acts/as/multiple/state_machines/supporting_classes/state_transition.rb
+- test/test_acts_as_multiple_state_machines.rb
+- test/fixtures/conversations.yml
+has_rdoc: true
+homepage: http://acts-as-multiple-state-machines.rubyforge.com
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: similar to acts_as_state_machine, but provides multiple State Machines per ActiveRecord Model
+test_files: 
+- test/fixtures/conversations.yml
+- test/test_acts_as_multiple_state_machines.rb