state_machine 0.9.4 → 0.10.0

data/lib/state_machine/integrations/base.rb

@@ -0,0 +1,64 @@
+module StateMachine
+  module Integrations
+    # Provides a set of base helpers for managing individual integrations
+    module Base
+      # Never matches
+      def self.matches?(klass)
+        false
+      end
+      
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          extend ClassMethods
+        end
+      end
+      
+      module ClassMethods
+        # The default options to use for state machines using this integration
+        attr_reader :defaults
+        
+        # Tracks the various version overrides for an integration
+        def versions
+          @versions ||= []
+        end
+        
+        # Creates a new version override for an integration.  When this
+        # integration is activated, each version that is marked as active will
+        # also extend the integration.
+        # 
+        # == Example
+        # 
+        #   module StateMachine
+        #     module Integrations
+        #       module ORMLibrary
+        #         version '0.2.x - 0.3.x' do
+        #           def self.active?
+        #             ::ORMLibrary::VERSION >= '0.2.0' && ::ORMLibrary::VERSION < '0.4.0'
+        #           end
+        #           
+        #           def invalidate(object, attribute, message, values = [])
+        #             # Override here...
+        #           end
+        #         end
+        #       end
+        #     end
+        #   end
+        # 
+        # In the above example, a version override is defined for the ORMLibrary
+        # integration when the version is between 0.2.x and 0.3.x.
+        def version(name, &block)
+          versions << mod = Module.new(&block)
+          mod
+        end
+        
+        # Extends the given object with any version overrides that are currently
+        # active
+        def extended(base)
+          versions.each do |version|
+             base.extend(version) if version.active?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/state_machine/integrations/data_mapper.rb

@@ -241,6 +241,10 @@ module StateMachine
     # support for DataMapper observers.  See StateMachine::Integrations::DataMapper::Observer
     # for more information.
     module DataMapper
+      include Base
+      
+      require 'state_machine/integrations/data_mapper/versions'
+      
       # The default options to use for state machines using this integration
       class << self; attr_reader :defaults; end
       @defaults = {:action => :save, :use_transactions => false}
@@ -255,28 +259,17 @@ module StateMachine
       # Loads additional files specific to DataMapper
       def self.extended(base) #:nodoc:
         require 'dm-core/version' unless ::DataMapper.const_defined?('VERSION')
-        require 'state_machine/integrations/data_mapper/observer' if ::DataMapper.const_defined?('Observer')
+        super
       end
       
       # Forces the change in state to be recognized regardless of whether the
       # state value actually changed
-      def write(object, attribute, value)
-        if attribute == :state
-          result = super
-          
-          # Change original attributes in 0.9.4 - 0.10.2
-          if ::DataMapper::VERSION =~ /^0\.9\./
-            object.original_values[self.attribute] = "#{value}-ignored" if object.original_values[self.attribute] == value
-          elsif ::DataMapper::VERSION =~ /^0\.10\./
-            property = owner_class.properties[self.attribute]
-            object.original_attributes[property] = "#{value}-ignored" unless object.original_attributes.include?(property)
-          else
-            object.persisted_state = ::DataMapper::Resource::State::Dirty.new(object) if object.persisted_state.is_a?(::DataMapper::Resource::State::Clean)
-            property = owner_class.properties[self.attribute]
-            object.persisted_state.original_attributes[property] = value unless object.persisted_state.original_attributes.include?(property)
-          end
-        else
-          result = super
+      def write(object, attribute, value, *args)
+        result = super
+        
+        if attribute == :state || attribute == :event && value
+          value = read(object, :state) if attribute == :event
+          mark_dirty(object, value)
         end
         
         result
@@ -293,6 +286,16 @@ module StateMachine
       end
       
       protected
+        # Initializes class-level extensions and defaults for this machine
+        def after_initialize
+          load_observer_extensions
+        end
+        
+        # Loads extensions to DataMapper's Observers
+        def load_observer_extensions
+          require 'state_machine/integrations/data_mapper/observer' if ::DataMapper.const_defined?('Observer')
+        end
+        
         # Is validation support currently loaded?
         def supports_validations?
           @supports_validations ||= ::DataMapper.const_defined?('Validate')
@@ -300,21 +303,24 @@ module StateMachine
         
         # Pluralizes the name using the built-in inflector
         def pluralize(word)
-          defined?(Extlib::Inflection) ? Extlib::Inflection.pluralize(word.to_s) : super
+          ::DataMapper::Inflector.pluralize(word.to_s)
+        end
+        
+        # Only allows state initialization on new records that aren't being
+        # created with a set of attributes that includes this machine's
+        # attribute.
+        def initialize_state?(object, options)
+          ignore = (options[:attributes] || {}).keys
+          !ignore.map {|attribute| attribute.to_sym}.include?(attribute) 
         end
         
         # Defines an initialization hook into the owner class for setting the
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          @instance_helper_module.class_eval <<-end_eval, __FILE__, __LINE__
-            def initialize(attributes = {}, *args)
-              ignore = attributes ? attributes.keys : []
-              initialize_state_machines(:dynamic => false, :ignore => ignore)
-              super
-              initialize_state_machines(:dynamic => true, :ignore => ignore)
-            end
-          end_eval
+          define_helper(:instance, :initialize) do |machine, object, _super, *args|
+            object.class.state_machines.initialize_states(object, :attributes => args.first) { _super.call }
+          end
         end
         
         # Skips defining reader/writer methods since this is done automatically
@@ -332,23 +338,20 @@ module StateMachine
         
         # Adds hooks into validation for automatically firing events
         def define_action_helpers
-          # 0.9.4 - 0.9.6 fails to run after callbacks when validations are
-          # enabled because of the way dm-validations integrates
-          return if ::DataMapper::VERSION =~ /^0\.9\.[4-6]/ && supports_validations?
+          super
           
-          if action == :save
-            if super(::DataMapper::VERSION =~ /^0\.\d\./ ? :save : :save_self) && supports_validations?
-              @instance_helper_module.class_eval do
-                define_method(:valid?) do |*args|
-                  self.class.state_machines.transitions(self, :save, :after => false).perform { super(*args) }
-                end
-              end
+          if action == :save && supports_validations?
+            define_helper(:instance, :valid?) do |machine, object, _super, *|
+              object.class.state_machines.transitions(object, :save, :after => false).perform { _super.call }
             end
-          else
-            super
           end
         end
         
+        # Uses internal save hooks if using the :save action
+        def action_hook
+          action == :save ? :save_self : super
+        end
+        
         # Creates a scope for finding records *with* a particular state or
         # states for the attribute
         def create_with_scope(name)
@@ -374,6 +377,14 @@ module StateMachine
           options[:bind_to_object] = true
           super
         end
+        
+        # Marks the object's state as dirty so that the record will be saved
+        # even if no actual modifications have been made to the data
+        def mark_dirty(object, value)
+          object.persisted_state = ::DataMapper::Resource::State::Dirty.new(object) if object.persisted_state.is_a?(::DataMapper::Resource::State::Clean)
+          property = owner_class.properties[self.attribute]
+          object.persisted_state.original_attributes[property] = value unless object.persisted_state.original_attributes.include?(property)
+        end
     end
   end
 end

data/lib/state_machine/integrations/data_mapper/observer.rb

@@ -1,15 +1,15 @@
 module StateMachine
   module Integrations #:nodoc:
     module DataMapper
-      # Adds support for creating before/after transition callbacks within a
-      # DataMapper observer.  These callbacks behave very similar to
-      # before/after hooks during save/update/destroy/etc., but with the
-      # following modifications:
-      # * Each callback can define a set of transition conditions (i.e. guards)
-      # that must be met in order for the callback to get invoked.
+      # Adds support for creating before/after/around/failure transition
+      # callbacks within a DataMapper observer.  These callbacks behave very
+      # similar to hooks during save/update/destroy/etc., but with the following
+      # modifications:
+      # * Each callback can define a set of transition requirements that must be
+      #   met in order for the callback to get invoked.
       # * An additional transition parameter is available that provides
-      # contextual information about the event (see StateMachine::Transition
-      # for more information)
+      #   contextual information about the event (see StateMachine::Transition
+      #   for more information)
       # 
       # To define a single observer for multiple state machines:
       # 
@@ -91,7 +91,7 @@ module StateMachine
         # Vehicle instance being transition).  This means that +self+ refers
         # to the vehicle record within each callback block.
         def before_transition(*args, &block)
-          add_transition_callback(:before, *args, &block)
+          add_transition_callback(:before_transition, *args, &block)
         end
         
         # Creates a callback that will be invoked *after* a transition is
@@ -101,7 +101,7 @@ module StateMachine
         # See +before_transition+ for a description of the possible configurations
         # for defining callbacks.
         def after_transition(*args, &block)
-          add_transition_callback(:after, *args, &block)
+          add_transition_callback(:after_transition, *args, &block)
         end
         
         # Creates a callback that will be invoked *around* a transition so long
@@ -137,7 +137,42 @@ module StateMachine
         # See +before_transition+ for a description of the possible configurations
         # for defining callbacks.
         def around_transition(*args, &block)
-          add_transition_callback(:around, *args, &block)
+          add_transition_callback(:around_transition, *args, &block)
+        end
+        
+        # Creates a callback that will be invoked *after* a transition failures to
+        # be performed so long as the given requirements match the transition.
+        # 
+        # == Example
+        # 
+        #   class Vehicle
+        #     include DataMapper::Resource
+        #     
+        #     property :id, Serial
+        #     property :state, :String
+        #     
+        #     state_machine :initial => :parked do
+        #       event :ignite do
+        #         transition :parked => :idling
+        #       end
+        #     end
+        #   end
+        #   
+        #   class VehicleObserver
+        #     after_transition_failure do |transition|
+        #       # log failure
+        #     end
+        #     
+        #     after_transition_failure :on => :ignite do
+        #       # log failure
+        #     end
+        #   end
+        # 
+        # See +before_transition+ for a description of the possible configurations
+        # for defining callbacks.  *Note* however that you cannot define the state
+        # requirements in these callbacks.  You may only define event requirements.
+        def after_transition_failure(*args, &block)
+          add_transition_callback(:after_failure, *args, &block)
         end
         
         private
@@ -162,7 +197,7 @@ module StateMachine
                   klass.state_machines.values
                 end
               
-              state_machines.each {|machine| machine.send("#{type}_transition", *args, &block)}
+              state_machines.each {|machine| machine.send(type, *args, &block)}
             end if observing
           end
       end

data/lib/state_machine/integrations/data_mapper/versions.rb

@@ -0,0 +1,62 @@
+module StateMachine
+  module Integrations #:nodoc:
+    module DataMapper
+      version '0.9.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.9\./
+        end
+        
+        def action_hook
+          action
+        end
+        
+        def mark_dirty(object, value)
+          object.original_values[self.attribute] = "#{value}-ignored" if object.original_values[self.attribute] == value
+        end
+      end
+      
+      version '0.9.x - 0.10.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.\d\./ || ::DataMapper::VERSION =~ /^0\.10\./
+        end
+        
+        def pluralize(word)
+          ::Extlib::Inflection.pluralize(word.to_s)
+        end
+      end
+      
+      version '1.0.0' do
+        def self.active?
+          ::DataMapper::VERSION == '1.0.0'
+        end
+        
+        def pluralize(word)
+          (defined?(::ActiveSupport::Inflector) ? ::ActiveSupport::Inflector : ::Extlib::Inflection).pluralize(word.to_s)
+        end
+      end
+      
+      version '0.9.4 - 0.9.6' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.9\.[4-6]/
+        end
+        
+        # 0.9.4 - 0.9.6 fails to run after callbacks when validations are
+        # enabled because of the way dm-validations integrates
+        def define_action_helpers?
+          super if action != :save || !supports_validations?
+        end
+      end
+      
+      version '0.10.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.10\./
+        end
+        
+        def mark_dirty(object, value)
+          property = owner_class.properties[self.attribute]
+          object.original_attributes[property] = "#{value}-ignored" unless object.original_attributes.include?(property)
+        end
+      end
+    end
+  end
+end

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -1,3 +1,5 @@
+require 'state_machine/integrations/active_model'
+
 module StateMachine
   module Integrations #:nodoc:
     # Adds support for integrating state machines with MongoMapper models.
@@ -184,8 +186,11 @@ module StateMachine
     # Note, also, that the transition can be accessed by simply defining
     # additional arguments in the callback block.
     module MongoMapper
+      include Base
       include ActiveModel
       
+      require 'state_machine/integrations/mongo_mapper/versions'
+      
       # The default options to use for state machines using this integration
       @defaults = {:action => :save}
       
@@ -196,20 +201,10 @@ module StateMachine
         defined?(::MongoMapper::Document) && klass <= ::MongoMapper::Document
       end
       
-      # Adds a validation error to the given object (no i18n support)
-      def invalidate(object, attribute, message, values = [])
-        object.errors.add(self.attribute(attribute), generate_message(message, values))
-      end
-      
       protected
-        # Does not support observers
-        def supports_observers?
-          false
-        end
-        
-        # Always adds validation support
-        def supports_validations?
-          true
+        # The name of this integration
+        def integration
+          :mongo_mapper
         end
         
         # Only runs validations on the action if using <tt>:save</tt>
@@ -217,71 +212,46 @@ module StateMachine
           action == :save
         end
         
-        # Always adds dirty tracking support
-        def supports_dirty_tracking?(object)
+        # MongoMapper uses its own implementation of mass-assignment security
+        # instead of ActiveModel's, but still has a similar enough API that it
+        # can get enabled
+        def supports_mass_assignment_security?
           true
         end
         
-        # Don't allow callback terminators
-        def callback_terminator
-        end
-        
-        # Don't allow translations
-        def translate(klass, key, value)
-          value.to_s.humanize.downcase
+        # Filters attributes that cannot be assigned through the initialization
+        # of the object
+        def filter_attributes(object, attributes)
+          object.send(:filter_protected_attrs, attributes)
         end
         
         # Defines an initialization hook into the owner class for setting the
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          @instance_helper_module.class_eval <<-end_eval, __FILE__, __LINE__
-            def initialize(attrs = {}, *args)
-              from_database = args.first
-              
-              if !from_database && (!attrs || !attrs.stringify_keys.key?('_id'))
-                filtered = respond_to?(:filter_protected_attrs) ? filter_protected_attrs(attrs) : attrs 
-                ignore = filtered ? filtered.keys : []
-                
-                initialize_state_machines(:dynamic => false, :ignore => ignore)
-                super
-                initialize_state_machines(:dynamic => true, :ignore => ignore)
-              else
-                super
-              end
-            end
-          end_eval
+          define_helper(:instance, :initialize) do |machine, object, _super, *args|
+            object.class.state_machines.initialize_states(object, :attributes => args.first) { _super.call }
+          end
         end
         
         # Skips defining reader/writer methods since this is done automatically
         def define_state_accessor
           owner_class.key(attribute, String) unless owner_class.keys.include?(attribute)
-          
-          name = self.name
-          owner_class.validates_each(attribute, :logic => lambda {|*|
-            machine = self.class.state_machine(name)
-            machine.invalidate(self, :state, :invalid) unless machine.states.match(self)
-          })
+          super
         end
         
-        # Adds support for defining the attribute predicate, while providing
-        # compatibility with the default predicate which determines whether
-        # *anything* is set for the attribute's value
-        def define_state_predicate
-          name = self.name
-          
-          # Still use class_eval here instance of define_instance_method since
-          # we need to be able to call +super+
-          @instance_helper_module.class_eval do
-            define_method("#{name}?") do |*args|
-              args.empty? ? super(*args) : self.class.state_machine(name).states.matches?(self, *args)
-            end
+        # Uses around callbacks to run state events if using the :save hook
+        def define_action_hook
+          if action_hook == :save
+            owner_class.set_callback(:save, :around, self, :prepend => true)
+          else
+            super
           end
         end
         
-        # Adds hooks into validation for automatically firing events
-        def define_action_helpers
-          super(action == :save ? :create_or_update : action)
+        # Runs state events around the machine's :save action
+        def around_save(object)
+          object.class.state_machines.transitions(object, action).perform { yield }
         end
         
         # Creates a scope for finding records *with* a particular state or
@@ -298,11 +268,14 @@ module StateMachine
         
         # Defines a new scope with the given name
         def define_scope(name, scope)
-          if defined?(::MongoMapper::Version) && ::MongoMapper::Version >= '0.8.0'
-            lambda {|model, values| model.query.merge(model.query(scope.call(values)))}
-          else
-            lambda {|model, values| model.all(scope.call(values))}
-          end
+          lambda {|model, values| model.query.merge(model.query(scope.call(values)))}
+        end
+        
+        # ActiveModel's use of method_missing / respond_to for attribute methods
+        # breaks both ancestor lookups and defined?(super).  Need to special-case
+        # the existence of query attribute methods.
+        def owner_class_ancestor_has_method?(method)
+          method == "#{name}?" || super
         end
     end
   end