state-fu 0.13.4 → 0.13.5

data/lib/blueprint.rb

@@ -0,0 +1,82 @@
+module StateFu
+  module Blueprint
+
+    def self.load_yaml(yaml)
+      hash = YAML.load(yaml) 
+      returning Machine.new(hash[:options] || {}) do |machine|
+        add_states machine, hash
+        add_events machine, hash
+        hash[:requirement_messages] &&
+          hash[:requirement_messages].each { |k, v| machine.requirement_messages[k] = v } 
+        hash[:initial_state] &&
+          machine.initial_state = hash[:initial_state] 
+        # TODO tools, helpers here
+      end
+    end
+        
+    def self.to_yaml(machine)
+      to_hash(machine).to_yaml
+    end
+   
+    private
+    
+    # serialization
+    
+    def self.to_hash(machine)
+      raise TypeError unless machine.serializable?
+      {
+        :states  => machine.states.map{ |s| state s }, 
+        :events  => machine.events.map{ |e| event e },        
+        :options => machine.options,
+        :helpers => machine.helpers,
+        :tools   => machine.tools,
+        :requirement_messages => machine.requirement_messages,
+        :initial_state => machine.initial_state.name
+      }.delete_if {|k, v| v == [] || v.nil?}
+    end
+    
+    def self.state(state)
+      {
+        :name         => state.name,
+        :hooks        => state.hooks.dup.delete_if {|k,v| v == []},
+        :requirements => state.requirements,
+        :options      => state.options
+      }.delete_if {|k,v| v == [] || v == {}}
+    end
+    
+    def self.event(event)
+      {
+        :name         => event.name,
+        :origins      => event.origins.names,
+        :targets      => event.targets.names,
+        :hooks        => event.hooks.dup.delete_if {|k,v| v == []},
+        :requirements => event.requirements,
+        :options      => event.options
+      }.delete_if {|k,v| v == [] || v == {}}
+    end
+    
+    # deserialization
+    
+    def self.add_states(machine, hash)
+      hash[:states].each do |h|
+        s = State.new(machine, h[:name], h[:options] || {})
+        # cheap hacks to get around the data structures used for hooks and requirements          
+        h[:hooks].each { |k, hooks| hooks.each { |hook| s.hooks[k] << hook }} if h[:hooks]
+        h[:requirements].each { |r| s.requirements << r } if h[:requirements]
+        machine.states << s
+      end        
+    end
+        
+    def self.add_events(machine, hash)
+      hash[:events].each do |h|          
+        e = Event.new(machine, h[:name], h[:options] || {})
+        e.origins = h[:origins]
+        e.targets = h[:targets]
+        # cheap hacks to get around the data structures used for hooks and requirements
+        h[:hooks].each { |k, hooks| hooks.each { |hook| e.hooks[k] << hook }} if h[:hooks]
+        h[:requirements].each { |r| e.requirements << r } if h[:requirements]
+        machine.events << e
+      end
+    end
+  end
+end

data/lib/lathe.rb

@@ -176,9 +176,6 @@ module StateFu
       end
     end
 
-
-    #####################################
-
     # define an event or state requirement.
     # options:
     #  :on => :entry|:exit|array (state only) - check requirement on state entry, exit or both?
@@ -283,6 +280,7 @@ module StateFu
 
     # set the target state(s) of an event
     # to :destination
+    # to :target_a, :target_b
     # to [:end, :finale, :intermission]
     def to *args, &block
       valid_in_context Event

data/lib/machine.rb

@@ -34,9 +34,10 @@ module StateFu
       options[:define_methods] = (name == DEFAULT) unless options.symbolize_keys!.has_key?(:define_methods)
       options[:field_name] ||= Persistence.default_field_name(name)
       options[:singleton] = true unless owner.is_a?(Class)
-      # define an accessor method with the given name
       if options[:singleton]
         _binding = StateFu::Binding.new machine, owner, name, options
+
+        # define an accessor method with the given name
         MethodFactory.define_singleton_method(owner, name) { _binding }
         if alias_name = options[:alias] || options[:as]
           MethodFactory.define_singleton_method(owner, alias_name) { _binding }
@@ -191,5 +192,18 @@ module StateFu
       @graphviz ||= Plotter.new(self).output
     end
 
+    def to_yaml
+      StateFu::Blueprint.to_yaml(self)
+    end
+    
+    # TODO simplify this by adding serializable? to state & event
+    def serializable?
+      named_procs.empty? && (states + events).all?(&:serializable?) 
+    end
+    
+    def self.load_yaml(yaml)
+      StateFu::Blueprint.load_yaml(yaml)
+    end
+    
   end
 end

data/lib/sprocket.rb

@@ -53,6 +53,10 @@ module StateFu
       self.to_sym === other.to_sym || super(other)
     end
     
+    def serializable?
+      !hooks.values.flatten.map(&:class).include?(Proc) && !!(options.to_yaml rescue false)
+    end
+    
   end
 end
 

data/lib/state-fu.rb

@@ -29,6 +29,7 @@ end
   'support/exceptions',
   'executioner',
   'machine',
+  'blueprint',
   'lathe',
   'method_factory',
   'binding',

data/lib/support/exceptions.rb

@@ -36,7 +36,7 @@ module StateFu
     attr_reader :transition
 
     def initialize transition, message=nil, options={}
-      raise caller.inspect unless transition.is_a?(Transition)
+      # raise caller.inspect unless transition.is_a?(Transition)
       @transition = transition 
       super transition.binding, message, options
     end
@@ -99,7 +99,7 @@ module StateFu
     attr_reader :legal_transitions
 
     def initialize transition, message=nil, valid_transitions=nil, options={}
-      @valid_transitions = valid_transitions
+      @legal_transitions = valid_transitions
       super transition, message, options
     end    
   end

data/lib/transition.rb

@@ -61,7 +61,7 @@ module StateFu
       
       machine.inject_helpers_into( self )
       self.args = argument_list            
-      apply!(argument_list, &block )       
+      apply!(argument_list, &block ) # initialize arguments and eval block last       
     end
     
     

data/spec/features/serialization_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "serializing a state machine" do
+  
+  before do
+    make_pristine_class('Document') do
+      machine do
+        states :draft, :published, :meta => {:isbn => 'snoo-factory'}
+        
+        state :draft do
+          requires :working_title, :message => "What's it called?"      
+          on_exit :bump_version
+        end
+                
+        event :publish, :from => :draft, :to => :published, :meta => :wibble do          
+          execute :generate_publicity
+          requires :title, :message => "It needs a title"
+        end
+        initial_state :blank
+      end
+    end
+    @machine = Document.machine
+  end
+  
+  it 'should respond to #to_yaml' do
+    @machine.should respond_to(:to_yaml)
+  end
+  
+  describe "=> to_yaml" do
+    before do
+      @yaml = YAML.load(@machine.to_yaml)
+    end
+    
+    it "should have states" do
+      @yaml[:states].map{|s| s[:name] }.should == [:draft, :published, :blank]
+    end
+    
+    it "should have an initial_state" do
+      @yaml[:initial_state].should == :blank
+    end
+    
+    it "should have events" do
+      @yaml[:events].map{|e| e[:name] }.should == [:publish]
+      @yaml[:events][0][:origins].should == [:draft]
+      @yaml[:events][0][:targets].should == [:published]
+    end
+
+    it "should have state requirements" do
+      @yaml[:states][0][:requirements].should == [:working_title]
+    end
+    it "should have event requirements" do
+      @yaml[:events][0][:requirements].should == [:title]
+    end    
+    it "should have state hooks" do
+      @yaml[:states][0][:hooks].should == {:exit=>[:bump_version]}
+    end
+    it "should have event hooks" do
+      @yaml[:events][0][:hooks].should == {:execute=>[:generate_publicity]}
+    end
+   
+    it "should have helpers"
+    it "should have tools"
+
+    it "should have requirement_messages" do
+      @yaml[:requirement_messages][:title].should == "It needs a title"
+    end
+    
+    it "should have arbitrary options for states" do
+      @yaml[:states][0][:options].should == {:meta => {:isbn=>"snoo-factory"}}
+    end
+        
+    it "should have arbitrary options for events" do
+      @yaml[:events][0][:options].should == {:meta => :wibble}
+    end
+     
+    it "should have options" do
+      @yaml[:options].should == {:field_name=>:state_fu_field, :define_methods=>true}
+    end
+    
+    it "raise TypeError if it is not serializable?" do
+      other_machine = StateFu::Machine.new do
+        named_proc(:do_stuff) { puts "I has a proc" }
+      end
+      lambda do
+        other_machine.to_yaml
+      end.should raise_error(TypeError)
+    end    
+  end
+  
+  describe "StateFu::Machine.load_yaml" do
+    before do
+      @loaded = StateFu::Machine.load_yaml(@machine.to_yaml)
+    end
+    
+    it "should return a machine" do
+      @loaded.should be_kind_of(StateFu::Machine)
+    end
+    
+    it "should have states with the same names" do
+      @loaded.states.names.should == @machine.states.names
+    end
+
+    it "should have events with the same names" do
+      @loaded.events.names.should == @machine.events.names
+    end
+   
+    it "should have event hooks" do
+      @loaded.events.first.hooks.should == {:before=>[], :after=>[], :execute=>[:generate_publicity]}
+    end
+    
+    it "should have state hooks" do
+      @loaded.states.first.hooks.should == {:exit=>[:bump_version], :entry=>[], :accepted=>[]}
+    end
+    
+    it "should return the same yaml if serialized again" do
+      YAML.load(@loaded.to_yaml).should == YAML.load(@machine.to_yaml)
+    end    
+  end
+  
+end

data/spec/integration/transition_spec.rb

@@ -525,42 +525,37 @@ describe StateFu::Transition do
 
     describe "fire! calling hooks" do
       before do
-        @t      = @obj.state_fu.transition( :go )
+        @t = @obj.state_fu.transition(:go)
       end
 
-      it "should update the object's state after state:entering and before event:after" do
-        @binding  = @obj.state_fu
-        pending
-        @t.fire!
-      end
-
-      it "should be accepted after state:entering and before event:after" do
-        pending
-        mock( @obj ).entering_b( @t ) { @t.should_not be_accepted }
-        mock( @obj ).after_go(@t)     { @t.should be_accepted }
-        mock( @obj ).accepted_b(@t)   { @t.should be_accepted }
+      it "should change state between state:entering and event:after" do        
+        @binding = @obj.state_fu
+        @obj.should_receive(:entering_b).and_return do
+          @obj.current_state.name.should == :a    
+        end
+        @obj.should_receive(:after_go).and_return do
+          @obj.current_state.name.should == :b
+        end
         @t.fire!
       end
 
       it "should call the method for each hook on @obj in order, with the transition" do
-        pending
-        mock( @obj ).before_go(@t)  { @called << :before_go  }
-        mock( @obj ).exiting_a(@t)  { @called << :exiting_a  }
-        mock( @obj ).execute_go(@t) { @called << :execute_go }
-        mock( @obj ).entering_b(@t) { @called << :entering_b }
-        mock( @obj ).after_go(@t)   { @called << :after_go   }
-        mock( @obj ).accepted_b(@t) { @called << :accepted_b }
-
+        hooks = [:before_go, :exiting_a, :execute_go, :entering_b, :after_go, :accepted_b]
+        hooks.each do |hook|
+          @obj.should_receive(hook).and_return do
+            @obj.called hook
+          end
+        end
         @t.fire!()
+        @obj.calls.should == hooks
       end
 
       describe "adding an anonymous hook for event.hooks[:execute]" do
         before do
-          called = @called # get us a ref for the closure
           Klass.state_fu_machine do
             event( :go ) do
               execute do |ctx|
-                called( :execute_proc )
+                called :execute_proc
               end
             end
           end
@@ -581,76 +576,63 @@ describe StateFu::Transition do
         end
 
         it "should be replace the previous proc for a slot if redefined" do
-          pending
           called = @called # get us a ref for the closure
           Klass.state_fu_machine do
             event( :go ) do
               execute do |ctx|
-                called << :execute_proc_2
+                called(:updated)
               end
             end
           end
-
-          @event.hooks[:execute].length.should == 2
-          @event.hooks[:execute].first.class.should == Symbol
-          @event.hooks[:execute].last.class.should == Proc
-
-          @t.fire!()
-          @called.should == [ :before_go,
-                              :exiting_a,
-                              :execute_go,
-                              :execute_proc_2,
-                              :entering_b,
-                              :after_go,
-                              :accepted_b ]
+          @t.fire!
+          @obj.calls.should == [:before_go, 
+                                :exiting_a, 
+                                :execute_go, 
+                                :updated, 
+                                :entering_b, 
+                                :after_go, 
+                                :accepted_b]
         end
       end   # anonymous hook
 
       describe "adding a named hook with a block" do
         describe "with arity of -1/0" do
           it "should call the block in the context of the transition" do
-            pending
-            called = @called # get us a ref for the closure
             Klass.state_fu_machine do
               event( :go ) do
                 execute(:named_execute) do
-                  raise self.class.inspect unless self.is_a?( StateFu::Transition )
-                  called << :execute_named_proc
+                  called :execute_named_proc
                 end
               end
             end
             @t.fire!()
-            @called.should == [ :before_go,
-                                :exiting_a,
-                                :execute_go,
-                                :execute_named_proc,
-                                :entering_b,
-                                :after_go,
-                                :accepted_b ]
+            @obj.calls.should == [ :before_go,
+                                   :exiting_a,
+                                   :execute_go,
+                                   :execute_named_proc,
+                                   :entering_b,
+                                   :after_go,
+                                   :accepted_b ]
           end
         end # arity 0
 
         describe "with arity of 1" do
           it "should call the proc in the context of the object, passing the transition as the argument" do
-            pending
-            called = @called # get us a ref for the closure
             Klass.state_fu_machine do
               event( :go ) do
-                execute(:named_execute) do |ctx|
-                  raise ctx.class.inspect unless ctx.is_a?( StateFu::Transition )
-                  raise self.class.inspect unless self.is_a?( Klass )
-                  called << :execute_named_proc
+                execute(:named_execute) do |t|
+                  called [:execute_named_proc, t]
                 end
               end
             end
             @t.fire!()
-            @called.should == [ :before_go,
-                                :exiting_a,
-                                :execute_go,
-                                :execute_named_proc,
-                                :entering_b,
-                                :after_go,
-                                :accepted_b ]
+            @obj.calls.should == [:before_go,
+                                  :exiting_a,
+                                  :execute_go,
+                                  [:execute_named_proc, @t],
+                                  :entering_b,
+                                  :after_go,
+                                  :accepted_b]
           end
         end # arity 1
       end   # named proc
@@ -714,7 +696,6 @@ describe StateFu::Transition do
       @event = @machine.events[:go]
       @a = @machine.states[:a]
       @b = @machine.states[:b]
-      # stub(@obj).ok? { true }
     end
 
     describe "when no block is supplied for the requirement" do
@@ -735,8 +716,6 @@ describe StateFu::Transition do
 
 
       it "should contain the event in @binding.valid_events if @obj.ok? is true" do
-        # stub( @binding ).ok?() {  true }
-#        set_method_arity(@binding,:ok, 0)
         @obj.ok = true
         @binding.current_state.should == @machine.initial_state
         @binding.events.should == @machine.events
@@ -744,14 +723,12 @@ describe StateFu::Transition do
       end
 
       it "should not contain :go in @binding.valid_events if !@obj.ok?" do
-        # stub( @binding ).ok?() { false }
         @obj.ok = false
         @binding.events.should == @machine.events
         @binding.valid_events.should == []
       end
 
       it "should raise a RequirementError if requirements are not satisfied" do
-        #stub( @binding ).ok? { false }
         @obj.ok = false
         lambda do
           @obj.state_fu.fire_transition!( :go )
@@ -814,14 +791,12 @@ describe StateFu::Transition do
       end
 
       it "should be invalid if @obj.entry_ok? is false" do
-        #mock( @obj ).entry_ok? { false }
         @obj.entry_ok = false
         @b.entry_requirements.should == [:entry_ok?]
         @binding.valid_next_states.should == []
       end
 
       it "should be valid if @obj.entry_ok? is true" do
-        # mock( @obj ).entry_ok? { true }
         @obj.entry_ok = true
         @binding.valid_next_states.should == [@b]
       end
@@ -863,18 +838,6 @@ describe StateFu::Transition do
 
     describe "a method defined on the stateful object" do
 
-      it "should be able to conditionally execute code based on whether the transition is a test" do
-        pending
-        testing = nil
-        @obj.__define_singleton_method(:run_exec) do
-          testing = t.testing?
-        end
-        @obj.state_fu.fire! :run do |t|
-          t.test_only = true
-        end
-        testing.should == true
-      end
-
       it "should be able to call methods on the transition mixed in via machine.helper" do
         t1 = @obj.state_fu.transition( :run)
         t1.should_not respond_to(:my_rad_method)
@@ -901,31 +864,25 @@ describe StateFu::Transition do
       end
 
       it "should be able to access the args / options passed to fire! via transition.args" do
-        pending
         # NOTE a trailing hash gets munged into options - not args
         args = [:a, :b, { 'c' => :d }]
-        @obj.__define_singleton_method(:run_exec) do
-          t.args.should == [:a, :b,{'c' => :d}]
-          t.options.should == {}
+        Klass.state_fu_machine do
+          event(:run, :from => :start, :to => :finish ) do
+            execute( :run_exec ) do |t|
+              t.args.should == [:a, :b, {'c' => :d}]
+              t.options.should == {:c => :d} # options are symbolized
+            end
+          end
         end
-        trans = @obj.state_fu.fire!( :run, *args )
+        trans = @obj.state_fu.run!( *args )
         trans.should be_accepted
       end
     end # method defined on object
 
     describe "a block passed to binding.transition" do
-      it "should execute in the context of the transition initializer after it's set up" do
-        pending
-        @obj.__define_singleton_method(:run_exec) do
-          t.args.should == ['who','yo','daddy?']
-          t.options.should == {:hi => :mum}
-        end
-        trans = @obj.state_fu.transition( :run ) do
-          @args    = %w/ who yo daddy? /
-          @options = {:hi => :mum}
-
-        end
-        trans.fire!()
+      
+      it "should not be possible unless it's made less confusing" do
+        pending "wtf is the use case?"
       end
     end
 
@@ -934,7 +891,6 @@ describe StateFu::Transition do
   describe "next_transition" do
     describe "when there are multiple events but only one is fireable?" do
       before do
-        pending
         reset!
         make_pristine_class("Klass")
         @machine = Klass.state_fu_machine do
@@ -954,8 +910,6 @@ describe StateFu::Transition do
         @obj     = Klass.new()
         @binding = @obj.state_fu
         @binding.events.length.should == 2
-        #@machine.events[:impossibility].fireable_by?( @binding ).should == false
-        #@machine.events[:inevitability].fireable_by?( @binding ).should == true
       end
 
       describe "when the fireable? event has only one target" do
@@ -1022,8 +976,8 @@ describe StateFu::Transition do
           t.should be_nil
         end
 
-        it "should raise an IllegalTransition if next! is called" do
-          lambda { @binding.next! }.should raise_error( StateFu::IllegalTransition )
+        it "should raise TransitionNotFound if next! is called" do
+          lambda { @binding.next! }.should raise_error( StateFu::TransitionNotFound )
         end
       end
 

data/spec/spec_helper.rb

@@ -93,9 +93,7 @@ module MySpecHelper
       RelaxDB.replicate_db "relaxdb_spec_base", "relaxdb_spec"
       RelaxDB.enable_view_creation
     rescue => e
-      puts "\n===== Run rake create_base_db before the first spec run ====="
-      puts
-      exit!
+      puts "\n===== Run rake create_base_db in the relaxdb gem folder before the first spec run ====="
     end
     #
   end

data/spec/units/exceptions_spec.rb

@@ -1,30 +1,56 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
+module MockTransitionHelper
+  def mock_transition
+    transition = Object.new()
+    # hmm, seems we have to stub #binding ourselves ...
+    transition.instance_eval do
+      (class << self; self; end).class_eval do
+        def binding
+          @binding ||= Object.new
+        end        
+      end
+    end
+    transition
+  end
+end
+
 describe StateFu::RequirementError do
+  include MockTransitionHelper
 
   describe "constructor" do
     before do
-      @transition = Object.new()
+      @transition = mock_transition
     end
 
+    it "should create an exception given a transition" do
+      e = StateFu::RequirementError.new(@transition)
+      e.should be_kind_of(StateFu::RequirementError)
+    end
+    
+    it "should become an array of requirement messages with #to_a" do
+      e = StateFu::RequirementError.new(@transition)
+      e.should be_kind_of(StateFu::RequirementError)
+      @transition.should_receive(:unmet_requirement_messages).and_return(['oshit'])
+      e.to_a.should == ['oshit']
+    end
   end
 end
 
 describe StateFu::TransitionHalted do
+  include MockTransitionHelper
 
   describe "constructor" do
     before do
-      @transition = Object.new()
+      @transition = mock_transition
     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 )
@@ -32,14 +58,12 @@ 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
+      e.message.should == "StateFu::TransitionHalted"
     end
 
     it "should allow access to the transition" do
-      pending
       e = StateFu::TransitionHalted.new( @transition )
       e.transition.should == @transition
     end
@@ -47,36 +71,31 @@ describe StateFu::TransitionHalted do
 end
 
 describe StateFu::IllegalTransition do
+  include MockTransitionHelper
+
   before do
-    @binding = Object.new
-    @origin  = Object.new
-    @event   = Object.new
-    @target  = Object.new
+    @transition = mock_transition
   end
 
   describe "constructor" do
-    it "should create an IllegalTransition given a binding, event, origin & target" do
-      pending
-      e = StateFu::IllegalTransition.new( @binding, @event, @origin, @target )
+    it "should create an IllegalTransition given a transition" do
+      e = StateFu::IllegalTransition.new( @transition)
       e.should be_kind_of( StateFu::IllegalTransition )
-      e.message.should == StateFu::IllegalTransition::DEFAULT_MESSAGE
-    end
+      e.transition.should == @transition
+      e.message.should == "StateFu::IllegalTransition"
+    end    
 
     it "should allow a custom message" do
-      pending
-      msg = 'helo'
-      e = StateFu::IllegalTransition.new( @binding, @event, @origin, @target, msg )
+      e = StateFu::IllegalTransition.new( @transition, 'danger' )
       e.should be_kind_of( StateFu::IllegalTransition )
-      e.message.should == msg
+      e.transition.should == @transition
+      e.message.should == 'danger'
     end
 
-    it "should allow access to the binding, event, origin, and target" do
-      pending
-      e = StateFu::IllegalTransition.new( @binding, @event, @origin, @target )
-      e.binding.should == @binding
-      e.event.should   == @event
-      e.origin.should  == @origin
-      e.target.should  == @target
+    it "should allow access to a list of valid transitions if provided" do
+      e = StateFu::IllegalTransition.new( @transition, 'danger', [:a, :b] )
+      e.should be_kind_of( StateFu::IllegalTransition )
+      e.legal_transitions.should == [:a, :b]
     end
   end
 end

data/spec/units/machine_spec.rb

@@ -222,5 +222,26 @@ describe StateFu::Machine do
 
     end # named_procs
 
+    describe "#serializable?" do
+      it "should be true if the machine has no procs / lambdas" do
+        StateFu::Machine.new.should be_serializable
+      end
+
+      it "should be false if it has a named_proc" do
+        other_machine = StateFu::Machine.new do
+          named_proc(:do_stuff) { puts "I has a proc" }
+        end
+        other_machine.serializable?.should == false
+      end
+
+      it "should be false if any states / events are not seralizable" do
+        other_machine = StateFu::Machine.new do
+          state :red
+        end
+        other_machine.states.first.should_receive(:serializable?).and_return(false)
+        other_machine.serializable?.should == false      
+      end
+    end
+
   end # instance methods
 end

data/spec/units/sprocket_spec.rb

@@ -65,5 +65,28 @@ describe "Common features / functionality for StateFu::State & StateFu::Event" d
       end
     end
 
+    describe "#serializable?" do
+      it "should be true if hooks contains no procs and options are empty" do
+        @sprocket.hooks.values.flatten.map(&:class).include?(Proc).should == false
+        @sprocket.options = {}
+        @sprocket.serializable?.should == true
+      end
+      
+      it "should be false if hooks contains any procs" do
+        pending 
+        # ...
+        @sprocket.serializable?.should == false
+      end
+      
+      it "should be false if options contains anything which cannot be turned into yaml" do
+        @sprocket.serializable?.should == true
+        @sprocket.options[:whut] = Class
+        lambda do
+          @sprocket.options.to_yaml
+        end.should raise_error
+        @sprocket.serializable?.should == false   
+      end
+    end
+    
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state-fu
 version: !ruby/object:Gem::Version 
-  version: 0.13.4
+  version: 0.13.5
 platform: ruby
 authors: 
 - David Lee
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-13 00:00:00 +11:00
+date: 2010-01-08 00:00:00 +11:00
 default_executable: 
 dependencies: []
 
@@ -25,6 +25,7 @@ extra_rdoc_files:
 files: 
 - Rakefile
 - lib/binding.rb
+- lib/blueprint.rb
 - lib/event.rb
 - lib/executioner.rb
 - lib/hooks.rb
@@ -76,6 +77,7 @@ files:
 - spec/features/machine_alias_spec.rb
 - spec/features/not_requirements_spec.rb
 - spec/features/plotter_spec.rb
+- spec/features/serialization_spec.rb
 - spec/features/shared_log_spec.rb
 - spec/features/singleton_machine_spec.rb
 - spec/features/state_and_array_options_accessor_spec.rb
@@ -143,6 +145,7 @@ test_files:
 - spec/features/machine_alias_spec.rb
 - spec/features/not_requirements_spec.rb
 - spec/features/plotter_spec.rb
+- spec/features/serialization_spec.rb
 - spec/features/shared_log_spec.rb
 - spec/features/singleton_machine_spec.rb
 - spec/features/state_and_array_options_accessor_spec.rb