state-fu 0.11.1 → 0.12.1

data/lib/binding.rb

@@ -3,13 +3,12 @@ module StateFu
 
     attr_reader :object, :machine, :method_name, :field_name, :persister, :transitions, :options, :target
 
-
     # the constructor should not be called manually; a binding is
     # returned when an instance of a class with a StateFu::Machine
     # calls:
     #
     # instance.#state_fu (for the default machine which is called :state_fu),
-    # instance.#state_fu( :<machine_name> ) ,or
+    # instance.#state_fu(:<machine_name>) ,or
     # instance.#<machine_name>
     #
     def initialize( machine, object, method_name, options={} )
@@ -18,13 +17,18 @@ module StateFu
       @method_name   = method_name
       @transitions   = []
       @options       = options.symbolize_keys!
-      @target        = singleton? ? object : object.class
-      @field_name    = options[:field_name] || @target.state_fu_field_names[method_name]
-      @persister     = Persistence.for( self )
+      if options[:singleton]
+        @target      = object
+      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")      
+      @persister     = Persistence.for self
 
       # define event methods on this binding and its @object
-      MethodFactory.new( self ).install!
-      @machine.helpers.inject_into( self )
+      MethodFactory.new(self).install!
+      @machine.helpers.inject_into self 
     end
 
     alias_method :o,             :object

data/lib/interface.rb

@@ -2,21 +2,19 @@ module StateFu
   module Interface
     module SoftAlias
 
-      # define aliases that won't clobber existing methods - 
-      # so we can be liberal with them.
-      def soft_alias(x)
-        aliases  = [ x.to_a[0] ].flatten
-        original = aliases.shift
+      def soft_alias(hash)
         existing_method_names = (self.instance_methods | self.protected_instance_methods | self.private_instance_methods).map(&:to_sym)
-        taken, ok = aliases.partition { |a| existing_method_names.include?(a.to_sym) }
-        StateFu::Logger.debug("#{self.to_s} alias for ## #{original} already taken: #{taken.inspect}")  unless taken.empty?
-        ok.each { |a| alias_method a, original}
-      end
-      
+        hash.each do |original, aliases|
+          aliases.
+            reject { |a| existing_method_names.include?(a.to_sym) }.
+            each { |a| alias_method a, original}
+        end
+      end      
     end
 
     module Aliases
-
+      # define aliases that won't clobber existing methods - 
+      # so we can be liberal with them.
       def self.extended(base)
         base.extend SoftAlias
         base.class_eval do
@@ -70,8 +68,8 @@ module StateFu
       end
       alias_method :machine, :state_fu_machine
 
-      def state_fu_field_names
-        @_state_fu_field_names ||= {}
+      def state_fu_options
+        @_state_fu_options ||= {}
       end
 
       def state_fu_machines
@@ -97,7 +95,7 @@ module StateFu
       # can access a StateFu::Machine, the object's current state, the
       # methods which trigger event transitions, etc.
 
-      def state_fu_binding( name = DEFAULT )
+      def state_fu_binding(name = DEFAULT)
         name = name.to_sym 
         if machine = self.class.state_fu_machines[name]
           state_fu_bindings[name] ||= StateFu::Binding.new( machine, self, name )

data/lib/machine.rb

@@ -4,7 +4,7 @@ module StateFu
     def self.BINDINGS
       @@_bindings ||= {}
     end
-
+    
     include Applicable
     include HasOptions
     
@@ -17,10 +17,9 @@ module StateFu
     def self.for_class(klass, name, options={}, &block)
       options.symbolize_keys!
       name = name.to_sym
-
       unless machine = klass.state_fu_machines[ name ]
         machine = new(options)
-        machine.bind! klass, name, options[:field_name] 
+        machine.bind! klass, name, options
       end
       if block_given?
         machine.apply! &block 
@@ -30,26 +29,36 @@ module StateFu
 
     # make it so that a class which has included StateFu has a binding to
     # this machine
-    def self.bind!( machine, owner, name, field_name)
+    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)
+      options[:singleton] = true unless owner.is_a?(Class)
       # define an accessor method with the given name
-      if owner.class == Class
-        owner.state_fu_machines[name]    = machine
-        owner.state_fu_field_names[name] = field_name
+      if options[:singleton]
+        _binding = StateFu::Binding.new machine, owner, name, options
+        MethodFactory.define_singleton_method(owner, name) { _binding }
+        if alias_name = options[:alias] || options[:as]
+          MethodFactory.define_singleton_method(owner, alias_name) { _binding }
+        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)
+        StateFu::MethodFactory.define_once_only_method_missing owner 
+        unless owner.respond_to? name          
           owner.class_eval do
             define_method name do
-              state_fu( name )
+              state_fu name
+            end
+            # allow aliases to be set up, e.g. machine(:as => :status)
+            if alias_name = options[:alias] || options[:as]
+              alias_method alias_name, name
             end
           end
         end
         # prepare the persistence field
-        StateFu::Persistence.prepare_field owner, field_name 
-      else
-        _binding = StateFu::Binding.new machine, owner, name, :field_name => field_name, :singleton => true 
-        MethodFactory.define_singleton_method(owner, name) { _binding }
+        StateFu::Persistence.prepare_field owner, options[:field_name]
       end
     end
 
@@ -116,9 +125,8 @@ module StateFu
 
     # make it so a class which has included StateFu has a binding to
     # this machine
-    def bind!( owner, name= DEFAULT, field_name = nil )
-      field_name ||= Persistence.default_field_name( name )
-      self.class.bind!(self, owner, name, field_name)
+    def bind!(owner, name=DEFAULT, options={})
+      self.class.bind!(self, owner, name, options)
     end
 
     def empty?

data/lib/method_factory.rb

@@ -7,14 +7,15 @@ module StateFu
   
   class MethodFactory
     attr_accessor :method_definitions
-    attr_reader   :binding
-    
+    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  
-      simple_events, complex_events = @binding.machine.events.partition(&:simple?)
+    def initialize(_binding)
+      @binding                      = _binding
+      @machine                      = binding.machine
+      simple_events, complex_events = machine.events.partition &:simple?
       @method_definitions           = {}
       
       # simple event methods
@@ -95,7 +96,7 @@ module StateFu
         end unless event.targets.nil?
       end
       
-      @binding.machine.states.each do |state|
+      machine.states.each do |state|
         method_definitions["#{state.name}?"] = lambda do 
          _binding.current_state == state
         end
@@ -114,9 +115,9 @@ module StateFu
     # Note this happens when a machine is first bound to the class,
     # not when StateFu is included.
 
-    def self.prepare_class( klass )
+    def self.prepare_class(klass)
       raise caller.inspect
-      self.define_once_only_method_missing( klass )
+      self.define_once_only_method_missing(klass)
     end # prepare_class
 
     # When triggered, method_missing will first call state_fu!,
@@ -137,7 +138,7 @@ module StateFu
     # or thoroughly understand what's happening in
     # MethodFactory#define_once_only_method_missing.
 
-    def self.define_once_only_method_missing( klass )
+    def self.define_once_only_method_missing(klass)
       raise ArgumentError.new(klass.to_s) unless klass.is_a?(Class)      
       
       klass.class_eval do                
@@ -160,14 +161,14 @@ module StateFu
           end
         
           # call the newly defined method, or the original method_missing
-          if respond_to?(method_name, true) 
+          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 )
+            __send__ method_name, *args, &block
           else 
             # call the original method_missing (method_missing_before_state_fu)
-            method_missing( method_name, *args, &block )
+            method_missing method_name, *args, &block
           end
         end # method_missing
       end # class_eval
@@ -177,8 +178,8 @@ module StateFu
     # 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 )
+      define_event_methods_on @binding       
+      define_event_methods_on @binding.object if @binding.options[:define_methods]
     end
 
     #
@@ -202,13 +203,13 @@ module StateFu
     # itself.  The remaining arguments are passed into the transition,
     # as with simple event methods.
     #
-    def define_event_methods_on( obj )
+    def define_event_methods_on(obj)
       method_definitions.each do |method_name, method_body|
-        define_singleton_method( obj, method_name, &method_body)
+        define_singleton_method obj, method_name, &method_body
       end
     end # define_event_methods_on
 
-    def define_singleton_method( object, method_name, &block )
+    def define_singleton_method(object, method_name, &block)
       MethodFactory.define_singleton_method object, method_name, &block
     end
 
@@ -221,8 +222,8 @@ module StateFu
     #
     # existing methods will never be overwritten.
 
-    def self.define_singleton_method( object, method_name, options={}, &block )
-      if object.respond_to?(method_name, true) 
+    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} "\
           "for #{object.class} #{object} "\
@@ -231,7 +232,7 @@ module StateFu
       else
         metaclass = class << object; self; end
         metaclass.class_eval do
-          define_method( method_name, &block )
+          define_method method_name, &block
         end
       end
     end

data/lib/persistence.rb

@@ -39,7 +39,7 @@ module StateFu
     end
 
     # returns the appropriate persister class for the given class & field name.
-    def self.class_for( klass, field_name )
+    def self.class_for(klass, field_name)
       raise ArgumentError if [klass, field_name].any?(&:nil?)
       @@class_for[klass] ||= {}
       @@class_for[klass][field_name] ||=
@@ -52,7 +52,7 @@ module StateFu
         end
     end
 
-    def self.for_class( klass, binding, field_name )
+    def self.for_class(klass, binding, field_name)
       persister_class = class_for klass, field_name
       prepare_field( klass, field_name, persister_class)
       returning persister_class.new( binding, field_name ) do |persister|
@@ -60,7 +60,7 @@ module StateFu
       end
     end
 
-    def self.for_instance( binding, field_name )
+    def self.for_instance(binding, field_name)
       metaclass = class << binding.object; self; end
       for_class( metaclass, binding, field_name )
     end
@@ -69,7 +69,7 @@ module StateFu
     # also ensures the persister class method :prepare_field has been called
     # once for the given class & field name so the field can be set up; eg an
     # attr_accessor or a before_save hook defined
-    def self.for( binding )
+    def self.for(binding)
       field_name = binding.field_name.to_sym
       if binding.singleton?
         for_instance( binding, field_name )
@@ -95,21 +95,21 @@ module StateFu
     # checks to see if the field_name for persistence is a
     # RelaxDB attribute.
     # Safe to use (skipped) if RelaxDB is not included.
-    def self.relaxdb_document_property?( klass, field_name )
+    def self.relaxdb_document_property?(klass, field_name)
       Object.const_defined?('RelaxDB') &&
         klass.ancestors.include?( ::RelaxDB::Document ) &&
-        klass.properties.map(&:to_s).include?( field_name.to_s )
+        klass.properties.map(&:to_s).include?(field_name.to_s)
     end
 
     # checks to see if the field_name for persistence is an
     # ActiveRecord column.
     # Safe to use (skipped) if ActiveRecord is not included.
-    def self.active_record_column?( klass, field_name )
+    def self.active_record_column?(klass, field_name)
       Object.const_defined?("ActiveRecord") &&
         ::ActiveRecord.const_defined?("Base") &&
-        klass.ancestors.include?( ::ActiveRecord::Base ) &&
+        klass.ancestors.include?(::ActiveRecord::Base) &&
         klass.table_exists? &&
-        klass.columns.map(&:name).include?( field_name.to_s )
+        klass.columns.map(&:name).include?(field_name.to_s)
     end
 
   end

data/lib/support/logger.rb

@@ -1,4 +1,3 @@
-
 require 'logger'
 module StateFu
   #
@@ -32,9 +31,9 @@ module StateFu
     @@shared    = false
     @@log_level = nil
 
-    def self.new( logger = $stdout, options={} )
-      self.suppress = false
-      self.logger   = logger, options
+    def self.new( logger=nil, options={} )
+      @@suppress = false
+      set_logger(logger, options)
       self
     end
 
@@ -55,19 +54,19 @@ module StateFu
     end
 
     def self.shared?
-      !! @@shared
+      !!@@shared
     end
 
     def self.prefix
       shared? ? @@prefix : nil
     end
 
-    def self.logger= logger
-      set_logger logger
+    def self.logger= new_logger
+      set_logger new_logger
     end
 
     def self.instance
-      @@logger ||= set_logger(Logger.default_logger)
+      @@logger ||= default_logger
     end
 
     def self.suppress!
@@ -108,7 +107,7 @@ module StateFu
       when Logger.activesupport_logger_available? && ActiveSupport::BufferedLogger
         @@logger = logger
       else
-        raise ArgumentError.new
+        default_logger
       end
       self.shared = !!options.symbolize_keys![:shared]
       if shared?
@@ -123,27 +122,19 @@ module StateFu
 
     private
     
-    def self.get_logger( logr = $stdout )
-      if Object.const_defined?( "RAILS_DEFAULT_LOGGER" )
-        set_logger RAILS_DEFAULT_LOGGER, :shared => true
-      else
-        if Object.const_defined?( 'ActiveSupport' ) && ActiveSupport.const_defined?('BufferedLogger')
-          set_logger( ActiveSupport::BufferedLogger.new( logr ))
-        else
-          set_logger ::Logger.new( logr )
-        end
-      end
-    end
-
     def self.activesupport_logger_available?
       Object.const_defined?( 'ActiveSupport' ) && ActiveSupport.const_defined?('BufferedLogger')
     end
     
-    def self.default_logger
-      if Object.const_defined?( "RAILS_DEFAULT_LOGGER" )
-        RAILS_DEFAULT_LOGGER
-      else
-        $stdout
+    def self.default_logger(target=$stdout)
+      if activesupport_logger_available?
+        if Object.const_defined?("RAILS_DEFAULT_LOGGER")
+          RAILS_DEFAULT_LOGGER
+        else
+          ActiveSupport::BufferedLogger.new(target)
+        end
+      else      
+        ::Logger.new(target)
       end
     end
     
@@ -156,7 +147,7 @@ module StateFu
       when nil
         level
       else
-        raise ArgumentError
+        raise ArgumentError.new(input.inspect)
       end
     end
     

data/spec/features/machine_alias_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "defining an alias for the default machine" do
+  describe "with machine(:as => :status)" do
+    before do
+      make_pristine_class('Klass')
+      Klass.machine :as => :status do
+        state :active
+      end
+      @obj = Klass.new
+    end
+
+    it "should not prevent normal access through #state_fu" do
+      @obj.state_fu.machine.should == Klass.machine
+    end
+    
+    it "should not affect the internal name of the machine" do
+      @obj.status.method_name.should == :default
+    end
+    
+    it "should let you access the machine through #status" do
+      @obj.status.should be_kind_of(StateFu::Binding)
+      @obj.status.machine.should == Klass.machine
+      @obj.status.current_state.should == :active
+    end
+    
+  end
+end
+
+describe "defining an alias for a default singleton machine" do
+  describe "with #bind! :default, :as => :alias" do
+    before do
+      make_pristine_class('Klass')
+      @machine = StateFu::Machine.new do
+        state :exemplary
+      end
+      @obj = Klass.new
+      @machine.bind!( @obj, :default, :as => :example)
+    end
+    
+    it "should work too" do
+      @obj.example.machine.should == @machine
+    end    
+  end
+end
+

data/spec/features/singleton_machine_spec.rb

@@ -5,7 +5,7 @@ describe "singleton machines" do
     make_pristine_class('Klass')
     @m = StateFu::Machine.new do
       state :a do
-        event :beatify, :transitions_to => :b
+        event :bify, :transitions_to => :b
       end
     end
     @m.events.length.should == 1
@@ -20,9 +20,22 @@ describe "singleton machines" do
     @obj.my_binding.object.should == @obj
   end
 
-  it "should have event methods defined" do
-    %w/beatify can_beatify? beatify!/.each do |method_name|
+  it "should have methods defined on the binding by default" do
+    %w/bify can_bify? bify!/.each do |method_name|
       @obj.my_binding.should respond_to(method_name)
+    end
+  end
+  
+  it "should not have methods defined on the instance by default" do
+    %w/bify can_bify? bify!/.each do |method_name|
+      @obj.should_not respond_to(method_name)
+    end    
+  end
+  
+
+  it "should have methods defined on the instance if bound with :define_methods => true" do
+    @m.bind!( @obj, :my_binding, :define_methods => true)
+    %w/bify can_bify? bify!/.each do |method_name|
       @obj.should respond_to(method_name)
     end
   end
@@ -30,7 +43,7 @@ describe "singleton machines" do
   it "should transition" do
     @b = @obj.my_binding
     @b.current_state.should == :a
-    t = @obj.beatify!
+    t = @obj.my_binding.bify!
     t.should be_kind_of(StateFu::Transition)
     t.should be_accepted
     @b.current_state.should == :b

data/spec/features/when_methods_are_defined_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "instance methods defined for a class's machine," do
+  before do
+    make_pristine_class('Klass')
+  end
+  
+  describe "for the default machine" do
+    it "should define methods for states and events" do
+      Klass.machine do
+        event :go, :from => :a, :to => :b
+      end
+      instance = Klass.new
+      instance.state_fu!
+      instance.should respond_to(:a?)
+      instance.should respond_to(:can_go?)      
+    end   
+
+    it "should not define methods given :define_methods => false" do
+      Klass.machine :define_methods => false do
+        event :go, :from => :a, :to => :b
+      end
+      instance = Klass.new
+      instance.state_fu!
+      instance.should_not respond_to(:a?)
+      instance.should_not respond_to(:can_go?)
+    end   
+  end
+  
+  describe "for other machines" do
+    it "should not define methods" do
+      Klass.machine :other do
+        event :go, :from => :a, :to => :b
+      end
+      instance = Klass.new
+      instance.state_fu!
+      instance.should_not respond_to(:a?)
+      instance.should_not respond_to(:can_go?)      
+    end
+    
+    it "should define methods given :define_methods => true" do
+      Klass.machine :define_methods => true do
+        event :go, :from => :a, :to => :b
+      end
+      instance = Klass.new
+      instance.state_fu!
+      instance.should respond_to(:a?)
+      instance.should respond_to(:can_go?)
+    end
+  end
+end
+
+
+describe "instance methods when you #bind! a machine" do
+  before do
+    make_pristine_class('Klass')
+    @machine = StateFu::Machine.new do
+      state :hot
+      state :cold
+    end
+  end
+  
+  describe "as the default machine," do
+    describe "the default behaviour" do
+      before do
+        @machine.bind! Klass, :default, :define_methods => true
+      end
+
+      it "defines methods" do
+        instance = Klass.new
+        instance.state_fu!
+        instance.should respond_to(:hot?)      
+      end
+    end
+
+    describe "when it is bound with :define_methods => false" do
+      before do
+        @machine.bind! Klass, :default, :define_methods => false
+      end
+
+      it "should not define methods" do
+        instance = Klass.new
+        instance.state_fu!
+        instance.should_not respond_to(:hot?)      
+      end
+    end
+  end
+
+  describe "as another machine," do
+    describe "the default behaviour" do
+      before do
+        @machine.bind! Klass, :temperature
+      end
+
+      it "should not define methods" do
+        instance = Klass.new
+        instance.state_fu!
+        instance.should_not respond_to(:hot?)      
+      end
+    end
+
+    describe "when it is bound with :define_methods => true" do
+      before do
+        @machine.bind! Klass, :temperature, :define_methods => true
+      end
+
+      it "should define methods" do
+        instance = Klass.new
+        instance.state_fu!
+        instance.should respond_to(:hot?)      
+      end
+    end
+  end
+end 

data/spec/state_fu_spec.rb

@@ -885,7 +885,23 @@ describe "Chameleon" do
         event :go_inside,  :from => {:outside => :inside}
       end 
       
-      machine :skin do
+      # With :define_methods => true, we can create methods for the :skin
+      # machine directly on our Chameleon, so we can type e.g. 
+      #        
+      # @chameleon.comoflage! :bark
+      # instead of:
+      # @chameleon.skin.camoflage! :bark
+      #
+      # This is the usual behaviour for the default machine, but not for any
+      # machine given an explicit name. Otherwise, it would cause confusion
+      # when (like the PokerMachine example) multiple machines would compete
+      # for the same methods.
+      #
+      # Hint for the masochistic: state / event methods will never overwrite a
+      # pre-existing method, so in the event of overlap, the first machine
+      # defined will take precedence.
+      
+      machine :skin, :define_methods => true do
         initial_state :green
         
         states :plaid, :paisley, :tartan, :location => :indoors
@@ -897,9 +913,9 @@ describe "Chameleon" do
           else
             case transition.target[:location]
             when :indoors
-              inside?
+              location.inside?
             when :outdoors
-              outside?
+              location.outside?
             else
               true
             end
@@ -923,13 +939,13 @@ describe "Chameleon" do
       @chameleon.current_state(:location).should == :outside
       @chameleon.current_state(:skin).should     == :green
 
-      @chameleon.outside?.should == true
+      @chameleon.location.outside?.should == true
       
       @chameleon.skin.valid_transitions.targets.names.should == [:bark, :pebbles, :foliage]
       @chameleon.camoflage!(:bark)
       @chameleon.skin.should == :bark
       
-      @chameleon.go_inside!
+      @chameleon.location.go_inside!
       @chameleon.skin.valid_transitions.targets.names.should == [:green, :plaid, :paisley, :tartan]
       
       @chameleon.camoflage!(:tartan)
@@ -943,6 +959,7 @@ describe "Chameleon" do
     end
     
   end
+    
 end
 
 

data/spec/units/binding_spec.rb

@@ -14,12 +14,6 @@ describe StateFu::Binding do
   end
 
 
-  #
-  #
-  #
-
-
-
   #
   #
   #
@@ -33,8 +27,10 @@ describe StateFu::Binding do
 
   describe "constructor" do
     before do
-      mock(Klass).state_fu_field_names.at_most(1) do
-        { :example => :example_field }
+      mock(Klass).state_fu_options.at_most(2) do
+        { 
+          :example => {:field_name => :example_field} 
+        }
       end
     end
 
@@ -63,10 +59,12 @@ describe StateFu::Binding do
       end
 
       describe "when StateFu::Persistence.active_record_column? is true" do
+        
         before do
           mock( StateFu::Persistence ).active_record_column?(Klass, :example_field).times(1) { true }
           mock( Klass ).before_create( :state_fu!) { }
         end
+        
         it "should get an ActiveRecord persister" do
           mock( StateFu::Persistence::ActiveRecord ).new( anything, :example_field ) { @p }
           b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )

data/spec/units/machine_spec.rb

@@ -20,22 +20,19 @@ describe StateFu::Machine do
         before do
           reset!
           make_pristine_class 'Klass'
-  #        mock( Klass ).machines() { {} }
         end
 
         it "should create a new machine and bind! it" do
           @machine = Object.new
-          mock( @machine ).bind!( Klass, :moose, nil )
-          mock( StateFu::Machine ).new( {} ) { @machine }
-          StateFu::Machine.for_class( Klass, :moose )
+          mock(@machine).bind!(Klass, :moose, {})
+          mock(StateFu::Machine).new({}) { @machine }
+          StateFu::Machine.for_class Klass, :moose
         end
 
         it "should apply the block (via lathe) if one is given" do
-          @m = StateFu::Machine.for_class( Klass, :snoo ) do
+          @m = StateFu::Machine.for_class Klass, :snoo do
             state :porpoise
           end
-#          mock( Klass ).machines() { {} }
- #         @m.states.map(&:name).should == [:porpoise]
         end
       end
 
@@ -85,7 +82,7 @@ describe StateFu::Machine do
         name       = :StinkJuice
         field_name = 'stink_juice_field'
         @m.bind!( Klass, name )
-        Klass.state_fu_field_names[name].should == 'stink_juice_field'
+        Klass.state_fu_options[name][:field_name].should == 'stink_juice_field'
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state-fu
 version: !ruby/object:Gem::Version 
-  version: 0.11.1
+  version: 0.12.1
 platform: ruby
 authors: 
 - David Lee
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-26 00:00:00 +10:00
+date: 2009-09-26 00:00:00 +10:00
 default_executable: 
 dependencies: []
 
@@ -73,6 +73,7 @@ files:
 - lib/transition_query.rb
 - spec/custom_formatter.rb
 - spec/features/binding_and_transition_helper_mixin_spec.rb
+- spec/features/machine_alias_spec.rb
 - spec/features/method_missing_only_once_spec.rb
 - spec/features/not_requirements_spec.rb
 - spec/features/plotter_spec.rb
@@ -80,6 +81,7 @@ files:
 - spec/features/singleton_machine_spec.rb
 - spec/features/state_and_array_options_accessor_spec.rb
 - spec/features/transition_boolean_comparison_spec.rb
+- spec/features/when_methods_are_defined_spec.rb
 - spec/helper.rb
 - spec/integration/active_record_persistence_spec.rb
 - spec/integration/binding_extension_spec.rb
@@ -138,6 +140,7 @@ summary: A rich library for state-oriented programming with state machines / wor
 test_files: 
 - spec/custom_formatter.rb
 - spec/features/binding_and_transition_helper_mixin_spec.rb
+- spec/features/machine_alias_spec.rb
 - spec/features/method_missing_only_once_spec.rb
 - spec/features/not_requirements_spec.rb
 - spec/features/plotter_spec.rb
@@ -145,6 +148,7 @@ test_files:
 - spec/features/singleton_machine_spec.rb
 - spec/features/state_and_array_options_accessor_spec.rb
 - spec/features/transition_boolean_comparison_spec.rb
+- spec/features/when_methods_are_defined_spec.rb
 - spec/helper.rb
 - spec/integration/active_record_persistence_spec.rb
 - spec/integration/binding_extension_spec.rb