davidlee-state-fu 0.3.1 → 0.10.0

data/spec/integration/requirement_reflection_spec.rb

@@ -6,8 +6,17 @@ describe "Transition requirement reflection" do
 
   before do
     reset!
-    make_pristine_class("Klass")
-    @machine = Klass.machine do
+    make_pristine_class("Klass") do
+      def turban?;         false end
+      def arrest_warrant?; false end
+      def papers_in_order?; true end
+      def papers_in_order?; true end
+      def money_for_bribe?; true end
+      def spacesuit?;       true end
+      def plane_ticket?;    true end
+      def fuel?;            true end
+    end
+    @machine = Klass.state_fu_machine do
       state :soviet_russia do
         requires( :papers_in_order?, :on => [:entry, :exit] )
         requires( :money_for_bribe?, :on => [:entry, :exit] )
@@ -38,29 +47,23 @@ describe "Transition requirement reflection" do
 
     end # machine
     @obj = Klass.new()
-    stub( @obj ).papers_in_order?   { true }
-    stub( @obj ).money_for_bribe?   { true }
-    stub( @obj ).no_turban?         { true }
-    stub( @obj ).no_arrest_warrant? { true }
-    stub( @obj ).spacesuit?         { true }
-    stub( @obj ).plane_ticket?      { true }
-    stub( @obj ).fuel?              { true }
   end  # before
 
   describe "transition.valid? / transition.requirements_met?" do
     it "should be true if all requirements are met (return truth)" do
-      @obj.state_fu.next_states[:moon].entry_requirements.should == [:spacesuit?]
-      @obj.state_fu.evaluate_requirement_with_args(:spacesuit?).should == true
-      @obj.fly_spaceship?(:moon).should == true
-      @obj.fly_spaceship(:moon).requirements_met?.should == true
-      @obj.fly_spaceship(:moon).should be_valid
+      #@obj.state_fu.next_states[:moon].entry_requirements.should == [:spacesuit?]
+      
+      #@obj.state_fu.fireable?([:fly_spaceship,:moon]).should == true
+      @obj.can_fly_spaceship?(:moon).should == true
+      #@obj.fly_spaceship(:moon).requirements_met?.should == true
+      #@obj.fly_spaceship(:moon).should be_valid
     end
 
     it "should be false if not all requirements are met" do
       stub( @obj ).spacesuit?() { false }
       @obj.state_fu.next_states[:moon].entry_requirements.should == [:spacesuit?]
-      @obj.state_fu.evaluate_requirement_with_args(:spacesuit?).should == false
-      @obj.fly_spaceship?(:moon).should == false
+      # @obj.state_fu.evaluate(:spacesuit?).should == false
+      @obj.can_fly_spaceship?(:moon).should == false
       @obj.fly_spaceship(:moon).requirements_met?.should == false
       @obj.fly_spaceship(:moon).should_not be_valid
     end
@@ -68,11 +71,11 @@ describe "Transition requirement reflection" do
 
   describe "flying from russia to america without one's affairs in order while wearing a turban" do
     before do
-      mock( @obj ).us_visa?() { false }
-      mock( @obj ).no_turban?() { false }
-      mock( @obj ).no_arrest_warrant?() { false }
-      mock( @obj ).money_for_bribe?() { false }
-      mock( @obj ).papers_in_order?() { false }
+      mock( @obj ).us_visa?(anything) { false }
+      mock( @obj ).no_turban?(anything) { false }
+      mock( @obj ).no_arrest_warrant?(anything) { false }
+      mock( @obj ).money_for_bribe?(anything) { false }
+      mock( @obj ).papers_in_order?(anything) { false }
     end
 
     describe "when no messages are supplied for the requirements" do
@@ -88,14 +91,15 @@ describe "Transition requirement reflection" do
 
       describe "given transition.unmet_requirement_messages" do
         it "should return a list of nils" do
-          @obj.state_fu.catch_plane(:america).unmet_requirement_messages.should == [nil,nil,nil,nil,nil]
+          @obj.state_fu.catch_plane(:america).unmet_requirement_messages.should ==
+            [:papers_in_order?, :money_for_bribe?, :no_turban?, :us_visa?, :no_arrest_warrant?]
         end
       end # unmet_requirement_messages
     end
 
     describe "when a message is supplied for the money_for_bribe? entry requirement" do
       before do
-        Klass.machine do
+        Klass.state_fu_machine do
           state :soviet_russia do
             requires( :money_for_bribe?, :message => "This guard is thirsty! Do you have anything to declare?" )
           end
@@ -114,13 +118,15 @@ describe "Transition requirement reflection" do
 
       describe "given transition.unmet_requirement_messages" do
         it "should contain a list of nils plus the requirement message for money_for_bribe? as a string" do
-          @obj.state_fu.catch_plane(:america).unmet_requirement_messages.should == [ nil,
-                                                                                     "This guard is thirsty! Do you have anything to declare?",
-                                                                                     nil,
-                                                                                     nil,
-                                                                                     nil ]
+          @obj.state_fu.catch_plane(:america).unmet_requirement_messages.should ==
+            [:papers_in_order?,
+             "This guard is thirsty! Do you have anything to declare?",
+             :no_turban?,
+             :us_visa?,
+             :no_arrest_warrant?]
         end
       end
+
     end
   end # flying with a turban
 
@@ -131,8 +137,8 @@ describe "Transition requirement reflection" do
 
     describe "when a message is supplied for the requirement" do
       it "should contain a list of the requirement failure messages as strings" do
-        mock( @obj ).spacesuit?() { false }
-        mock( @obj ).fuel?() { false }
+        mock( @obj ).spacesuit?(anything) { false }
+        mock( @obj ).fuel?(anything) { false }
         @obj.state_fu.fly_spaceship(:moon).unmet_requirements.should == [:spacesuit?, :fuel?]
       end
     end
@@ -154,9 +160,10 @@ describe "Transition requirement reflection" do
         messages = t.unmet_requirement_messages
         messages.should be_kind_of( Array )
         messages.length.should == 2
-        messages.compact.length.should == 1
-        messages.compact.first.should be_kind_of( String )
-        messages.compact.first.should == @msg
+        messages.strings.length.should == 1
+        messages.symbols.length.should == 1
+        messages.strings.first.should == @msg
+        messages.symbols.first.should == :fuel?
       end
     end
 
@@ -177,15 +184,16 @@ describe "Transition requirement reflection" do
           messages = t.unmet_requirement_messages
           messages.should be_kind_of( Array )
           messages.length.should == 2
-          messages.compact.length.should == 1
-          messages.compact.first.should be_kind_of( String )
-          messages.compact.first.should == "I am a StateFu::Transition and I fail it"
+          messages.strings.length.should == 1
+          messages.strings.first.should be_kind_of( String )
+          messages.strings.first.should == "I am a StateFu::Transition and I fail it"
+          messages.symbols.first.should == :fuel?
         end
       end # arity 1
 
       describe "when the arity of the proc is 0" do
         before do
-          @msg = lambda { "I am a #{self.class} and I fail it" }
+          @msg = lambda { "No #{t.target.name} for you!" }
           @machine.requirement_messages[:spacesuit?] = @msg
         end
 
@@ -195,52 +203,53 @@ describe "Transition requirement reflection" do
           messages = t.unmet_requirement_messages
           messages.should be_kind_of( Array )
           messages.length.should == 2
-          messages.compact.length.should == 1
-          messages.compact.first.should be_kind_of( String )
-          messages.compact.first.should == "I am a StateFu::Transition and I fail it"
+          messages.strings.length.should == 1
+          messages.strings.first.should be_kind_of( String )
+          messages.strings.first.should == "No moon for you!"
+          messages.symbols.first.should == :fuel?
         end
       end # arity 1
 
     end # 1 proc msg of 2
     describe "when a symbol message is defined for one of two unmet_requirements" do
       before do
-        stub( @obj ).spacesuit?() { false }
-        stub( @obj ).fuel?() { false }
+
         @machine.requirement_messages[:spacesuit?] = :no_spacesuit_msg_method
         Klass.class_eval do
           attr_accessor :arg
-
-          def no_spacesuit_msg_method( t )
-            self.arg = t
-            raise ArgumentError unless t.is_a?( StateFu::Transition )
+          def spacesuit?; false end
+          def fuel?;      false end            
+          
+          def no_spacesuit_msg_method(t)
             "You can't go to the #{t.target.name} without a spacesuit!"
           end
+          
         end
       end
 
       describe "when there is no named proc on the machine matching the symbol" do
 
-        it "should call the method on @obj given transition.evaluate_named_proc_or_method() with the method name" do
-          @obj.method( :no_spacesuit_msg_method ).arity.should == 1
+        it "should call the method on @obj given transition.evaluate() with the method name" do          
           t = @obj.state_fu.fly_spaceship(:moon)
-          x = @obj.state_fu.evaluate_named_proc_or_method(:no_spacesuit_msg_method, t)
-          @obj.arg.should == t
-          x.should =~ /You can't go to the moon/
+          @obj.arg.should == nil
+          t.unmet_requirement_messages.should == ["You can't go to the moon without a spacesuit!", :fuel?]
         end
 
         it "should call t.evaluate_named_proc_or_method(:no_spacesuit_msg_method)" do
           t = @obj.state_fu.fly_spaceship(:moon)
           t.unmet_requirements.length.should == 2
-          mock( t ).evaluate_named_proc_or_method(:no_spacesuit_msg_method, t) { :my_string }
+          stub( t ).evaluate( anything) { false }
+
+          mock( t ).evaluate(:no_spacesuit_msg_method){ ":)" }
           messages = t.unmet_requirement_messages
-          messages.should include(:my_string )
+          messages.should include( ":)" )
         end
 
         it "should call the method on @obj with the name of the symbol, passing it a transition" do
           t = @obj.state_fu.fly_spaceship(:moon)
           t.unmet_requirements.length.should == 2
           messages = t.unmet_requirement_messages
-          @obj.arg.should == t
+          @obj.arg.should == nil
         end
 
         it "should return the result of the method execution as the message" do
@@ -248,9 +257,9 @@ describe "Transition requirement reflection" do
           t.unmet_requirements.length.should == 2
           messages = t.unmet_requirement_messages
           messages.length.should == 2
-          messages.compact.length.should == 1
-          @obj.arg.should == t
-          messages.compact[0].should == "You can't go to the moon without a spacesuit!"
+          messages.strings.length.should == 1
+          #@obj.arg.should == t
+          messages.strings[0].should == "You can't go to the moon without a spacesuit!"
         end
       end # no named proc
     end   # symbol message

data/spec/integration/state_definition_spec.rb

@@ -14,37 +14,37 @@ describe "Adding states to a Machine" do
   end
 
   it "should allow me to call machine() { state(:egg) }" do
-    lambda {Klass.machine(){ state :egg } }.should_not raise_error()
+    lambda {Klass.state_fu_machine(){ state :egg } }.should_not raise_error()
   end
 
   describe "having called machine() { state(:egg) }" do
 
     before(:each) do
-      Klass.machine(){ state :egg }
+      Klass.state_fu_machine(){ state :egg }
     end
 
     it "should return [:egg] given machine.state_names" do
-      Klass.machine.should respond_to(:state_names)
-      Klass.machine.state_names.should == [:egg]
+      Klass.state_fu_machine.should respond_to(:state_names)
+      Klass.state_fu_machine.state_names.should == [:egg]
     end
 
     it "should return [<StateFu::State @name=:egg>] given machine.states" do
-      Klass.machine.should respond_to(:states)
-      Klass.machine.states.length.should == 1
-      Klass.machine.states.first.should be_kind_of( StateFu::State )
-      Klass.machine.states.first.name.should == :egg
+      Klass.state_fu_machine.should respond_to(:states)
+      Klass.state_fu_machine.states.length.should == 1
+      Klass.state_fu_machine.states.first.should be_kind_of( StateFu::State )
+      Klass.state_fu_machine.states.first.name.should == :egg
     end
 
     it "should return :egg given machine.states.first.name" do
-      Klass.machine.should respond_to(:states)
-      Klass.machine.states.length.should == 1
-      Klass.machine.states.first.should respond_to(:name)
-      Klass.machine.states.first.name.should == :egg
+      Klass.state_fu_machine.should respond_to(:states)
+      Klass.state_fu_machine.states.length.should == 1
+      Klass.state_fu_machine.states.first.should respond_to(:name)
+      Klass.state_fu_machine.states.first.name.should == :egg
     end
 
     it "should return a <StateFu::State @name=:egg> given machine.states[:egg]" do
-      Klass.machine.should respond_to(:states)
-      result = Klass.machine.states[:egg]
+      Klass.state_fu_machine.should respond_to(:states)
+      result = Klass.state_fu_machine.states[:egg]
       result.should_not be_nil
       result.should be_kind_of( StateFu::State )
       result.name.should == :egg
@@ -52,22 +52,22 @@ describe "Adding states to a Machine" do
 
 
     it "should allow me to call machine(){ state(:chick) }" do
-      lambda {Klass.machine(){ state :chick } }.should_not raise_error()
+      lambda {Klass.state_fu_machine(){ state :chick } }.should_not raise_error()
     end
 
     describe "having called machine() { state(:chick) }" do
       before do
-        Klass.machine() { state :chick }
+        Klass.state_fu_machine() { state :chick }
       end
 
       it "should return [:egg] given machine.state_names" do
-        Klass.machine.should respond_to(:state_names)
-        Klass.machine.state_names.should == [:egg, :chick]
+        Klass.state_fu_machine.should respond_to(:state_names)
+        Klass.state_fu_machine.state_names.should == [:egg, :chick]
       end
 
       it "should return a <StateFu::State @name=:chick> given machine.states[:egg]" do
-        Klass.machine.should respond_to(:states)
-        result = Klass.machine.states[:chick]
+        Klass.state_fu_machine.should respond_to(:states)
+        result = Klass.state_fu_machine.states[:chick]
         result.should_not be_nil
         result.should be_kind_of( StateFu::State )
         result.name.should == :chick
@@ -79,7 +79,7 @@ describe "Adding states to a Machine" do
 
       it "should yield the state to the block as |s|" do
         state = nil
-        Klass.machine() do
+        Klass.state_fu_machine() do
           state(:bird) do |s|
             state = s
           end
@@ -94,14 +94,14 @@ describe "Adding states to a Machine" do
 
       it "should instance_eval the block as a StateFu::Lathe" do
         lathe = nil
-        Klass.machine() do
+        Klass.state_fu_machine() do
           state(:bird) do
             lathe = self
           end
         end
         lathe.should be_kind_of(StateFu::Lathe)
-        lathe.sprocket.should be_kind_of(StateFu::State)
-        lathe.sprocket.name.should == :bird
+        lathe.state_or_event.should be_kind_of(StateFu::State)
+        lathe.state_or_event.name.should == :bird
       end
 
     end
@@ -109,10 +109,10 @@ describe "Adding states to a Machine" do
     describe "calling state(:bird) consecutive times" do
 
       it "should yield the same state each time" do
-        Klass.machine() { state :bird }
-        bird_1 = Klass.machine.states[:bird]
-        Klass.machine() { state :bird }
-        bird_2 = Klass.machine.states[:bird]
+        Klass.state_fu_machine() { state :bird }
+        bird_1 = Klass.state_fu_machine.states[:bird]
+        Klass.state_fu_machine() { state :bird }
+        bird_2 = Klass.state_fu_machine.states[:bird]
         bird_1.should == bird_2
       end
 
@@ -122,56 +122,62 @@ describe "Adding states to a Machine" do
   describe "calling machine() { states(:egg, :chick, :bird, :poultry => true) }" do
 
     it "should create 3 states" do
-      Klass.machine().should be_empty
-      Klass.machine() { states(:egg, :chick, :bird, :poultry => true) }
-      Klass.machine().state_names().should == [:egg, :chick, :bird]
-      Klass.machine().states.length.should == 3
-      Klass.machine().states.map(&:name).should == [:egg, :chick, :bird]
-      Klass.machine().states().each do |s|
+      Klass.state_fu_machine().should be_empty
+      Klass.state_fu_machine() { states(:egg, :chick, :bird, :poultry => true) }
+      Klass.state_fu_machine().state_names().should == [:egg, :chick, :bird]
+      Klass.state_fu_machine().states.length.should == 3
+      Klass.state_fu_machine().states.map(&:name).should == [:egg, :chick, :bird]
+      Klass.state_fu_machine().states().each do |s|
         s.options[:poultry].should be_true
         s.should be_kind_of(StateFu::State)
       end
+    end
 
-      describe "merging options" do
-        it "should merge options when states are mentioned more than once" do
-          StateFu::FuSpace.reset!
-          Klass.machine() { states(:egg, :chick, :bird, :poultry => true) }
-          machine = Klass.machine
-          machine.states.length.should == 3
-
-          # make sure they're the same states
-          states_1 = machine.states
-          Klass.machine(){ states( :egg, :chick, :bird, :covering => 'feathers')}
-          states_1.should == machine.states
-
-          # ensure options were merged
-          machine.states().each do |s|
-            s.options[:poultry].should be_true
-            s.options[:covering].should == 'feathers'
-            s.should be_kind_of(StateFu::State)
-          end
+    describe "merging options" do
+      before do
+        make_pristine_class('Klass')          
+      end     
+      it "should merge options when states are mentioned more than once" do
+        # reset! 
+        machine = Klass.state_fu_machine
+        machine.states.length.should == 0
+        Klass.state_fu_machine() { states(:egg, :chick, :bird, :poultry => true) }
+        machine = Klass.state_fu_machine
+        machine.states.length.should == 3
+
+        # make sure they're the same states
+        states_1 = machine.states
+        Klass.state_fu_machine(){ states( :egg, :chick, :bird, :covering => 'feathers')}
+        states_1.should == machine.states
+
+        # ensure options were merged
+        machine.states().each do |s|
+          s.options[:poultry].should be_true
+          s.options[:covering].should == 'feathers'
+          s.should be_kind_of(StateFu::State)
         end
       end
     end
   end
+end
 
-  describe "adding events inside a state block" do
-    before do
-      @lambda = lambda{ Klass.machine(){ state(:egg){ event(:hatch, :to => :chick) }}}
-    end
+describe "adding events inside a state block" do
+  before do
+    @lambda = lambda{ Klass.state_fu_machine(){ state(:egg){ event(:hatch, :to => :chick) }}}
+  end
 
-    it "should not throw an error" do
-      @lambda.should_not raise_error
-    end
+  it "should not throw an error" do
+    @lambda.should_not raise_error
+  end
 
-    describe "Klass.machine(){ state(:egg){ event(:hatch, :to => :chick) }}}" do
-      before() do
-        Klass.machine(){ state(:egg){ event(:hatch, :to => :chick) }}
-      end
-      it "should add an event :hatch to the machine" do
-      end
+  describe "Klass.state_fu_machine(){ state(:egg){ event(:hatch, :to => :chick) }}}" do
+    before() do
+      Klass.state_fu_machine(){ state(:egg){ event(:hatch, :to => :chick) }}
+    end
+    it "should add an event :hatch to the machine" do
     end
   end
-
 end
 
+
+