state_machine 0.9.4 → 0.10.0

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

@@ -0,0 +1,30 @@
+module StateMachine
+  module Integrations #:nodoc:
+    module ActiveModel
+      version '2.x' do
+        def self.active?
+          !defined?(::ActiveModel::VERSION) || ::ActiveModel::VERSION::MAJOR == 2
+        end
+        
+        def define_validation_hook
+          action = self.action
+          define_helper(:instance, :valid?) do |machine, object, _super, *|
+            object.class.state_machines.transitions(object, action, :after => false).perform { _super.call }
+          end
+        end
+      end
+      
+      version '3.0.x' do
+        def self.active?
+          defined?(::ActiveModel::VERSION) && ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR == 0
+        end
+        
+        def define_validation_hook
+          # +around+ callbacks don't have direct access to results until AS 3.1
+          owner_class.set_callback(:validation, :after, 'value', :prepend => true)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/state_machine/integrations/active_record.rb

@@ -1,3 +1,5 @@
+require 'state_machine/integrations/active_model'
+
 module StateMachine
   module Integrations #:nodoc:
     # Adds support for integrating state machines with ActiveRecord models.
@@ -219,15 +221,15 @@ module StateMachine
     # *are* supported.  For example, if a transition for a record's +state+
     # attribute changes the state from +parked+ to +idling+ via the +ignite+
     # event, the following observer methods are supported:
-    # * before/after_ignite_from_parked_to_idling
-    # * before/after_ignite_from_parked
-    # * before/after_ignite_to_idling
-    # * before/after_ignite
-    # * before/after_transition_state_from_parked_to_idling
-    # * before/after_transition_state_from_parked
-    # * before/after_transition_state_to_idling
-    # * before/after_transition_state
-    # * before/after_transition
+    # * before/after/after_failure_to-_ignite_from_parked_to_idling
+    # * before/after/after_failure_to-_ignite_from_parked
+    # * before/after/after_failure_to-_ignite_to_idling
+    # * before/after/after_failure_to-_ignite
+    # * before/after/after_failure_to-_transition_state_from_parked_to_idling
+    # * before/after/after_failure_to-_transition_state_from_parked
+    # * before/after/after_failure_to-_transition_state_to_idling
+    # * before/after/after_failure_to-_transition_state
+    # * before/after/after_failure_to-_transition
     # 
     # The following class shows an example of some of these hooks:
     # 
@@ -313,8 +315,11 @@ module StateMachine
     #         events:
     #           park: 'estacionarse'
     module ActiveRecord
+      include Base
       include ActiveModel
       
+      require 'state_machine/integrations/active_record/versions'
+      
       # The default options to use for state machines using this integration
       @defaults = {:action => :save}
       
@@ -327,83 +332,50 @@ module StateMachine
       
       def self.extended(base) #:nodoc:
         require 'active_record/version'
-        require 'state_machine/integrations/active_model/observer'
-        
-        ::ActiveRecord::Observer.class_eval do
-          include StateMachine::Integrations::ActiveModel::Observer
-        end unless ::ActiveRecord::Observer < StateMachine::Integrations::ActiveModel::Observer
-        
-        if defined?(I18n)
-          locale = "#{File.dirname(__FILE__)}/active_record/locale.rb"
-          I18n.load_path.unshift(locale) unless I18n.load_path.include?(locale)
-        end
-      end
-      
-      # Adds a validation error to the given object 
-      def invalidate(object, attribute, message, values = [])
-        if defined?(I18n)
-          super
-        else
-          object.errors.add(self.attribute(attribute), generate_message(message, values))
-        end
+        super
       end
       
       protected
-        # Always adds observer support
-        def supports_observers?
-          true
-        end
-        
-        # Always adds validation support
-        def supports_validations?
-          true
+        # The name of this integration
+        def integration
+          :active_record
         end
         
-        # Only runs validations on the action if using <tt>:save</tt>
-        def runs_validations_on_action?
-          action == :save
-        end
-        
-        # Only adds dirty tracking support if ActiveRecord supports it
-        def supports_dirty_tracking?(object)
-          defined?(::ActiveRecord::Dirty) && object.respond_to?("#{attribute}_changed?") || super
+        # Loads locale files needed for translations
+        def load_locale
+          load_i18n_version
+          super
         end
         
-        # Always uses the <tt>:activerecord</tt> translation scope
-        def i18n_scope
-          :activerecord
+        # Loads the version of the i18n library so that that proper
+        # interpolation syntax can be used
+        def load_i18n_version
+          begin
+            require 'i18n/version'
+          rescue Exception => ex
+          end
         end
         
-        # The default options to use when generating messages for validation
-        # errors
-        def default_error_message_options(object, attribute, message)
-          if ::ActiveRecord::VERSION::MAJOR >= 3
-            super
-          else
-            {:default => @messages[message]}
-          end
+        # Loads extensions to ActiveRecord's Observers
+        def load_observer_extensions
+          super
+          ::ActiveRecord::Observer.class_eval do
+            include StateMachine::Integrations::ActiveModel::Observer
+          end unless ::ActiveRecord::Observer < StateMachine::Integrations::ActiveModel::Observer
         end
         
-        # Only allows translation of I18n is available
-        def translate(klass, key, value)
-          if defined?(I18n)
-            super
-          else
-            value ? value.to_s.humanize.downcase : 'nil'
-          end
+        # Only runs validations on the action if using <tt>:save</tt>
+        def runs_validations_on_action?
+          action == :save
         end
         
-        # Attempts to look up a class's ancestors via:
-        # * #lookup_ancestors (3.0.0+)
-        # * #self_and_descendants_from_active_record (2.3.2 - 2.3.x)
-        # * #self_and_descendents_from_active_record (2.0.0 - 2.3.1)
-        def ancestors_for(klass)
-          if ::ActiveRecord::VERSION::MAJOR >= 3
+        # 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)
+          if object.new_record? && !object.instance_variable_defined?('@initialized_state_machines')
+            object.instance_variable_set('@initialized_state_machines', true)
             super
-          elsif ::ActiveRecord::VERSION::MINOR == 3 && ::ActiveRecord::VERSION::TINY >= 2
-            klass.self_and_descendants_from_active_record
-          else
-            klass.self_and_descendents_from_active_record
           end
         end
         
@@ -411,66 +383,37 @@ module StateMachine
         # 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__
-            # Ensure that the attributes setter gets used to force initialization
-            # of the state machines
-            def initialize(attributes = nil, *args)
-              attributes ||= {}
-              super
-            end
-            
-            # Hooks in to attribute initialization to set the states *prior*
-            # to the attributes being set
-            def attributes=(new_attributes, *args)
-              if new_record? && !@initialized_state_machines
-                @initialized_state_machines = true
-                
-                ignore = if new_attributes
-                  attributes = new_attributes.dup
-                  attributes.stringify_keys!
-                  if ::ActiveRecord::VERSION::MAJOR >= 3
-                    sanitize_for_mass_assignment(attributes).keys
-                  else
-                    remove_attributes_protected_from_mass_assignment(attributes).keys
-                  end
-                else
-                  []
-                end
-                
-                initialize_state_machines(:dynamic => false, :ignore => ignore)
-                super
-                initialize_state_machines(:dynamic => true, :ignore => ignore)
-              else
-                super
-              end
-            end
-          end_eval
+          # Ensure that the attributes setter gets used to force initialization
+          # of the state machines
+          define_helper(:instance, :initialize) do |machine, object, _super, *args|
+            _super.call(args.shift || {}, *args)
+          end
+          
+          # Hooks in to attribute initialization to set the states *prior*
+          # to the attributes being set
+          define_helper(:instance, :attributes=) do |machine, object, _super, new_attributes, *|
+            object.class.state_machines.initialize_states(object, :attributes => new_attributes) { _super.call }
+          end
         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
         # states for the attribute
         def create_with_scope(name)
-          define_scope(name, lambda {|values| {:conditions => {attribute => values}}})
+          define_scope(name, lambda {|values| {attribute => values}})
         end
         
         # Creates a scope for finding records *without* a particular state or
@@ -478,7 +421,7 @@ module StateMachine
         def create_without_scope(name)
           define_scope(name, lambda {|values|
             connection = owner_class.connection
-            {:conditions => ["#{connection.quote_table_name(owner_class.table_name)}.#{connection.quote_column_name(attribute)} NOT IN (?)", values]}
+            ["#{connection.quote_table_name(owner_class.table_name)}.#{connection.quote_column_name(attribute)} NOT IN (?)", values]
           })
         end
         
@@ -489,33 +432,16 @@ module StateMachine
           object.class.transaction {raise ::ActiveRecord::Rollback unless yield}
         end
         
-      private
         # Defines a new named scope with the given name
         def define_scope(name, scope)
-          if ::ActiveRecord::VERSION::MAJOR >= 3
-            lambda {|model, values| model.where(scope.call(values)[:conditions])}
-          else
-            if owner_class.respond_to?(:named_scope)
-              name = name.to_sym
-              machine_name = self.name
-              
-              # Since ActiveRecord does not allow direct access to the model
-              # being used within the evaluation of a dynamic named scope, the
-              # scope must be generated manually.  It's necessary to have access
-              # to the model so that the state names can be translated to their
-              # associated values and so that inheritance is respected properly.
-              owner_class.named_scope(name)
-              owner_class.scopes[name] = lambda do |model, *states|
-                machine_states = model.state_machine(machine_name).states
-                values = states.flatten.map {|state| machine_states.fetch(state).value}
-                
-                ::ActiveRecord::NamedScope::Scope.new(model, scope.call(values))
-              end
-            end
-            
-            # Prevent the Machine class from wrapping the scope
-            false
-          end
+          lambda {|model, values| model.where(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

data/lib/state_machine/integrations/active_record/locale.rb

@@ -2,13 +2,6 @@ filename = "#{File.dirname(__FILE__)}/../active_model/locale.rb"
 translations = eval(IO.read(filename), binding, filename)
 translations[:en][:activerecord] = translations[:en].delete(:activemodel)
 
-# Only ActiveRecord 2.3.5+ can pull i18n >= 0.1.3 from system-wide gems (and
-# therefore possibly have I18n::VERSION available)
-begin
-  require 'i18n/version'
-rescue Exception => ex
-end unless ::ActiveRecord::VERSION::MAJOR == 2 && (::ActiveRecord::VERSION::MINOR < 3 || ::ActiveRecord::VERSION::TINY < 5)
-
 # Only i18n 0.4.0+ has the new %{key} syntax
 if !defined?(I18n::VERSION) || I18n::VERSION < '0.4.0'
   translations[:en][:activerecord][:errors][:messages].each do |key, message|

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

@@ -0,0 +1,149 @@
+module StateMachine
+  module Integrations #:nodoc:
+    module ActiveRecord
+      version '2.x' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2
+        end
+        
+        def load_locale
+          super if defined?(I18n)
+        end
+        
+        def define_scope(name, scope)
+          if owner_class.respond_to?(:named_scope)
+            name = name.to_sym
+            machine_name = self.name
+            
+            # Since ActiveRecord does not allow direct access to the model
+            # being used within the evaluation of a dynamic named scope, the
+            # scope must be generated manually.  It's necessary to have access
+            # to the model so that the state names can be translated to their
+            # associated values and so that inheritance is respected properly.
+            owner_class.named_scope(name)
+            owner_class.scopes[name] = lambda do |model, *states|
+              machine_states = model.state_machine(machine_name).states
+              values = states.flatten.map {|state| machine_states.fetch(state).value}
+              
+              ::ActiveRecord::NamedScope::Scope.new(model, :conditions => scope.call(values))
+            end
+          end
+          
+          # Prevent the Machine class from wrapping the scope
+          false
+        end
+        
+        def invalidate(object, attribute, message, values = [])
+          if defined?(I18n)
+            super
+          else
+            object.errors.add(self.attribute(attribute), generate_message(message, values))
+          end
+        end
+        
+        def translate(klass, key, value)
+          if defined?(I18n)
+            super
+          else
+            value ? value.to_s.humanize.downcase : 'nil'
+          end
+        end
+        
+        def supports_observers?
+          true
+        end
+        
+        def supports_validations?
+          true
+        end
+        
+        def supports_mass_assignment_security?
+          true
+        end
+        
+        def i18n_scope(klass)
+          :activerecord
+        end
+        
+        def action_hook
+          action == :save ? :create_or_update : super
+        end
+        
+        def filter_attributes(object, attributes)
+          object.send(:remove_attributes_protected_from_mass_assignment, attributes)
+        end
+      end
+      
+      version '2.0 - 2.2.x' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2 && ::ActiveRecord::VERSION::MINOR < 3
+        end
+        
+        def default_error_message_options(object, attribute, message)
+          {:default => @messages[message]}
+        end
+      end
+      
+      version '2.0 - 2.3.1' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2 && (::ActiveRecord::VERSION::MINOR < 3 || ::ActiveRecord::VERSION::TINY < 2)
+        end
+        
+        def ancestors_for(klass)
+          klass.self_and_descendents_from_active_record
+        end
+      end
+      
+      version '2.0 - 2.3.4' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2 && (::ActiveRecord::VERSION::MINOR < 3 || ::ActiveRecord::VERSION::TINY < 5)
+        end
+        
+        def load_i18n_version
+        end
+      end
+      
+      version '2.0.x' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2 && ::ActiveRecord::VERSION::MINOR == 0
+        end
+        
+        def supports_dirty_tracking?(object)
+          false
+        end
+      end
+      
+      version '2.1.x - 2.3.x' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2 && ::ActiveRecord::VERSION::MINOR > 0
+        end
+        
+        def supports_dirty_tracking?(object)
+          object.respond_to?("#{attribute}_changed?")
+        end
+      end
+      
+      version '2.3.2 - 2.3.x' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 2 && ::ActiveRecord::VERSION::MINOR == 3 && ::ActiveRecord::VERSION::TINY >= 2
+        end
+        
+        def ancestors_for(klass)
+          klass.self_and_descendants_from_active_record
+        end
+      end
+      
+      version '3.0.x' do
+        def self.active?
+          ::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR == 0
+        end
+        
+        def define_action_hook
+          # +around+ callbacks don't have direct access to results until AS 3.1
+          owner_class.set_callback(:save, :after, 'value', :prepend => true) if action_hook == :save
+          super
+        end
+      end
+    end
+  end
+end