acts_as_state_machine 2.1.3

data/CHANGELOG

@@ -0,0 +1,16 @@
+* 2.1.1
+  packaged it up as a gem [Jacques Crocker]
+
+* trunk *
+  break with true value [Kaspar Schiess]
+
+* 2.1 *
+  After actions [Saimon Moore]
+
+* 2.0 * (2006-01-20 15:26:28 -0500)
+  Enter / Exit actions
+  Transition guards
+  Guards and actions can be a symbol pointing to a method or a Proc
+
+* 1.0 * (2006-01-15 12:16:55 -0500)
+	Initial Release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Scott Barron
+
+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/README

@@ -0,0 +1,33 @@
+= Acts As State Machine
+
+This act gives an Active Record model the ability to act as a finite state
+machine (FSM).
+
+Acquire via subversion at:
+
+http://elitists.textdriven.com/svn/plugins/acts_as_state_machine/trunk
+
+If prompted, use the user/pass anonymous/anonymous.
+
+== Example
+
+ class Order < ActiveRecord::Base
+   acts_as_state_machine :initial => :opened
+
+   state :opened
+   state :closed, :enter => Proc.new {|o| Mailer.send_notice(o)}
+   state :returned
+
+   event :close do
+     transitions :to => :closed, :from => :opened
+   end
+
+   event :return do
+     transitions :to => :returned, :from => :closed
+   end
+ end
+
+ o = Order.create
+ o.close! # notice is sent by mailer
+ o.return!
+

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => [:clean_db, :test]
+
+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 state machine plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts as state machine plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Acts As State Machine'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('TODO')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1,11 @@
+* Currently invalid events are ignored, create an option so that they can be
+  ignored or raise an exception.
+
+* Query for a list of possible next states.
+
+* Make listing states optional since they can be inferred from the events.
+  Only required to list a state if you want to define a transition block for it.
+
+* Real transition actions
+
+* Default states

data/acts_as_state_machine.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name = 'acts_as_state_machine'
+  s.version = '2.1.3'
+  s.date = '2010-02-14'
+  
+  s.summary = "Allows ActiveRecord models to define states and transition actions between them"
+  s.description = "This act gives an Active Record model the ability to act as a finite state machine (FSM)."
+  
+  s.authors = ['RailsJedi', 'Scott Barron']
+  s.email = 'railsjedi@gmail.com'
+  s.homepage = 'http://github.com/jcnetdev/acts_as_state_machine'
+  
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+
+  s.add_dependency 'activerecord', ['>= 2.1']
+  
+  s.files = ["CHANGELOG",
+             "MIT-LICENSE",
+             "README",
+             "Rakefile",
+             "TODO",
+             "acts_as_state_machine.gemspec",
+             "init.rb",
+             "lib/acts_as_state_machine.rb",
+             "rails/init.rb"]
+
+  s.test_files = ["test/fixtures",
+                  "test/fixtures/conversations.yml",
+                  "test/test_acts_as_state_machine.rb"]
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/acts_as_state_machine.rb

@@ -0,0 +1,277 @@
+module ScottBarron                   #:nodoc:
+  module Acts                        #:nodoc:
+    module StateMachine              #:nodoc:
+      class InvalidState < Exception #:nodoc:
+      end
+      class NoInitialState < Exception #:nodoc:
+      end
+
+      def self.included(base)        #:nodoc:
+        base.extend ActMacro
+      end
+
+      module SupportingClasses
+        # Default transition action.  Always returns true.
+        NOOP = lambda { |o| true }
+
+        class State
+          attr_reader :name, :value
+
+          def initialize(name, options)
+            @name  = name.to_sym
+            @value = (options[:value] || @name).to_s
+            @after = Array(options[:after])
+            @enter = options[:enter] || NOOP
+            @exit  = options[:exit] || NOOP
+          end
+
+          def entering(record)
+            record.send(:run_transition_action, @enter)
+          end
+
+          def entered(record)
+            @after.each { |action| record.send(:run_transition_action, action) }
+          end
+
+          def exited(record)
+            record.send(:run_transition_action, @exit)
+          end
+        end
+
+        class StateTransition
+          attr_reader :from, :to, :opts
+
+          def initialize(options)
+            @from  = options[:from].to_s
+            @to    = options[:to].to_s
+            @guard = options[:guard] || NOOP
+            @opts  = options
+          end
+
+          def guard(obj)
+            @guard ? obj.send(:run_transition_action, @guard) : true
+          end
+
+          def perform(record)
+            return false unless guard(record)
+            loopback = record.current_state.to_s == to
+            states = record.class.read_inheritable_attribute(:states)
+            next_state = states[to]
+            old_state = states[record.current_state.to_s]
+
+            next_state.entering(record) unless loopback
+
+            record.update_attribute(record.class.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
+
+        class Event
+          attr_reader :name
+          attr_reader :transitions
+          attr_reader :opts
+
+          def initialize(name, opts, transition_table, &block)
+            @name = name.to_sym
+            @transitions = transition_table[@name] = []
+            instance_eval(&block) if block
+            @opts = opts
+            @opts.freeze
+            @transitions.freeze
+            freeze
+          end
+
+          def next_states(record)
+            @transitions.select { |t| t.from == record.current_state.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(trans_opts.merge({:from => s.to_sym}))
+            end
+          end
+        end
+      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 = {})
+          class_eval do
+            extend ClassMethods
+            include InstanceMethods
+
+            raise NoInitialState unless options[:initial]
+
+            write_inheritable_attribute :states, {}
+            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'
+
+            class_inheritable_reader    :initial_state
+            class_inheritable_reader    :state_column
+            class_inheritable_reader    :transition_table
+            class_inheritable_reader    :event_table
+
+            before_create               :set_initial_state
+            after_create                :run_initial_state_actions
+          end
+        end
+      end
+
+      module InstanceMethods
+        def set_initial_state #:nodoc:
+          write_attribute self.class.state_column, self.class.initial_state.to_s
+        end
+
+        def run_initial_state_actions
+          initial = self.class.read_inheritable_attribute(:states)[self.class.initial_state.to_s]
+          initial.entering(self)
+          initial.entered(self)
+        end
+
+        # Returns the current state the object is in, as a Ruby symbol.
+        def current_state
+          self.send(self.class.state_column).to_sym
+        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)
+          self.class.read_inheritable_attribute(:transition_table)[event.to_sym].select do |s|
+            s.from == current_state.to_s
+          end
+        end
+
+        def run_transition_action(action)
+          Symbol === action ? self.method(action).call : action.call(self)
+        end
+        private :run_transition_action
+      end
+
+      module ClassMethods
+        # Returns an array of all known states.
+        def states
+          read_inheritable_attribute(:states).keys.collect { |state| state.to_sym }
+        end
+
+        # Define an event.  This takes a block which describes all valid transitions
+        # for this event.
+        #
+        # Example:
+        #
+        # class Order < ActiveRecord::Base
+        #   acts_as_state_machine :initial => :open
+        #
+        #   state :open
+        #   state :closed
+        #
+        #   event :close_order do
+        #     transitions :to => :closed, :from => :open
+        #   end
+        # end
+        #
+        # +transitions+ takes a hash where <tt>:to</tt> is the state to transition
+        # to and <tt>:from</tt> is a state (or Array of states) from which this
+        # event can be fired.
+        #
+        # This creates an instance method used for firing the event.  The method
+        # created is the name of the event followed by an exclamation point (!).
+        # Example: <tt>order.close_order!</tt>.
+        def event(event, opts={}, &block)
+          tt = read_inheritable_attribute(:transition_table)
+
+          e = SupportingClasses::Event.new(event, opts, tt, &block)
+          write_inheritable_hash(:event_table, event.to_sym => e)
+          define_method("#{event.to_s}!") { e.fire(self) }
+        end
+
+        # Define a state of the system. +state+ can take an optional Proc object
+        # which will be executed every time the system transitions into that
+        # state.  The proc will be passed the current object.
+        #
+        # Example:
+        #
+        # class Order < ActiveRecord::Base
+        #   acts_as_state_machine :initial => :open
+        #
+        #   state :open
+        #   state :closed, Proc.new { |o| Mailer.send_notice(o) }
+        # end
+        def state(name, opts={})
+          state = SupportingClasses::State.new(name, opts)
+          write_inheritable_hash(:states, state.value => state)
+
+          define_method("#{state.name}?") { current_state.to_s == state.value }
+        end
+
+        # Wraps ActiveRecord::Base.find to conveniently find all records in
+        # a given state.  Options:
+        #
+        # * +number+ - This is just :first or :all from ActiveRecord +find+
+        # * +state+ - The state to find
+        # * +args+ - The rest of the args are passed down to ActiveRecord +find+
+        def find_in_state(number, state, *args)
+          with_state_scope state do
+            find(number, *args)
+          end
+        end
+
+        # Wraps ActiveRecord::Base.count to conveniently count all records in
+        # a given state.  Options:
+        #
+        # * +state+ - The state to find
+        # * +args+ - The rest of the args are passed down to ActiveRecord +find+
+        def count_in_state(state, *args)
+          with_state_scope state do
+            count(*args)
+          end
+        end
+
+        # Wraps ActiveRecord::Base.calculate to conveniently calculate all records in
+        # a given state.  Options:
+        #
+        # * +state+ - The state to find
+        # * +args+ - The rest of the args are passed down to ActiveRecord +calculate+
+        def calculate_in_state(state, *args)
+          with_state_scope state do
+            calculate(*args)
+          end
+        end
+
+        protected
+        def with_state_scope(state)
+          raise InvalidState unless states.include?(state.to_sym)
+
+          with_scope :find => {:conditions => ["#{table_name}.#{state_column} = ?", state.to_s]} do
+            yield if block_given?
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include ScottBarron::Acts::StateMachine
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'acts_as_state_machine'

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_state_machine.rb

@@ -0,0 +1,631 @@
+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__) + "/../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  => "state_machine.sqlite3.db"
+  },
+
+  "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"] || "sqlite")
+
+# 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
+  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 ScottBarron::Acts::StateMachine
+  fixtures :conversations
+
+  def teardown
+    Conversation.class_eval do
+      write_inheritable_attribute :states, {}
+      write_inheritable_attribute :initial_state, nil
+      write_inheritable_attribute :transition_table, {}
+      write_inheritable_attribute :event_table, {}
+      write_inheritable_attribute :state_column, "state"
+
+      # 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"
+      state :needs_attention
+    end
+
+    assert_equal "state_machine", Conversation.state_column
+  end
+
+  def test_initial_state_value
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+    end
+
+    assert_equal :needs_attention, Conversation.initial_state
+  end
+
+  def test_initial_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+    end
+
+    c = Conversation.create!
+    assert_equal :needs_attention, c.current_state
+    assert c.needs_attention?
+  end
+
+  def test_states_were_set
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+    end
+
+    [:needs_attention, :read, :closed, :awaiting_response, :junk].each do |state|
+      assert Conversation.states.include?(state)
+    end
+  end
+
+  def test_query_methods_created
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+      state :closed
+      state :awaiting_response
+      state :junk
+    end
+
+    c = Conversation.create!
+    [:needs_attention?, :read?, :closed?, :awaiting_response?, :junk?].each do |query|
+      assert c.respond_to?(query)
+    end
+  end
+
+  def test_event_methods_created
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    c = Conversation.create!
+    [:new_message!, :view!, :reply!, :close!, :junk!, :unjunk!].each do |event|
+      assert c.respond_to?(event)
+    end
+  end
+
+  def test_transition_table
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    tt = Conversation.transition_table
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :read, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :closed, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :awaiting_response, :to => :needs_attention))
+  end
+
+  def test_next_state_for_event
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal :read, c.next_state_for_event(:view)
+  end
+
+  def test_change_state
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    c.view!
+    assert c.read?
+  end
+
+  def test_can_go_from_read_to_closed_because_guard_passes
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    c = Conversation.create!
+    c.can_close = true
+    c.view!
+    c.reply!
+    c.close!
+    assert_equal :closed, c.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
+      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
+
+    c = Conversation.create!
+    c.can_close = false
+    c.view!
+    c.reply!
+    c.close!
+    assert_equal :read, c.current_state
+  end
+
+  def test_ignore_invalid_events
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    c = Conversation.create
+    c.view!
+    c.junk!
+
+    # This is the invalid event
+    c.new_message!
+    assert_equal :junk, c.current_state
+  end
+
+  def test_entry_action_executed
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      state :needs_attention
+      state :read, :enter => :read_enter_action
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    c.read_enter = false
+    c.view!
+    assert c.read_enter
+  end
+
+  def test_after_actions_executed
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    c = Conversation.create!
+
+    c.read_after_first = false
+    c.read_after_second = false
+    c.closed_after = false
+
+    c.view!
+    assert c.read_after_first
+    assert c.read_after_second
+
+    c.can_close = true
+    c.close!
+
+    assert c.closed_after
+    assert_equal :closed, c.current_state
+  end
+
+  def test_after_actions_not_run_on_loopback_transition
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    c = Conversation.create!
+
+    c.view!
+    c.read_after_first = false
+    c.read_after_second = false
+    c.view!
+
+    assert !c.read_after_first
+    assert !c.read_after_second
+
+    c.can_close = true
+
+    c.close!
+    c.closed_after = false
+    c.close!
+
+    assert !c.closed_after
+  end
+
+  def test_exit_action_executed
+    Conversation.class_eval do
+      acts_as_state_machine :initial => :needs_attention
+      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
+
+    c = Conversation.create!
+    c.read_exit = false
+    c.view!
+    c.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
+      state :needs_attention
+      state :read, :exit => lambda { |o| o.read_exit = true }
+
+      event :view do
+        transitions :to => :read, :from => [:needs_attention, :read]
+      end
+    end
+
+    c = Conversation.create!
+    c.view!
+    c.read_enter = false
+    c.read_exit  = false
+    c.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
+      state :needs_attention, :enter => lambda { |o| o.needs_attention_enter = true },
+      :after => lambda { |o| o.needs_attention_after = true }
+    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
+      state :needs_attention
+    end
+
+    c = Conversation.create!
+    assert_raises(NoMethodError) { c.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"
+      state :needs_attention
+      state :read
+    end
+
+    cs = Conversation.find_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    c = Conversation.find_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    cs = Conversation.find_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    c = Conversation.find_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    cnt0 = Conversation.count(:conditions => ['state_machine = ?', 'read'])
+    cnt  = Conversation.count_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    cnt0 = Conversation.count(:conditions => ['state_machine = ? AND subject = ?', 'read', 'Foo'])
+    cnt  = Conversation.count_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    assert_raises(InvalidState) do
+      Conversation.find_in_state(: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"
+      state :needs_attention
+      state :read
+    end
+
+    assert_raise(InvalidState) do
+      Conversation.count_in_state(: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"
+      state :needs_attention
+      state :junk
+
+      event :junk, :note => "finished" do
+        transitions :to => :junk, :from => :needs_attention
+      end
+    end
+
+    event = Conversation.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"
+      state :needs_attention, :value => "NEEDS_ATTENTION"
+      state :read, :value => "READ"
+
+      event :view do
+        transitions :to => "READ", :from => ["NEEDS_ATTENTION", "READ"]
+      end
+    end
+
+    c = Conversation.create!
+    assert_equal "NEEDS_ATTENTION", c.state_machine
+    assert c.needs_attention?
+    c.view!
+    assert_equal "READ", c.state_machine
+    assert c.read?
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_state_machine
+version: !ruby/object:Gem::Version 
+  version: 2.1.3
+platform: ruby
+authors: 
+- RailsJedi
+- Scott Barron
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-14 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.1"
+    version: 
+description: This act gives an Active Record model the ability to act as a finite state machine (FSM).
+email: railsjedi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README
+- Rakefile
+- TODO
+- acts_as_state_machine.gemspec
+- init.rb
+- lib/acts_as_state_machine.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/jcnetdev/acts_as_state_machine
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Allows ActiveRecord models to define states and transition actions between them
+test_files: 
+- test/fixtures/conversations.yml
+- test/test_acts_as_state_machine.rb