anthonyw-simple_state 0.1.2 → 0.1.3

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
+:patch: 3
 :major: 0
 :minor: 1
-:patch: 2

data/lib/simple_state/builder.rb

@@ -30,7 +30,21 @@ module SimpleState
         include ::SimpleState::Mixins
       RUBY
 
+      # Create an anonymous module which will be added to the state machine
+      # class's inheritance chain.
+      mod = @mod = Module.new do
+        def self.inspect
+          "SimpleState::#{@klass}StateMachine"
+        end
+      end
+
+      # Declare the state machine rules.
       instance_eval(&blk)
+
+      # Insert the anonymous module.
+      @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include mod
+      RUBY
     end
 
     ##
@@ -46,22 +60,22 @@ module SimpleState
       @klass.states[name] = []
       @klass.initial_state ||= name
 
-      @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      @mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}?                # def prepared?
           self.state == :#{name}    #   self.state == :prepared
         end                         # end
       RUBY
 
       # Define transitions for this state.
-      StateBuilder.new(@klass, name).build(&blk) if blk
+      StateBuilder.new(@klass, @mod, name).build(&blk) if blk
     end
 
     ##
     # Responsible for building events for a given state.
     #
     class StateBuilder
-      def initialize(klass, state)
-        @klass, @state = klass, state
+      def initialize(klass, mod, state)
+        @klass, @module, @state = klass, mod, state
       end
 
       ##
@@ -89,7 +103,7 @@ module SimpleState
         # Keep track of valid transitions for this state.
         @klass.states[@state].push([event, opts[:transitions_to]])
 
-        unless @klass.method_defined?(:"#{event}!")
+        unless @module.method_defined?(:"#{event}!")
           # Example:
           #
           # def process!
@@ -100,7 +114,7 @@ module SimpleState
           #     false
           #   end
           # end
-          @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          @module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{event}!
               if self.class._valid_transition?(self.state, :#{event})
                 self.state =

data/spec/event_methods_spec.rb

@@ -1,91 +1,119 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
-# Event Validation ===========================================================
+describe 'Generated event methods' do
 
-describe 'Generated event methods when the transition is valid' do
-  before(:each) do
-    @c = state_class do
-      state :begin do
-        event :go, :transitions_to => :state_one
+  it 'should permit the use of super when overriding them' do
+    @c = Class.new do
+      attr_reader :called
+
+      extend SimpleState
+
+      state_machine do
+        state :begin do
+          event :go, :transitions_to => :finished
+        end
+
+        state :finished
       end
 
-      state :state_one
-    end
-  end
+      def go!
+        @called = true
+        super()
+      end
+    end.new
 
-  it 'should return the new state' do
-    @c.go!.should == :state_one
+    @c.should be_begin
+    lambda { @c.go! }.should_not raise_error(NoMethodError)
+    @c.should be_finished
+    @c.called.should be_true
   end
 
-  it 'should transition the instance to the new state' do
-    @c.go!
-    @c.should be_state_one
-  end
-end
+  # Event Validation =========================================================
 
-describe 'Generated event methods when the transition is not valid' do
-  before(:each) do
-    @c = state_class do
-      state :begin do
-        event :go, :transitions_to => :state_one
-      end
+  describe 'when the transition is valid' do
+    before(:each) do
+      @c = state_class do
+        state :begin do
+          event :go, :transitions_to => :state_one
+        end
 
-      state :state_one do
-        event :go_again, :transitions_to => :state_two
+        state :state_one
       end
+    end
 
-      state :state_two
+    it 'should return the new state' do
+      @c.go!.should == :state_one
     end
-  end
 
-  it 'should return false' do
-    @c.go_again!.should be_false
+    it 'should transition the instance to the new state' do
+      @c.go!
+      @c.should be_state_one
+    end
   end
 
-  it "should not change the instance's state" do
-    @c.go_again!
-    @c.should be_begin
+  describe 'when the transition is not valid' do
+    before(:each) do
+      @c = state_class do
+        state :begin do
+          event :go, :transitions_to => :state_one
+        end
+
+        state :state_one do
+          event :go_again, :transitions_to => :state_two
+        end
+
+        state :state_two
+      end
+    end
+
+    it 'should return false' do
+      @c.go_again!.should be_false
+    end
+
+    it "should not change the instance's state" do
+      @c.go_again!
+      @c.should be_begin
+    end
   end
-end
 
+  # Multiple Paths Definition ================================================
 
-# Multiple Paths Definition ==================================================
+  describe 'when mulitple states share the same event' do
+    before(:each) do
+      @path = state_class do
+        state :begin do
+          event :s1, :transitions_to => :state_one
+          event :s2, :transitions_to => :state_two
+        end
 
-describe 'Generated event methods when mulitple states share the same event' do
-  before(:each) do
-    @path = state_class do
-      state :begin do
-        event :s1, :transitions_to => :state_one
-        event :s2, :transitions_to => :state_two
-      end
+        state :state_one do
+          event :go, :transitions_to => :state_three
+        end
 
-      state :state_one do
-        event :go, :transitions_to => :state_three
-      end
+        state :state_two do
+          event :go, :transitions_to => :state_four
+        end
 
-      state :state_two do
-        event :go, :transitions_to => :state_four
+        state :state_three
+        state :state_four
       end
+    end
 
-      state :state_three
-      state :state_four
+    it 'should transition to state_three if currently in state_one' do
+      @path.s1!
+      @path.go!
+      @path.should be_state_three
     end
-  end
 
-  it 'should transition to state_three if currently in state_one' do
-    @path.s1!
-    @path.go!
-    @path.should be_state_three
+    it 'should transition to state_four if current in state_two' do
+      @path.s2!
+      @path.go!
+      @path.should be_state_four
+    end
   end
 
-  it 'should transition to state_four if current in state_two' do
-    @path.s2!
-    @path.go!
-    @path.should be_state_four
-  end
 end
 
-
 # Test full workflow =========================================================
 # This tests all the possible transition permutations of a state machine.
 

data/spec/predicate_methods_spec.rb

@@ -17,4 +17,24 @@ describe SimpleState, 'generated predicate methods' do
     @predicate_test.should_not be_state_two
     @predicate_test.should_not be_state_three
   end
+
+  it 'should permit the use of super when overriding them' do
+    @c = Class.new do
+      attr_reader :called
+
+      extend SimpleState
+
+      state_machine do
+        state :begin
+      end
+
+      def begin?
+        @called = true
+        super()
+      end
+    end.new
+
+    lambda { @c.begin? }.should_not raise_error(NoMethodError)
+    @c.called.should be_true
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: anthonyw-simple_state
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Anthony Williams
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-09 00:00:00 -07:00
+date: 2009-03-10 00:00:00 -07:00
 default_executable: 
 dependencies: []