davidlee-state-fu 0.3.1 → 0.10.0

data/spec/units/method_factory_spec.rb

@@ -13,17 +13,30 @@ describe StateFu::MethodFactory do
     describe "defined on the stateful instance / object before state_fu has been called" do
 
       before do
-          @machine = Klass.machine do
+          @machine = Klass.state_fu_machine do
             event( :simple_event,
                    :from => { [:a, :b] => :targ } )
-
-          state( :a ) { cycle }
+            state( :a ) { cycle }
           end # machine
           @obj     = Klass.new
       end
 
       describe "when there is a method_missing already defined for the class" do
-        it "should still call the pre-defined method_missing"
+        before do
+          reset!
+          make_pristine_class('Klass')
+          Klass.class_eval do
+            def method_missing method_name, *args
+              callme
+            end 
+          end
+          Klass.state_fu_machine(){}
+        end 
+        it "should call the original method_missing on an unexpected method call" do 
+          @k = Klass.new
+          mock(@k).callme 
+          @k.whut?
+        end
       end
 
       describe "event creation methods" do
@@ -33,8 +46,13 @@ describe StateFu::MethodFactory do
         end
 
         it "should call state_fu!" do
-          mock.proxy( StateFu::Binding ).new( Klass.machine, @obj, :state_fu )
+          mock.proxy( StateFu::Binding ).new( Klass.state_fu_machine, @obj, StateFu::DEFAULT )
+          @obj
+          @obj.private_methods.map(&:to_sym).should include(:state_fu_field)
+          #@obj.should respond_to StateFu::DEFAULT_FIELD
+          @obj.state_fu.machine.events.should_not be_empty
           @obj.simple_event!
+
           # @obj.should_have_received( :state_fu! )
         end
 
@@ -42,14 +60,9 @@ describe StateFu::MethodFactory do
           lambda { @obj.simple_event! }.should_not raise_error( NoMethodError )
         end
 
-        it "should call binding.fire!( :simple_event ... ) with no args" do
-          mock.instance_of( StateFu::Binding ).fire!( is_a(StateFu::Event) )
-          t = @obj.simple_event!
-        end
-
         it "should call binding.fire!( :simple_event ... ) with any specified args" do
-          mock.instance_of( StateFu::Binding ).fire!( is_a(StateFu::Event), :a, :b, {:c => "d"} )
-          t = @obj.simple_event!( :a, :b, :c => "d" )
+          mock.instance_of( StateFu::Binding ).fire!( anything, :a, :b, {:c => "d"} )
+          t = @obj.simple_event!( nil, :a, :b, :c => "d" )
         end
 
         it "should fire the transition" do
@@ -58,13 +71,6 @@ describe StateFu::MethodFactory do
           t.should be_accepted
           @obj.send(:state_fu_field).should == 'targ'
         end
-
-        it "should accept a block and pass it to the method on the binding" do 
-          block = lambda { }
-          mock.instance_of( StateFu::Binding ).fire!( is_a(StateFu::Event) )
-          @obj.simple_event! &block
-          pending "don't know how to mock this"
-        end   
       end
     end
 
@@ -72,7 +78,7 @@ describe StateFu::MethodFactory do
     describe "defined on the binding" do
       describe "when the event is simple (has only one possible target)" do
         before do
-          @machine = Klass.machine do
+          @machine = Klass.state_fu_machine do
             event( :simple_event,
                    :from => { [:a, :b] => :targ } )
           end # machine
@@ -101,28 +107,28 @@ describe StateFu::MethodFactory do
           end
 
           it "should add any arguments / options it is called with to the transition" do
-            t = @binding.simple_event(:a, :b, :c, {'d' => 'e'})
-            t.should be_kind_of( StateFu::Transition )
-            t.target.should == @machine.states[:targ]
-            t.event.should == @machine.events[:simple_event]
-            t.args.should == [:a,:b,:c]
+            t = @binding.simple_event nil, :a, :b, :c, {'d' => 'e'}
+            #t.should be_kind_of( StateFu::Transition )
+            #t.target.should  == @machine.states[:targ]
+            #t.event.should   == @machine.events[:simple_event]
+            t.args.should    == [:a,:b,:c,{'d' => 'e'}]
             t.options.should == {:d => 'e'}
           end
         end # transition builder
 
         describe "method which tests if the event is fireable?" do
           it "should have the name of the event suffixed with ?" do
-            @binding.should respond_to(:simple_event?)
+            @binding.should respond_to(:can_simple_event?)
           end
 
           it "should be true when the binding says it\'s fireable?" do
             @binding.fireable?( :simple_event ).should == true
-            @binding.simple_event?.should == true
+            @binding.can_simple_event?.should == true
           end
 
           it "should be false when the binding says it\'s not fireable?" do
             mock( @binding ).fireable?( anything ) { false }
-            @binding.simple_event?.should == false
+            @binding.can_simple_event?.should == false
           end
         end # fireable?
 
@@ -138,9 +144,9 @@ describe StateFu::MethodFactory do
           end
 
           it "should pass any arguments to the transition as args / options" do
-            t = @binding.simple_event!( :a, :b, {'c' => :d } )
+            t = @binding.simple_event!( nil, :a, :b, {'c' => :d } )
             t.should be_kind_of( StateFu::Transition )
-            t.args.should    == [:a, :b ]
+            t.args.should    == [:a, :b, {'c' => :d} ]
             t.options.should == { :c => :d }
           end
         end # bang!
@@ -148,7 +154,7 @@ describe StateFu::MethodFactory do
 
       describe "when the event is complex (has more than one possible target)" do
         before do
-          @machine = Klass.machine do
+          @machine = Klass.state_fu_machine do
             state :orphan
             event( :complex_event,
                    :from => :home,
@@ -172,11 +178,11 @@ describe StateFu::MethodFactory do
           end
 
           it "should raise an error if called without any arguments" do
-            lambda { @binding.complex_event() }.should raise_error( ArgumentError )
+            lambda { @binding.complex_event() }.should raise_error( StateFu::UnknownTarget )
           end
 
           it "should raise an ArgumentError if called with a nonexistent target state" do
-            lambda { @binding.complex_event(:nonexistent) }.should raise_error( ArgumentError )
+            lambda { @binding.complex_event(:nonexistent) }.should raise_error( StateFu::UnknownTarget )
           end
 
           it "should raise an InvalidTransition if called with an invalid target state" do
@@ -193,31 +199,31 @@ describe StateFu::MethodFactory do
             t = @binding.complex_event(:x,
                                        :a, :b, :c, {'d' => 'e'})
             t.should be_kind_of( StateFu::Transition )
-            t.args.should == [:a,:b,:c]
+            t.args.should == [:a,:b,:c,{'d' =>'e'}]
             t.options.should == {:d => 'e'}
           end
         end # transition builder
 
         describe "method which tests if the event is fireable?" do
           it "should have the name of the event suffixed with ?" do
-            @binding.should respond_to(:complex_event?)
+            @binding.should respond_to(:can_complex_event?)
           end
 
           it "should require a valid state name" do
-            lambda { @binding.complex_event?(:nonexistent) }.should raise_error( ArgumentError )
-            lambda { @binding.complex_event?(:orphan) }.should_not  raise_error()
-            @binding.complex_event?(:orphan).should == nil
-            lambda { @binding.complex_event?(:x) }.should_not       raise_error
+            lambda { @binding.can_complex_event?(:nonexistent) }.should raise_error( StateFu::UnknownTarget )
+            lambda { @binding.can_complex_event?(:orphan) }.should_not  raise_error()
+            @binding.can_complex_event?(:orphan).should == nil
+            lambda { @binding.can_complex_event?(:x) }.should_not       raise_error
           end
 
           it "should be true when the binding says the event is fireable? " do
             @binding.fireable?( [:complex_event, :x] ).should == true
-            @binding.complex_event?(:x).should == true
+            @binding.can_complex_event?(:x).should == true
           end
 
           it "should be false when the binding says the event is not fireable?" do
             mock( @binding ).fireable?( anything ) { false }
-            @binding.complex_event?(:x).should == false
+            @binding.can_complex_event?(:x).should == false
           end
         end # fireable?
 
@@ -227,7 +233,7 @@ describe StateFu::MethodFactory do
           end
 
           it "should require a valid state name" do
-            lambda { @binding.complex_event!(:nonexistent) }.should raise_error( ArgumentError )
+            lambda { @binding.complex_event!(:nonexistent) }.should raise_error( StateFu::UnknownTarget )
             lambda { @binding.complex_event!(:orphan) }.should      raise_error( StateFu::InvalidTransition )
             lambda { @binding.complex_event!(:x) }.should_not       raise_error
           end
@@ -244,7 +250,7 @@ describe StateFu::MethodFactory do
                                          :a, :b, {'c' => :d } )
             t.should be_kind_of( StateFu::Transition )
             t.target.should  == @machine.states[:x]
-            t.args.should    == [:a, :b ]
+            t.args.should    == [:a, :b,{'c' =>:d} ]
             t.options.should == { :c => :d }
           end
         end # bang!
@@ -254,7 +260,7 @@ describe StateFu::MethodFactory do
       describe "cycle and next_state methods" do
         describe "when there is a valid transition available for cycle and next_state" do
           before do
-            @machine = Klass.machine do
+            @machine = Klass.state_fu_machine do
               initial_state :groundhog_day
 
               state(:groundhog_day) do
@@ -299,7 +305,7 @@ describe StateFu::MethodFactory do
 
         describe "when the machine is empty" do
           before do
-            @machine = Klass.machine() {}
+            @machine = Klass.state_fu_machine() {}
             @obj     = Klass.new
             @binding = @obj.state_fu
           end
@@ -323,8 +329,8 @@ describe StateFu::MethodFactory do
             end
 
             describe "cycle!" do
-              it "should raise_error( InvalidTransition )" do
-                lambda { @binding.cycle!.should == nil }.should raise_error( StateFu::InvalidTransition )
+              it "should raise_error( TransitionNotFound )" do
+                lambda { @binding.cycle!.should == nil }.should raise_error( StateFu::TransitionNotFound )
               end
             end
           end # cycle
@@ -338,13 +344,14 @@ describe StateFu::MethodFactory do
 
             describe "next_state?" do
               it "should return nil" do
+                pending
                 @binding.next_state?.should == nil
               end
             end
 
             describe "next_state!" do
               it "should raise_error( InvalidTransition )" do
-                lambda { @binding.next_state! }.should raise_error( StateFu::InvalidTransition )
+                lambda { @binding.next_state! }.should raise_error( StateFu::TransitionNotFound )
               end
             end
           end # next_state

data/spec/units/sprocket_spec.rb

@@ -9,7 +9,7 @@ describe "Common features / functionality for StateFu::State & StateFu::Event" d
   include MySpecHelper
   Sprocket = StateFu::Sprocket
   before do
-    @machine = Object.new
+    @machine = StateFu::Machine.new
   end
 
   describe "calling Sprocket.new" do
@@ -40,24 +40,22 @@ describe "Common features / functionality for StateFu::State & StateFu::Event" d
         @sprocket.apply!{ yielded = self }
         yielded.should == @sprocket
       end
-    end
-
-    describe "update!" do
+      
       it "should merge any options passed into .options" do
         opts    = @sprocket.options
         newopts =  { :size => "huge", :colour => "orange" }
-        @sprocket.update!( newopts )
+        @sprocket.apply!( newopts )
         @sprocket.options.should == opts.merge(newopts)
       end
 
       it "should instance_eval the block if one is passed" do
         ref = nil
-        @sprocket.update!(){ ref = self }
+        @sprocket.apply!(){ ref = self }
         ref.should == @sprocket
       end
 
       it "should return itself" do
-        @sprocket.update!.should == @sprocket
+        @sprocket.apply!.should == @sprocket
       end
     end
 

data/spec/units/state_spec.rb

@@ -7,44 +7,53 @@ require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 describe StateFu::State do
   include MySpecHelper
 
-  before do
+  before(:each) do
     @machine = Object.new
+    @state   = StateFu::State.new( @machine, :flux, {:meta => "wibble"} )
   end
 
   describe "instance methods" do
-    before do
-      @state = StateFu::State.new( @machine, :flux, {:meta => "wibble"} )
+
+    describe "#after?(other_state)" do
+      
+      it "should be true when the other state is is after? this one" do
+        m = StateFu::Machine.new do
+          states :red, :green, :yellow
+        end
+        m.states[:green].after?(:red).should be_true
+        m.states[:green].after?(:yellow).should be_false
+        m.states[:green].after?(:green).should be_false        
+        m.states[:green].after?(m.states[:red]).should be_true
+        m.states[:green].after?(m.states[:yellow]).should be_false
+        m.states[:green].after?(m.states[:green]).should be_false        
+      end
+    end
+
+    describe "##before?(other_state)" do
+      
+      it "should be true when the other state is is before this one" do
+        m = StateFu::Machine.new do
+          states :red, :green, :yellow
+        end
+        m.states[:green].before?(:red).should be_false
+        m.states[:green].before?(:yellow).should be_true
+        m.states[:green].after?(:green).should be_false        
+        m.states[:green].before?(m.states[:red]).should be_false
+        m.states[:green].before?(m.states[:yellow]).should be_true
+        m.states[:green].after?(m.states[:green]).should be_false        
+      end
     end
 
-    describe ".events" do
+    describe "#events" do
 
       it "should call machine.events.from(self)" do
         machine_events = Object.new
-        mock( @machine ).events { machine_events }
+        mock( @machine ).events { machine_events }          
         mock( machine_events ).from( @state ) { nil }
         @state.events
       end
 
     end
 
-    describe ".event" do
-
-      it "should act as a proxy for lathe.event without a block" do
-        lathe = Object.new
-        mock( @state ).lathe { lathe }
-        mock( lathe ).event( :evt_name, :from => :old, :to => :new ) { nil }
-        @state.event( :evt_name, :from => :old, :to => :new )
-      end
-
-      it "should act as a proxy for lathe.event with a block" do
-        lathe = Object.new
-        block  = lambda{}
-        stub( @state ).lathe { lathe }
-        args = [:evt_name, {:from => :old, :to => :new}]
-        mock( lathe ).event( *args ) {}
-        @state.event( *args ){ puts "TODO: can't find a way to test the block is passed" }
-      end
-
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: davidlee-state-fu
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.10.0
 platform: ruby
 authors: 
 - David Lee
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-26 00:00:00 -07:00
+date: 2009-08-25 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -26,6 +26,7 @@ files:
 - Rakefile
 - lib/no_stdout.rb
 - lib/state-fu.rb
+- lib/state_fu.rb
 - lib/state_fu/active_support_lite/array.rb
 - lib/state_fu/active_support_lite/array/access.rb
 - lib/state_fu/active_support_lite/array/conversions.rb
@@ -35,25 +36,28 @@ files:
 - lib/state_fu/active_support_lite/array/wrapper.rb
 - lib/state_fu/active_support_lite/blank.rb
 - lib/state_fu/active_support_lite/cattr_reader.rb
-- lib/state_fu/active_support_lite/inheritable_attributes.rb
 - lib/state_fu/active_support_lite/keys.rb
 - lib/state_fu/active_support_lite/misc.rb
+- lib/state_fu/active_support_lite/module.rb
+- lib/state_fu/active_support_lite/module/delegation.rb
 - lib/state_fu/active_support_lite/object.rb
 - lib/state_fu/active_support_lite/string.rb
 - lib/state_fu/active_support_lite/symbol.rb
+- lib/state_fu/applicable.rb
+- lib/state_fu/arrays.rb
 - lib/state_fu/binding.rb
 - lib/state_fu/core_ext.rb
 - lib/state_fu/event.rb
 - lib/state_fu/exceptions.rb
-- lib/state_fu/fu_space.rb
-- lib/state_fu/helper.rb
+- lib/state_fu/executioner.rb
+- lib/state_fu/has_options.rb
 - lib/state_fu/hooks.rb
 - lib/state_fu/interface.rb
 - lib/state_fu/lathe.rb
 - lib/state_fu/logger.rb
 - lib/state_fu/machine.rb
 - lib/state_fu/method_factory.rb
-- lib/state_fu/mock_transition.rb
+- lib/state_fu/methodical.rb
 - lib/state_fu/persistence.rb
 - lib/state_fu/persistence/active_record.rb
 - lib/state_fu/persistence/attribute.rb
@@ -64,19 +68,24 @@ files:
 - lib/state_fu/sprocket.rb
 - lib/state_fu/state.rb
 - lib/state_fu/transition.rb
+- lib/state_fu/transition_query.rb
+- lib/tasks/spec_last.rake
+- lib/tasks/state_fu.rake
 - lib/vizier.rb
-- spec/BDD/plotter_spec.rb
+- spec/custom_formatter.rb
 - spec/features/binding_and_transition_helper_mixin_spec.rb
+- spec/features/method_missing_only_once_spec.rb
 - spec/features/not_requirements_spec.rb
+- spec/features/plotter_spec.rb
+- spec/features/shared_log_spec.rb
+- spec/features/singleton_machine_spec.rb
 - spec/features/state_and_array_options_accessor_spec.rb
-- spec/features/transition_boolean_comparison.rb
+- spec/features/transition_boolean_comparison_spec.rb
 - spec/helper.rb
 - spec/integration/active_record_persistence_spec.rb
 - spec/integration/binding_extension_spec.rb
 - spec/integration/class_accessor_spec.rb
-- spec/integration/dynamic_requirement_spec.rb
 - spec/integration/event_definition_spec.rb
-- spec/integration/ex_machine_for_accounts_spec.rb
 - spec/integration/example_01_document_spec.rb
 - spec/integration/example_02_string_spec.rb
 - spec/integration/instance_accessor_spec.rb
@@ -84,14 +93,14 @@ files:
 - spec/integration/machine_duplication_spec.rb
 - spec/integration/relaxdb_persistence_spec.rb
 - spec/integration/requirement_reflection_spec.rb
-- spec/integration/sanity_spec.rb
 - spec/integration/state_definition_spec.rb
 - spec/integration/transition_spec.rb
 - spec/spec.opts
+- spec/spec_helper.rb
+- spec/state_fu_spec.rb
 - spec/units/binding_spec.rb
 - spec/units/event_spec.rb
 - spec/units/exceptions_spec.rb
-- spec/units/fu_space_spec.rb
 - spec/units/lathe_spec.rb
 - spec/units/machine_spec.rb
 - spec/units/method_factory_spec.rb
@@ -101,6 +110,7 @@ files:
 - README.textile
 has_rdoc: false
 homepage: http://github.com/davidlee/state-fu
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -121,23 +131,25 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: state-fu
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A rich library for state-oriented programming with state machines / workflows
 test_files: 
-- spec/BDD/plotter_spec.rb
+- spec/custom_formatter.rb
 - spec/features/binding_and_transition_helper_mixin_spec.rb
+- spec/features/method_missing_only_once_spec.rb
 - spec/features/not_requirements_spec.rb
+- spec/features/plotter_spec.rb
+- spec/features/shared_log_spec.rb
+- spec/features/singleton_machine_spec.rb
 - spec/features/state_and_array_options_accessor_spec.rb
-- spec/features/transition_boolean_comparison.rb
+- spec/features/transition_boolean_comparison_spec.rb
 - spec/helper.rb
 - spec/integration/active_record_persistence_spec.rb
 - spec/integration/binding_extension_spec.rb
 - spec/integration/class_accessor_spec.rb
-- spec/integration/dynamic_requirement_spec.rb
 - spec/integration/event_definition_spec.rb
-- spec/integration/ex_machine_for_accounts_spec.rb
 - spec/integration/example_01_document_spec.rb
 - spec/integration/example_02_string_spec.rb
 - spec/integration/instance_accessor_spec.rb
@@ -145,13 +157,13 @@ test_files:
 - spec/integration/machine_duplication_spec.rb
 - spec/integration/relaxdb_persistence_spec.rb
 - spec/integration/requirement_reflection_spec.rb
-- spec/integration/sanity_spec.rb
 - spec/integration/state_definition_spec.rb
 - spec/integration/transition_spec.rb
+- spec/spec_helper.rb
+- spec/state_fu_spec.rb
 - spec/units/binding_spec.rb
 - spec/units/event_spec.rb
 - spec/units/exceptions_spec.rb
-- spec/units/fu_space_spec.rb
 - spec/units/lathe_spec.rb
 - spec/units/machine_spec.rb
 - spec/units/method_factory_spec.rb

data/lib/state_fu/active_support_lite/inheritable_attributes.rb

@@ -1 +0,0 @@
-

data/lib/state_fu/fu_space.rb

@@ -1,51 +0,0 @@
-module StateFu
-  # Provides a place to stash references.
-  # In most cases you won't need to access it directly, though
-  # calling reset! before each of your tests/specs can be helpful.
-  class FuSpace
-    cattr_reader :named_machines, :class_machines, :field_names
-
-    # return the default machine, or an empty hash, given a missing index.
-    #
-    # * class_machines[ Class ][ method_name ] # => a StateFu::Machine
-    # * class_machines[ Klass ][ nil ]         # => the Klass's default Machine
-    # * field_names[ Class ][ method_name ]    # => name of attribute / db field
-    #
-    LAZY_HASH = lambda do |h, k|
-      if k.nil?
-        self[ StateFu::DEFAULT_MACHINE ]
-      else
-        h[k]= Hash.new()
-      end
-    end
-
-    # Add a machine to StateFu::FuSpace and register it with a given class, by a given name.
-    def self.insert!( klass, machine, name, field_name )
-      name                       = name.to_sym
-      field_name                 = field_name.to_sym
-      existing_machine              = @@class_machines[klass][name]
-      if existing_machine && !existing_machine.empty?
-        raise("#{klass} already knows a non-empty Machine #{machine} by the name #{name}.")
-      else
-        @@class_machines[klass][name] = machine
-        @@field_names[klass][name] = field_name
-      end
-    end
-    class << self
-      alias_method :insert,  :insert!
-    end
-
-    # Clears all machines and their bindings to classes.
-    # Also initializes the hashes we use to store our references.
-    def self.beginners_mind!
-      @@named_machines = Hash.new
-      @@class_machines = Hash.new( &LAZY_HASH )
-      @@field_names = Hash.new( &LAZY_HASH )
-    end
-    class << self
-      alias_method :reset!,  :beginners_mind!
-      alias_method :forget!, :beginners_mind!
-    end
-    beginners_mind!
-  end
-end

data/lib/state_fu/mock_transition.rb

@@ -1,38 +0,0 @@
-module StateFu
-  class MockTransition
-    include StateFu::Helper
-    include ContextualEval
-
-    attr_reader(  :binding,
-                  :machine,
-                  :origin,
-                  :target,
-                  :event,
-                  :args,
-                  :errors,
-                  :object,
-                  :options,
-                  :current_hook_slot,
-                  :current_hook )
-
-    attr_accessor :test_only, :args, :options
-
-    def initialize( binding, event, target=nil, *args, &block )
-      @options    = args.extract_options!.symbolize_keys!
-      if @binding = binding
-        @machine = binding.machine       rescue nil
-        @object  = binding.object        rescue nil
-        @origin  = binding.current_state rescue nil
-      end
-      @event   = event
-      @target  = find_event_target( event, target )
-      @args    = args
-      @errors  = []
-      @testing = true
-
-      machine.respond_to?(:inject_helpers_into) && machine.inject_helpers_into( self )
-      apply!( &block ) if block_given?
-    end
-
-  end
-end