davidlee-state-fu 0.3.1 → 0.10.0

data/spec/integration/class_accessor_spec.rb

@@ -1,6 +1,5 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
-StateFu::FuSpace.reset!
 
 ##
 ##
@@ -12,92 +11,79 @@ describe "A pristine class Klass with StateFu included:" do
     make_pristine_class 'Klass'
   end
 
-  it "should return a new Machine bound to the class given Klass.machine()" do
-    Klass.should respond_to(:machine)
-    Klass.machine.should be_kind_of(StateFu::Machine)
-    machine = Klass.machine
-    Klass.machine.should == machine
+  it "should return a new Machine bound to the class given Klass.state_fu_machine()" do
+    Klass.should respond_to(:state_fu_machine)
+    Klass.state_fu_machine.should be_kind_of(StateFu::Machine)
+    machine = Klass.state_fu_machine
+    Klass.state_fu_machine.should == machine
   end
 
-  it "should return {} given Klass.machines()" do
-    Klass.should respond_to(:machines)
-    Klass.machines.should == {}
-  end
-
-  it "should return [] given Klass.machine_names()" do
-    Klass.should respond_to(:machine_names)
-    Klass.machine_names.should == []
+  it "should return {} given Klass.state_fu_machines" do
+    Klass.should respond_to(:state_fu_machines)
+    Klass.state_fu_machines.should == {}
   end
 
   ##
   ##
   ##
 
-  describe "Having called Klass.machine() with an empty block:" do
+  describe "Having called Klass.state_fu_machine() with an empty block:" do
     before(:each) do
-      Klass.machine do
+      Klass.state_fu_machine do
       end
-      StateFu::DEFAULT_MACHINE.should == :state_fu
     end
 
-    it "should return a StateFu::Machine given Klass.machine()" do
-      Klass.should respond_to(:machine)
-      Klass.machine.should_not be_nil
-      Klass.machine.should be_kind_of( StateFu::Machine )
+    it "should return a StateFu::Machine given Klass.state_fu_machine()" do
+      Klass.should respond_to(:state_fu_machine)
+      Klass.state_fu_machine.should_not be_nil
+      Klass.state_fu_machine.should be_kind_of( StateFu::Machine )
     end
 
-    it "should return { :state_fu => <StateFu::Machine> } given Klass.machines()" do
-      Klass.should respond_to(:machines)
-      machines = Klass.machines()
+    it "should return { :default => <StateFu::Machine> } given Klass.state_fu_machines()" do
+      Klass.should respond_to(:state_fu_machines)
+      machines = Klass.state_fu_machines()
       machines.should be_kind_of(Hash)
       machines.should_not be_empty
       machines.length.should == 1
-      machines.keys.should == [:state_fu]
+      machines.keys.should == [StateFu::DEFAULT]
       machines.values.first.should be_kind_of( StateFu::Machine )
     end
 
-    it "should returns [:state_fu] given Klass.machine_names()" do
-      Klass.should respond_to(:machine_names)
-      Klass.machine_names.should == [:state_fu]
-    end
-
-    describe "Having called Klass.machine(:two) with an empty block:" do
+    describe "Having called Klass.state_fu_machine(:two) with an empty block:" do
       before(:each) do
-        Klass.machine(:two) do
+        Klass.state_fu_machine(:two) do
         end
       end
 
-      it "should return a StateFu::Machine given Klass.machine(:two)" do
-        Klass.should respond_to(:machine)
-        Klass.machine(:two).should_not be_nil
-        Klass.machine(:two).should be_kind_of( StateFu::Machine )
+      it "should return a StateFu::Machine given Klass.state_fu_machine(:two)" do
+        Klass.should respond_to(:state_fu_machine)
+        Klass.state_fu_machine(:two).should_not be_nil
+        Klass.state_fu_machine(:two).should be_kind_of( StateFu::Machine )
       end
 
-      it "should return a new Machine given Klass.machine(:three)" do
-        Klass.should respond_to(:machine)
-        Klass.machine(:three).should be_kind_of( StateFu::Machine )
-        three = Klass.machine(:three)
-        Klass.machine(:three).should == three
-        # StateFu::FuSpace.class_machines[Klass][:three].should == :three
+      it "should return a new Machine given Klass.state_fu_machine(:three)" do
+        Klass.should respond_to(:state_fu_machine)
+        Klass.state_fu_machine(:three).should be_kind_of( StateFu::Machine )
+        three = Klass.state_fu_machine(:three)
+        Klass.state_fu_machines[:three].should == three
+        Klass.state_fu_machine(:three).should == three        
       end
 
-      it "should return { :state_fu => <StateFu::Machine>, :two => <StateFu::Machine> } given Klass.machines()" do
-        Klass.should respond_to(:machines)
-        machines = Klass.machines()
+      it "should return { :default => <StateFu::Machine>, :two => <StateFu::Machine> } given Klass.state_fu_machines()" do
+        Klass.should respond_to(:state_fu_machines)
+        machines = Klass.state_fu_machines()
         machines.should be_kind_of(Hash)
         machines.should_not be_empty
         machines.length.should == 2
-        machines.keys.should include :state_fu
+        machines.keys.should include StateFu::DEFAULT
         machines.keys.should include :two
         machines.values.length.should == 2
         machines.values.each { |v| v.should be_kind_of( StateFu::Machine ) }
       end
 
-      it "should return [:state_fu, :two] give Klass.machine_names (unordered)" do
-        Klass.should respond_to(:machine_names)
-        Klass.machine_names.length.should == 2
-        Klass.machine_names.should include :state_fu
-        Klass.machine_names.should include :two
+      it "should return [DEFAULT, :two] give Klass.state_fu_machines.keys" do
+        Klass.should respond_to(:state_fu_machines)
+        Klass.state_fu_machines.keys.should =~ [StateFu::DEFAULT, :two]
       end
     end
 
@@ -110,16 +96,20 @@ describe "A pristine class Klass with StateFu included:" do
 
       # sorry, Lamarckism not supported
       it "does NOT inherit it's parent class' Machines !!" do
-        Child.machine.should_not == Klass.machine
+        Child.state_fu_machine.should_not == Klass.state_fu_machine
       end
 
-      it "should know the Machine after calling Klass.machine.bind!( Child )" do
-        Child.machine.should_not == Klass.machine
-        Klass.machine.bind!( Child )
-        Child.machine.should == Klass.machine
-        Klass.machine.bind!( Child, :snoo )
-        Child.machine(:snoo).should == Klass.machine
-
+      it "should know the Machine after calling Klass.state_fu_machine.bind!( Child )" do
+        Child.state_fu_machine.should_not == Klass.state_fu_machine
+        Klass.state_fu_machine.bind!( Child )
+        Klass.state_fu_machines.should == { StateFu::DEFAULT => Klass.state_fu_machine }
+        Child.state_fu_machine.should == Klass.state_fu_machine
+        Klass.state_fu_machine.bind!( Child, :snoo )
+        Child.state_fu_machines.should == {
+          StateFu::DEFAULT => Klass.state_fu_machine,
+          :snoo            => Klass.state_fu_machine
+        }
+        Child.state_fu_machine(:snoo).should == Klass.state_fu_machine
       end
 
     end

data/spec/integration/event_definition_spec.rb

@@ -12,18 +12,18 @@ describe "Adding events to a Machine outside a state block" do
     before do
       reset!
       make_pristine_class 'Klass'
-      Klass.machine() { }
+      Klass.state_fu_machine() { }
     end
 
-    describe "calling Klass.machine().events" do
+    describe "calling Klass.state_fu_machine().events" do
       it "should return []" do
-        Klass.machine().events.should == []
+        Klass.state_fu_machine().events.should == []
       end
     end
 
-    describe "calling event(:die){ from :dead, :to => :alive } in a Klass.machine()" do
+    describe "calling event(:die){ from :dead, :to => :alive } in a Klass.state_fu_machine()" do
       before do
-        Klass.machine do
+        Klass.state_fu_machine do
           event :die do # arity == 0
             from :dead, :to => :alive
           end
@@ -31,31 +31,31 @@ describe "Adding events to a Machine outside a state block" do
       end
 
       it "should require a name when calling machine.event()" do
-        lambda { Klass.machine(){ event {} } }.should raise_error(ArgumentError)
+        lambda { Klass.state_fu_machine(){ event {} } }.should raise_error(ArgumentError)
       end
 
       it "should add 2 states to the machine called: [:dead, :alive] " do
-        Klass.machine.state_names.should == [:dead, :alive]
-        Klass.machine.states.length.should == 2
-        Klass.machine.states.each { |s| s.should be_kind_of(StateFu::State) }
-        Klass.machine.states.map(&:name).sort.should == [:alive, :dead]
+        Klass.state_fu_machine.state_names.should == [:dead, :alive]
+        Klass.state_fu_machine.states.length.should == 2
+        Klass.state_fu_machine.states.each { |s| s.should be_kind_of(StateFu::State) }
+        Klass.state_fu_machine.states.map(&:name).sort.should == [:alive, :dead]
       end
 
       describe "the <StateFu::Event> created" do
-        it "should be accessible through Klass.machine.events" do
-          Klass.machine.events.should be_kind_of(Array)
-          Klass.machine.events.length.should == 1
-          Klass.machine.events.first.should be_kind_of( StateFu::Event )
-          Klass.machine.events.first.name.should == :die
+        it "should be accessible through Klass.state_fu_machine.events" do
+          Klass.state_fu_machine.events.should be_kind_of(Array)
+          Klass.state_fu_machine.events.length.should == 1
+          Klass.state_fu_machine.events.first.should be_kind_of( StateFu::Event )
+          Klass.state_fu_machine.events.first.name.should == :die
         end
       end
 
     end
 
     # arity of blocks is optional, thanks to magic fairy dust ;)
-    describe "calling event(:die){ |s| s.from :dead, :to => :alive } in a Klass.machine()" do
+    describe "calling event(:die){ |s| s.from :dead, :to => :alive } in a Klass.state_fu_machine()" do
       before do
-        Klass.machine do
+        Klass.state_fu_machine do
           event :die do |s|
             s.from :dead, :to => :alive
           end
@@ -63,9 +63,9 @@ describe "Adding events to a Machine outside a state block" do
       end
 
       it "should add 2 states to the machine called [:dead, :alive] " do
-        Klass.machine.state_names.should == [:dead, :alive]
-        Klass.machine.states.length.should == 2
-        Klass.machine.states.each { |s| s.should be_kind_of( StateFu::State ) }
+        Klass.state_fu_machine.state_names.should == [:dead, :alive]
+        Klass.state_fu_machine.states.length.should == 2
+        Klass.state_fu_machine.states.each { |s| s.should be_kind_of( StateFu::State ) }
       end
     end
 

data/spec/integration/example_01_document_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
-# require 'activesupport' 
+# require 'activesupport'
 # require 'activerecord'
 
 describe "Document" do
@@ -26,7 +26,7 @@ describe "Document" do
         # puts "new feed!"
       end
 
-      machine( :status ) do
+      state_fu_machine( :status ) do
         state :draft do
           event :publish, :to => :published
         end
@@ -40,8 +40,8 @@ describe "Document" do
           execute :destroy
         end
 
-        events do
-          after :save!
+        states do
+          accepted :save!
         end
       end
     end
@@ -61,6 +61,7 @@ describe "Document" do
     end
 
     it "should raise a RequirementError when publish! is called" do
+      @doc.status.name.should == :draft
       lambda { @doc.status.publish! }.should raise_error( StateFu::RequirementError )
       begin
         @doc.status.publish!
@@ -84,12 +85,11 @@ describe "Document" do
     end
 
     it "should not raise an error when publish! is called" do
-      @doc.status.evaluate_requirement_with_args(:author).should == "Susan"
       lambda { @doc.status.publish! }.should_not raise_error( )
     end
 
     it "should call update_rss when publish! is called" do
-      mock( @doc ).update_rss() {}
+      mock( @doc ).update_rss(anything) {}
       @doc.status.publish!
     end
 
@@ -99,7 +99,12 @@ describe "Document" do
     end
 
     describe "status_field attribute" do
-      it "should be private in ruby 1.8 and 1.9"
+
+      # need to think about this
+      #
+      # it "should be private in ruby 1.8 and 1.9" do
+      #   lambda { @doc.status_field }.should raise_error()
+      # end
 
       it "should be defined before state_fu is called" do
         @doc.send( :status_field ).should == 'draft'
@@ -119,7 +124,7 @@ describe "Document" do
   describe "delete!" do
 
     it "should execute destroy()" do
-      mock( @doc ).destroy() {}
+      mock( @doc ).destroy(anything) {}
       @doc.status.delete!
     end
 

data/spec/integration/example_02_string_spec.rb

@@ -24,6 +24,7 @@ describe String do
       end
 
       def shell_escape
+        #
         klone = clone
         begin
           klone.shell.escape!
@@ -32,7 +33,7 @@ describe String do
         klone
       end
 
-      machine (:shell) do
+      state_fu_machine (:shell) do
         event(:escape, :from => {:dirty => :clean}) do
           execute :sanitize_for_shell!
         end
@@ -48,7 +49,7 @@ 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! {}
+    mock( @str ).sanitize_for_shell!(anything) {}
     @str.shell.escape!
     @str.should_not be_dirty
     @str.should be_clean

data/spec/integration/instance_accessor_spec.rb

@@ -1,7 +1,5 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
-StateFu::FuSpace.reset!
-
 ##
 ##
 ##
@@ -14,32 +12,31 @@ describe "An instance of Klass with StateFu included:" do
   end
 
   describe "when no machine is defined" do
-    it "should return nil given .state_fu()" do
-      @k.state_fu().should be_nil
+    it "should raise an ArgumentError given .state_fu()" do
+      lambda { @k.state_fu() }.should raise_error(ArgumentError)
     end
 
     it "should return {} given .bindings()" do
-      @k.bindings().should == {}
+      @k.state_fu_bindings.should == {}
     end
 
     it "should return [] given .state_fu!()" do
       @k.state_fu!.should == []
-    end
+    end 
   end # no machine
 
   describe "when an empty machine is defined for the class with the default name:" do
     before(:each) do
-      Klass.machine() {}
-      StateFu::DEFAULT_MACHINE.should == :state_fu
+      Klass.state_fu_machine() {}
     end
 
     it "should return a StateFu::Binding given .state_fu()" do
-      @k.state_fu().should be_kind_of( StateFu::Binding )
+      @k.state_fu_binding.should be_kind_of( StateFu::Binding )
     end
 
     describe "before a binding is instantiated by calling .state_fu() or .state_fu!" do
       it "should return {} given .bindings()" do
-        @k.bindings().should == {}
+        @k.bindings.should == {}
       end
     end
 
@@ -50,7 +47,7 @@ describe "An instance of Klass with StateFu included:" do
 
       it "should return { :state_fu => <StateFu::Binding>} given .bindings()" do
         @k.bindings().length.should == 1
-        @k.bindings().keys.should == [:state_fu]
+        @k.bindings().keys.should == [StateFu::DEFAULT]
         @k.bindings().values.first.should be_kind_of( StateFu::Binding )
       end
     end
@@ -59,7 +56,7 @@ describe "An instance of Klass with StateFu included:" do
       it "should return { :state_fu => <StateFu::Binding>} given .bindings()" do
         @k.state_fu!()
         @k.bindings().length.should == 1
-        @k.bindings().keys.should == [:state_fu]
+        @k.bindings().keys.should == [StateFu::DEFAULT]
         @k.bindings().values.first.should be_kind_of( StateFu::Binding )
       end
     end
@@ -71,29 +68,29 @@ describe "An instance of Klass with StateFu included:" do
 
     describe "when there is an empty machine called :two for the class" do
       before(:each) do
-        Klass.machine(:two) {}
+        Klass.state_fu_machine(:two) {}
       end
 
       it "should return the same Binding given .state_fu() and .state_fu(:state_fu)" do
         @k.state_fu().should be_kind_of( StateFu::Binding )
-        @k.state_fu().should == @k.state_fu(:state_fu)
+        @k.state_fu().should == @k.state_fu(StateFu::DEFAULT)
       end
 
       it "should return a StateFu::Binding for the machine called :two given .state_fu(:two)" do
         @k.state_fu(:two).should be_kind_of( StateFu::Binding )
-        @k.state_fu(:two).should_not == @k.state_fu(:state_fu)
-        @k.state_fu(:two).machine.should == Klass.machine(:two)
+        @k.state_fu(:two).should_not == @k.state_fu(StateFu::DEFAULT)
+        @k.state_fu(:two).machine.should == Klass.state_fu_machine(:two)
       end
 
-      it "should return nil when .state_fu() is called with the name of a machine which doesn't exist" do
-        @k.state_fu(:hibiscus).should be_nil
+      it "should raise an ArgumentError when .state_fu() is called with the name of a machine which doesn't exist" do
+        lambda { @k.state_fu(:hibiscus) }.should raise_error(ArgumentError)
       end
 
       it "should return an array of the two StateFu::Bindings given .state_fu!" do
         @k.state_fu!.should be_kind_of( Array )
         @k.state_fu!.length.should == 2
         @k.state_fu!.each { |m| m.should be_kind_of( StateFu::Binding ) }
-        @k.state_fu!.map(&:method_name).sort_by(&:to_s).should == [:state_fu, :two]
+        @k.state_fu!.map(&:method_name).sort_by(&:to_s).should == [StateFu::DEFAULT, :two]
       end
     end
   end

data/spec/integration/lathe_extension_spec.rb

@@ -12,7 +12,7 @@ describe "extending StateFu::Lathe" do
     before do
       reset!
       make_pristine_class('Klass')
-      @machine = Klass.machine() do
+      @machine = Klass.state_fu_machine() do
         state :init
       end
     end # before
@@ -56,7 +56,7 @@ describe "extending StateFu::Lathe" do
           tool :bench_grinder
           snark()
         end
-        m2 = Klass.machine(:two) do
+        m2 = Klass.state_fu_machine(:two) do
         end
         lambda { m2.lathe.snark }.should raise_error( NoMethodError )
       end

data/spec/integration/machine_duplication_spec.rb

@@ -12,7 +12,7 @@ describe "Copying / cloning a Machine" do
     before do
       reset!
       make_pristine_class("Klass")
-      @original = Klass.machine do
+      @original = Klass.state_fu_machine do
         state :a do
           event :goto_b, :to => :b
         end
@@ -20,24 +20,37 @@ describe "Copying / cloning a Machine" do
       @copy = @original.clone
     end
 
-    it "should update a state or event in the original when it's changed in the copy" do
-      @original.events[:goto_b].should == @copy.events[:goto_b]
-      @copy.lathe do
-        event( :goto_b, :wibble => :updated ) do
-          to :bee
-        end
-        state( :b, :picture => "Bee" ) do
-        end
-      end
-      @copy.    events[:goto_b].options[:wibble].should == :updated
-      @original.events[:goto_b].options[:wibble].should == :updated
-      @copy.    states[:b].options[:picture].should == 'Bee'
-      @original.states[:b].options[:picture].should == 'Bee'
-    end
+    # let's just test for strict object equality w/ equal? and call it a day
+
+    it "should update an event's options in the original when it's changed in the copy" do
+      @original.events[:goto_b].should be_equal @copy.events[:goto_b]
+      @original.events[:goto_b].options.should be_equal @copy.events[:goto_b].options
+    end   
 
-    it "should update the original with any changes to helpers"
-    it "should update the original with any changes to named_procs"
-    it "should update the original with any changes to requirement_messages"
+    it "should update a state's options in the original when it's changed in the copy" do
+      @original.states[:a].should be_equal @copy.states[:a]
+      @original.states[:a].options.should be_equal @copy.states[:a].options
+    end   
+
+    it "should update the original when an event is added to the clone" do
+      @original.events.should be_equal @copy.events
+    end 
+
+    it "should update the original when a state is added to the clone" do
+      @original.states.should be_equal @copy.states
+    end 
+
+    it "should update the original with any changes to helpers" do
+      @original.helpers.should be_equal @copy.helpers
+    end
+    
+    it "should update the original with any changes to named_procs" do
+      @original.named_procs.should be_equal @copy.named_procs
+    end
+    
+    it "should update the original with any changes to requirement_messages" do
+      @original.requirement_messages.should be_equal @copy.requirement_messages      
+    end
 
   end # shallow
 
@@ -45,7 +58,7 @@ describe "Copying / cloning a Machine" do
     before do
       reset!
       make_pristine_class("Klass")
-      @original = Klass.machine do
+      @original = Klass.state_fu_machine do
         state :a do
           event :goto_b, :to => :b
         end
@@ -53,26 +66,35 @@ describe "Copying / cloning a Machine" do
       @copy = @original.deep_copy()
     end
 
-    it "should NOT update a state or event in the original when it's changed in the copy" do
-      @copy.states.map(&:name).should == @original.states.map(&:name)
-      @copy.events.map(&:name).should == @original.events.map(&:name)
+    it "should NOT update an event's options in the original when it's changed in the copy" do
+      @original.events[:goto_b].should_not be_equal @copy.events[:goto_b]
+      @original.events[:goto_b].options.should_not be_equal @copy.events[:goto_b].options
+    end   
 
-      @copy.lathe do
-        event( :goto_b, :wibble => :updated ) do
-          to :bee
-        end
-        state( :b, :picture => "Bee" ) do
-        end
-      end
-      @copy.    events[:goto_b].options[:wibble].should == :updated
-      @original.events[:goto_b].options[:wibble].should == nil
-      @copy.    states[:b].options[:picture].should == 'Bee'
-      @original.states[:b].options[:picture].should == nil
-    end
+    it "should NOT update a state's options in the original when it's changed in the copy" do
+      @original.states[:a].should_not be_equal @copy.states[:a]
+      @original.states[:a].options.should_not be_equal @copy.states[:a].options
+    end   
 
-    it "should NOT update the original with any changes to helpers"
-    it "should NOT update the original with any changes to named_procs"
-    it "should NOT update the original with any changes to requirement_messages"
+    it "should NOT update the original when an event is added to the clone" do
+      @original.events.should_not be_equal @copy.events
+    end 
+
+    it "should NOT update the original when a state is added to the clone" do
+      @original.states.should_not be_equal @copy.states
+    end 
+
+    it "should NOT update the original with any changes to helpers" do
+      @original.helpers.should_not be_equal @copy.helpers
+    end
+    
+    it "should NOT update the original with any changes to named_procs" do
+      @original.named_procs.should_not be_equal @copy.named_procs
+    end
+    
+    it "should NOT update the original with any changes to requirement_messages" do
+      @original.requirement_messages.should_not be_equal @copy.requirement_messages      
+    end
 
   end # deep
 

data/spec/integration/relaxdb_persistence_spec.rb

@@ -8,6 +8,9 @@ describe "a RelaxDB::Document's persister" do
   end
 
   before(:each) do
+    if skip_slow_specs? 
+      skip_slow_specs and return false
+    end
     skip_unless_relaxdb()
     reset!
     make_pristine_class( 'ExampleDoc', RelaxDB::Document )
@@ -24,7 +27,7 @@ describe "a RelaxDB::Document's persister" do
     before do
       ExampleDoc.class_eval do
         property :property_field
-        machine :field_name => "property_field" do
+        state_fu_machine :field_name => "property_field" do
           # ...
         end
       end
@@ -39,7 +42,7 @@ describe "a RelaxDB::Document's persister" do
   describe "when the :field_name is not a RelaxDB property" do
     before do
       ExampleDoc.class_eval do
-        machine :field_name => "not_a_property" do
+        state_fu_machine :field_name => "not_a_property" do
           # ...
         end
       end
@@ -64,7 +67,7 @@ describe StateFu::Persistence::RelaxDB do
       make_pristine_class( 'ExampleDoc', RelaxDB::Document )
       ExampleDoc.class_eval do
         property :state_fu_field
-        machine do
+        state_fu_machine do
           state :hungry do
             event :eat, :to => :satiated
           end