state-fu 0.12.3 → 0.13.0

data/README.textile

@@ -165,7 +165,7 @@ It is also delightfully elegant and easy to use for simple things:
       # this wants to be last, as it iterates over each state which is
       # already defined.
       states do
-        accepted { object.save! }
+        accepted { save! }
       end
     end
   end

data/lib/binding.rb

@@ -19,16 +19,16 @@ module StateFu
       @options       = options.symbolize_keys!
       if options[:singleton]
         @target      = object
-      else 
+      else
         @target      = object.class
         @options     = @target.state_fu_options[@method_name].merge(options)
-      end 
-      @field_name    = @options.delete(:field_name) || raise("No field_name supplied")      
+      end
+      @field_name    = @options.delete(:field_name) || raise("No field_name supplied")
       @persister     = Persistence.for self
 
       # define event methods on this binding and its @object
       MethodFactory.new(self).install!
-      @machine.helpers.inject_into self 
+      @machine.helpers.inject_into self
     end
 
     alias_method :o,             :object
@@ -143,7 +143,6 @@ module StateFu
     def transition( event_or_array, *args, &block )
       return transitions.with(*args, &block).find(event_or_array)
     end
-
     #
     # next_transition and friends: when there's exactly one valid move
     #
@@ -292,5 +291,11 @@ module StateFu
       s
     end
 
+    # little kludge - allows the binding to reuse the same method definitions as 'object'
+    # in MethodFactory#method_definitions_for
+    def state_fu(name=nil)
+      self
+    end
+    
   end
 end

data/lib/executioner.rb

@@ -1,65 +1,40 @@
 module StateFu
   #
-  # delegator class for evaluation methods / procs in the context of
-  # your object.
+  # class that handles executing stuff in the context of your 'object'
   #
     
   class Executioner
 
-    # give us a blank slate
-    # instance_methods.each { |m| undef_method m unless m =~ /(^__|^self|^nil\?$|^send$|proxy_|^object_id|^respond_to\?|^instance_exec|^instance_eval|^method$)/ }
+    attr_reader :transition, :object
 
     def initialize transition, &block
-      @transition     = transition
-      @__target__     = transition.object
-      @__self___      = self
-      yield self if block_given?
-      # forces method_missing to snap back to its pre-state-fu condition:
-      # @__target__.initialize_state_fu!
+      @transition = transition
+      @object     = transition.object
       self
     end
 
-    delegate :origin,  :to => :transition, :prefix => true # transition_origin
-    delegate :target,  :to => :transition, :prefix => true # transition_target
-    delegate :event,   :to => :transition, :prefix => true # transition_event
-
-    delegate :halt!,   :to => :transition
-    delegate :args,    :to => :transition
-    delegate :options, :to => :transition
-
-    def binding
-      transition.binding
-    end
-
-    attr_reader :transition, :__target__, :__self__
-
-    alias_method :t,                    :transition
-    alias_method :current_transition,   :transition
-    alias_method :context,              :transition
-    alias_method :ctx,                  :transition
-
-    alias_method :arguments,            :args
-    alias_method :transition_arguments, :args
-
-    def machine 
-      binding.machine
+    def evaluate method_name_or_proc
+      args = [transition, transition.arguments]
+      evaluate_with_arguments(method_name_or_proc, *args)
     end
     
-    def states
-      machine.states
-    end
-    # delegate :machine, :to => :transition
-
-    def evaluate_with_arguments method_name_or_proc, *arguments
-      if method_name_or_proc.is_a?(Proc) && meth = method_name_or_proc
-      elsif meth = transition.machine.named_procs[method_name_or_proc]
-      elsif respond_to?( method_name_or_proc) && meth = method(method_name_or_proc)        
+    private
+    
+    def evaluate_with_arguments method_name_or_proc, *arguments      
+      if method_name_or_proc.is_a?(Proc) && 
+        meth = method_name_or_proc 
+        # got a proc
+      elsif meth = transition.machine.named_procs[method_name_or_proc] 
+        # got a named proc belonging to the machine
+      elsif object.__send__(:respond_to?, method_name_or_proc, true) && 
+        meth = object.__send__(:method, method_name_or_proc)
+        # got the name of a method on 'object'
       elsif method_name_or_proc.to_s =~ /^not?_(.*)$/
-        # special case: prefix a method with no_ or not_ and get the 
-        # boolean opposite of its evaluation result
-        return !( evaluate_with_arguments $1, *args )
+        # special case: given a method name prefixed with no_ or not_ 
+        # return the boolean opposite of its evaluation result
+        return !( evaluate_with_arguments $1.to_sym, *arguments )
       else
-        raise NoMethodError.new( "undefined method_name `#{method_name_or_proc.to_s}' for \"#{__target__}\":#{__target__.class.to_s}" )
+        raise NoMethodError.new( "undefined method_name `#{method_name_or_proc.to_s}' for \"#{object}\":#{object.class.to_s}" )
       end      
 
       if arguments.length < meth.arity.abs && meth.arity != -1
@@ -71,50 +46,8 @@ module StateFu
       end
       
       # execute it!
-      __target__.with_methods_on(self) do
-        self.instance_exec *arguments, &meth
-      end
-    end
-
-    def evaluate method_name_or_proc
-      arguments = [transition, args, __target__]
-      evaluate_with_arguments(method_name_or_proc, *arguments)
-    end
-
-    alias_method :executioner_respond_to?, :respond_to?
-
-    def respond_to? method_name, include_private = false
-      executioner_respond_to?(method_name, include_private) ||
-      __target__.__send__( :respond_to?, method_name, include_private )
-    end
-
-    alias_method :executioner_method, :method
-    def method method_name
-      begin
-        executioner_method(method_name)
-      rescue NameError
-        __target__.__send__ :method, method_name
-      end
-    end
-
-    private
-
-    # Forwards any missing method call to the \target.
-    # TODO / NOTE: we don't (can't ?) handle block arguments ...    
-    def method_missing(method_name, *args)
-      if __target__.respond_to?(method_name, true)
-        begin
-          meth = __target__.__send__ :method, method_name
-        rescue NameError
-          super
-        end
-        __target__.instance_exec( *args, &meth)
-      else # let's hope it's a named proc
-        evaluate_with_arguments(method_name, *args)
-      end
-      
+      object.__send__(:instance_exec, *arguments, &meth)
     end
     
-    # NOTE: const_missing is not handled.
   end
 end

data/lib/lathe.rb

@@ -442,7 +442,7 @@ module StateFu
 
       # allow requirements and messages to be added as options
       if k = [:requires, :guard, :must, :must_be, :needs].detect {|k| options.has_key?(k) }
-        # Logger.debug("removing option #{k} - will use as requirement ..")
+        # Logging.debug("removing option #{k} - will use as requirement ..")
         req = options.delete(k)
         msg = options.delete(:message) || options.delete(:msg)
         raise ArgumentError unless msg.nil? || req.is_a?(Symbol)

data/lib/machine.rb

@@ -4,10 +4,10 @@ module StateFu
     def self.BINDINGS
       @@_bindings ||= {}
     end
-    
+
     include Applicable
     include HasOptions
-    
+
     attr_reader :hooks
 
     #
@@ -19,17 +19,17 @@ module StateFu
       name = name.to_sym
       unless machine = klass.state_fu_machines[ name ]
         machine = new(options)
-        machine.bind! klass, name, options
       end
       if block_given?
-        machine.apply! &block 
+        machine.apply! &block
       end
+      machine.bind! klass, name, options
       machine
     end
 
     # make it so that a class which has included StateFu has a binding to
     # this machine
-    def self.bind!(machine, owner, name, options={})      
+    def self.bind!(machine, owner, name, options={})
       name = name.to_sym
       options[:define_methods] = (name == DEFAULT) unless options.symbolize_keys!.has_key?(:define_methods)
       options[:field_name] ||= Persistence.default_field_name(name)
@@ -40,14 +40,17 @@ module StateFu
         MethodFactory.define_singleton_method(owner, name) { _binding }
         if alias_name = options[:alias] || options[:as]
           MethodFactory.define_singleton_method(owner, alias_name) { _binding }
-        end      
+        end
       else
-        owner.state_fu_machines[name] = machine
-        owner.state_fu_options[name]  = options
-        # method_missing to catch NoMethodError for event methods, etc
-        StateFu::MethodFactory.define_once_only_method_missing owner 
-        unless owner.respond_to? name          
-          owner.class_eval do
+        klass = owner
+        klass.state_fu_machines[name] = machine
+        klass.state_fu_options[name]  = options
+
+        # prepare the state machine accessor method
+        if owner.respond_to? name
+          raise "FIXME " + name
+        else
+          klass.class_eval do
             define_method name do
               state_fu name
             end
@@ -57,6 +60,10 @@ module StateFu
             end
           end
         end
+
+        # prepare event / state class methods
+        StateFu::MethodFactory.prepare_class_machine klass, machine, name, options
+
         # prepare the persistence field
         StateFu::Persistence.prepare_field owner, options[:field_name]
       end
@@ -99,10 +106,6 @@ module StateFu
       tools.inject_into( obj )
     end
 
-    def inject_methods_into( obj )
-      #puts 'inject_methods_into'
-    end
-
     # the modules listed here will be mixed into Binding and
     # Transition objects for this machine. use this to define methods,
     # references or data useful to you during transitions, event

data/lib/method_factory.rb

@@ -4,106 +4,110 @@ module StateFu
   # TODO: all events, simple or complex, should get the same method signature
   # simple events will be called as:  event_name! nil,    *args
   # complex events will be called as: event_name! :state, *args
-  
+
   class MethodFactory
     attr_accessor :method_definitions
     attr_reader   :binding, :machine
 
     # An instance of MethodFactory is created to define methods on a specific StateFu::Binding, and
     # on the object it is bound to.
-    
+
     def initialize(_binding)
-      @binding                      = _binding
-      @machine                      = binding.machine
-      simple_events, complex_events = machine.events.partition &:simple?
-      @method_definitions           = {}
-      
-      # simple event methods
-      # all arguments are passed into the transition / transition query
-      
-      simple_events.each do |event|
-        method_definitions["#{event.name}"]      = lambda do |*args| 
-          _binding.find_transition(event, event.target, *args) 
-        end
-        
-        method_definitions["can_#{event.name}?"] = lambda do |*args|
-          _binding.can_transition?(event, event.target, *args)
-        end
+      @binding            = _binding
+      @machine            = binding.machine
+      @method_definitions = MethodFactory.method_definitions_for(@machine, @binding.method_name)
+      self
+    end
 
-        method_definitions["#{event.name}!"]     = lambda do |*args|
-          _binding.fire_transition!(event, event.target, *args)
-        end
-      end
+    def self.method_definitions_for(machine, name)
+      returning({}) do |method_definitions|
+        simple_events, complex_events = machine.events.partition &:simple?
 
-      # complex event methods
-      # the first argument is the target state
-      # any remaining arguments are passed into the transition / transition query
-
-      # object.event_name [:target], *arguments
-      #
-      # returns a new transition. Will raise an IllegalTransition if 
-      # it is not given arguments which result in a valid combination
-      # of event and target state being deducted.
-      #
-      # object.event_name [nil] suffices if the event has only one valid 
-      # target (ie only one transition which would not raise a 
-      # RequirementError if fired) 
-      
-      # object.event_name! [:target], *arguments
-      #
-      # as per the method above, except that it also fires the event
-
-      # object.can_event_name? [:target], *arguments
-      #
-      # tests that calling event_name or event_name! would not raise an error
-      # ie, the transition is legal and is valid with the arguments supplied
-      
-      complex_events.each do |event|
-        method_definitions["#{event.name}"]      = lambda do |target, *args|
-          _binding.find_transition(event, target, *args) 
-        end
-        
-        method_definitions["can_#{event.name}?"] = lambda do |target, *args|
-          begin 
-            t = _binding.find_transition(event, target, *args) 
-            t.valid?
-          rescue IllegalTransition
-            false
+        # simple event methods
+        # all arguments are passed into the transition / transition query
+
+        simple_events.each do |event|
+          method_definitions["#{event.name}"]      = lambda do |*args|
+            state_fu(name).find_transition(event, event.target, *args)
           end
-        end
 
-        method_definitions["#{event.name}!"]     = lambda do |target, *args|
-          _binding.fire_transition!(event, target, *args)
+          method_definitions["can_#{event.name}?"] = lambda do |*args|
+            state_fu(name).can_transition?(event, event.target, *args)
+          end
+
+          method_definitions["#{event.name}!"]     = lambda do |*args|
+            state_fu(name).fire_transition!(event, event.target, *args)
+          end
         end
-      end
-      
-      # methods dedicated to a combination of event and target
-      # all arguments are passed into the transition / transition query
-      
-      (simple_events + complex_events).each do |event|
-        event.targets.each do |target|
-          method_definitions["#{event.name}_to_#{target.name}"]      = lambda do |*args| 
-            _binding.find_transition(event, target, *args) 
+
+        # complex event methods
+        # the first argument is the target state
+        # any remaining arguments are passed into the transition / transition query
+
+        # object.event_name [:target], *arguments
+        #
+        # returns a new transition. Will raise an IllegalTransition if
+        # it is not given arguments which result in a valid combination
+        # of event and target state being deducted.
+        #
+        # object.event_name [nil] suffices if the event has only one valid
+        # target (ie only one transition which would not raise a
+        # RequirementError if fired)
+
+        # object.event_name! [:target], *arguments
+        #
+        # as per the method above, except that it also fires the event
+
+        # object.can_event_name? [:target], *arguments
+        #
+        # tests that calling event_name or event_name! would not raise an error
+        # ie, the transition is legal and is valid with the arguments supplied
+
+        complex_events.each do |event|
+          method_definitions["#{event.name}"]      = lambda do |target, *args|
+            state_fu(name).find_transition(event, target, *args)
           end
 
-          method_definitions["can_#{event.name}_to_#{target.name}?"] = lambda do |*args|
-            _binding.can_transition?(event, target, *args)
+          method_definitions["can_#{event.name}?"] = lambda do |target, *args|
+            begin
+              t = state_fu(name).find_transition(event, target, *args)
+              t.valid?
+            rescue IllegalTransition
+              false
+            end
           end
 
-          method_definitions["#{event.name}_to_#{target.name}!"]     = lambda do |*args|
-            _binding.fire_transition!(event, target, *args)
-          end          
-        end unless event.targets.nil?
-      end
-      
-      machine.states.each do |state|
-        method_definitions["#{state.name}?"] = lambda do 
-         _binding.current_state == state
+          method_definitions["#{event.name}!"]     = lambda do |target, *args|
+            state_fu(name).fire_transition!(event, target, *args)
+          end
+        end
+
+        # methods dedicated to a combination of event and target
+        # all arguments are passed into the transition / transition query
+
+        (simple_events + complex_events).each do |event|
+          event.targets.each do |target|
+            method_definitions["#{event.name}_to_#{target.name}"]      = lambda do |*args|
+              state_fu(name).find_transition(event, target, *args)
+            end
+
+            method_definitions["can_#{event.name}_to_#{target.name}?"] = lambda do |*args|
+              state_fu(name).can_transition?(event, target, *args)
+            end
+
+            method_definitions["#{event.name}_to_#{target.name}!"]     = lambda do |*args|
+              state_fu(name).fire_transition!(event, target, *args)
+            end
+          end unless event.targets.nil?
+        end
+
+        machine.states.each do |state|
+          method_definitions["#{state.name}?"] = lambda do
+            state_fu(name).current_state == state
+          end
         end
       end
-      
-    end 
-          
+    end
 
     #
     # Class Methods
@@ -115,71 +119,25 @@ module StateFu
     # Note this happens when a machine is first bound to the class,
     # not when StateFu is included.
 
-    def self.prepare_class(klass)
-      raise caller.inspect
-      self.define_once_only_method_missing(klass)
-    end # prepare_class
+    def self.prepare_class_machine(klass, machine, name, options)
+      return unless options[:define_methods]
 
-    # When triggered, method_missing will first call state_fu!,
-    # instantating all bindings & installing their attendant
-    # MethodFactories, then check if the object now responds to the
-    # missing method name; otherwise it will call the original
-    # method_missing.
-    #
-    # method_missing will then revert to its original implementation.
-    #
-    # The purpose of all this is to allow dynamically created methods
-    # to be called, without worrying about whether they have been
-    # defined yet, and without incurring the expense of loading all
-    # the object's StateFu::Bindings before they're likely to be needed.
-    #
-    # Note that if you redefine method_missing on your StateFul
-    # classes, it's best to either do it before you include StateFu,
-    # or thoroughly understand what's happening in
-    # MethodFactory#define_once_only_method_missing.
-
-    def self.define_once_only_method_missing(klass)
-      raise ArgumentError.new(klass.to_s) unless klass.is_a?(Class)      
-      
-      klass.class_eval do                
-        return false if @_state_fu_prepared
-        @_state_fu_prepared = true
-
-        alias_method(:method_missing_before_state_fu, :method_missing) # if defined?(:method_missing, true)
-
-        def method_missing(method_name, *args, &block)
-          # invoke state_fu! to ensure event, etc methods are defined
-          begin            
-            state_fu! unless defined? initialize_state_fu!            
-          rescue NoMethodError => e
-            raise e
-          end
-          
-          # reset method_missing for this instance
-          class << self; self; end.class_eval do
-            alias_method :method_missing, :method_missing_before_state_fu              
+      method_definitions_for(machine, name).each do |method_name, block|
+        unless klass.respond_to? method_name, true
+          klass.class_eval do
+            define_method method_name, &block
           end
-        
-          # call the newly defined method, or the original method_missing
-          if respond_to? method_name, true
-            # it was defined by calling state_fu!, which instantiated bindings
-            # for its state machines, which defined singleton methods for its
-            # states & events when it was constructed.
-            __send__ method_name, *args, &block
-          else 
-            # call the original method_missing (method_missing_before_state_fu)
-            method_missing method_name, *args, &block
-          end
-        end # method_missing
-      end # class_eval
-    end # define_once_only_method_missing
+        end
+      end
+
+    end # prepare_class
 
     # Define the same helper methods on the StateFu::Binding and its
     # object.  Any existing methods will not be tampered with, but a
     # warning will be issued in the logs if any methods cannot be defined.
     def install!
-      define_event_methods_on @binding       
-      define_event_methods_on @binding.object if @binding.options[:define_methods]
+      define_event_methods_on @binding
+      define_event_methods_on @binding.object if @binding.options[:define_methods] && @binding.options[:singleton]
     end
 
     #
@@ -225,7 +183,7 @@ module StateFu
     def self.define_singleton_method(object, method_name, options={}, &block)
       if object.respond_to? method_name, true
         msg = !options[:force]
-        Logger.info "Existing method #{method(method_name) rescue [method_name].inspect} "\
+        Logging.info "Existing method #{method(method_name) rescue [method_name].inspect} "\
           "for #{object.class} #{object} "\
           "#{options[:force] ? 'WILL' : 'won\'t'} "\
           "be overwritten."
@@ -237,7 +195,7 @@ module StateFu
       end
     end
     alias_method :define_singleton_method, :define_singleton_method
-    
+
   end # class MethodFactory
 end # module StateFu