davidlee-state-fu 0.0.2 → 0.2.0

data/lib/state_fu/persistence/active_record.rb

@@ -5,8 +5,7 @@ module StateFu
       def self.prepare_field( klass, field_name )
         _field_name = field_name
         klass.send :before_save, :state_fu!
-          # validates_presence_of _field_name
-
+        # validates_presence_of _field_name
       end
 
       private
@@ -19,6 +18,7 @@ module StateFu
       end
 
       def write_attribute( string_value )
+        # Logger.warn(" :write_attribute,#{ field_name},#{ string_value} \n=========================================================")
         object.send( :write_attribute, field_name, string_value )
       end
 

data/lib/state_fu/persistence/attribute.rb

@@ -4,7 +4,7 @@ module StateFu
 
       def self.prepare_field( klass, field_name )
         # ensure getter exists
-        unless klass.instance_methods.include?( field_name )
+        unless klass.instance_methods.map(&:to_sym).include?( field_name.to_sym )
           Logger.info "Adding attr_reader :#{field_name} for #{klass}"
           _field_name = field_name
           klass.class_eval do
@@ -14,7 +14,7 @@ module StateFu
         end
 
         # ensure setter exists
-        unless klass.instance_methods.include?( "#{field_name}=" )
+        unless klass.instance_methods.map(&:to_sym).include?( :"#{field_name}=" )
           Logger.info "Adding attr_writer :#{field_name}= for #{klass}"
           _field_name = field_name
           klass.class_eval do
@@ -31,13 +31,13 @@ module StateFu
 
       def read_attribute
         string = object.send( field_name )
-        Logger.info "Read attribute #{field_name}, got #{string} for #{object}"
+        Logger.info "Read attribute #{field_name}, got #{string.inspect} for #{object.inspect}"
         string
       end
 
       def write_attribute( string_value )
         writer_method = "#{field_name}="
-        Logger.info "Writing attribute #{field_name} -> #{string_value} for #{object}"
+        Logger.info "Writing attribute #{field_name} -> #{string_value.inspect} for #{object.inspect}"
         object.send( writer_method, string_value )
       end
 

data/lib/state_fu/persistence/base.rb

@@ -38,7 +38,7 @@ module StateFu
           Logger.info("Machine has no states: #{machine}") if machine.states.empty?
         else
           persist!
-          Logger.debug("Object resumes at #{current_state.name}: #{object}")
+          # Logger.debug("Object #{object} resuming #{binding.method_name} at #{current_state.name}: #{object.inspect}")
         end
       end
 

data/lib/state_fu/sprocket.rb

@@ -22,6 +22,10 @@ module StateFu
       StateFu::Lathe.new( machine, self, options, &block )
     end
 
+    def deep_copy
+      raise NotImeplementedError # abstract
+    end
+
   end
 end
 

data/lib/state_fu/state.rb

@@ -25,15 +25,15 @@ module StateFu
       end
     end
 
-    def enterable_by?( binding )
+    def enterable_by?( binding, *args )
       entry_requirements.reject do |r|
-        res = binding.evaluate_requirement( r )
+        res = binding.evaluate_requirement_with_args( r, *args )
       end.empty?
     end
 
-    def exitable_by?( binding )
+    def exitable_by?( binding, *args )
       exit_requirements.reject do |r|
-        binding.evaluate_requirement( r )
+        binding.evaluate_requirement_with_args( r, *args )
       end.empty?
     end
 

data/lib/state_fu/transition.rb

@@ -9,6 +9,7 @@ module StateFu
   class Transition
     include StateFu::Helper
     include ContextualEval
+
     attr_reader(  :binding,
                   :machine,
                   :origin,
@@ -24,25 +25,18 @@ module StateFu
     attr_accessor :test_only, :args, :options
 
     def initialize( binding, event, target=nil, *args, &block )
+      @binding    = binding
+      @machine    = binding.machine
+      @object     = binding.object
+      @origin     = binding.current_state
+
       # ensure event is a StateFu::Event
       if event.is_a?( Symbol ) && e = binding.machine.events[ event ]
         event = e
       end
       raise( ArgumentError, "Not an event: #{event}" ) unless event.is_a?( StateFu::Event )
 
-      # infer target if necessary
-      case target
-      when StateFu::State # good
-      when Symbol
-        target = binding.machine.states[ target ] ||
-          raise( ArgumentError, "target cannot be determined: #{target.inspect}" )
-      when NilClass
-        unless target = event.target
-          raise( ArgumentError, "target cannot be determined: #{target.inspect}" )
-        end
-      else
-        raise ArgumentError.new( target.inspect )
-      end
+      target = find_event_target( event, target ) || raise( ArgumentError, "target cannot be determined: #{target.inspect}" )
 
       # ensure target is valid for the event
       unless event.targets.include?( target )
@@ -57,10 +51,6 @@ module StateFu
       end
 
       @options    = args.extract_options!.symbolize_keys!
-      @binding    = binding
-      @machine    = binding.machine
-      @object     = binding.object
-      @origin     = binding.current_state
       @target     = target
       @event      = event
       @args       = args
@@ -79,18 +69,30 @@ module StateFu
 
     def unmet_requirements
       requirements.reject do |requirement|
-        binding.evaluate_requirement( requirement )
+        binding.evaluate_requirement_with_transition( requirement, self )
+      end
+    end
+
+    def evaluate_requirement_message( name )
+      msg = machine.requirement_messages[name]
+      case msg
+      when String, nil
+        msg
+      when Symbol, Proc
+        evaluate_named_proc_or_method( msg, self )
+      else
+        raise msg.class.to_s
       end
     end
 
     def unmet_requirement_messages
-      unmet_requirements.map do |r|
-        binding.evaluate_requirement_message(r, self )
+      unmet_requirements.map do |requirement|
+        evaluate_requirement_message( requirement )
       end
     end
 
     def check_requirements!
-      raise RequirementError.new( unmet_requirements.inspect ) unless requirements_met?
+      raise RequirementError.new( self, unmet_requirements.inspect ) unless requirements_met?
     end
 
     def requirements_met?
@@ -117,7 +119,7 @@ module StateFu
     end
 
     def run_hook( hook )
-      evaluate_named_proc_or_method( hook )
+      evaluate_named_proc_or_method( hook, self )
     end
 
     def halt!( message )

data/spec/helper.rb

@@ -28,8 +28,9 @@ module MySpecHelper
 
   def prepare_active_record( options={}, &migration )
     begin
+      require 'activesupport'
       require 'active_record'
-    rescue MissingSourceFile => e
+    rescue LoadError => e
       pending "skipping specifications due to load error: #{e}"
       return false
     end
@@ -81,9 +82,10 @@ module MySpecHelper
   end
 
   def set_method_arity( object, method_name, needed_arity = 1 )
-    a = Object.new
+    a = Proc.new {}
     stub( a ).arity() { needed_arity }
-    stub( object ).method(method_name) { a }
+    stub( object ).method( anything ) { |x| object.send(x) }
+    stub( object ).method( method_name ) { a }
   end
 
 end

data/spec/integration/binding_extension_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module BenchGrinder
+  def snark
+  end
+end
+
+describe "extending StateFu::Lathe" do
+  include MySpecHelper
+
+  describe "helpers" do
+    before do
+      reset!
+      make_pristine_class('Klass')
+      @machine = Klass.machine() do
+        state :init
+      end
+    end # before
+
+    describe "lathe.helper" do
+      it "should add the arguments to the machine's collection of helpers" do
+        @machine.should respond_to(:helpers)
+        @machine.helpers.should be_empty
+        @machine.lathe do
+          helper :bench_grinder
+        end
+        @machine.helpers.should_not be_empty
+        @machine.helpers.should include(:bench_grinder)
+      end
+
+      it "should extend the binding with the helper's methods" do
+        @machine.lathe do
+          helper :bench_grinder
+        end
+        @machine.helpers.should include(:bench_grinder)
+        @obj = Klass.new
+        @obj.state_fu.should respond_to(:snark)
+      end
+    end
+  end
+end

data/spec/integration/dynamic_requirement_spec.rb

@@ -0,0 +1,160 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module MySpecHelper
+  module DynamicTransitionObjectInstanceMethods
+    def method_which_expects_nothing_passed_to_it()
+      true
+    end
+
+    def method_which_requires_one_arg( t )
+      t.args.length == 1
+    end
+
+    def given_any_arg?( t = nil )
+      t.is_a?( StateFu::Transition ) && !t.args.empty?
+    end
+
+    def falsey?( t = nil )
+      t.is_a?( StateFu::Transition ) && !t.args.empty? && t.args.first == false
+    end
+
+    def truthy?( t = nil )
+      t.is_a?( StateFu::Transition ) && !t.args.empty? && t.args.first == true
+    end
+
+    def method_which_always_returns_true( t = nil )
+      true
+    end
+
+    def method_which_always_returns_false( t = nil )
+      false
+    end
+  end
+end
+
+describe "Transition requirement evaluation with dynamic conditions" do
+  include MySpecHelper
+
+  before do
+    reset!
+    make_pristine_class("Klass")
+
+    Klass.send :include, MySpecHelper::DynamicTransitionObjectInstanceMethods
+
+    @machine = Klass.machine do
+
+      state :default do
+        requires :method_which_requires_one_arg, :on => [:entry, :exit]
+
+        cycle do
+          requires :method_which_requires_one_arg
+        end
+
+        event :truthify, :to => :truth do
+          requires :truthy?
+        end
+
+        event :falsify, :to => :falsehood do
+          requires :falsey?
+          requires :method_which_expects_nothing_passed_to_it
+        end
+
+        #event :impossify, :to => :impossible do
+         # requires :method_which_always_returns_false
+        #end
+
+      end
+    end
+    @obj = Klass.new
+    @fu  = @obj.state_fu # binding
+    # Because RR changes the arity of the method on @obj we need to do this:
+    # stub( @fu ).limit_arguments( anything ) { |t| t }
+  end
+
+  describe "a requirement that the transition was given one arg" do
+
+    describe "object.cycle?()" do
+
+      it "should return false given no args" do
+        @fu.cycle?().should == false
+      end
+
+      it "should be true given one arg" do
+        @fu.cycle?(1).should == true
+      end
+
+      it "should be false given two args" do
+        @fu.cycle?(1,2).should == false
+      end
+    end
+
+    it "should evaluate the requirement by passing it a transition when requirements_met? is called" do
+      t = @fu.cycle()
+      # mock.proxy( @fu ).evaluate_requirement_with_transition(:method_which_requires_one_arg, t ).at_least(2)
+      t.requirements_met?.should == false
+      t.args = [1]
+      t.requirements_met?.should == true
+    end
+
+    describe "binding.evaluate_requirement_with_args" do
+
+    end
+
+    describe "valid_transitions" do
+      describe "given no arguments" do
+        it "should return {}" do
+          @fu.valid_transitions.should == {}
+        end
+      end
+
+      it "should pass each requirement method a transition object with no args" do
+      end
+
+      it "should call method_which_requires_one_arg given call_on_object_with_optional_args(:method_which_requires_one_arg .. )" do
+        t = @fu.blank_mock_transition( :first_arg )
+        @obj.respond_to?(:method_which_requires_one_arg).should be_true
+        meth = @obj.method(:method_which_requires_one_arg)
+        meth.arity.should == 1
+        @fu.limit_arguments( meth, t ).should == [t]
+        @fu.call_on_object_with_optional_args( :method_which_requires_one_arg, t )
+      end
+
+      it "should call method_which_requires_one_arg with a mock transition with one argument" do
+        t = @fu.blank_mock_transition( :first_arg )
+        # mock( @obj ).method_which_requires_one_arg( t )
+        @fu.call_on_object_with_optional_args( :method_which_requires_one_arg, t ).should == true
+      end
+
+      it "should contain the :cycle_default event only if an arg is supplied" do
+        @fu.should == :default
+        ves = @fu.valid_events( )
+        ves.length.should == 0
+        ves = @fu.valid_events( 1 )
+        ves.length.should == 1
+        ves.first.should == @machine.events[:cycle_default]
+
+        @machine.events[:cycle_default].target.should == @fu.current_state
+        @fu.evaluate_requirement_with_args( :method_which_requires_one_arg ).should == false
+        @fu.evaluate_requirement_with_args( :method_which_requires_one_arg, 1 ).should == true
+        @fu.current_state.enterable_by?( @fu ).should == false
+        @fu.current_state.enterable_by?( @fu, 1 ).should == true
+
+        vts = @fu.valid_transitions()
+        vts.should be_kind_of( Hash )
+        vts.should be_empty
+        vts = @fu.valid_transitions( 1 )
+        vts.should_not be_empty
+        vts.length.should  == 1
+        vts.keys.first.should   == @machine.events[:cycle_default]
+        vts.values.first.should == [@machine.states[:default]]
+      end
+
+      it "should pass method_which_requires_one_argument() a transition with no arguments" do
+        # mock.proxy( @obj ).method_which_requires_one_arg( is_a(StateFu::MockTransition) ).times(3)
+        @fu.valid_transitions( 1 )
+      end
+
+    end
+  end
+
+end

data/spec/integration/example_01_document_spec.rb

@@ -1,6 +1,7 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
-require 'activerecord'
+# require 'activesupport' 
+# require 'activerecord'
 
 describe "Document" do
   include MySpecHelper

data/spec/integration/lathe_extension_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module BenchGrinder
+  def snark
+  end
+end
+
+describe "extending StateFu::Lathe" do
+  include MySpecHelper
+
+  describe "helpers" do
+    before do
+      reset!
+      make_pristine_class('Klass')
+      @machine = Klass.machine() do
+        state :init
+      end
+    end # before
+
+    describe "lathe.tool" do
+
+      it "should add the arguments to the machine's collection of tools" do
+        @machine.should respond_to(:tools)
+        @machine.tools.should be_empty
+        @machine.lathe do
+          tool :bench_grinder
+        end
+        @machine.tools.should_not be_empty
+        @machine.tools.should include(:bench_grinder)
+      end
+
+      it "should extend the machine's lathe" do
+        @machine.lathe do
+          tool :bench_grinder
+          snark()
+        end
+        @machine.lathe.should respond_to( :snark )
+        @machine.lathe.snark
+      end
+
+      it "should extend the machine's lathe for state and events" do
+        @machine.lathe do
+          tool :bench_grinder
+          snark()
+          state :grinding do
+            snark()
+            event :grind do
+              snark()
+            end
+          end
+        end
+      end
+
+      it "should not extend another machine's lathe" do
+        @machine.lathe do
+          tool :bench_grinder
+          snark()
+        end
+        m2 = Klass.machine(:two) do
+        end
+        lambda { m2.lathe.snark }.should raise_error( NoMethodError )
+      end
+
+    end # tool
+
+  end
+end

data/spec/integration/requirement_reflection_spec.rb

@@ -9,15 +9,15 @@ describe "Transition requirement reflection" do
     make_pristine_class("Klass")
     @machine = Klass.machine do
       state :soviet_russia do
-        requires( :papers_in_order?,
-                  :money_for_bribe?, :on => [:entry, :exit] )
+        requires( :papers_in_order?, :on => [:entry, :exit] )
+        requires( :money_for_bribe?, :on => [:entry, :exit] )
       end
 
       state :america do
         requires( :no_turban?,
                   :us_visa?,
                   :on => :entry )
-        requires( :no_arrest_warrant, :on => [:entry,:exit] )
+        requires( :no_arrest_warrant?, :on => [:entry,:exit] )
       end
 
       state :moon do
@@ -66,18 +66,79 @@ describe "Transition requirement reflection" do
     end
   end
 
+  describe "flying from russia to america without one's affairs in order while wearing a turban" do
+    before do
+      mock( @obj ).us_visa?() { false }
+      mock( @obj ).no_turban?() { false }
+      mock( @obj ).no_arrest_warrant?() { false }
+      mock( @obj ).money_for_bribe?() { false }
+      mock( @obj ).papers_in_order?() { false }
+    end
+
+    describe "when no messages are supplied for the requirements" do
+      describe "given transition.unmet_requirements" do
+        it "should contain a list of failing requirement names as symbols" do
+          @obj.state_fu.catch_plane(:america).unmet_requirements.should == [ :papers_in_order?,
+                                                                             :money_for_bribe?,
+                                                                             :no_turban?,
+                                                                             :us_visa?,
+                                                                             :no_arrest_warrant? ]
+        end
+      end # unmet requirements
+
+      describe "given transition.unmet_requirement_messages" do
+        it "should return a list of nils" do
+          @obj.state_fu.catch_plane(:america).unmet_requirement_messages.should == [nil,nil,nil,nil,nil]
+        end
+      end # unmet_requirement_messages
+    end
+
+    describe "when a message is supplied for the money_for_bribe? entry requirement" do
+      before do
+        Klass.machine do
+          state :soviet_russia do
+            requires( :money_for_bribe?, :message => "This guard is thirsty! Do you have anything to declare?" )
+          end
+        end
+      end
+
+      describe "given transition.unmet_requirements" do
+        it "should still contain a list of failing requirement names as symbols" do
+          @obj.state_fu.catch_plane(:america).unmet_requirements.should == [ :papers_in_order?,
+                                                                             :money_for_bribe?,
+                                                                             :no_turban?,
+                                                                             :us_visa?,
+                                                                             :no_arrest_warrant? ]
+        end
+      end
+
+      describe "given transition.unmet_requirement_messages" do
+        it "should contain a list of nils plus the requirement message for money_for_bribe? as a string" do
+          @obj.state_fu.catch_plane(:america).unmet_requirement_messages.should == [ nil,
+                                                                                     "This guard is thirsty! Do you have anything to declare?",
+                                                                                     nil,
+                                                                                     nil,
+                                                                                     nil ]
+        end
+      end
+    end
+  end # flying with a turban
+
   describe "transition.unmet_requirements" do
     it "should be empty when all requirements are met" do
       @obj.state_fu.fly_spaceship(:moon).unmet_requirements.should == []
     end
 
-    it "should contain a list of failing requirements" do
-      mock( @obj ).spacesuit?() { false }
-      mock( @obj ).fuel?() { false }
-      @obj.state_fu.fly_spaceship(:moon).unmet_requirements.should == [:spacesuit?, :fuel?]
+    describe "when a message is supplied for the requirement" do
+      it "should contain a list of the requirement failure messages as strings" do
+        mock( @obj ).spacesuit?() { false }
+        mock( @obj ).fuel?() { false }
+        @obj.state_fu.fly_spaceship(:moon).unmet_requirements.should == [:spacesuit?, :fuel?]
+      end
     end
   end
 
+
   describe "transition.unmet_requirement_messages" do
     describe "when a string message is defined for one of two unmet_requirements" do
       before do
@@ -162,7 +223,7 @@ describe "Transition requirement reflection" do
         it "should call the method on @obj given transition.evaluate_named_proc_or_method() with the method name" do
           @obj.method( :no_spacesuit_msg_method ).arity.should == 1
           t = @obj.state_fu.fly_spaceship(:moon)
-          x = t.evaluate_named_proc_or_method(:no_spacesuit_msg_method)
+          x = @obj.state_fu.evaluate_named_proc_or_method(:no_spacesuit_msg_method, t)
           @obj.arg.should == t
           x.should =~ /You can't go to the moon/
         end
@@ -170,7 +231,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
-          mock( t ).evaluate_named_proc_or_method(:no_spacesuit_msg_method) { :my_string }
+          mock( t ).evaluate_named_proc_or_method(:no_spacesuit_msg_method, t) { :my_string }
           messages = t.unmet_requirement_messages
           messages.should include(:my_string )
         end
@@ -183,7 +244,7 @@ describe "Transition requirement reflection" do
         end
 
         it "should return the result of the method execution as the message" do
-          t = @obj.state_fu.fly_spaceship(:moon)
+          t = @obj.state_fu.fly_spaceship( :moon )
           t.unmet_requirements.length.should == 2
           messages = t.unmet_requirement_messages
           messages.length.should == 2
@@ -194,7 +255,6 @@ describe "Transition requirement reflection" do
       end # no named proc
     end   # symbol message
   end     # transition.unmet_requirement_messages
-
 end
 
 

data/spec/integration/temp_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe StateFu::State do
+  include MySpecHelper
+
+  it "should respond to deep_copy" do
+    reset!
+    make_pristine_class "Klass"
+    @machine = Klass.machine do
+      state :initial
+    end
+    @state = @machine.states.first
+    @state.should respond_to(:deep_copy)
+  end
+
+end
+