golem_statemachine 0.9 → 0.9.5

data/README.rdoc

@@ -24,11 +24,24 @@ easy.
 
 == 1. Installation
 
-Install as a Rails plugin:
+Install as a Gem:
+
+  gem install golem_statemachine
+
+Then, if you're using Rails 2.3.x, in your environment.rb:
+
+  config.gem 'golem_statemachine', :lib => 'golem'
+
+And if you're using Rails 3.x, add it to your Gemfile:
+
+  gem 'golem_statemachine', :require => 'golem'
+
+Or, install as a Rails plugin:
 
   script/plugin install git://github.com/zuk/golem_statemachine.git
 
-If using Golem in an ActiveRecord model:
+
+If you're using Golem in an ActiveRecord model:
 
   class Example < ActiveRecord::Base
 
@@ -59,7 +72,7 @@ A light switch is initially in an "off" state. When you flip the switch, it tran
 
 Here's the UML state machine diagram of an on/off switch:
 
-http://cloud.github.com/downloads/zuk/golem_statemachine/on_off_switch_UML.png
+http://github.com/zuk/golem_statemachine/raw/master/examples/UML/on_off_switch_UML.png
 
 And here's what this looks like in Ruby code using Golem:
 
@@ -107,7 +120,7 @@ inside the <tt>define_statemachine</tt> block:
 
 Now to create some states:
 
-http://cloud.github.com/downloads/zuk/golem_statemachine/monster_1_UML.png
+http://github.com/zuk/golem_statemachine/raw/master/examples/UML/monster_1_UML.png
 
   class Monster
     include Golem
@@ -120,7 +133,7 @@ http://cloud.github.com/downloads/zuk/golem_statemachine/monster_1_UML.png
 
 And an event:
 
-http://cloud.github.com/downloads/zuk/golem_statemachine/monster_2_UML.png
+http://github.com/zuk/golem_statemachine/raw/master/examples/UML/monster_2_UML.png
 
   class Monster
     include Golem
@@ -139,7 +152,7 @@ The block for each state describes what will happen when a given event occurs. I
 
 Now to make things a bit more interesting:
 
-http://cloud.github.com/downloads/zuk/golem_statemachine/monster_3_UML.png
+http://github.com/zuk/golem_statemachine/raw/master/examples/UML/monster_3_UML.png
 
   class Monster
     include Golem
@@ -195,7 +208,7 @@ Finally, every state can have an <tt>enter</tt> and <tt>exit</tt> action that wi
 is entered or exited. This can be a block, a callback method (as a Symbol), or a Proc/lambda. Also, in the interest
 of leaner code, we rewrite things using more compact syntax:
 
-http://cloud.github.com/downloads/zuk/golem_statemachine/monster_4_UML.png
+http://github.com/zuk/golem_statemachine/raw/master/examples/UML/monster_4_UML.png
 
  class Monster
     include Golem
@@ -261,7 +274,7 @@ from {Scott W. Ambler's primer on UML2 State Machine Diagrams}[http://www.agilem
 
 The UML state machine diagram:
 
-http://cloud.github.com/downloads/zuk/golem_statemachine/seminar_enrollment_UML.png
+http://github.com/zuk/golem_statemachine/raw/master/examples/UML/seminar_enrollment_UML.png
 
 The Ruby implementation (see blow for discussion):
 

data/golem_statemachine.gemspec

@@ -0,0 +1,25 @@
+
+$gemspec = Gem::Specification.new do |s|
+  s.name     = 'golem_statemachine'
+  s.version  = '0.9.5'
+  s.authors  = ["Matt Zukowski"]
+  s.email    = ["matt@roughest.net"]
+  s.homepage = 'http://github.com/zuk/golem_statemachine'
+  s.platform = Gem::Platform::RUBY
+  s.summary  = %q{Adds finite state machine behaviour to Ruby classes.}
+  s.description  = %q{Adds finite state machine behaviour to Ruby classes. Meant as an alternative to acts_as_state_machine/AASM.}
+
+  s.files  = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec`.split("\n")
+
+  s.require_path = "lib"
+
+  s.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
+
+  s.add_dependency("activesupport")
+
+  s.rdoc_options = [
+    '--quiet', '--title', 'Golem Statmeachine Docs', '--opname',
+    'index.html', '--line-numbers', '--main', 'README.rdoc', '--inline-source'
+  ]
+end

data/lib/golem.rb

@@ -1,27 +1,45 @@
-require 'activesupport'
+require 'active_support/all'
 
 require 'golem/dsl/state_machine_def'
-
+require 'ruby-debug'
 module Golem
+
   def self.included(mod)
     mod.extend Golem::ClassMethods
 
     # Override the initialize method in the object we're imbuing with statemachine
     # functionality so that we can do statemachine initialization when the object
     # is instantiated.
+    #
+    # For ActiveRecord, we use the after_initialize callback instead.
+    # FIXME: should use an ActiveRecord::Observer here since this will conflict with
+    #        any user-set after_initialize callback.
     mod.class_eval do
-      alias_method :_initialize, :initialize
-      def initialize(*args)
-        # call the original initialize
-        _initialize(*args)
+      if Object.const_defined?('ActiveRecord') && mod < ActiveRecord::Base
+        
+        after_initialize do
+          if respond_to?(:statemachines)
+            self.statemachines.each{|name, sm| sm.init(self)}
+          end
+        end
         
-        if respond_to?(:statemachines)
-          self.statemachines.each{|name, sm| sm.init(self, *args)}
+      else
+        
+        alias_method :_initialize, :initialize
+
+        def initialize(*args)
+          # call the original initialize
+          _initialize(*args)
+
+          if respond_to?(:statemachines)
+            self.statemachines.each{|name, sm| sm.init(self)}
+          end
         end
+        
       end
     end
   end
-
+  
   module ClassMethods
     def define_statemachine(statemachine_name = nil, options = {}, &block)
       default_statemachine_name = :statemachine
@@ -64,9 +82,14 @@ module Golem
 
       # state reader
       define_method("#{state_attribute}".to_sym) do
+        # TODO: the second two cases here should be collapsed into the first
         case
-        when state_attribute.respond_to?(:call)
-          state = state_attribute.call(self)
+        when statemachine.state_attribute_reader
+          if statemachine.state_attribute_reader.respond_to?(:call)
+            state = statemachine.state_attribute_reader.call(self)
+          else
+            state = self.send(statemachine.state_attribute_reader)
+          end
         when Object.const_defined?('ActiveRecord') && self.kind_of?(ActiveRecord::Base)
           state = self[state_attribute.to_s] && self[state_attribute.to_s].to_sym
         else
@@ -89,14 +112,31 @@ module Golem
         new_state = new_state.to_sym
         raise ArgumentError, "#{new_state.inspect} is not a valid state for #{statemachine}!" unless statemachine.states[new_state]
         
+        # transition takes care of calling on_exit, so don't do it if we're in the middle of a transition
+        unless statemachine.is_transitioning?
+          from_state_obj = statemachine.states[self.send("#{state_attribute}")]
+          from_state_obj.callbacks[:on_exit].call(self) if from_state_obj.callbacks[:on_exit]
+        end
+        
+        # TODO: the second two cases here whould be collapsed into the first
         case
-        when state_attribute.respond_to?(:call)
-          state_attribute.call(self, new_state)
+        when statemachine.state_attribute_writer
+          if statemachine.state_attribute_writer.respond_to?(:call)
+            statemachine.state_attribute_writer.call(self, new_state)
+          else
+            self.send(statemachine.state_attribute_writer, new_state)
+          end
         when Object.const_defined?('ActiveRecord') && self.kind_of?(ActiveRecord::Base)
           self[state_attribute.to_s] = new_state.to_s # store as String rather than Symbol to prevent serialization weirdness
         else
           self.instance_variable_set("@#{state_attribute}", new_state)
         end
+        
+        # transition takes care of calling on_entry, so don't do it if we're in the middle of a transition
+        unless statemachine.is_transitioning?
+          new_state_obj = statemachine.states[new_state]
+          new_state_obj.callbacks[:on_enter].call(self) if new_state_obj.callbacks[:on_enter]
+        end
       end
 
       validate :check_for_transition_errors if respond_to? :validate

data/lib/golem/dsl/state_def.rb

@@ -13,6 +13,15 @@ module Golem
         @machine = machine
         @state = @machine.get_or_define_state(state_name)
         @options = options
+        
+        if options[:enter]
+          @state.callbacks[:on_enter] = Golem::Model::Callback.new(options[:enter]) 
+        end
+        
+        if options[:exit]
+           @state.callbacks[:on_exit] = Golem::Model::Callback.new(options[:exit])
+        end
+        
         instance_eval(&block) if block
       end
 
@@ -21,11 +30,13 @@ module Golem
       end
 
       def enter(callback = nil, &block)
+        raise Golem::DefinitionSyntaxError, "Enter action already set." if @state.callbacks[:on_enter]
         raise Golem::DefinitionSyntaxError, "Provide either a callback method or a block, not both." if callback && block
         @state.callbacks[:on_enter] = Golem::Model::Callback.new(block || callback)
       end
 
       def exit(callback = nil, &block)
+        raise Golem::DefinitionSyntaxError, "Exit action already set." if @state.callbacks[:on_exit]
         raise Golem::DefinitionSyntaxError, "Provide either a callback method or a block, not both." if callback && block
         @state.callbacks[:on_exit] = Golem::Model::Callback.new(block || callback)
       end

data/lib/golem/dsl/state_machine_def.rb

@@ -42,7 +42,17 @@ module Golem
 
       # Sets the state_attribute name.
       def state_attribute=(attribute)
-        @state_attribute = attribute
+        @machine.state_attribute = attribute
+      end
+      
+      # Sets the state_attribute reader.
+      def state_attribute_reader(reader = nil)
+        @machine.state_attribute_reader = reader
+      end
+      
+      # Sets the state_attribute writer.
+      def state_attribute_writer(writer = nil)
+        @machine.state_attribute_writer = writer
       end
 
       def on_all_transitions(callback = nil, &block)

data/lib/golem/model/state_machine.rb

@@ -10,6 +10,8 @@ module Golem
     class StateMachine
       attr_accessor :name
       attr_accessor :state_attribute
+      attr_accessor :state_attribute_reader
+      attr_accessor :state_attribute_writer
       attr_reader :states
       attr_reader :events
       attr_accessor :transition_errors
@@ -26,6 +28,7 @@ module Golem
         @events = Golem::Util::ElementCollection.new(Golem::Model::Event)
         @transition_errors = []
         @throw_exceptions = false
+        @is_transitioning = false
       end
 
       def initial_state
@@ -44,6 +47,11 @@ module Golem
       def all_events
         @events
       end
+      
+      # true if this statemachine is currently in the middle of a transition
+      def is_transitioning?
+        @is_transitioning
+      end
 
       def get_current_state_of(obj)
         obj.send(state_attribute)
@@ -53,13 +61,9 @@ module Golem
         obj.send("#{state_attribute}=".to_sym, state)
       end
 
-      def init(obj, *args)
+      def init(obj)
         # set the initial state
-        set_current_state_of(obj, initial_state)
-
-        # call the on_entry callback for the initial state (if defined)
-        init_state = states[get_current_state_of(obj)]
-        init_state.callbacks[:on_enter].call(obj, *args) if init_state && init_state.callbacks[:on_enter]
+        set_current_state_of(obj, get_current_state_of(obj) || initial_state)
       end
 
       def fire_event_with_exceptions(obj, event, *args)
@@ -79,9 +83,11 @@ module Golem
         on_all_events.call(obj, event, args) if on_all_events
 
         if transition
+          @is_transitioning = true
+          
           before_state = states[get_current_state_of(obj)]
           before_state.callbacks[:on_exit].call(obj, *args) if before_state.callbacks[:on_exit]
-          
+        
           set_current_state_of(obj, transition.to.name)
           transition.callbacks[:on_transition].call(obj, *args) if transition.callbacks[:on_transition]
           on_all_transitions.call(obj, event, transition, *args) if on_all_transitions
@@ -89,12 +95,23 @@ module Golem
           after_state = states[get_current_state_of(obj)]
           after_state.callbacks[:on_enter].call(obj, *args) if after_state.callbacks[:on_enter]
           
+          @is_transitioning = false
+          
           save_result = true
-          if @throw_exceptions
-            save_result = obj.save! if obj.respond_to?(:save!)
-          else
-            save_result = obj.save if obj.respond_to?(:save)
+          if obj.respond_to?(:save!)
+            if @throw_exceptions
+              save_result = obj.save!
+            else
+              (save_result = obj.save!) rescue return false
+            end
+          elsif obj.respond_to?(:save)
+            if @throw_exceptions
+              save_result = obj.save
+            else
+              (save_result = obj.save) rescue return false
+            end
           end
+          
           return save_result
         else
           return false

data/test/active_record_test.rb

@@ -10,9 +10,7 @@ rescue
   require 'sqlite3'
 end
 
-require 'activerecord'
-
-require 'ruby-debug'
+require 'active_record'
 
 class ActiveRecordTest < Test::Unit::TestCase
 
@@ -45,7 +43,7 @@ class ActiveRecordTest < Test::Unit::TestCase
   def teardown
     self.class.send(:remove_const, :Foo)
   end
-
+  
   def test_restore_state
     foo = Foo.create(
       :state => 'b',
@@ -178,6 +176,55 @@ class ActiveRecordTest < Test::Unit::TestCase
       foo = Foo.create
     end
   end
+  
+  
+  def test_fire_entry_action_on_restore_state
+    foo = Foo.create(
+      :state => 'b',
+      :alpha_state => 'c',
+      :status => 'd'
+    )
+    
+    Foo.instance_eval do
+      define_statemachine do
+        initial_state :a
+        state :a
+        state :b, :enter => proc{|foo| foo.instance_variable_set(:@woot, "yup")}
+        state :c
+        state :d
+      end
+
+      define_statemachine(:alpha) do
+        initial_state :a
+        state :a
+        state :b, :enter => proc{|foo| foo.instance_variable_set(:@woot, "nope")}
+        state :c
+        state :d
+      end
+
+      define_statemachine(:beta) do
+        state_attribute(:status)
+        initial_state :a
+        state :a, :enter => proc{|foo| foo.instance_variable_set(:@woot, "poop")}
+        state :b
+        state :c
+        state :d
+      end
+    end
+
+    foo = Foo.find(foo.id)
+
+    assert_equal "yup", foo.instance_variable_get(:@woot)
+
+    # check that initial state works too
+    foo = Foo.create
+    
+    assert_equal "poop", foo.instance_variable_get(:@woot)
+
+    foo = Foo.find(foo.id)
+
+    assert_equal "poop", foo.instance_variable_get(:@woot)
+  end
 
 
   def test_transaction_around_fire_event

data/test/dsl_test.rb

@@ -111,6 +111,102 @@ class MonsterTest < Test::Unit::TestCase
     assert_equal :two, obj.alpha_state
     assert_equal :three, obj.foo
   end
+  
+  def test_define_state_attribute_reader_symbol
+    @klass.instance_eval do
+      define_statemachine do
+        initial_state :one
+        
+        state_attribute_reader :foo
+        
+        state :worked
+      end
+      
+      define_method(:foo) do
+        return :worked
+      end
+    end
+
+    obj = @klass.new
+    assert_equal :worked, obj.state
+  end
+  
+  def test_define_state_attribute_reader_proc
+    @klass.instance_eval do
+      define_statemachine do
+        initial_state :one
+        
+        state_attribute_reader(Proc.new do |obj|
+          obj.foo
+        end)
+        
+        state :worked
+      end
+      
+      define_method(:foo) do
+        return :worked
+      end
+    end
+
+    obj = @klass.new
+    assert_equal :worked, obj.state
+  end
+  
+  def test_define_state_attribute_writer_symbol
+    @klass.instance_eval do
+      define_statemachine do
+        initial_state :one
+        
+        state_attribute_writer :foo=
+        state_attribute_reader :foo
+        
+        state :worked
+      end
+      
+      define_method(:foo=) do |new_state|
+        @foo = new_state
+      end
+      define_method(:foo) do
+        @foo
+      end
+    end
+
+    obj = @klass.new
+    assert_equal :one, obj.state
+    
+    obj.state = :worked
+    assert_equal :worked, obj.state
+    assert_equal :worked, obj.instance_variable_get(:@foo)
+  end
+  
+  def test_define_state_attribute_writer_proc
+    @klass.instance_eval do
+      define_statemachine do
+        initial_state :one
+        
+        state_attribute_writer(Proc.new do |obj, new_state|
+          obj.foo = new_state
+        end)
+        state_attribute_reader :foo
+        
+        state :worked
+      end
+      
+      define_method(:foo=) do |new_state|
+        @foo = new_state
+      end
+      define_method(:foo) do
+        @foo
+      end
+    end
+
+    obj = @klass.new
+    assert_equal :one, obj.state
+    
+    obj.state = :worked
+    assert_equal :worked, obj.state
+    assert_equal :worked, obj.instance_variable_get(:@foo)
+  end
 
 
   def test_define_states

data/test/test_helper.rb

@@ -2,4 +2,5 @@ require 'test/unit'
 
 $: << File.dirname(__FILE__)+'/../lib'
 
+require 'rubygems'
 require 'golem'

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: golem_statemachine
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
+  prerelease: false
   segments: 
   - 0
   - 9
-  version: "0.9"
+  - 5
+  version: 0.9.5
 platform: ruby
 authors: 
 - Matt Zukowski
@@ -14,17 +14,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-28 00:00:00 Z
+date: 2011-12-07 00:00:00 -05:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -45,10 +44,17 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
+- examples/UML/monster_1_UML.png
+- examples/UML/monster_2_UML.png
+- examples/UML/monster_3_UML.png
+- examples/UML/monster_4_UML.png
+- examples/UML/on_off_switch_UML.png
+- examples/UML/seminar_enrollment_UML.png
 - examples/document.rb
 - examples/monster.rb
 - examples/seminar.rb
 - examples/seminar_enrollment.rb
+- golem_statemachine.gemspec
 - init.rb
 - install.rb
 - lib/golem.rb
@@ -71,9 +77,9 @@ files:
 - test/problematic_test.rb
 - test/seminar_test.rb
 - test/statemachine_assertions.rb
-- test/test.db
 - test/test_helper.rb
 - uninstall.rb
+has_rdoc: true
 homepage: http://github.com/zuk/golem_statemachine
 licenses: []
 
@@ -91,27 +97,23 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Adds finite state machine behaviour to Ruby classes.