state-fu 0.13.1 → 0.13.3

data/lib/support/vizier.rb

@@ -25,6 +25,7 @@ module Vizier  #:nodoc:all
     end
 
     def legal?( str )
+      str = str.to_s
       str =~ /^[#{LEGAL_CHARS}]+$/ && str == str.split
     end
 

data/spec/features/plotter_spec.rb

@@ -47,29 +47,29 @@ describe StateFu::Plotter do
     describe ".generate" do
 
       it "should call generate_dot!" do
-        mock( @plotter ).generate_dot!() { "dot" }
+        @plotter.should_receive(:generate_dot!).and_return("dot")
         @plotter.generate
       end
 
       it "should store the result in the dot attribute" do
-        mock( @plotter).generate_dot!() { "dot" }
+        @plotter.should_receive(:generate_dot!).and_return("dot")
         @plotter.generate
         @plotter.dot.should == "dot"
       end
 
       describe ".save_as(filename)" do
         it "should save the string to a file" do
-          mock( File).open( 'filename', 'w' ).yields( @fh = Object.new() )
-          mock( @fh ).write( @plotter.output )
+          File.should_receive(:open).with('filename', 'w').and_yield(@fh = Object.new())
+          @fh.should_receive(:write).with(@plotter.output)
           @plotter.output.save_as( 'filename' )
         end
       end
 
       describe ".save!" do
         it "should save the string in a tempfile and return the path" do
-          mock(@tempfile = Object.new).path {"path"}.subject
-          mock(Tempfile).new(['state_fu_graph','.dot']).yields( @fh = Object.new() ) { @tempfile }
-          mock( @fh ).write( @plotter.output )
+          (@tempfile = Object.new).should_receive(:path).and_return('path')
+          (@fh = Object.new()).should_receive(:write).with(@plotter.output)          
+          Tempfile.should_receive(:new).with(['state_fu_graph','.dot']).and_yield(@fh).and_return(@tempfile)
           @plotter.output.save!.should == 'path'
         end
       end

data/spec/helper.rb

@@ -1,13 +1,3 @@
 #!/usr/bin/env ruby
 require File.join(File.dirname(__FILE__),'spec_helper')
 
-begin
-  require 'rr'
-rescue LoadError => e
-  STDERR.puts "The '#{gem_name}' gem is required to run StateFu's specs. Please install it by running (as root):\ngem install #{gem_name}\n\n"
-  exit 1;
-end
-
-Spec::Runner.configure do |config|
-  config.mock_with :rr
-end

data/spec/integration/active_record_persistence_spec.rb

@@ -111,22 +111,14 @@ describe "an ActiveRecord model with StateFu included:" do
     # satisfy the not null constraint
     describe "automagic state_fu! before_save filter and validations" do
 
-      it "should call state_fu! before a record is created" do
-        @ex.should be_new_record
-        mock.proxy( @ex ).state_fu!.at_least( 1 ) { }
-        @ex.save!
-      end
-
-      it "should call state_fu! before a record is updated" do
-        @ex.should be_new_record
-        mock.proxy( @ex ).state_fu!.at_least( 1 ) { }
-        @ex.save!
-      end
+      it "should call state_fu! before a record is created"
+      it "should call state_fu! before a record is updated"
 
       it "should create a record given only a name, with the field set to the initial state" do
         ex = ExampleRecord.new( :name => "exemplar" )
-        ex.should be_valid
         ex.state_fu_field.should == nil
+        ex.should be_valid
+        ex.state_fu_field.should == 'initial'
         ex.save!
         ex.should_not be_new_record
         ex.state_fu_field.should == 'initial'

data/spec/integration/example_01_document_spec.rb

@@ -89,7 +89,7 @@ describe "Document" do
     end
 
     it "should call update_rss when publish! is called" do
-      mock( @doc ).update_rss(anything) {}
+      @doc.should_receive(:update_rss)
       @doc.status.publish!
     end
 
@@ -125,7 +125,7 @@ describe "Document" do
   describe "delete!" do
 
     it "should execute destroy()" do
-      mock( @doc ).destroy(anything) {}
+      @doc.should_receive(:destroy)
       @doc.status.delete!
     end
 

data/spec/integration/example_02_string_spec.rb

@@ -49,7 +49,8 @@ describe String do
   it "should call sanitize_for_shell! when shell.escape! is called, and be clean afterwards " do
     @str.should be_dirty
     @str.should_not be_clean
-    mock( @str ).sanitize_for_shell!(anything) {}
+    @str.should_receive(:sanitize_for_shell!)
+    
     @str.shell.escape!
     @str.should_not be_dirty
     @str.should be_clean

data/spec/integration/requirement_reflection_spec.rb

@@ -51,18 +51,14 @@ describe "Transition requirement reflection" do
 
   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.fireable?([:fly_spaceship,:moon]).should == true
+      @obj.state_fu.next_states[:moon].entry_requirements.should == [:spacesuit?]      
       @obj.can_fly_spaceship?(:moon).should == true
-      #@obj.fly_spaceship(:moon).requirements_met?.should == true
-      #@obj.fly_spaceship(:moon).should be_valid
+      @obj.fly_spaceship(:moon).should be_valid
     end
 
     it "should be false if not all requirements are met" do
-      stub( @obj ).spacesuit?() { false }
+      @obj.should_receive(:spacesuit?).any_number_of_times.and_return(false)
       @obj.state_fu.next_states[:moon].entry_requirements.should == [:spacesuit?]
-      # @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
@@ -71,11 +67,9 @@ 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?(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 }
+      %w(us_visa? no_turban? no_arrest_warrant? money_for_bribe? papers_in_order?).each do |meth|
+        @obj.should_receive(meth).any_number_of_times.and_return(false)
+      end
     end
 
     describe "when no messages are supplied for the requirements" do
@@ -136,9 +130,9 @@ describe "Transition requirement reflection" do
     end
 
     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?(anything) { false }
-        mock( @obj ).fuel?(anything) { false }
+      it "should contain a list of the requirement failure messages as strings" do        
+        @obj.should_receive(:spacesuit?).and_return(false)
+        @obj.should_receive(:fuel?).and_return(false)
         @obj.state_fu.fly_spaceship(:moon).unmet_requirements.should == [:spacesuit?, :fuel?]
       end
     end
@@ -148,8 +142,8 @@ describe "Transition requirement reflection" do
   describe "transition.unmet_requirement_messages" do
     describe "when a string message is defined for one of two unmet_requirements" do
       before do
-        stub( @obj ).spacesuit?() { false }
-        stub( @obj ).fuel?() { false }
+        @obj.should_receive(:spacesuit?).and_return(false)
+        @obj.should_receive(:fuel?).and_return(false)
         @msg = "You got no spacesuit."
         @machine.requirement_messages[:spacesuit?] = @msg
       end
@@ -169,8 +163,8 @@ describe "Transition requirement reflection" do
 
     describe "when a proc message is defined for one of two unmet_requirements" do
       before do
-        stub( @obj ).spacesuit?() { false }
-        stub( @obj ).fuel?() { false }
+        @obj.should_receive(:spacesuit?).any_number_of_times.and_return(false)
+        @obj.should_receive(:fuel?).any_number_of_times.and_return(false)
       end
 
       describe "when the arity of the proc is 1" do
@@ -239,9 +233,7 @@ describe "Transition requirement reflection" do
         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
-          stub( t ).evaluate( anything) { false }
-
-          mock( t ).evaluate(:no_spacesuit_msg_method){ ":)" }
+          t.should_receive(:evaluate).with(:no_spacesuit_msg_method).and_return ':)'
           messages = t.unmet_requirement_messages
           messages.should include( ":)" )
         end

data/spec/spec_helper.rb

@@ -20,16 +20,16 @@ module MySpecHelper
 
   def prepare_active_record( options={}, &migration )
     if skip_slow_specs?
-      skip_slow_specs and return false
+      skip_slow_specs and return 
     end
 
     begin
-      require 'activesupport'
+      require 'active_support'
       require 'active_record'
       require 'sqlite3'
     rescue LoadError => e
       pending "skipping specifications due to load error: #{e}"
-      return false
+      return 
     end
 
     options.symbolize_keys!

data/spec/state_fu_spec.rb

@@ -219,7 +219,7 @@ describe "A door which opens and shuts:" do
       rescue StateFu::RequirementError => e
         e.to_a.should == ["Sorry, it's locked."]
         e.to_h.should == {:not_locked? => "Sorry, it's locked."}
-        e.to_enum.should be_kind_of(Enumerable::Enumerator)
+        e.should respond_to(:to_enum)
         e.should_not be_empty
         e.length.should == 1
         e.each do |requirement, message|

data/spec/units/binding_spec.rb

@@ -27,11 +27,9 @@ describe StateFu::Binding do
 
   describe "constructor" do
     before do
-      mock(Klass).state_fu_options.at_most(3) do
-        { 
-          :example => {:field_name => :example_field} 
-        }
-      end
+      Klass.should_receive(:state_fu_options).at_most(3).times.and_return({
+        :example => {:field_name => :example_field}         
+      })
     end
 
     it "should create a new Binding given valid arguments" do
@@ -61,12 +59,12 @@ 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(1) { true }
-          mock( Klass ).before_create( :state_fu!) { }
+          StateFu::Persistence.should_receive(:active_record_column?).with(Klass, :example_field).and_return true
+          Klass.should_receive(:before_validation_on_create).with(:state_fu!)
         end
         
         it "should get an ActiveRecord persister" do
-          mock( StateFu::Persistence::ActiveRecord ).new( anything, :example_field ) { @p }
+          StateFu::Persistence::ActiveRecord.should_receive(:new).with(anything, :example_field).and_return(@p)
           b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )
           b.persister.should == @p
         end
@@ -74,10 +72,10 @@ describe StateFu::Binding do
 
       describe "when StateFu::Persistence.active_record_column? is false" do
         before do
-          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field) { false }
+          StateFu::Persistence.should_receive(:active_record_column?).with(Klass, :example_field).and_return false
         end
         it "should get an Attribute persister" do
-          mock( StateFu::Persistence::Attribute ).new( anything, :example_field ) { @p }
+          StateFu::Persistence::Attribute.should_receive(:new).with(anything, :example_field).and_return @p
           b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )
           b.persister.should == @p
         end
@@ -173,6 +171,7 @@ describe StateFu::Binding do
       describe "when called with additional arguments after the destination event/state" do
 
         # This would make very little sense to someone trying to understand how to use the library.
+        # figure out how to spec it properly.
         it "should pass the arguments to any requirements to determine transition availability" do
           pending
           t = nil

data/spec/units/event_spec.rb

@@ -8,7 +8,7 @@ describe StateFu::Event do
   include MySpecHelper
   before do
     @machine = Object.new
-    stub(@machine).tools() { [].extend( StateFu::ToolArray ) }
+    @machine.should_receive(:tools).any_number_of_times.and_return [].extend(StateFu::ToolArray)
   end
 
   describe "Instance methods" do
@@ -30,29 +30,29 @@ describe StateFu::Event do
 
         describe "target" do
           it "should be nil if targets is nil" do
-            stub( @event ).targets() { nil }
+            @event.should_receive(:targets).and_return nil
             @event.target.should == nil
           end
 
           it "should be nil if targets has more than one state" do
-            stub( @event ).targets() { [@state_a, @state_b] }
+            @event.should_receive(:targets).at_least(1).times.and_return [@state_a, @state_b]
             @event.target.should == nil
           end
 
           it "should be the sole state if targets is set and there is only one" do
-            stub( @event ).targets() { [@state_a] }
+            @event.should_receive(:targets).at_least(1).times.and_return [@state_a]
             @event.target.should == @state_a
           end
         end
 
         describe 'origins=' do
           it "should call get_states_list_by_name with its argument" do
-            mock( @machine ).find_or_create_states_by_name( :initial ) { }
+            @machine.should_receive(:find_or_create_states_by_name).with(:initial).and_return []
             @event.origins= :initial
           end
 
           it "should set @origin to the result" do
-            mock( @machine ).find_or_create_states_by_name( :initial ) { [:result] }
+            @machine.should_receive(:find_or_create_states_by_name).with(:initial).and_return [:result]
             @event.origins= :initial
             @event.origins.should == [:result]
           end
@@ -61,12 +61,12 @@ describe StateFu::Event do
 
         describe 'targets=' do
           it "should call get_states_list_by_name with its argument" do
-            mock( @machine ).find_or_create_states_by_name( :initial ) { [] }
+            @machine.should_receive(:find_or_create_states_by_name).with(:initial).and_return []
             @event.targets= :initial
           end
 
           it "should set @target to the result" do
-            mock( @machine ).find_or_create_states_by_name( :initial ) { [:result] }
+            @machine.should_receive(:find_or_create_states_by_name).with(:initial).and_return [:result]
             @event.targets= :initial
             @event.targets.should == [:result]
           end
@@ -95,9 +95,12 @@ describe StateFu::Event do
           describe "given @event.from :initial, :to => :final" do
             describe "setting attributes" do
               before do
-                stub( @machine ).find_or_create_states_by_name( anything ) { |*a| raise(a.inspect) }
-                stub( @machine ).find_or_create_states_by_name( :initial ) { [@initial] }
-                stub( @machine ).find_or_create_states_by_name( :final   ) { [@final]   }
+                @machine.should_receive(:find_or_create_states_by_name).with(:initial).and_return [@initial]
+                @machine.should_receive(:find_or_create_states_by_name).with(:final).and_return [@final]
+                
+                # stub( @machine ).find_or_create_states_by_name( anything ) { |*a| raise(a.inspect) }
+                # stub( @machine ).find_or_create_states_by_name( :initial ) { [@initial] }
+                # stub( @machine ).find_or_create_states_by_name( :final   ) { [@final]   }
               end
 
               it "should call @machine.find_or_create_states_by_name() with :initial and :final" do
@@ -118,23 +121,15 @@ describe StateFu::Event do
 
           describe "given @event.from <Array>, :to => <Array>" do
             it "should call @machine.find_or_create_states_by_name() with both arrays" do
-              stub( @machine ).find_or_create_states_by_name(:initial, :start) do
-                [@initial, @start]
-              end
-              stub( @machine ).find_or_create_states_by_name(:final, :end) do
-                [@final, @end]
-              end
-
+              @machine.should_receive(:find_or_create_states_by_name).with(:initial, :start).and_return [@initial, @start]
+              @machine.should_receive(:find_or_create_states_by_name).with(:final, :end).and_return [@final, @end]
               @event.from( [:initial, :start], :to => [:final, :end] )
             end
           end
 
           describe "given @event.from :ALL, :to => :ALL" do
             it "should set origins and targets to @machine.states" do
-              stub( @machine ).states() { [:all, :of, :them ] }
-              stub( @machine ).find_or_create_states_by_name(anything) do |x|
-                x
-              end
+              @machine.should_receive(:states).any_number_of_times.and_return [:all, :of, :them]
               @event.from( :ALL, :to => :ALL )
               @event.origins.should == [:all, :of, :them ]
               @event.targets.should == [:all, :of, :them ]
@@ -146,7 +141,7 @@ describe StateFu::Event do
         describe '.to()' do
           describe "given :final" do
             it "should set @event.target to machine.find_or_create_states_by_name( :final )" do
-              mock( @machine ).find_or_create_states_by_name(:final) { [@final] }
+              @machine.should_receive(:find_or_create_states_by_name).with(:final).and_return [@final]
               @event.to :final
               @event.targets.should == [@final]
             end
@@ -157,16 +152,16 @@ describe StateFu::Event do
 
       describe 'origin_names' do
         it "should return an array of state names in origin when origin is not nil" do
-          mock( @machine ).find_or_create_states_by_name(:initial) { [@initial] }
-          mock( @machine ).find_or_create_states_by_name(:final) { [@final] }
+          @machine.should_receive(:find_or_create_states_by_name).with(:initial).and_return [@initial]
+          @machine.should_receive(:find_or_create_states_by_name).with(:final).and_return [@final]
           @event.from :initial, :to => :final
           @event.origin.should == @initial
-          mock( @initial ).to_sym().times(any_times) { :initial }
+          @initial.should_receive(:to_sym).any_number_of_times.and_return(:initial)
           @event.origin_names.should == [:initial]
         end
 
         it "should return nil when origin is nil" do
-          mock( @event ).origins().times(any_times) { nil }
+          @event.should_receive(:origins).any_number_of_times.and_return nil
           @event.origin_names.should == nil
         end
 
@@ -174,37 +169,37 @@ describe StateFu::Event do
 
       describe 'target_names' do
         it "should return an array of state names in target when target is not nil" do
-          mock( @event ).targets.times( any_times ) { [@final] }
-          mock( @final ).to_sym { :final }
+          @event.should_receive(:targets).any_number_of_times.and_return [@final]
+          @final.should_receive(:to_sym).any_number_of_times.and_return(:final)          
           @event.target_names.should == [:final]
         end
 
         it "should return nil when target is nil" do
-          mock( @event ).targets().times(any_times) { nil }
+          @event.should_receive(:targets).any_number_of_times.and_return nil
           @event.target_names.should == nil
         end
       end
 
       describe 'to?' do
         it "should return true given a symbol which is the name of a state in @target" do
-          mock( @event ).targets.times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.should_receive(:targets).any_number_of_times.and_return [StateFu::State.new(@machine,:a)]          
           @event.to?( :a ).should == true
         end
 
         it "should return false given a symbol which is not the name of a state in @target" do
-          mock( @event ).targets.times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.should_receive(:targets).any_number_of_times.and_return [StateFu::State.new(@machine,:a)]          
           @event.to?( :b ).should == false
         end
       end
 
       describe 'from?' do
         it "should return true given a symbol which is the name of a state in @origin" do
-          mock( @event ).origins.times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.should_receive(:origins).any_number_of_times.and_return [StateFu::State.new(@machine,:a)]          
           @event.from?( :a ).should == true
         end
 
         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.should_receive(:origins).any_number_of_times.and_return [StateFu::State.new(@machine,:a)]          
           @event.from?( :b ).should == nil
         end
       end

data/spec/units/lathe_spec.rb

@@ -10,12 +10,12 @@ describe StateFu::Lathe do
     @state   = Object.new()
     @event   = Object.new()
 
-    stub(@machine).tools() { [].extend( StateFu::ToolArray ) }
+    @machine.should_receive(:tools).any_number_of_times.and_return([].extend( StateFu::ToolArray ))
     @lathe = StateFu::Lathe.new( @machine )
-    @states = [].extend StateFu::StateArray
-    stub( @machine ).states() { @states }
+    @states = [].extend StateFu::StateArray    
+    @machine.should_receive(:states).any_number_of_times.and_return(@states)
     @events = [].extend StateFu::EventArray
-    stub( @machine ).events() { @events }
+    @machine.should_receive(:events).any_number_of_times.and_return(@events)
   end
 
   describe "constructor" do
@@ -29,7 +29,7 @@ describe StateFu::Lathe do
 
     it "should accept a state_or_event (state / event ) and if given one, be a child" do
       options = {}
-      mock( @state ).apply!( options ) {}
+      @state.should_receive(:apply!).with(options)
       lathe = StateFu::Lathe.new( @machine, @state )
       lathe.should be_kind_of( StateFu::Lathe )
       lathe.machine.should  == @machine
@@ -63,10 +63,9 @@ describe StateFu::Lathe do
         options = {:banana => :flower}
         @state = Object.new()
         @child = Object.new()
-        # can't mock the block :(
-        mock( StateFu::State ).new( @machine, :wobble, options ) { @state }
-        mock( StateFu::Lathe ).new( @machine, @state, options ) { @child }
-        mock( @child )
+        StateFu::State.should_receive(:new).with(@machine, :wobble, options).and_return(@state)
+        StateFu::Lathe.should_receive(:new).with(@machine, @state, options).and_return(@child)        
+        # TODO mock the block 
         @lathe.state( :wobble, options )
       end
 
@@ -183,10 +182,9 @@ describe StateFu::Lathe do
         options = {:banana => :flower}
         @event = Object.new()
         @child = Object.new()
-        # can't mock the block :(
-        mock( StateFu::Event ).new( @machine, :wobble, options ) { @event }
-        mock( StateFu::Lathe ).new( @machine, @event, options ) { @child }
-        mock( @child )
+        # TODO mock the block 
+        StateFu::Event.should_receive(:new).with(@machine, :wobble, options).and_return(@event)
+        StateFu::Lathe.should_receive(:new).with(@machine, @event, options).and_return(@child)                
         @lathe.event( :wobble, options )
       end
 
@@ -327,7 +325,7 @@ describe StateFu::Lathe do
 
     describe "helper" do
       it "should call machine.helper *args" do
-        mock( @machine ).helper( :fee, :fi, :fo, :fum )
+        @machine.should_receive(:helper).with( :fee, :fi, :fo, :fum )
         @lathe.helper( :fee, :fi, :fo, :fum )
       end
     end
@@ -380,7 +378,7 @@ describe StateFu::Lathe do
 
     describe ".event(:name)" do
       before do
-        mock( @machine ).find_or_create_states_by_name( @lathe.state_or_event ).at_least(1) { @lathe.state_or_event }
+        @machine.should_receive(:find_or_create_states_by_name).with(@lathe.state_or_event).at_least(1).times.and_return(@lathe.state_or_event)        
       end
 
       it "should create the named event if it does not exist" do
@@ -477,25 +475,23 @@ describe StateFu::Lathe do
       @master = @lathe
       @event  = @lathe.event( :go )
       @lathe  = StateFu::Lathe.new( @machine, @event )
-      stub( @machine ).find_or_create_states_by_name(:a) { [:a] }
-      stub( @machine ).find_or_create_states_by_name(:b) { [:b] }
     end
 
     describe ".from" do
       it "should create any states mentioned which do not exist" do
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
         @lathe.from( :a, :b )
       end
 
       it "should set the origins to the result of machine.find_or_create_states_by_name" do
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
         @lathe.from( :a, :b )
         @event.origins.should == [:a, :b]
       end
 
       it "should accumulate @origins on successive invocations" do
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
-        mock( @machine ).find_or_create_states_by_name(:x, :y) { [:x, :y] }
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
+        @machine.should_receive(:find_or_create_states_by_name).with(:x, :y).and_return([:x, :y])
         @lathe.from( :a, :b )
         @event.origins.should == [:a, :b]
         @lathe.from( :x, :y )
@@ -503,10 +499,10 @@ describe StateFu::Lathe do
       end
 
       it "should set / update both origin and target if a hash is given" do
-        mock( @machine ).find_or_create_states_by_name(:a) { [:a] }
-        mock( @machine ).find_or_create_states_by_name(:b) { [:b] }
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
-        mock( @machine ).find_or_create_states_by_name(:x, :y) { [:x, :y] }
+        @machine.should_receive(:find_or_create_states_by_name).with(:a).and_return [:a] 
+        @machine.should_receive(:find_or_create_states_by_name).with(:b).and_return [:b] 
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
+        @machine.should_receive(:find_or_create_states_by_name).with(:x, :y).and_return([:x, :y])
         @lathe.from( :a => :b )
         @event.origin.should == :a
         @event.target.should == :b
@@ -519,20 +515,20 @@ describe StateFu::Lathe do
     end
 
     describe ".to" do
-      it "should create any states mentioned which do not exist" do
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
+      it "should create any states mentioned which do not exist" do        
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
         @lathe.to( :a, :b )
       end
 
       it "should set the targets to the result of machine.find_or_create_states_by_name" do
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
         @lathe.to( :a, :b )
         @event.targets.should == [:a, :b]
       end
 
       it "should update @origins on successive invocations" do
-        mock( @machine ).find_or_create_states_by_name(:a, :b) { [:a, :b] }
-        mock( @machine ).find_or_create_states_by_name(:x, :y) { [:x, :y] }
+        @machine.should_receive(:find_or_create_states_by_name).with(:a, :b).and_return([:a, :b])
+        @machine.should_receive(:find_or_create_states_by_name).with(:x, :y).and_return([:x, :y])
         @lathe.to( :a, :b )
         @event.targets.should == [:a, :b]
         @lathe.to( :x, :y )

data/spec/units/machine_spec.rb

@@ -24,8 +24,8 @@ describe StateFu::Machine do
 
         it "should create a new machine and bind! it" do
           @machine = Object.new
-          mock(@machine).bind!(Klass, :moose, {})
-          mock(StateFu::Machine).new({}) { @machine }
+          @machine.should_receive(:bind!).with(Klass, :moose, {})
+          StateFu::Machine.should_receive(:new).and_return @machine
           StateFu::Machine.for_class Klass, :moose
         end
 
@@ -73,7 +73,7 @@ describe StateFu::Machine do
     describe ".bind!" do
       it "should call StateFu::Machine.bind! with itself and its arguments" do
         field_name = :my_field_name
-        mock( StateFu::Machine ).bind!( @m, Klass, :newname, field_name ) {}
+        StateFu::Machine.should_receive(:bind!).with @m, Klass, :newname, field_name 
         @m.bind!( Klass, :newname, field_name )
       end
 
@@ -119,7 +119,7 @@ describe StateFu::Machine do
       end
 
       it "should return the first state if one exists" do
-        stub( @m ).states() {  [:a, :b, :c] }
+        @m.should_receive(:states).and_return [:a, :b, :c] 
         @m.initial_state.should == :a
       end
 

data/spec/units/method_factory_spec.rb

@@ -34,18 +34,21 @@ describe StateFu::MethodFactory do
         end 
         it "should call the original method_missing on an unexpected method call" do 
           @k = Klass.new
-          mock(@k).callme 
+          @k.should_receive(:callme)
           @k.whut?
         end
       end
 
       describe "event creation methods" do
         it "should call method_missing" do
+          pending "RSpec mocking makes this tricky ..."
+          @obj.should_receive(:method_missing).with(:simple_event!)
           mock( @obj ).method_missing( :simple_event! )
           @obj.simple_event!
         end
 
         it "should call state_fu!" do
+          pending "RSpec mocking makes this tricky ..."
           mock.proxy( StateFu::Binding ).new( Klass.state_fu_machine, @obj, StateFu::DEFAULT )
           @obj
           @obj.private_methods.map(&:to_sym).should include(:state_fu_field)
@@ -61,6 +64,8 @@ describe StateFu::MethodFactory do
         end
 
         it "should call binding.fire!( :simple_event ... ) with any specified args" do
+          pending "RSpec mocking makes this tricky ..."
+          
           mock.instance_of( StateFu::Binding ).fire_transition!( is_a(StateFu::Event), is_a(StateFu::State), :aa, :bb, {:cc => "dd"} )
           t = @obj.simple_event!( :aa, :bb, :cc => "dd" )
         end
@@ -127,7 +132,7 @@ describe StateFu::MethodFactory do
           end
 
           it "should be false when the binding says it\'s not can_transition?" do
-            mock( @binding ).can_transition?( is_a(StateFu::Event), is_a(StateFu::State) ) { false }
+            @binding.should_receive(:can_transition?).with(@machine.events[:simple_event], @machine.states[:targ]).and_return false
             @binding.can_simple_event?.should == false
           end
         end # can_transition?

data/spec/units/state_spec.rb

@@ -48,8 +48,8 @@ describe StateFu::State do
 
       it "should call machine.events.from(self)" do
         machine_events = Object.new
-        mock( @machine ).events { machine_events }          
-        mock( machine_events ).from( @state ) { nil }
+        @machine.should_receive(:events).and_return machine_events
+        machine_events.should_receive(:from).with(@state).and_return nil
         @state.events
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state-fu
 version: !ruby/object:Gem::Version 
-  version: 0.13.1
+  version: 0.13.3
 platform: ruby
 authors: 
 - David Lee
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-18 00:00:00 +11:00
+date: 2009-12-13 00:00:00 +11:00
 default_executable: 
 dependencies: []