state_manager 0.2.8 → 0.2.9

data/VERSION

@@ -1 +1 @@
-0.2.8
+0.2.9

data/lib/state_manager/adapters/active_record.rb

@@ -1,6 +1,9 @@
 module StateManager
   module Adapters
     module ActiveRecord
+
+      class DirtyTransition < StandardError; end;
+
       include Base
 
       def self.matching_ancestors
@@ -11,7 +14,15 @@ module StateManager
 
         def self.included(base)
           # Make sure that the model is in a valid state before it is saved
-          base.before_validation :_validate_states
+          base.before_validation do
+            validate_states!
+          end
+          base.before_save do
+            state_managers.values.map(&:before_save)
+          end
+          base.after_save do
+            state_managers.values.map(&:after_save)
+          end
 
           base.extend(ClassMethods)
         end
@@ -42,14 +53,46 @@ module StateManager
 
       module ManagerMethods
 
-        def write_state(value)
-          # Since new objects will have a nil state value, this method will be called
-          # during instantiation. We want to hold off on writing to the database.
-          if resource.new_record?
-            resource.send :write_attribute, self.class._state_property, value.path
-          else
-            resource.send :update_attribute, self.class._state_property, value.path
+        attr_accessor :pending_transition
+
+        def self.included(base)
+          base.class_eval do
+            alias_method :_run_before_callbacks, :run_before_callbacks
+            alias_method :_run_after_callbacks, :run_after_callbacks
+
+            # In the AR use case, we don't want to run any callbacks
+            # until the model has been saved
+            def run_before_callbacks(*args)
+              self.pending_transition = args
+            end
+
+            def run_after_callbacks(*args)
+            end
           end
+        end  
+
+        def transition_to(path)
+          raise(DirtyTransition, "Only one state transition may be performed before saving a record. This error could be caused by the record being initialized to a default state.") if pending_transition
+          super(path)
+        end
+
+        def before_save
+          return unless pending_transition
+          _run_before_callbacks(*pending_transition)
+        end
+
+        def after_save
+          return unless pending_transition
+          _run_after_callbacks(*pending_transition)
+          self.pending_transition = nil
+        end
+
+        def write_state(value)
+          resource.send :write_attribute, self.class._state_property, value.path
+        end
+
+        def persist_state
+          resource.save
         end
 
       end

data/lib/state_manager/base.rb

@@ -55,18 +55,12 @@ module StateManager
       # a transition to the current state?
       to_state = enter_states.last || from_state
 
-      # Before Callbacks
-      will_transition(from_state, to_state, current_event)
-      exit_states.each{ |s| s.exit }
-      enter_states.each{ |s| s.enter }
+      run_before_callbacks(from_state, to_state, current_event, enter_states, exit_states)
 
       # Set the state on the underlying resource
       self.current_state = to_state
 
-      # After Callbacks
-      exit_states.each{ |s| s.exited }
-      enter_states.each{ |s| s.entered }
-      did_transition(from_state, to_state, current_event)
+      run_after_callbacks(from_state, to_state, current_event, enter_states, exit_states)
     end
 
     def current_state
@@ -78,16 +72,19 @@ module StateManager
       write_state(value)
     end
 
-    # Send an event to the current state.
-    #
-    # Unlike the regular send_event method, this method recursively walks the
-    # path of states starting at the current state.
     def send_event!(name, *args)
+      result = send_event(name, *args)
+      persist_state
+      result
+    end
+
+    def send_event(name, *args)
       self.current_event = name
       state = find_state_for_event(name)
       raise(InvalidEvent, name) unless state
-      state.send_event name, *args
+      result = state.perform_event name, *args
       self.current_event = nil
+      result
     end
 
     def respond_to_event?(name)
@@ -138,6 +135,9 @@ module StateManager
       resource.send self.class._state_property
     end
 
+    def persist_state
+    end
+
     def will_transition(from, to, event)
     end
 
@@ -175,6 +175,18 @@ module StateManager
 
     attr_accessor :current_event
 
+    def run_before_callbacks(from_state, to_state, current_event, enter_states, exit_states)
+      will_transition(from_state, to_state, current_event)
+      exit_states.each{ |s| s.exit }
+      enter_states.each{ |s| s.enter }
+    end
+
+    def run_after_callbacks(from_state, to_state, current_event, enter_states, exit_states)
+      exit_states.each{ |s| s.exited }
+      enter_states.each{ |s| s.entered }
+      did_transition(from_state, to_state, current_event)
+    end
+
   end
 
 end

data/lib/state_manager/state.rb

@@ -87,11 +87,12 @@ module StateManager
       !!self.class.specification.events[name]
     end
 
-    def send_event(name, *args)
+    def perform_event(name, *args)
       name = name.to_sym
       event = self.class.specification.events[name]
-      send(name, *args) if respond_to?(name)
+      result = send(name, *args) if respond_to?(name)
       transition_to(event[:transitions_to]) if event[:transitions_to]
+      result
     end
 
     # Find all the states along the path

data/state_manager.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "state_manager"
-  s.version = "0.2.8"
+  s.version = "0.2.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gordon Hempton"]
-  s.date = "2012-07-30"
+  s.date = "2012-08-29"
   s.description = "Finite state machine implementation that keeps logic separate from model classes and supports sub-states."
   s.email = "ghempton@gmail.com"
   s.extra_rdoc_files = [

data/test/adapters/active_record_test.rb

@@ -3,6 +3,9 @@ require 'helper'
 class ActiveRecordTest < Test::Unit::TestCase
 
   class PostStates < StateManager::Base
+    attr_accessor :before_callbacks_called
+    attr_accessor :after_callbacks_called
+
     state :unsubmitted do
       event :submit, :transitions_to => 'submitted.awaiting_review'
     end
@@ -20,6 +23,14 @@ class ActiveRecordTest < Test::Unit::TestCase
     end
     state :active
     state :rejected
+
+    def will_transition(*args)
+      self.before_callbacks_called = true
+    end
+
+    def did_transition(*args)
+      self.after_callbacks_called = true
+    end
   end
 
   class Post < ActiveRecord::Base
@@ -67,7 +78,12 @@ class ActiveRecordTest < Test::Unit::TestCase
   def test_persist_initial_state
     @resource = Post.find(1)
     assert_state 'unsubmitted'
-    assert !@resource.changed?, "state should have been persisted"
+    assert !@resource.state_manager.before_callbacks_called
+    assert !@resource.state_manager.after_callbacks_called
+    assert @resource.changed?, "state should not have been persisted"
+    @resource.save
+    assert @resource.state_manager.before_callbacks_called
+    assert @resource.state_manager.after_callbacks_called
   end
 
   def test_initial_state_value
@@ -119,4 +135,21 @@ class ActiveRecordTest < Test::Unit::TestCase
     assert_equal 4, Post.active.count
     assert_equal 0, Post.rejected.count
   end
+
+  def test_multiple_transitions
+    @resource = Post.find(2)
+    @resource.submit!
+    assert_state 'submitted.awaiting_review'
+    @resource.review!
+    assert_state 'submitted.reviewing'
+  end
+
+  def test_dirty_transition
+    @resource = Post.find(2)
+    @resource.state_manager.send_event :submit
+    assert_state 'submitted.awaiting_review'
+    assert_raise(StateManager::Adapters::ActiveRecord::DirtyTransition) do
+      @resource.state_manager.send_event :review
+    end
+  end
 end

data/test/helper.rb

@@ -14,6 +14,7 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'pry'
 require 'delayed_job_active_record'
 require 'state_manager'
+require 'timecop'
 
 class Test::Unit::TestCase
 
@@ -26,4 +27,21 @@ class Test::Unit::TestCase
     assert_equal path, state_manager.current_state.path
   end
 
+  def teardown
+    ActiveRecord::Base.connection.disconnect!
+    Timecop.return
+  end
+
+  # Convince delayed job that the duration has passed and perform any jobs that
+  # need doing
+  def time_warp(duration)
+    Timecop.travel(duration.from_now)
+    Delayed::Worker.new.work_off
+
+    # Check for any errors inside the delayed job
+    jobs = Delayed::Job.where('last_error IS NOT NULL')
+    error = jobs.last && jobs.last.last_error
+    raise "Delayed job error: #{error}" if error
+  end
+
 end

data/test/plugins/delayed_job_test.rb

@@ -63,28 +63,11 @@ class DelayedJobTest < Test::Unit::TestCase
     state_manager
   end
 
-  def teardown
-    ActiveRecord::Base.connection.disconnect!
-    Timecop.return
-  end
-
-
-  # Convince delayed job that the duration has passed and perform any jobs that
-  # need doing
-  def time_warp(duration)
-    Timecop.travel(duration.from_now)
-    Delayed::Worker.new.work_off
-
-    # Check for any errors inside the delayed job
-    jobs = Delayed::Job.where('last_error IS NOT NULL')
-    error = jobs.last && jobs.last.last_error
-    raise "Delayed job error: #{error}" if error
-  end
-
   def test_delayed_event
     @resource = Project.find(1)
-    
     assert_state 'unsubmitted.initial'
+    assert_equal 0, Delayed::Job.count
+    @resource.save
     assert_equal 1, Delayed::Job.count
 
     time_warp(4.hours)
@@ -104,22 +87,23 @@ class DelayedJobTest < Test::Unit::TestCase
 
   def test_expired_event
     @resource = Project.find(1)
-
     assert_state 'unsubmitted.initial'
+    @resource.save
     assert_equal 1, Delayed::Job.count
 
     @resource.submit!
 
     assert_state 'submitted'
 
-    time_warp(4.hours)
+    time_warp(1.month)
 
+    assert_equal 0, Delayed::Job.count
     assert_state 'submitted', 'should not have transitioned'
   end
 
   def test_event_name_clashes
     @resource = Project.find(1)
-
+    @resource.save
     assert_state 'unsubmitted.initial'
     assert_equal 1, Delayed::Job.count
 
@@ -133,4 +117,12 @@ class DelayedJobTest < Test::Unit::TestCase
     assert_state 'accepted', 'remind event should not have been triggered'
   end
 
+  def test_new_record
+    @resource = Project.create
+    assert_state 'unsubmitted.initial'
+    time_warp(1.day)
+    @resource.reload
+    assert_state 'unsubmitted.reminded'
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_manager
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-30 00:00:00.000000000 Z
+date: 2012-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -271,7 +271,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 443953156936998846
+      hash: 1941568341528515178
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: