state_machine 0.9.4 → 0.10.0

data/lib/state_machine/callback.rb

@@ -1,4 +1,4 @@
-require 'state_machine/guard'
+require 'state_machine/branch'
 require 'state_machine/eval_helpers'
 
 module StateMachine
@@ -67,6 +67,7 @@ module StateMachine
     # * +before+
     # * +after+
     # * +around+
+    # * +failure+
     attr_accessor :type
     
     # An optional block for determining whether to cancel the callback chain
@@ -98,17 +99,17 @@ module StateMachine
     #   end
     attr_reader :terminator
     
-    # The guard that determines whether or not this callback can be invoked
+    # The branch that determines whether or not this callback can be invoked
     # based on the context of the transition.  The event, from state, and
-    # to state must all match in order for the guard to pass.
+    # to state must all match in order for the branch to pass.
     # 
-    # See StateMachine::Guard for more information.
-    attr_reader :guard
+    # See StateMachine::Branch for more information.
+    attr_reader :branch
     
     # Creates a new callback that can get called based on the configured
     # options.
     # 
-    # In addition to the possible configuration options for guards, the
+    # In addition to the possible configuration options for branches, the
     # following options can be configured:
     # * <tt>:bind_to_object</tt> - Whether to bind the callback to the object involved.
     #   If set to false, the object will be passed as a parameter instead.
@@ -121,7 +122,7 @@ module StateMachine
     # callback can be found in their attribute definitions.
     def initialize(type, *args, &block)
       @type = type
-      raise ArgumentError, 'Type must be :before, :after, or :around' unless [:before, :after, :around].include?(type)
+      raise ArgumentError, 'Type must be :before, :after, :around, or :failure' unless [:before, :after, :around, :failure].include?(type)
       
       options = args.last.is_a?(Hash) ? args.pop : {}
       @methods = args
@@ -138,23 +139,23 @@ module StateMachine
       end
       
       @terminator = options.delete(:terminator)
-      @guard = Guard.new(options)
+      @branch = Branch.new(options)
     end
     
     # Gets a list of the states known to this callback by looking at the
-    # guard's known states
+    # branch's known states
     def known_states
-      guard.known_states
+      branch.known_states
     end
     
-    # Runs the callback as long as the transition context matches the guard
+    # Runs the callback as long as the transition context matches the branch
     # requirements configured for this callback.  If a block is provided, it
     # will be called when the last method has run.
     # 
     # If a terminator has been configured and it matches the result from the
     # evaluated method, then the callback chain should be halted.
     def call(object, context = {}, *args, &block)
-      if @guard.matches?(object, context)
+      if @branch.matches?(object, context)
         run_methods(object, context, 0, *args, &block)
         true
       else
@@ -162,12 +163,6 @@ module StateMachine
       end
     end
     
-    # Verifies that the success requirement for this callback matches the given
-    # value
-    def matches_success?(success)
-      guard.success_requirement.matches?(success)
-    end
-    
     private
       # Runs all of the methods configured for this callback.
       # 

data/lib/state_machine/error.rb

@@ -0,0 +1,13 @@
+module StateMachine
+  # An error occurred during a state machine invocation
+  class Error < StandardError
+    # The object that failed
+    attr_reader :object
+    
+    def initialize(object, message = nil) #:nodoc:
+      @object = object
+      
+      super(message)
+    end
+  end
+end

data/lib/state_machine/eval_helpers.rb

@@ -64,9 +64,12 @@ module StateMachine
           # supports yielding within blocks)
           if block_given? && Proc === method && arity != 0
             if [1, 2].include?(arity)
+              # Force the block to be either the only argument or the 2nd one
+              # after the object (may mean additional arguments get discarded)
               limit = arity
               args.insert(limit - 1, block)
             else
+              # Tack the block to the end of the args
               limit += 1 unless limit < 0
               args.push(block)
             end

data/lib/state_machine/event.rb

@@ -1,16 +1,25 @@
 require 'state_machine/transition'
-require 'state_machine/guard'
+require 'state_machine/branch'
 require 'state_machine/assertions'
 require 'state_machine/matcher_helpers'
+require 'state_machine/error'
 
 module StateMachine
   # An invalid event was specified
-  class InvalidEvent < StandardError
+  class InvalidEvent < Error
+    # The event that was attempted to be run
+    attr_reader :event
+    
+    def initialize(object, event_name) #:nodoc:
+      @event = event_name
+      
+      super(object, "#{event.inspect} is an unknown state machine event")
+    end
   end
   
   # An event defines an action that transitions an attribute from one state to
   # another.  The state that an attribute is transitioned to depends on the
-  # guards configured for the event.
+  # branches configured for the event.
   class Event
     include Assertions
     include MatcherHelpers
@@ -27,12 +36,12 @@ module StateMachine
     # The human-readable name for the event
     attr_writer :human_name
     
-    # The list of guards that determine what state this event transitions
+    # The list of branches that determine what state this event transitions
     # objects to when fired
-    attr_reader :guards
+    attr_reader :branches
     
     # A list of all of the states known to this event using the configured
-    # guards/transitions as the source
+    # branches/transitions as the source
     attr_reader :known_states
     
     # Creates a new event within the context of the given machine
@@ -46,17 +55,23 @@ module StateMachine
       @name = name
       @qualified_name = machine.namespace ? :"#{name}_#{machine.namespace}" : name
       @human_name = options[:human_name] || @name.to_s.tr('_', ' ')
-      @guards = []
+      @branches = []
       @known_states = []
       
-      add_actions
+      # Output a warning if another event has a conflicting qualified name
+      if conflict = machine.owner_class.state_machines.detect {|name, other_machine| other_machine != @machine && other_machine.events[qualified_name, :qualified_name]}
+        name, other_machine = conflict
+        warn "Event #{qualified_name.inspect} for #{machine.name.inspect} is already defined in #{other_machine.name.inspect}"
+      else
+        add_actions
+      end
     end
     
     # Creates a copy of this event in addition to the list of associated
-    # guards to prevent conflicts across events within a class hierarchy.
+    # branches to prevent conflicts across events within a class hierarchy.
     def initialize_copy(orig) #:nodoc:
       super
-      @guards = @guards.dup
+      @branches = @branches.dup
       @known_states = @known_states.dup
     end
     
@@ -101,6 +116,9 @@ module StateMachine
     #   transition :parked => same                          # Loops :parked back to :parked
     #   transition [:parked, :stalled] => same              # Loops either :parked or :stalled back to the same state
     #   transition all - :parked => same                    # Loops every state but :parked back to the same state
+    #   
+    #   # Transitions to :idling if :parked, :first_gear if :idling, or :second_gear if :first_gear
+    #   transition :parked => :idling, :idling => :first_gear, :first_gear => :second_gear
     # 
     # == Verbose transitions
     # 
@@ -146,6 +164,7 @@ module StateMachine
     # 
     #   transition :parked => :idling, :if => :moving?
     #   transition :parked => :idling, :unless => :stopped?
+    #   transition :idling => :first_gear, :first_gear => :second_gear, :if => :seatbelt_on?
     #   
     #   transition :from => :parked, :to => :idling, :if => :moving?
     #   transition :from => :parked, :to => :idling, :unless => :stopped?
@@ -162,27 +181,36 @@ module StateMachine
       # requirements
       assert_valid_keys(options, :from, :to, :except_from, :if, :unless) if (options.keys - [:from, :to, :on, :except_from, :except_to, :except_on, :if, :unless]).empty?
       
-      guards << guard = Guard.new(options.merge(:on => name))
-      @known_states |= guard.known_states
-      guard
+      branches << branch = Branch.new(options.merge(:on => name))
+      @known_states |= branch.known_states
+      branch
     end
     
     # Determines whether any transitions can be performed for this event based
     # on the current state of the given object.
     # 
     # If the event can't be fired, then this will return false, otherwise true.
-    def can_fire?(object)
-      !transition_for(object).nil?
+    def can_fire?(object, requirements = {})
+      !transition_for(object, requirements).nil?
     end
     
     # Finds and builds the next transition that can be performed on the given
     # object.  If no transitions can be made, then this will return nil.
+    # 
+    # Valid requirement options:
+    # * <tt>:from</tt> - One or more states being transitioned from.  If none
+    #   are specified, then this will be the object's current state.
+    # * <tt>:to</tt> - One or more states being transitioned to.  If none are
+    #   specified, then this will match any to state.
+    # * <tt>:guard</tt> - Whether to guard transitions with the if/unless
+    #   conditionals defined for each one.  Default is true.
     def transition_for(object, requirements = {})
+      assert_valid_keys(requirements, :from, :to, :guard)
       requirements[:from] = machine.states.match!(object).name unless custom_from_state = requirements.include?(:from)
       
-      guards.each do |guard|
-        if match = guard.match(object, requirements)
-          # Guard allows for the transition to occur
+      branches.each do |branch|
+        if match = branch.match(object, requirements)
+          # Branch allows for the transition to occur
           from = requirements[:from]
           to = match[:to].values.empty? ? from : match[:to].values.first
           
@@ -206,19 +234,28 @@ module StateMachine
       if transition = transition_for(object)
         transition.perform(*args)
       else
-        machine.invalidate(object, :state, :invalid_transition, [[:event, human_name(object.class)]])
+        on_failure(object)
         false
       end
     end
     
+    # Marks the object as invalid and runs any failure callbacks associated with
+    # this event.  This should get called anytime this event fails to transition.
+    def on_failure(object)
+      machine.invalidate(object, :state, :invalid_transition, [[:event, human_name(object.class)]])
+      
+      state = machine.states.match!(object).name
+      Transition.new(object, machine, name, state, state).run_callbacks(:before => false)
+    end
+    
     # Draws a representation of this event on the given graph.  This will
-    # create 1 or more edges on the graph for each guard (i.e. transition)
+    # create 1 or more edges on the graph for each branch (i.e. transition)
     # configured.
     # 
     # A collection of the generated edges will be returned.
     def draw(graph)
       valid_states = machine.states.by_priority.map {|state| state.name}
-      guards.collect {|guard| guard.draw(graph, name, valid_states)}.flatten
+      branches.collect {|branch| branch.draw(graph, name, valid_states)}.flatten
     end
     
     # Generates a nicely formatted description of this event's contents.
@@ -229,8 +266,8 @@ module StateMachine
     #   event.transition all - :idling => :parked, :idling => same
     #   event   # => #<StateMachine::Event name=:park transitions=[all - :idling => :parked, :idling => same]>
     def inspect
-      transitions = guards.map do |guard|
-        guard.state_requirements.map do |state_requirement|
+      transitions = branches.map do |branch|
+        branch.state_requirements.map do |state_requirement|
           "#{state_requirement[:from].description} => #{state_requirement[:to].description}"
         end * ', '
       end
@@ -243,24 +280,24 @@ module StateMachine
       # the current event
       def add_actions
         # Checks whether the event can be fired on the current object
-        machine.define_instance_method("can_#{qualified_name}?") do |machine, object|
-          machine.event(name).can_fire?(object)
+        machine.define_helper(:instance, "can_#{qualified_name}?") do |machine, object, _super, *args|
+          machine.event(name).can_fire?(object, *args)
         end
         
         # Gets the next transition that would be performed if the event were
         # fired now
-        machine.define_instance_method("#{qualified_name}_transition") do |machine, object|
-          machine.event(name).transition_for(object)
+        machine.define_helper(:instance, "#{qualified_name}_transition") do |machine, object, _super, *args|
+          machine.event(name).transition_for(object, *args)
         end
         
         # Fires the event
-        machine.define_instance_method(qualified_name) do |machine, object, *args|
+        machine.define_helper(:instance, qualified_name) do |machine, object, _super, *args|
           machine.event(name).fire(object, *args)
         end
         
         # Fires the event, raising an exception if it fails
-        machine.define_instance_method("#{qualified_name}!") do |machine, object, *args|
-          object.send(qualified_name, *args) || raise(StateMachine::InvalidTransition, "Cannot transition #{machine.name} via :#{name} from #{machine.states.match!(object).name.inspect}")
+        machine.define_helper(:instance, "#{qualified_name}!") do |machine, object, _super, *args|
+          object.send(qualified_name, *args) || raise(StateMachine::InvalidTransition.new(object, machine, name))
         end
       end
   end

data/lib/state_machine/event_collection.rb

@@ -7,6 +7,16 @@ module StateMachine
     
     # Gets the list of events that can be fired on the given object.
     # 
+    # Valid requirement options:
+    # * <tt>:from</tt> - One or more states being transitioned from.  If none
+    #   are specified, then this will be the object's current state.
+    # * <tt>:to</tt> - One or more states being transitioned to.  If none are
+    #   specified, then this will match any to state.
+    # * <tt>:on</tt> - One or more events that fire the transition.  If none
+    #   are specified, then this will match any event.
+    # * <tt>:guard</tt> - Whether to guard transitions with the if/unless
+    #   conditionals defined for each one.  Default is true.
+    # 
     # == Examples
     # 
     #   class Vehicle
@@ -28,8 +38,8 @@ module StateMachine
     #   
     #   vehicle.state = 'idling'
     #   events.valid_for(vehicle)           # => [#<StateMachine::Event name=:park transitions=[:idling => :parked]>]
-    def valid_for(object)
-      select {|event| event.can_fire?(object)}
+    def valid_for(object, requirements = {})
+      match(requirements).select {|event| event.can_fire?(object, requirements)}
     end
     
     # Gets the list of transitions that can be run on the given object.
@@ -41,6 +51,8 @@ module StateMachine
     #   specified, then this will match any to state.
     # * <tt>:on</tt> - One or more events that fire the transition.  If none
     #   are specified, then this will match any event.
+    # * <tt>:guard</tt> - Whether to guard transitions with the if/unless
+    #   conditionals defined for each one.  Default is true.
     # 
     # == Examples
     # 
@@ -67,7 +79,7 @@ module StateMachine
     #   # Search for explicit transitions regardless of the current state
     #   events.transitions_for(vehicle, :from => :parked) # => [#<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>]
     def transitions_for(object, requirements = {})
-      map {|event| event.transition_for(object, requirements)}.compact
+      match(requirements).map {|event| event.transition_for(object, requirements)}.compact
     end
     
     # Gets the transition that should be performed for the event stored in the
@@ -118,5 +130,10 @@ module StateMachine
       
       result
     end
+    
+    private
+      def match(requirements) #:nodoc:
+        requirements && requirements[:on] ? [fetch(requirements.delete(:on))] : self
+      end
   end
 end

data/lib/state_machine/extensions.rb

@@ -138,12 +138,12 @@ module StateMachine
     #   vehicle.fire_events!(:ignite, :disable_alarm) # => StateMachine::InvalidTranstion: Cannot run events in parallel: ignite, disable_alarm
     def fire_events!(*events)
       run_action = [true, false].include?(events.last) ? events.pop : true
-      fire_events(*(events + [run_action])) || raise(StateMachine::InvalidTransition, "Cannot run events in parallel: #{events * ', '}")
+      fire_events(*(events + [run_action])) || raise(StateMachine::InvalidParallelTransition.new(self, events))
     end
     
     protected
-      def initialize_state_machines(options = {}) #:nodoc:
-        self.class.state_machines.initialize_states(self, options)
+      def initialize_state_machines(options = {}, &block) #:nodoc:
+        self.class.state_machines.initialize_states(self, options, &block)
       end
   end
 end

data/lib/state_machine/integrations.rb

@@ -1,4 +1,5 @@
 # Load each available integration
+require 'state_machine/integrations/base'
 Dir["#{File.dirname(__FILE__)}/integrations/*.rb"].sort.each do |path|
   require "state_machine/integrations/#{File.basename(path)}"
 end
@@ -45,6 +46,10 @@ module StateMachine
     #     include DataMapper::Resource
     #   end
     #   
+    #   class MongoidVehicle
+    #     include Mongoid::Document
+    #   end
+    #   
     #   class MongoMapperVehicle
     #     include MongoMapper::Document
     #   end
@@ -56,6 +61,7 @@ module StateMachine
     #   StateMachine::Integrations.match(ActiveModelVehicle)  # => StateMachine::Integrations::ActiveModel
     #   StateMachine::Integrations.match(ActiveRecordVehicle) # => StateMachine::Integrations::ActiveRecord
     #   StateMachine::Integrations.match(DataMapperVehicle)   # => StateMachine::Integrations::DataMapper
+    #   StateMachine::Integrations.match(MongoidVehicle)      # => StateMachine::Integrations::Mongoid
     #   StateMachine::Integrations.match(MongoMapperVehicle)  # => StateMachine::Integrations::MongoMapper
     #   StateMachine::Integrations.match(SequelVehicle)       # => StateMachine::Integrations::Sequel
     def self.match(klass)
@@ -73,6 +79,7 @@ module StateMachine
     #   StateMachine::Integrations.find(:active_record)   # => StateMachine::Integrations::ActiveRecord
     #   StateMachine::Integrations.find(:active_model)    # => StateMachine::Integrations::ActiveModel
     #   StateMachine::Integrations.find(:data_mapper)     # => StateMachine::Integrations::DataMapper
+    #   StateMachine::Integrations.find(:mongoid)         # => StateMachine::Integrations::Mongoid
     #   StateMachine::Integrations.find(:mongo_mapper)    # => StateMachine::Integrations::MongoMapper
     #   StateMachine::Integrations.find(:sequel)          # => StateMachine::Integrations::Sequel
     #   StateMachine::Integrations.find(:invalid)         # => NameError: wrong constant name Invalid

data/lib/state_machine/integrations/active_model.rb

@@ -8,6 +8,7 @@ module StateMachine
     # following features need to be included in order for the integration to be
     # detected:
     # * ActiveModel::Dirty
+    # * ActiveModel::MassAssignmentSecurity
     # * ActiveModel::Observing
     # * ActiveModel::Validations
     # 
@@ -16,6 +17,7 @@ module StateMachine
     # 
     #   class Vehicle
     #     include ActiveModel::Dirty
+    #     include ActiveModel::MassAssignmentSecurity
     #     include ActiveModel::Observing
     #     include ActiveModel::Validations
     #     
@@ -65,6 +67,44 @@ module StateMachine
     #   vehicle.ignite                # => false
     #   vehicle.errors.full_messages  # => ["State cannot transition via \"ignite\""]
     # 
+    # === Security implications
+    # 
+    # Beware that public event attributes mean that events can be fired
+    # whenever mass-assignment is being used.  If you want to prevent malicious
+    # users from tampering with events through URLs / forms, the attribute
+    # should be protected like so:
+    # 
+    #   class Vehicle
+    #     include ActiveModel::MassAssignmentSecurity
+    #     attr_accessor :state
+    #     
+    #     attr_protected :state_event
+    #     # attr_accessible ... # Alternative technique
+    #     
+    #     state_machine do
+    #       ...
+    #     end
+    #   end
+    # 
+    # If you want to only have *some* events be able to fire via mass-assignment,
+    # you can build two state machines (one public and one protected) like so:
+    # 
+    #   class Vehicle
+    #     include ActiveModel::MassAssignmentSecurity
+    #     attr_accessor :state
+    #     
+    #     attr_protected :state_event # Prevent access to events in the first machine
+    #     
+    #     state_machine do
+    #       # Define private events here
+    #     end
+    #     
+    #     # Public machine targets the same state as the private machine
+    #     state_machine :public_state, :attribute => :state do
+    #       # Define public events here
+    #     end
+    #   end
+    # 
     # == Callbacks
     # 
     # All before/after transition callbacks defined for ActiveModel models
@@ -108,15 +148,15 @@ module StateMachine
     # hooks *are* supported.  For example, if a transition for a object'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:
     # 
@@ -135,6 +175,10 @@ module StateMachine
     #     def after_transition(vehicle, transition)
     #       Audit.log(vehicle, transition)
     #     end
+    #     
+    #     def after_failure_to_transition(vehicle, transition)
+    #       Audit.error(vehicle, transition)
+    #     end
     #   end
     # 
     # More flexible transition callbacks can be defined directly within the
@@ -200,7 +244,7 @@ module StateMachine
     #     end
     #     
     #     protected
-    #       def runs_validation_on_action?
+    #       def runs_validations_on_action?
     #         action == :persist
     #       end
     #       
@@ -214,47 +258,35 @@ module StateMachine
     # must add these independent of the ActiveModel integration.  See the
     # ActiveRecord implementation for examples of these customizations.
     module ActiveModel
-      module ClassMethods
-        # The default options to use for state machines using this integration
-        attr_reader :defaults
-        
-        # Loads additional files specific to ActiveModel
-        def extended(base) #:nodoc:
-          require 'state_machine/integrations/active_model/observer'
-          
-          if defined?(I18n)
-            locale = "#{File.dirname(__FILE__)}/active_model/locale.rb"
-            I18n.load_path.unshift(locale) unless I18n.load_path.include?(locale)
-          end
-        end
-      end
-      
       def self.included(base) #:nodoc:
-        base.class_eval do
-          extend ClassMethods
-        end
+        base.versions.unshift(*versions)
       end
       
+      include Base
       extend ClassMethods
       
+      require 'state_machine/integrations/active_model/versions'
+      
+      @defaults = {}
+      
       # Should this integration be used for state machines in the given class?
-      # Classes that include ActiveModel::Dirty, ActiveModel::Observing, or
-      # ActiveModel::Validations will automatically use the ActiveModel
-      # integration.
+      # Classes that include ActiveModel::Dirty, ActiveModel::MassAssignmentSecurity,
+      # ActiveModel::Observing, or ActiveModel::Validations will automatically
+      # use the ActiveModel integration.
       def self.matches?(klass)
-        features = %w(Dirty Observing Validations)
+        features = %w(Dirty MassAssignmentSecurity Observing Validations)
         defined?(::ActiveModel) && features.any? {|feature| ::ActiveModel.const_defined?(feature) && klass <= ::ActiveModel.const_get(feature)}
       end
       
-      @defaults = {}
-      
       # Forces the change in state to be recognized regardless of whether the
       # state value actually changed
-      def write(object, attribute, value)
+      def write(object, attribute, value, *args)
         result = super
-        if attribute == :state && supports_dirty_tracking?(object) && !object.send("#{self.attribute}_changed?")
+        
+        if (attribute == :state || attribute == :event && value) && supports_dirty_tracking?(object) && !object.send("#{self.attribute}_changed?")
           object.send("#{self.attribute}_will_change!")
         end
+        
         result
       end
       
@@ -278,6 +310,11 @@ module StateMachine
       end
       
       protected
+        # The name of this integration
+        def integration
+          :active_model
+        end
+        
         # Whether observers are supported in the integration.  Only true if
         # ActiveModel::Observer is available.
         def supports_observers?
@@ -303,14 +340,40 @@ module StateMachine
           defined?(::ActiveModel::Dirty) && owner_class <= ::ActiveModel::Dirty && object.respond_to?("#{self.attribute}_changed?")
         end
         
+        # Whether the protection of attributes via mass-assignment is supported
+        # in this integration.  Only true if the ActiveModel feature is enabled
+        # on the owner class.
+        def supports_mass_assignment_security?
+          defined?(::ActiveModel::MassAssignmentSecurity) && owner_class <= ::ActiveModel::MassAssignmentSecurity
+        end
+        
         # Gets the terminator to use for callbacks
         def callback_terminator
           @terminator ||= lambda {|result| result == false}
         end
         
         # Determines the base scope to use when looking up translations
-        def i18n_scope
-          owner_class.i18n_scope
+        def i18n_scope(klass)
+          klass.i18n_scope
+        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)
+          if supports_mass_assignment_security?
+            attributes = (options[:attributes] || {}).dup.stringify_keys!
+            ignore = filter_attributes(object, attributes).keys
+            !ignore.map {|attribute| attribute.to_sym}.include?(attribute) 
+          else
+            super
+          end
+        end
+        
+        # Filters attributes that cannot be assigned through the initialization
+        # of the object
+        def filter_attributes(object, attributes)
+          object.send(:sanitize_for_mass_assignment, attributes)
         end
         
         # The default options to use when generating messages for validation
@@ -322,7 +385,7 @@ module StateMachine
         # Translates the given key / value combo.  Translation keys are looked
         # up in the following order:
         # * <tt>#{i18n_scope}.state_machines.#{model_name}.#{machine_name}.#{plural_key}.#{value}</tt>
-        # * <tt>#{i18n_scope}.state_machines.#{machine_name}.#{plural_key}.#{value}
+        # * <tt>#{i18n_scope}.state_machines.#{machine_name}.#{plural_key}.#{value}</tt>
         # * <tt>#{i18n_scope}.state_machines.#{plural_key}.#{value}</tt>
         # 
         # If no keys are found, then the humanized value will be the fallback.
@@ -334,7 +397,7 @@ module StateMachine
           # Generate all possible translation keys
           translations = ancestors.map {|ancestor| :"#{ancestor.model_name.underscore}.#{name}.#{group}.#{value}"}
           translations.concat([:"#{name}.#{group}.#{value}", :"#{group}.#{value}", value.humanize.downcase])
-          I18n.translate(translations.shift, :default => translations, :scope => [i18n_scope, :state_machines])
+          I18n.translate(translations.shift, :default => translations, :scope => [i18n_scope(klass), :state_machines])
         end
         
         # Build a list of ancestors for the given class to use when
@@ -343,12 +406,34 @@ module StateMachine
           klass.lookup_ancestors
         end
         
-        # Adds the default callbacks for notifying ActiveModel observers
-        # before/after a transition has been performed.
+        # Initializes class-level extensions and defaults for this machine
         def after_initialize
+          load_locale
+          load_observer_extensions
+          add_default_callbacks
+        end
+        
+        # Loads any locale files needed for translating validation errors
+        def load_locale
+          I18n.load_path.unshift(locale_path) unless I18n.load_path.include?(locale_path)
+        end
+        
+        # The path to the locale file containing state_machine translations
+        def locale_path
+          "#{File.dirname(__FILE__)}/#{integration}/locale.rb"
+        end
+        
+        # Loads extensions to ActiveModel's Observers
+        def load_observer_extensions
+          require 'state_machine/integrations/active_model/observer'
+        end
+        
+        # Adds a set of default callbacks that utilize the Observer extensions
+        def add_default_callbacks
           if supports_observers?
             callbacks[:before] << Callback.new(:before) {|object, transition| notify(:before, object, transition)}
             callbacks[:after] << Callback.new(:after) {|object, transition| notify(:after, object, transition)}
+            callbacks[:failure] << Callback.new(:failure) {|object, transition| notify(:after_failure_to, object, transition)}
           end
         end
         
@@ -363,15 +448,20 @@ module StateMachine
         end
         
         # Adds hooks into validation for automatically firing events
-        def define_action_helpers(*args)
+        def define_action_helpers
           super
-          
-          action = self.action
-          @instance_helper_module.class_eval do
-            define_method(:valid?) do |*args|
-              self.class.state_machines.transitions(self, action, :after => false).perform { super(*args) }
-            end
-          end if runs_validations_on_action?
+          define_validation_hook if runs_validations_on_action?
+        end
+        
+        # Hooks into validations by defining around callbacks for the
+        # :validation event
+        def define_validation_hook
+          owner_class.set_callback(:validation, :around, self, :prepend => true)
+        end
+        
+        # Runs state events around the object's validation process
+        def around_validation(object)
+          object.class.state_machines.transitions(object, action, :after => false).perform { yield }
         end
         
         # Creates a new callback in the callback chain, always inserting it
@@ -406,15 +496,15 @@ module StateMachine
         # Notifies observers on the given object that a callback occurred
         # involving the given transition.  This will attempt to call the
         # following methods on observers:
-        # * #{type}_#{qualified_event}_from_#{from}_to_#{to}
-        # * #{type}_#{qualified_event}_from_#{from}
-        # * #{type}_#{qualified_event}_to_#{to}
-        # * #{type}_#{qualified_event}
-        # * #{type}_transition_#{machine_name}_from_#{from}_to_#{to}
-        # * #{type}_transition_#{machine_name}_from_#{from}
-        # * #{type}_transition_#{machine_name}_to_#{to}
-        # * #{type}_transition_#{machine_name}
-        # * #{type}_transition
+        # * <tt>#{type}_#{qualified_event}_from_#{from}_to_#{to}</tt>
+        # * <tt>#{type}_#{qualified_event}_from_#{from}</tt>
+        # * <tt>#{type}_#{qualified_event}_to_#{to}</tt>
+        # * <tt>#{type}_#{qualified_event}</tt>
+        # * <tt>#{type}_transition_#{machine_name}_from_#{from}_to_#{to}</tt>
+        # * <tt>#{type}_transition_#{machine_name}_from_#{from}</tt>
+        # * <tt>#{type}_transition_#{machine_name}_to_#{to}</tt>
+        # * <tt>#{type}_transition_#{machine_name}</tt>
+        # * <tt>#{type}_transition</tt>
         # 
         # This will always return true regardless of the results of the
         # callbacks.