davidlee-state-fu 0.3.1 → 0.10.0

data/spec/units/binding_spec.rb

@@ -27,29 +27,27 @@ describe StateFu::Binding do
   before do
     reset!
     make_pristine_class('Klass')
-    Klass.machine(){}
+    Klass.state_fu_machine(){}
     @obj = Klass.new()
   end
 
   describe "constructor" do
     before do
-      mock( StateFu::FuSpace ).field_names() do
-        {
-          Klass => { :example => :example_field }
-        }
+      mock(Klass).state_fu_field_names.at_most(1) do
+        { :example => :example_field }
       end
     end
 
     it "should create a new Binding given valid arguments" do
-      b = StateFu::Binding.new( Klass.machine, @obj, :example )
+      b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )
       b.should be_kind_of( StateFu::Binding )
       b.object.should      == @obj
-      b.machine.should     == Klass.machine
+      b.machine.should     == Klass.state_fu_machine
       b.method_name.should == :example
     end
 
     it "should add any options supplied to the binding" do
-      b = StateFu::Binding.new( Klass.machine, @obj, :example,
+      b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example,
                                 :colour => :red,
                                 :style  => [:robust, :fruity] )
       b.options.should == { :colour => :red, :style  => [:robust, :fruity] }
@@ -66,23 +64,23 @@ describe StateFu::Binding do
 
       describe "when StateFu::Persistence.active_record_column? is true" do
         before do
-          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field).times(2) { true }
-          mock( Klass ).before_save( :state_fu!) { }
+          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field).times(1) { true }
+          mock( Klass ).before_create( :state_fu!) { }
         end
         it "should get an ActiveRecord persister" do
           mock( StateFu::Persistence::ActiveRecord ).new( anything, :example_field ) { @p }
-          b = StateFu::Binding.new( Klass.machine, @obj, :example )
+          b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )
           b.persister.should == @p
         end
       end
 
       describe "when StateFu::Persistence.active_record_column? is false" do
         before do
-          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field).times(2) { false }
+          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field) { false }
         end
         it "should get an Attribute persister" do
           mock( StateFu::Persistence::Attribute ).new( anything, :example_field ) { @p }
-          b = StateFu::Binding.new( Klass.machine, @obj, :example )
+          b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )
           b.persister.should == @p
         end
       end
@@ -93,10 +91,10 @@ describe StateFu::Binding do
     it "should create a new StateFu::Binding with default method-name & field_name" do
       b = @obj.state_fu()
       b.should be_kind_of( StateFu::Binding )
-      b.machine.should == Klass.machine
-      b.object.should == @obj
-      b.method_name.should == :state_fu
-      b.field_name.should  == :state_fu_field
+      b.machine.should      == Klass.state_fu_machine
+      b.object.should       == @obj
+      b.method_name.should       == StateFu::DEFAULT
+      b.field_name.to_sym.should == StateFu::DEFAULT_FIELD
     end
   end
 
@@ -104,13 +102,13 @@ describe StateFu::Binding do
     before do
       reset!
       make_pristine_class('Klass')
-      Klass.machine do
+      Klass.state_fu_machine do
         state :new do
           event :age, :to => :old
         end
         state :old
       end
-      @machine   = Klass.machine()
+      @machine   = Klass.state_fu_machine()
       @object    = Klass.new()
       @binding   = @object.state_fu()
     end
@@ -144,9 +142,14 @@ describe StateFu::Binding do
       before do
         reset!
         make_pristine_class("Klass")
-        @machine = Klass.machine do
+        Klass.class_eval do
+          def tissue?(*args); "o_O"; end
+        end
+        @machine = Klass.state_fu_machine do
           state :snoo do
-            event :am_fireable, :to => :wizz
+            event :am_fireable, :to => :wizz do
+              requires :tissue?
+            end
           end
           state :wizz do
             event :not_fireable, :to => :pong
@@ -171,7 +174,15 @@ describe StateFu::Binding do
       end
 
       describe "when called with additional arguments after the destination event/state" do
-        it "should pass the arguments to any requirements to determine transition availability"
+
+        # This would make very little sense to someone trying to understand how to use the library.
+        it "should pass the arguments to any requirements to determine transition availability" do
+          pending
+          mock(@obj).tissue?() do
+            current_transition.should be_kind_of(StateFu::Transition)
+          end #{|tr| tr.args.should == [:a,:b] }
+          @obj.state_fu.am_fireable?(:a, :b)
+        end
       end
 
     end

data/spec/units/event_spec.rb

@@ -86,7 +86,7 @@ describe StateFu::Event do
           end
 
           it "should have the event as the sprocket" do
-            @lathe.sprocket.should == @event
+            @lathe.state_or_event.should == @event
           end
 
         end
@@ -203,31 +203,12 @@ describe StateFu::Event do
           @event.from?( :a ).should == true
         end
 
-        it "should return false given a symbol which is not the name of a state in @origin" do
+        it "should return nil given a symbol which is not the name of a state in @origin" do
           mock( @event ).origins().times(any_times) {  [StateFu::State.new(@machine,:a)] }
-          @event.from?( :b ).should == false
+          @event.from?( :b ).should == nil
         end
       end
 
-      describe 'complete?' do
-        it "should be false if either origin / target are nil" do
-          @event.complete?.should == false
-        end
-
-        it "should be true when origin / target are both not nil" do
-          mock( @event ).origins { [:a] }
-          mock( @event ).targets { [:b] }
-          @event.complete?.should == true
-        end
-
-        it "should be false when either origin / target are nil" do
-          mock( @event ).origins { [:a] }
-          mock( @event ).targets { nil  }
-          @event.complete?.should == false
-        end
-
-      end
-
     end # describe instance methods
   end   # describe StateFu::Event
 end

data/spec/units/exceptions_spec.rb

@@ -18,11 +18,13 @@ describe StateFu::TransitionHalted do
     end
 
     it "should create a TransitionHalted given a transition" do
+      pending
       e = StateFu::TransitionHalted.new( @transition )
       e.should be_kind_of( StateFu::TransitionHalted )
     end
 
     it "should allow a custom message" do
+      pending
       msg = 'helo'
       e = StateFu::TransitionHalted.new( @transition, msg )
       e.should be_kind_of( StateFu::TransitionHalted )
@@ -30,12 +32,14 @@ describe StateFu::TransitionHalted do
     end
 
     it "should allow a message to be omitted" do
+      pending
       e = StateFu::TransitionHalted.new( @transition )
       e.should be_kind_of( StateFu::TransitionHalted )
       e.message.should == StateFu::TransitionHalted::DEFAULT_MESSAGE
     end
 
     it "should allow access to the transition" do
+      pending
       e = StateFu::TransitionHalted.new( @transition )
       e.transition.should == @transition
     end
@@ -52,12 +56,14 @@ describe StateFu::InvalidTransition do
 
   describe "constructor" do
     it "should create an InvalidTransition given a binding, event, origin & target" do
+      pending
       e = StateFu::InvalidTransition.new( @binding, @event, @origin, @target )
       e.should be_kind_of( StateFu::InvalidTransition )
       e.message.should == StateFu::InvalidTransition::DEFAULT_MESSAGE
     end
 
     it "should allow a custom message" do
+      pending
       msg = 'helo'
       e = StateFu::InvalidTransition.new( @binding, @event, @origin, @target, msg )
       e.should be_kind_of( StateFu::InvalidTransition )
@@ -65,6 +71,7 @@ describe StateFu::InvalidTransition do
     end
 
     it "should allow access to the binding, event, origin, and target" do
+      pending
       e = StateFu::InvalidTransition.new( @binding, @event, @origin, @target )
       e.binding.should == @binding
       e.event.should   == @event

data/spec/units/lathe_spec.rb

@@ -6,7 +6,7 @@ describe StateFu::Lathe do
   before do
     reset!
     make_pristine_class('Klass')
-    @machine = Object.new()
+    @machine = StateFu::Machine.new()
     @state   = Object.new()
     @event   = Object.new()
 
@@ -23,23 +23,23 @@ describe StateFu::Lathe do
       lathe = StateFu::Lathe.new( @machine )
       lathe.should be_kind_of( StateFu::Lathe )
       lathe.machine.should  == @machine
-      lathe.sprocket.should == nil
+      lathe.state_or_event.should == nil
       lathe.options.should  == {}
     end
 
-    it "should accept a sprocket (state / event ) and if given one, be a child" do
+    it "should accept a state_or_event (state / event ) and if given one, be a child" do
       options = {}
       mock( @state ).apply!( options ) {}
       lathe = StateFu::Lathe.new( @machine, @state )
       lathe.should be_kind_of( StateFu::Lathe )
       lathe.machine.should  == @machine
-      lathe.sprocket.should == @state
+      lathe.state_or_event.should == @state
       lathe.options.should  == {}
       lathe.should be_child
     end
   end
 
-  describe "lathe instance with no sprocket (master lathe for a machine)" do
+  describe "lathe instance with no state_or_event (master lathe for a machine)" do
     before do
     end
 
@@ -351,7 +351,7 @@ describe StateFu::Lathe do
         @lathe   = StateFu::Lathe.new( @machine, @state )
       end
 
-      it "should create a named event from and to the lathe's sprocket (state)" do
+      it "should create a named event from and to the lathe's state_or_event (state)" do
 
         @machine.events.should be_empty
         @machine.states.length.should == 1
@@ -380,7 +380,7 @@ describe StateFu::Lathe do
 
     describe ".event(:name)" do
       before do
-        mock( @machine ).find_or_create_states_by_name( @lathe.sprocket ).at_least(1) { @lathe.sprocket }
+        mock( @machine ).find_or_create_states_by_name( @lathe.state_or_event ).at_least(1) { @lathe.state_or_event }
       end
 
       it "should create the named event if it does not exist" do

data/spec/units/machine_spec.rb

@@ -16,17 +16,17 @@ describe StateFu::Machine do
     end
 
     describe "Machine.for_class" do
-      describe "when there's no matching machine in FuSpace" do
+      describe "when there's no machine defined for the class" do
         before do
           reset!
           make_pristine_class 'Klass'
-          mock( StateFu::FuSpace ).class_machines() { { Klass => {} } }
+  #        mock( Klass ).machines() { {} }
         end
 
         it "should create a new machine and bind! it" do
           @machine = Object.new
           mock( @machine ).bind!( Klass, :moose, nil )
-          mock( StateFu::Machine ).new( :moose, {} ) { @machine }
+          mock( StateFu::Machine ).new( {} ) { @machine }
           StateFu::Machine.for_class( Klass, :moose )
         end
 
@@ -34,15 +34,8 @@ describe StateFu::Machine do
           @m = StateFu::Machine.for_class( Klass, :snoo ) do
             state :porpoise
           end
-          @m.states.map(&:name).should == [:porpoise]
-        end
-      end
-
-      describe "when there's a matching machine in FuSpace" do
-        it "should retrieve the previously created machine" do
-          @machine = Object.new
-          mock( StateFu::FuSpace ).class_machines() { { Klass => { :moose => @machine } } }
-          StateFu::Machine.for_class( Klass, :moose ).should == @machine
+#          mock( Klass ).machines() { {} }
+ #         @m.states.map(&:name).should == [:porpoise]
         end
       end
 
@@ -56,24 +49,23 @@ describe StateFu::Machine do
     before do
       reset!
       make_pristine_class 'Klass'
-      @mchn = StateFu::Machine.new( :spec_machine, options={} )
+      @m = StateFu::Machine.new
     end
 
     describe "helper" do
       it "should add its arguments to the @@helpers array" do
         module Foo; FOO = :foo; end
         module Bar; BAR = :bar; end
-        @mchn.helper Foo, Bar
-        @mchn.helpers.should == [Foo, Bar]
+        @m.helper Foo, Bar
+        @m.helpers.should == [Foo, Bar]
       end
 
     end
 
     describe ".initialize" do
-      it "should require a name" do
-        lambda do
-          StateFu::Machine.new()
-        end.should raise_error( ArgumentError )
+      it "should apply options to the machine" do
+        @m = StateFu::Machine.new( :colour => "blue")
+        @m.options.should == {:colour => "blue" }
       end
     end
 
@@ -82,42 +74,42 @@ describe StateFu::Machine do
     end
 
     describe ".bind!" do
-      it "should call StateFu::FuSpace.insert! with itself and its arguments" do
+      it "should call StateFu::Machine.bind! with itself and its arguments" do
         field_name = :my_field_name
-        mock( StateFu::FuSpace ).insert!( Klass, @mchn, :newname, field_name ) {}
-        @mchn.bind!( Klass, :newname, field_name )
+        mock( StateFu::Machine ).bind!( @m, Klass, :newname, field_name ) {}
+        @m.bind!( Klass, :newname, field_name )
       end
 
       it "should generate a field name if none is given" do
         klass      = Klass
         name       = :StinkJuice
         field_name = 'stink_juice_field'
-        mock( StateFu::FuSpace ).insert!( Klass, @mchn, name, field_name.to_sym ) {}
-        @mchn.bind!( Klass, name )
+        @m.bind!( Klass, name )
+        Klass.state_fu_field_names[name].should == 'stink_juice_field'
       end
     end
 
     describe ".initial_state=" do
 
       it "should set @initial_state given a String, Symbol or State for an existing state" do
-        state = StateFu::State.new( @mchn, :wizzle )
-        @mchn.states << state
-        @mchn.initial_state = state
-        @mchn.initial_state.should == state
+        state = StateFu::State.new( @m, :wizzle )
+        @m.states << state
+        @m.initial_state = state
+        @m.initial_state.should == state
       end
 
       it "should create the state if it doesnt exist" do
-        @mchn.initial_state = :snoo
-        @mchn.initial_state.should be_kind_of( StateFu::State )
-        @mchn.initial_state.name.should == :snoo
-        @mchn.states.should include( @mchn.initial_state )
+        @m.initial_state = :snoo
+        @m.initial_state.should be_kind_of( StateFu::State )
+        @m.initial_state.name.should == :snoo
+        @m.states.should include( @m.initial_state )
       end
 
       it "should raise an ArgumentError given a number or an Array" do
-        lambda do @mchn.initial_state = 6
+        lambda do @m.initial_state = 6
         end.should raise_error( ArgumentError )
 
-        lambda do @mchn.initial_state = [:ping]
+        lambda do @m.initial_state = [:ping]
         end.should raise_error( ArgumentError )
       end
 
@@ -125,110 +117,110 @@ describe StateFu::Machine do
 
     describe ".initial_state" do
       it "should return nil if there are no states and initial_state= has not been called" do
-        @mchn.states.should == []
-        @mchn.initial_state.should == nil
+        @m.states.should == []
+        @m.initial_state.should == nil
       end
 
       it "should return the first state if one exists" do
-        stub( @mchn ).states() {  [:a, :b, :c] }
-        @mchn.initial_state.should == :a
+        stub( @m ).states() {  [:a, :b, :c] }
+        @m.initial_state.should == :a
       end
 
     end
 
     describe ".states" do
       it "should return an array extended with StateFu::StateArray" do
-        @mchn.states.should be_kind_of( Array )
-        @mchn.states.extended_by.should include( StateFu::StateArray )
+        @m.states.should be_kind_of( Array )
+        @m.states.extended_by.should include( StateFu::StateArray )
       end
     end
 
     describe ".state_names" do
       it "should return a list of symbols of state names" do
-        @mchn.states << StateFu::State.new( @mchn, :a )
-        @mchn.states << StateFu::State.new( @mchn, :b )
-        @mchn.state_names.should == [:a, :b ]
+        @m.states << StateFu::State.new( @m, :a )
+        @m.states << StateFu::State.new( @m, :b )
+        @m.state_names.should == [:a, :b ]
       end
     end
 
     describe ".events" do
       it "should return an array extended with StateFu::EventArray" do
-        @mchn.events.should be_kind_of( Array )
-        @mchn.events.extended_by.should include( StateFu::EventArray )
+        @m.events.should be_kind_of( Array )
+        @m.events.extended_by.should include( StateFu::EventArray )
       end
     end
 
     describe ".event_names" do
       it "should return a list of symbols of event names" do
-        @mchn.events << StateFu::Event.new( @mchn, :a )
-        @mchn.events << StateFu::Event.new( @mchn, :b )
-        @mchn.event_names.should == [:a, :b ]
+        @m.events << StateFu::Event.new( @m, :a )
+        @m.events << StateFu::Event.new( @m, :b )
+        @m.event_names.should == [:a, :b ]
       end
     end
 
     describe ".find_or_create_states_by_name" do
       describe "given an array of symbols" do
         it "should return the states named by the symbols if they exist" do
-          a = StateFu::State.new( @mchn, :a )
-          b = StateFu::State.new( @mchn, :b )
-          @mchn.states << a
-          @mchn.states << b
-          @mchn.find_or_create_states_by_name( :a, :b ).should == [a, b]
-          @mchn.find_or_create_states_by_name( [:a, :b] ).should == [a, b]
+          a = StateFu::State.new( @m, :a )
+          b = StateFu::State.new( @m, :b )
+          @m.states << a
+          @m.states << b
+          @m.find_or_create_states_by_name( :a, :b ).should == [a, b]
+          @m.find_or_create_states_by_name( [:a, :b] ).should == [a, b]
         end
 
         it "should return the states named by the symbols and create them if they don't exist" do
-          @mchn.states.should == []
-          res = @mchn.find_or_create_states_by_name( :a, :b )
+          @m.states.should == []
+          res = @m.find_or_create_states_by_name( :a, :b )
           res.should be_kind_of( Array )
           res.length.should == 2
           res.all? { |e| e.class == StateFu::State  }.should be_true
           res.map(&:name).should == [ :a, :b ]
-          @mchn.find_or_create_states_by_name( :a, :b ).should == res
+          @m.find_or_create_states_by_name( :a, :b ).should == res
         end
       end # arr symbols
 
       describe "given an array of states" do
         it "should return the states if they're in the machine's states array" do
-          a = StateFu::State.new( @mchn, :a )
-          b = StateFu::State.new( @mchn, :b )
-          @mchn.states << a
-          @mchn.states << b
-          @mchn.find_or_create_states_by_name( a, b ).should == [a, b]
-          @mchn.find_or_create_states_by_name( [a, b] ).should == [a, b]
-          @mchn.find_or_create_states_by_name( [[a, b]] ).should == [a, b]
+          a = StateFu::State.new( @m, :a )
+          b = StateFu::State.new( @m, :b )
+          @m.states << a
+          @m.states << b
+          @m.find_or_create_states_by_name( a, b ).should == [a, b]
+          @m.find_or_create_states_by_name( [a, b] ).should == [a, b]
+          @m.find_or_create_states_by_name( [[a, b]] ).should == [a, b]
         end
 
         it "should add the states to the machine's states array if they're absent" do
-          a = StateFu::State.new( @mchn, :a )
-          b = StateFu::State.new( @mchn, :b )
-          @mchn.find_or_create_states_by_name( a, b ).should == [a, b]
-          @mchn.find_or_create_states_by_name( [a, b] ).should == [a, b]
-          @mchn.find_or_create_states_by_name( [[a, b]] ).should == [a, b]
+          a = StateFu::State.new( @m, :a )
+          b = StateFu::State.new( @m, :b )
+          @m.find_or_create_states_by_name( a, b ).should == [a, b]
+          @m.find_or_create_states_by_name( [a, b] ).should == [a, b]
+          @m.find_or_create_states_by_name( [[a, b]] ).should == [a, b]
         end
       end # arr states
     end # find_or_create_states_by_name
 
     describe "requirement_messages" do
       it "should be a hash" do
-        @mchn.should respond_to(:requirement_messages)
-        @mchn.requirement_messages.should be_kind_of( Hash )
+        @m.should respond_to(:requirement_messages)
+        @m.requirement_messages.should be_kind_of( Hash )
       end
 
       it "should be empty by default" do
-        @mchn.requirement_messages.should be_empty
+        @m.requirement_messages.should be_empty
       end
 
     end # requirement_messages
 
     describe "named_procs" do
       it "should be a hash" do
-        @mchn.should respond_to(:named_procs)
-        @mchn.named_procs.should be_kind_of( Hash )
+        @m.should respond_to(:named_procs)
+        @m.named_procs.should be_kind_of( Hash )
       end
 
       it "should be empty by default" do
-        @mchn.named_procs.should be_empty
+        @m.named_procs.should be_empty
       end
 
     end # named_procs