state-fu 0.12.3 → 0.13.0

data/lib/persistence.rb

@@ -20,7 +20,7 @@ module StateFu
   #    end
   #
   #    def write_attribute( string_value )
-  #      Logger.debug "magnetising ( #{field_name} => #{string_value} on #{object.inspect}"
+  #      Logging.debug "magnetising ( #{field_name} => #{string_value} on #{object.inspect}"
   #      object.send "magnetised_#{field_name}=", string_value
   #    end
   #  end
@@ -56,7 +56,7 @@ module StateFu
       persister_class = class_for klass, field_name
       prepare_field( klass, field_name, persister_class)
       returning persister_class.new( binding, field_name ) do |persister|
-        Logger.debug( "#{persister_class}: method #{binding.method_name} as field #{persister.field_name}" )
+        Logging.debug( "#{persister_class}: method #{binding.method_name} as field #{persister.field_name}" )
       end
     end
 

data/lib/persistence/active_record.rb

@@ -4,7 +4,7 @@ module StateFu
 
       def self.prepare_field( klass, field_name )
         _field_name = field_name
-        Logger.debug("Preparing ActiveRecord field #{klass}.#{field_name}")
+        Logging.debug("Preparing ActiveRecord field #{klass}.#{field_name}")
 
         # this adds a before_save hook to ensure that the field is initialized 
         # (and the initial state set) before create.
@@ -20,12 +20,12 @@ module StateFu
       # Attribute version, so just do the simplest thing we can.
 
       def read_attribute
-        Logger.debug "Read attribute #{field_name}, got #{object.send(:read_attribute,field_name)} for #{object.inspect}"
+        Logging.debug "Read attribute #{field_name}, got #{object.send(:read_attribute,field_name)} for #{object.inspect}"
         object.send( :read_attribute, field_name )
       end
 
       def write_attribute( string_value )
-        Logger.debug "Write attribute #{field_name} to #{string_value} for #{object.inspect}"
+        Logging.debug "Write attribute #{field_name} to #{string_value} for #{object.inspect}"
         object.send( :write_attribute, field_name, string_value )
       end
 

data/lib/persistence/attribute.rb

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

data/lib/persistence/base.rb

@@ -8,25 +8,9 @@ module StateFu
 
       attr_reader :binding, :field_name, :current_state
 
-      def self.prepare_class( klass )
-        unless klass.instance_methods.include?( :method_missing_before_state_fu )
-          alias_method :method_missing_before_state_fu, :method_missing
-          klass.class_eval do
-            def method_missing( method_name, *args, &block )
-              state_fu!
-              begin
-                send( method_name, *args, &block )
-              rescue NoMethodError => e
-                method_missing_before_state_fu( method_name, *args, &block )
-              end
-            end
-          end
-        end
-      end
-
       # define this method in subclasses to do any preparation
       def self.prepare_field( klass, field_name )
-        Logger.warn("Abstract method in #{self}.prepare_field called. Override me!")
+        Logging.warn("Abstract method in #{self}.prepare_field called. Override me!")
       end
 
       def initialize( binding, field_name )
@@ -36,11 +20,11 @@ module StateFu
         @current_state = find_current_state()
 
         if current_state.nil?
-          Logger.warn("undefined state for binding #{binding} on #{object} with field_name #{field_name.inspect}")
-          Logger.warn("Machine for #{object} has no states: #{machine}") if machine.states.empty?
+          Logging.warn("undefined state for binding #{binding} on #{object} with field_name #{field_name.inspect}")
+          Logging.warn("Machine for #{object} has no states: #{machine}") if machine.states.empty?
         else
           persist!
-          Logger.debug("#{object} resumes #{binding.method_name} at #{current_state.name}")
+          Logging.debug("#{object} resumes #{binding.method_name} at #{current_state.name}")
         end
       end
 

data/lib/state-fu.rb

@@ -15,12 +15,14 @@
 # extend the core features.
 #
 # It is also delightfully elegant and easy to use for simple things.
+%w( support support/active_support_lite ).each do |path|
+  $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), path)))
+end
 
 [ 'support/core_ext',
-  'support/logger',
+  'support/logging',
   'support/applicable',
   'support/arrays',
-  'support/methodical',
   'support/has_options',
   'support/vizier',
   'support/plotter',

data/lib/support/core_ext.rb

@@ -38,53 +38,31 @@ class Array
 end
 
 class Object
-
-  def self.__define_method( method_name, &block )
-    self.class.class_eval do
-      define_method method_name, &block
-    end
-  end
-
-  def __define_singleton_method( method_name, &block )
-    (class << self; self; end).class_eval do
-      define_method method_name, &block
-    end
-  end
-
-
-  def with_methods_on(other)
-    (class << self; self; end).class_eval do
-      # we need some accounting to ensure that everything behaves itself when
-      # .with_methods_on is called more than once.
-      @_with_methods_on ||= []
-      if !@_with_methods_on.include?("method_missing_before_#{other.__id__}")
-        alias_method "method_missing_before_#{other.__id__}", :method_missing
-      end     
-      @_with_methods_on << "method_missing_before_#{other.__id__}"
-        
-      define_method :method_missing do |method_name, *args|
-        if _other.respond_to?(method_name, true)
-          _other.__send__( method_name, *args )
-        else
-          send "method_missing_before_#{other.__id__}", method_name, *args
-        end
-      end      
+  unless defined? instance_exec # 1.9
+    module InstanceExecMethods #:nodoc:
     end
+    include InstanceExecMethods
 
-    result = yield
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
 
-    (class << self; self; end).class_eval do
-      # heal the damage
-      if @_with_methods_on.pop != "method_missing_before_#{other.__id__}"
-        raise "there is no god"
-      end        
-      if !@_with_methods_on.include?("method_missing_before_#{other.__id__}")
-        alias_method :method_missing, "method_missing_before_#{other.__id__}"
-        undef_method "method_missing_before_#{other.__id__}"
-      end     
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
     end
-
-    result
-  end # with_methods_on
+  end
 end
 

data/lib/support/{logger.rb → logging.rb}

@@ -7,7 +7,7 @@ module StateFu
   # Use Rails' log if running as a rails plugin; allow independent control of 
   # StateFu log level.
   
-  class Logger
+  class Logging
     cattr_accessor :prefix   # prefix for log messages
     cattr_accessor :suppress # set true to send messages to /dev/null
     cattr_accessor :shared
@@ -101,10 +101,10 @@ module StateFu
       case logger
       when String
         file     = File.open(logger, File::WRONLY | File::APPEND)        
-        @@logger = Logger.activesupport_logger_available? ? ActiveSupport::BufferedLogger.new(file) : ::Logger.new(file)
-      when ::Logger
+        @@logger = activesupport_logger_available? ? ActiveSupport::BufferedLogger.new(file) : Logger.new(file)
+      when Logger
         @@logger = logger
-      when Logger.activesupport_logger_available? && ActiveSupport::BufferedLogger
+      when activesupport_logger_available? && ActiveSupport::BufferedLogger
         @@logger = logger
       else
         default_logger
@@ -134,7 +134,7 @@ module StateFu
           ActiveSupport::BufferedLogger.new(target)
         end
       else      
-        ::Logger.new(target)
+        Logger.new(target)
       end
     end
     

data/lib/transition.rb

@@ -165,7 +165,7 @@ module StateFu
     # halt a transition with a message
     # can be used to back out of a transition inside eg a state entry hook
     def halt! message 
-      raise TransitionHalted.new( self, message )
+      raise StateFu::TransitionHalted.new( self, message )
     end
 
     #
@@ -184,10 +184,10 @@ module StateFu
         StateFu::Hooks::ALL_HOOKS.map do |owner, slot|
           [ [owner, slot], send(owner).hooks[slot] ]
         end.each do |address, hooks|
-          Logger.info("running #{address.inspect} hooks for #{object.class} #{object}")
+          Logging.info("running #{address.inspect} hooks for #{object.class} #{object}")
           owner,slot = *address
           hooks.each do |hook|
-            Logger.info("running hook #{hooks} for #{object.class} #{object}")
+            Logging.info("running hook #{hooks} for #{object.class} #{object}")
             @current_hook_slot = address
             @current_hook      = hook
             run_hook hook 
@@ -195,14 +195,14 @@ module StateFu
           if slot == :entry
             @accepted                        = true
             @binding.persister.current_state = @target
-            Logger.info("State is now :#{@target.name} for #{object.class} #{object}")
+            Logging.info("State is now :#{@target.name} for #{object.class} #{object}")
           end
         end
         # transition complete
         @current_hook_slot               = nil
         @current_hook                    = nil
       rescue TransitionHalted => e
-        Logger.info("Transition halted for #{object.class} #{object}: #{e.inspect}")
+        Logging.info("Transition halted for #{object.class} #{object}: #{e.inspect}")
         @errors << e
       end
       self
@@ -292,17 +292,15 @@ module StateFu
       s
     end
 
+    def evaluate(method_name_or_proc)
+      executioner.evaluate(method_name_or_proc)
+    end
+    alias_method :call, :evaluate
+
     private
 
     def executioner
-      @executioner ||= Executioner.new( self ) do |ex|
-        machine.inject_helpers_into( ex )
-        machine.inject_methods_into( ex )
-      end
-    end
-
-    def evaluate(method_name_or_proc)
-      executioner.evaluate(method_name_or_proc)
+      @executioner ||= Executioner.new( self )
     end
 
     def evaluate_requirement_message( name, revalidate=false)

data/spec/features/active_record_auto_save_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "machine(:autosave => true)" do
+  before(:all) do
+    reset!
+    prepare_active_record() do
+      def self.up
+        create_table :example_records do |t|
+          t.string :name,           :null => false
+          t.string :state_fu_field, :null => false
+          t.string :description
+          t.string :status
+          t.timestamps
+        end
+      end
+    end
+  end
+  
+  it "should automatically save the record when a transition is complete" do
+    pending
+  end
+end

data/spec/features/not_requirements_spec.rb

@@ -1,57 +1,32 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
 module RequirementFeatureHelper
-  def account_expired?
-    !! account_expired
-  end
 
   def valid_password?
     !! valid_password
   end
 end
 
-# it_should_behave_like "!" do
-shared_examples_for "not requirements" do
-    describe "requirements with names beginning with no[t]_" do
-
-    it "should return the opposite of the requirement name without not_" do
-#      @obj.current_state.should == :guest
-      @obj.stfu.teleport! :anonymous
-      @obj.valid_password = false
-      @binding.can_has_valid_password?.should == false
-      @binding.can_has_not_valid_password?.should == true
-      @binding.can_has_no_valid_password?.should == true
-      @obj.valid_password = true
-      @binding.can_has_valid_password?.should == true
-      @binding.can_has_not_valid_password?.should == false
-      @binding.can_has_no_valid_password?.should == false
-    end
-
-    it "should call the method directly if one exists" do
-      @obj.valid_password = true
-      (class << @obj; self; end).class_eval do
-        define_method( :no_valid_password? ) { true }
-      end
-      @binding.can_has_valid_password?.should == true
-      @binding.can_has_not_valid_password?.should == false
-      @binding.can_has_no_valid_password?.should == true
-    end
-
-  end
-
-end
-
 describe "requirements" do
+
   before(:all) do
     reset!
     make_pristine_class('Klass')
+    
     Klass.class_eval do
       attr_accessor :valid_password
       attr_accessor :account_expired
+      
+      def account_expired?
+        !! account_expired
+      end      
     end
+    
     @machine = StateFu::Machine.new do
       initial_state :guest
 
+      define(:valid_password?) { !! valid_password }
+
       event :has_valid_password, :from => :anonymous, :to => :logged_in do
         requires :valid_password?
       end
@@ -62,9 +37,12 @@ describe "requirements" do
 
       event :has_no_valid_password, :from => :anonymous, :to => :suspect do
         requires :no_valid_password?
-      end
-      
+      end  
     end
+
+    @machine.bind!(Klass, :default)
+    @obj     = Klass.new
+    @binding = @obj.state_fu
   end
 
   before :each do
@@ -72,47 +50,31 @@ describe "requirements" do
     @obj.account_expired = false
   end
 
-  describe "requirements defined with a machine helper" do
-    before :all do
-      @machine.lathe { helper RequirementFeatureHelper }
-      @machine.bind!(Klass, :default)
-      @obj     = Klass.new
-      @binding = @obj.state_fu
-    end
-
-    it_should_behave_like "not requirements"
-
-    it "should not have methods on the object" do
-      @obj.respond_to?(:valid_password?).should == false
-      @obj.respond_to?(:account_expired?).should == false
-    end
-
-    it "should have methods on the binding" do
-      # this is a little misleading because theyre not evaluated on the binding ..
-      @binding.respond_to?(:valid_password?).should == true
-      @binding.respond_to?(:account_expired?).should == true
-      @binding.respond_to?(:not_valid_password?).should == false
-      @binding.respond_to?(:not_account_expired?).should == false
-    end
+  it "should have methods ...." do
+    @obj.should respond_to(:account_expired?)
+    @machine.named_procs.keys.should include(:valid_password?)
+  end
+  
+  it "should return the opposite of the requirement name without not_" do
+    @obj.stfu.teleport! :anonymous
+    @obj.valid_password = false
+    @binding.can_has_valid_password?.should == false
+    @binding.can_has_not_valid_password?.should == true
+    @binding.can_has_no_valid_password?.should == true
+    @obj.valid_password = true
+    @binding.can_has_valid_password?.should == true
+    @binding.can_has_not_valid_password?.should == false
+    @binding.can_has_no_valid_password?.should == false
   end
 
-  describe "requirements defined on the object" do
-    before :all do
-      @machine.bind!(Klass, :default)
-      @obj = Klass.new
-      @binding = @obj.state_fu
-      Klass.class_eval do
-        include RequirementFeatureHelper
-      end
+  it "should call the method directly if one exists" do
+    @obj.valid_password = true
+    (class << @obj; self; end).class_eval do
+      define_method( :no_valid_password? ) { true }
     end
+    @binding.can_has_valid_password?.should == true
+    @binding.can_has_not_valid_password?.should == false
+    @binding.can_has_no_valid_password?.should == true
+  end      
 
-    it_should_behave_like "not requirements"
-
-    it "should have methods on the object" do
-      @obj.respond_to?(:valid_password?).should == true
-      @obj.respond_to?(:not_valid_password?).should == false
-      @obj.respond_to?(:account_expired?).should == true
-      @obj.respond_to?(:not_account_expired?).should == false
-    end
-  end
 end