davidlee-state-fu 0.11.0 → 0.11.1

data/lib/{state_fu/binding.rb → binding.rb}

@@ -58,6 +58,36 @@ module StateFu
     alias_method :state_name, :current_state_name
     alias_method :to_sym,     :current_state_name
 
+    #
+    # These methods are called from methods defined by MethodFactory.
+    # 
+    
+    # event_name [target], *args
+    #
+    def find_transition(event, target=nil, *args)
+      target ||= args.last[:to].to_sym rescue nil      
+      query = transitions.for_event(event).to(target).with(*args)
+      query.find || query.valid.singular || nil 
+    end
+
+    # event_name? [target], *args
+    #
+    def can_transition?(event, target=nil, *args)
+      begin
+        if t = find_transition(event, target, *args) 
+          t.valid?(*args)
+        end
+      rescue IllegalTransition, UnknownTarget
+        nil
+      end      
+    end
+
+    # event_name! [target], *args
+    #
+    def fire_transition!(event, target=nil, *args)
+      find_transition(event, target, *args).fire!
+    end
+
     #
     # events
     #
@@ -109,6 +139,7 @@ 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
     #
@@ -248,39 +279,6 @@ module StateFu
       s << ">"
       s
     end
-
-    # These methods are called from methods defined by MethodFactory. 
-    # You probably don't want to call them directly.
     
-    # event_name 
-    def find_transition(event, target=nil, *args)
-      target ||= args.last[:to].to_sym rescue nil      
-      query = transitions.for_event(event).to(target).with(*args)
-      query.find || query.valid.singular || NilTransition.new      
-      # transition = binding.transitions.with(*args).search([event, target])
-    end
-
-    # event_name?
-    def can_transition?(event, target=nil, *args)
-      begin
-        if t = find_transition(event, target, *args) 
-          t.valid?(*args)
-        end
-      rescue IllegalTransition, UnknownTarget
-        nil
-      end      
-    end
-
-    # event_name!
-    def fire_transition!(event, target=nil, *args)
-      find_transition(event, target, *args).fire!
-    end
-
-    #
-    # transition constructor
-    #
-    def new_transition(event, target, *args, &block)
-      Transition.new( self, event, target, *args, &block )
-    end
   end
 end

data/lib/{state_fu/event.rb → event.rb}

@@ -10,9 +10,11 @@ module StateFu
       super( machine, name, options )
     end
 
-    # 
+    # Sequences: pretending events are state-local -
+    # probably a bad idea but here for a "compatibility mode"
+    # with eg the activemodel state machine
+    
     # build a hash of target => [origins]
-    #
     def add_to_sequence origin_states, target_state
       origin_states = [origin_states].flatten
       existing = origin_states.select {|s| target_for_origin(s) }
@@ -23,32 +25,25 @@ module StateFu
       end
       @sequence
     end
-    
+
+    def sequence?
+      !sequence.empty?
+    end
+
     def target_for_origin origin_state
       raise ArgumentError.new if origin_state.nil?
       name = sequence.detect do |k,v| 
         v.include?(origin_state.to_sym)
       end[0] rescue nil
       machine.states[name] if name
-      # if t
-      #   puts t.inspect + " <============================" if t
-      #   puts "======================"
-      #   puts origin_state.class
-      #   puts origin_state.name rescue origin_state.inspect
-      # end
-      # machine.states[t.first] if t
     end
     
+
     def can_transition_from?(origin_state) 
       ( origins && origins.include?(origin_state.to_sym) && !targets.blank?) ||
         target_for_origin(origin_state)
-    end
-    
-    def sequence?
-      !sequence.empty?
-    end
-    
-    
+    end    
+  
     # the names of all possible origin states
     def origin_names
       origins ? origins.map(&:to_sym) : nil

data/lib/{state_fu/executioner.rb → executioner.rb}

@@ -53,22 +53,12 @@ module StateFu
     alias_method :arguments,            :args
     alias_method :transition_arguments, :args
 
-    # delegate :machine, :to => :binding
-    #delegate :states,  :to => :machine
-
-
     def machine 
       binding.machine
     end
     
     def states
-      # puts binding
-      # puts binding.instance_eval() { @machine }
-      # puts binding.machine
-      # puts binding.machine.states.names
-      # puts machine
-      # puts machine.states
-      # machine.states
+      machine.states
     end
     # delegate :machine, :to => :transition
 
@@ -137,13 +127,12 @@ module StateFu
       
     end
 
-#    # Forwards any missing method call to the \target.
-#    def self.const_missing(const_name)
-#      unless __target__.class.const_defined?(const_name, true)
-#        super(const_name)
-#      end
-#      __target__.class.const_get(const_name)
-#    end
-#
+    # # Forwards any missing constant references to the \target.
+    # def self.const_missing(const_name)
+    #   unless __target__.class.const_defined?(const_name, true)
+    #     super(const_name)
+    #   end
+    #   __target__.class.const_get(const_name)
+    # end
   end
 end

data/lib/{state_fu/hooks.rb → hooks.rb}

@@ -20,16 +20,19 @@ module StateFu
 
     # just turn the above into what each class needs
     # and make it into a nice hash: { :name =>[ hook, ... ], ... }
-    def self.for( me )
-      x = if    me.is_a?(State);   STATE_HOOKS
-          elsif me.is_a?(Event);   EVENT_HOOKS
-          elsif me.is_a?(Machine); MACHINE_HOOKS
-          elsif me.is_a?(Sprocket); [] # let specs pass
-          else  raise me
-          end.
-        map { |type, name| [name, [].extend( OrderedHash )] }
-      hash = x.inject({}) {|h, a| h[a.first] = a.last; h }
-      hash.extend( OrderedHash ).freeze
+    def self.for( instance )
+      case instance
+      when State
+        STATE_HOOKS
+      when Event
+        EVENT_HOOKS
+      when Machine
+        MACHINE_HOOKS
+      when Sprocket
+        []
+      end.
+        map { |type, name| [name, [].extend( OrderedHash )] }.
+        to_h.extend( OrderedHash ).freeze
     end
 
   end

data/lib/{state_fu/lathe.rb → lathe.rb}

@@ -301,7 +301,7 @@ module StateFu
 
     # chain_states :a => [:b,:c], :c => :d, :c => :d
     # chain_states :a,:b,:c,:d, :a => :c
-    def connect_states *array, &b
+    def connect_states *array
       array.flatten!
       hash = array.extract_options!.symbolize_keys!
       array.inject(nil) do |origin, target|
@@ -320,6 +320,10 @@ module StateFu
     #
     # Define a series of states at once, or return and iterate over all states yet defined
     #
+    # states :a, :b, :c, :colour => "purple"
+    # states(:ALL) do
+    #
+    # end
     def states *args, &block
       valid_unless_nested()
       each_state_or_event 'state', *args, &block
@@ -502,9 +506,15 @@ module StateFu
       if args.empty? || args  == [:ALL]
         args = machine.send("#{type}s").except options.delete(:except)
       end
+      mod = case type.to_s
+            when 'state'
+              StateArray
+            when 'event'
+              EventArray
+            end
       args.map do |name|
         self.send type, name, options.dup, &block
-      end.extend ArrayWithSymbolAccessor
+      end.extend mod
     end
 
   end

data/lib/state-fu.rb

@@ -14,61 +14,23 @@
 # impose very few limits on your ability to introspect, manipulate and
 # extend the core features.
 #
-# It is also delightfully elegant and easy to use for simple things:
-#
-#   class Document < ActiveRecord::Base
-#     include StateFu
-#
-#     def update_rss
-#       puts "new feed!"
-#       # ... do something here
-#     end
-#
-#     machine( :status ) do
-#       state :draft do
-#         event :publish, :to => :published
-#       end
-#
-#       state :published do
-#         on_entry :update_rss
-#         requires :author  # a database column
-#       end
-#
-#       event :delete, :from => :ALL, :to => :deleted do
-#         execute :destroy
-#       end
-#     end
-#   end
-#
-#  my_doc = Document.new
-#
-#  my_doc.status                          # returns a StateFu::Binding, which lets us access the 'Fu
-#  my_doc.status.state     => 'draft'     # if this wasn't already a database column or attribute, an
-#                                         # attribute has been created to keep track of the state
-#  my_doc.status.name      => :draft      # the name of the current_state (defaults to the first defined)
-#  my_doc.status.publish!                 # raised =>  StateFu::RequirementError: [:author]
-#                                         # the author requirement prevented the transition
-#  my_doc.status.name      => :draft      # see? still a draft.
-#  my_doc.author = "Susan"                # so let's satisfy it ...
-#  my_doc.publish!                        # and try again
-#  "new feed!"                            # aha - our event hook fires!
-#  my_doc.status.name      => :published  # and the state has been updated.
+# It is also delightfully elegant and easy to use for simple things.
+
 
 require 'rubygems'
-# require 'activesupport'
 
-[ 'core_ext',
-  'logger',
-  'applicable',
-  'arrays',
-  'methodical',
-  'has_options',
+[ 'support/core_ext',
+  'support/logger',
+  'support/applicable',
+  'support/arrays',
+  'support/methodical',
+  'support/has_options',
+  'support/plotter',
+  'support/exceptions',
   'executioner',
-  'exceptions',
   'machine',
   'lathe',
   'method_factory',
-  'nil_transition',
   'binding',
   'persistence',
   'persistence/base',
@@ -81,10 +43,7 @@ require 'rubygems'
   'hooks',
   'interface',
   'transition',
-  'transition_query',
-  'plotter' ].each do |lib|
-  require File.expand_path( File.join( File.dirname(__FILE__), 'state_fu', lib ))
-end
+  'transition_query' ].each { |lib| require File.expand_path(File.join(File.dirname(__FILE__),lib))}
 
 module StateFu
   DEFAULT       = :default

data/lib/{state_fu → support}/core_ext.rb

@@ -4,6 +4,7 @@ require 'rubygems'
 # some convenience methods
 unless Object.const_defined?('ActiveSupport')  #:nodoc
   Dir[File.join(File.dirname( __FILE__), 'active_support_lite','**' )].sort.each do |lib|
+    lib = File.expand_path lib
     next unless File.file?( lib )
     require lib
   end

data/lib/{state_fu → support}/plotter.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__),'../vizier')
+require 'vizier'
 require 'tempfile'
 
 module StateFu

data/lib/{state_fu/transition.rb → transition.rb}

@@ -23,13 +23,13 @@ module StateFu
                 :current_hook_slot,
                 :current_hook 
 
-    alias_method :arguments, :args
+    alias_method :arguments, :args   
     
     def initialize( binding, event, target=nil, *argument_list, &block )
       # ensure we have an Event
       event = binding.machine.events[event] if event.is_a?(Symbol)
       raise( UnknownTarget.new(self, "Not an event: #{event} #{self.inspect}" )) unless event.is_a? Event 
-
+   
       @binding    = binding
       @machine    = binding.machine
       @object     = binding.object
@@ -159,7 +159,7 @@ module StateFu
     end
 
     #
-    #
+    # Halt a transition mid-execution
     #
 
     # halt a transition with a message
@@ -169,7 +169,7 @@ module StateFu
     end
 
     #
-    #
+    # Fire!
     #
     
     # actually fire the transition
@@ -235,6 +235,7 @@ module StateFu
       binding.current_state
     end
     
+    # a little convenience for debugging / display
     def destination
       [event, target].map(&:to_sym)
     end